Add FOR clause parsing support for SELECT statements

- Add ForClause interface and types: BrowseForClause, ReadOnlyForClause,
  UpdateForClause, XmlForClause, XmlForClauseOption
- Add ForClause field to QuerySpecification
- Parse FOR BROWSE, FOR READ ONLY, FOR UPDATE [OF columns] clauses
- Parse FOR XML with options: AUTO, EXPLICIT, RAW, PATH, ELEMENTS,
  XMLDATA, XMLSCHEMA, ROOT, TYPE, BINARY BASE64
- Add "FOR" to reserved keywords that shouldn't be parsed as table aliases
- Add JSON marshaling for all FOR clause types

Enables BaselinesCommon_ForClauseTests and ForClauseTests tests.

Author: claude

ast/for_clause.go

@@ -0,0 +1,43 @@
+package ast
+
+// ForClause is an interface for different types of FOR clauses.
+type ForClause interface {
+	Node
+	forClause()
+}
+
+// BrowseForClause represents a FOR BROWSE clause.
+type BrowseForClause struct{}
+
+func (*BrowseForClause) node()      {}
+func (*BrowseForClause) forClause() {}
+
+// ReadOnlyForClause represents a FOR READ ONLY clause.
+type ReadOnlyForClause struct{}
+
+func (*ReadOnlyForClause) node()      {}
+func (*ReadOnlyForClause) forClause() {}
+
+// UpdateForClause represents a FOR UPDATE [OF columns] clause.
+type UpdateForClause struct {
+	Columns []*ColumnReferenceExpression `json:"Columns,omitempty"`
+}
+
+func (*UpdateForClause) node()      {}
+func (*UpdateForClause) forClause() {}
+
+// XmlForClause represents a FOR XML clause with its options.
+type XmlForClause struct {
+	Options []*XmlForClauseOption `json:"Options,omitempty"`
+}
+
+func (*XmlForClause) node()      {}
+func (*XmlForClause) forClause() {}
+
+// XmlForClauseOption represents an option in a FOR XML clause.
+type XmlForClauseOption struct {
+	OptionKind string           `json:"OptionKind,omitempty"`
+	Value      *StringLiteral   `json:"Value,omitempty"`
+}
+
+func (*XmlForClauseOption) node() {}

ast/query_specification.go

@@ -10,6 +10,7 @@ type QuerySpecification struct {
 	GroupByClause   *GroupByClause    `json:"GroupByClause,omitempty"`
 	HavingClause    *HavingClause     `json:"HavingClause,omitempty"`
 	OrderByClause   *OrderByClause    `json:"OrderByClause,omitempty"`
+	ForClause       ForClause         `json:"ForClause,omitempty"`
 }
 
 func (*QuerySpecification) node()            {}

parser/marshal.go

@@ -1253,6 +1253,51 @@ func querySpecificationToJSON(q *ast.QuerySpecification) jsonNode {
 	if q.OrderByClause != nil {
 		node["OrderByClause"] = orderByClauseToJSON(q.OrderByClause)
 	}
+	if q.ForClause != nil {
+		node["ForClause"] = forClauseToJSON(q.ForClause)
+	}
+	return node
+}
+
+func forClauseToJSON(fc ast.ForClause) jsonNode {
+	switch f := fc.(type) {
+	case *ast.BrowseForClause:
+		return jsonNode{"$type": "BrowseForClause"}
+	case *ast.ReadOnlyForClause:
+		return jsonNode{"$type": "ReadOnlyForClause"}
+	case *ast.UpdateForClause:
+		node := jsonNode{"$type": "UpdateForClause"}
+		if len(f.Columns) > 0 {
+			cols := make([]jsonNode, len(f.Columns))
+			for i, col := range f.Columns {
+				cols[i] = columnReferenceExpressionToJSON(col)
+			}
+			node["Columns"] = cols
+		}
+		return node
+	case *ast.XmlForClause:
+		node := jsonNode{"$type": "XmlForClause"}
+		if len(f.Options) > 0 {
+			opts := make([]jsonNode, len(f.Options))
+			for i, opt := range f.Options {
+				opts[i] = xmlForClauseOptionToJSON(opt)
+			}
+			node["Options"] = opts
+		}
+		return node
+	default:
+		return jsonNode{"$type": "UnknownForClause"}
+	}
+}
+
+func xmlForClauseOptionToJSON(opt *ast.XmlForClauseOption) jsonNode {
+	node := jsonNode{"$type": "XmlForClauseOption"}
+	if opt.OptionKind != "" {
+		node["OptionKind"] = opt.OptionKind
+	}
+	if opt.Value != nil {
+		node["Value"] = stringLiteralToJSON(opt.Value)
+	}
 	return node
 }
 

parser/parse_select.go

@@ -186,6 +186,18 @@ func (p *Parser) parseQueryExpressionWithInto() (ast.QueryExpression, *ast.Schem
 		}
 	}
 
+	// Parse FOR clause (FOR BROWSE, FOR XML, FOR UPDATE, FOR READ ONLY)
+	if strings.ToUpper(p.curTok.Literal) == "FOR" {
+		forClause, err := p.parseForClause()
+		if err != nil {
+			return nil, nil, nil, err
+		}
+		// Attach to QuerySpecification
+		if qs, ok := left.(*ast.QuerySpecification); ok {
+			qs.ForClause = forClause
+		}
+	}
+
 	return left, into, on, nil
 }
 
@@ -1797,7 +1809,7 @@ func (p *Parser) parseNamedTableReference() (*ast.NamedTableReference, error) {
 	} else if p.curTok.Type == TokenIdent {
 		// Could be an alias without AS, but need to be careful not to consume keywords
 		upper := strings.ToUpper(p.curTok.Literal)
-		if upper != "WHERE" && upper != "GROUP" && upper != "HAVING" && upper != "ORDER" && upper != "OPTION" && upper != "GO" && upper != "WITH" && upper != "ON" && upper != "JOIN" && upper != "INNER" && upper != "LEFT" && upper != "RIGHT" && upper != "FULL" && upper != "CROSS" && upper != "OUTER" {
+		if upper != "WHERE" && upper != "GROUP" && upper != "HAVING" && upper != "ORDER" && upper != "OPTION" && upper != "GO" && upper != "WITH" && upper != "ON" && upper != "JOIN" && upper != "INNER" && upper != "LEFT" && upper != "RIGHT" && upper != "FULL" && upper != "CROSS" && upper != "OUTER" && upper != "FOR" {
 			ref.Alias = &ast.Identifier{Value: p.curTok.Literal, QuoteType: "NotQuoted"}
 			p.nextToken()
 		}
@@ -1857,7 +1869,7 @@ func (p *Parser) parseNamedTableReferenceWithName(son *ast.SchemaObjectName) (*a
 		// Could be an alias without AS, but need to be careful not to consume keywords
 		if p.curTok.Type == TokenIdent {
 			upper := strings.ToUpper(p.curTok.Literal)
-			if upper != "WHERE" && upper != "GROUP" && upper != "HAVING" && upper != "ORDER" && upper != "OPTION" && upper != "GO" && upper != "WITH" && upper != "ON" && upper != "JOIN" && upper != "INNER" && upper != "LEFT" && upper != "RIGHT" && upper != "FULL" && upper != "CROSS" && upper != "OUTER" {
+			if upper != "WHERE" && upper != "GROUP" && upper != "HAVING" && upper != "ORDER" && upper != "OPTION" && upper != "GO" && upper != "WITH" && upper != "ON" && upper != "JOIN" && upper != "INNER" && upper != "LEFT" && upper != "RIGHT" && upper != "FULL" && upper != "CROSS" && upper != "OUTER" && upper != "FOR" {
 				ref.Alias = p.parseIdentifier()
 			}
 		} else {
@@ -3436,3 +3448,168 @@ func (p *Parser) parsePredictTableReference() (*ast.PredictTableReference, error
 
 	return ref, nil
 }
+
+// parseForClause parses FOR BROWSE, FOR XML, FOR UPDATE, FOR READ ONLY clauses.
+func (p *Parser) parseForClause() (ast.ForClause, error) {
+	p.nextToken() // consume FOR
+
+	keyword := strings.ToUpper(p.curTok.Literal)
+
+	switch keyword {
+	case "BROWSE":
+		p.nextToken() // consume BROWSE
+		return &ast.BrowseForClause{}, nil
+
+	case "READ":
+		p.nextToken() // consume READ
+		if strings.ToUpper(p.curTok.Literal) == "ONLY" {
+			p.nextToken() // consume ONLY
+		}
+		return &ast.ReadOnlyForClause{}, nil
+
+	case "UPDATE":
+		p.nextToken() // consume UPDATE
+		clause := &ast.UpdateForClause{}
+
+		// Check for OF column_list
+		if strings.ToUpper(p.curTok.Literal) == "OF" {
+			p.nextToken() // consume OF
+
+			// Parse column list
+			for {
+				col, err := p.parseColumnReference()
+				if err != nil {
+					return nil, err
+				}
+				clause.Columns = append(clause.Columns, col)
+
+				if p.curTok.Type != TokenComma {
+					break
+				}
+				p.nextToken() // consume comma
+			}
+		}
+		return clause, nil
+
+	case "XML":
+		p.nextToken() // consume XML
+		return p.parseXmlForClause()
+
+	default:
+		return nil, fmt.Errorf("unexpected token after FOR: %s", p.curTok.Literal)
+	}
+}
+
+// parseXmlForClause parses FOR XML options.
+func (p *Parser) parseXmlForClause() (*ast.XmlForClause, error) {
+	clause := &ast.XmlForClause{}
+
+	// Parse XML options separated by commas
+	for {
+		option, err := p.parseXmlForClauseOption()
+		if err != nil {
+			return nil, err
+		}
+		clause.Options = append(clause.Options, option)
+
+		if p.curTok.Type != TokenComma {
+			break
+		}
+		p.nextToken() // consume comma
+	}
+
+	return clause, nil
+}
+
+// parseXmlForClauseOption parses a single XML FOR clause option.
+func (p *Parser) parseXmlForClauseOption() (*ast.XmlForClauseOption, error) {
+	option := &ast.XmlForClauseOption{}
+
+	keyword := strings.ToUpper(p.curTok.Literal)
+	p.nextToken() // consume the option keyword
+
+	switch keyword {
+	case "AUTO":
+		option.OptionKind = "Auto"
+	case "EXPLICIT":
+		option.OptionKind = "Explicit"
+	case "RAW":
+		option.OptionKind = "Raw"
+		// Check for optional element name: RAW ('name')
+		if p.curTok.Type == TokenLParen {
+			p.nextToken() // consume (
+			if p.curTok.Type == TokenString {
+				option.Value = p.parseStringLiteralValue()
+				p.nextToken() // consume string
+			}
+			if p.curTok.Type == TokenRParen {
+				p.nextToken() // consume )
+			}
+		}
+	case "PATH":
+		option.OptionKind = "Path"
+		// Check for optional path name: PATH ('name')
+		if p.curTok.Type == TokenLParen {
+			p.nextToken() // consume (
+			if p.curTok.Type == TokenString {
+				option.Value = p.parseStringLiteralValue()
+				p.nextToken() // consume string
+			}
+			if p.curTok.Type == TokenRParen {
+				p.nextToken() // consume )
+			}
+		}
+	case "ELEMENTS":
+		// Check for XSINIL or ABSENT
+		nextKeyword := strings.ToUpper(p.curTok.Literal)
+		if nextKeyword == "XSINIL" {
+			option.OptionKind = "ElementsXsiNil"
+			p.nextToken() // consume XSINIL
+		} else if nextKeyword == "ABSENT" {
+			option.OptionKind = "ElementsAbsent"
+			p.nextToken() // consume ABSENT
+		} else {
+			option.OptionKind = "Elements"
+		}
+	case "XMLDATA":
+		option.OptionKind = "XmlData"
+	case "XMLSCHEMA":
+		option.OptionKind = "XmlSchema"
+		// Check for optional namespace: XMLSCHEMA ('namespace')
+		if p.curTok.Type == TokenLParen {
+			p.nextToken() // consume (
+			if p.curTok.Type == TokenString {
+				option.Value = p.parseStringLiteralValue()
+				p.nextToken() // consume string
+			}
+			if p.curTok.Type == TokenRParen {
+				p.nextToken() // consume )
+			}
+		}
+	case "ROOT":
+		option.OptionKind = "Root"
+		// Check for optional root name: ROOT ('name')
+		if p.curTok.Type == TokenLParen {
+			p.nextToken() // consume (
+			if p.curTok.Type == TokenString {
+				option.Value = p.parseStringLiteralValue()
+				p.nextToken() // consume string
+			}
+			if p.curTok.Type == TokenRParen {
+				p.nextToken() // consume )
+			}
+		}
+	case "TYPE":
+		option.OptionKind = "Type"
+	case "BINARY":
+		// BINARY BASE64
+		if strings.ToUpper(p.curTok.Literal) == "BASE64" {
+			option.OptionKind = "BinaryBase64"
+			p.nextToken() // consume BASE64
+		}
+	default:
+		option.OptionKind = keyword
+	}
+
+	return option, nil
+}

parser/testdata/BaselinesCommon_ForClauseTests/metadata.json

@@ -1 +1 @@
-{"todo": true}
+{}

parser/testdata/ForClauseTests/metadata.json

@@ -1 +1 @@
-{"todo": true}
+{}