Add OPENJSON table reference support with WITH schema clause

- Create OpenJsonTableReference AST type for OPENJSON in FROM clause
- Create SchemaDeclarationItemOpenjson for WITH clause column definitions
- Handle OPENJSON specially in parseTableReferenceWithName()
- Parse WITH clause including column name, data type, COLLATE, path mapping, AS JSON
- Add marshaling for OpenJsonTableReference

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: kyleconroy

ast/openjson_table_reference.go

@@ -0,0 +1,22 @@
+package ast
+
+// OpenJsonTableReference represents an OPENJSON table reference in the FROM clause.
+type OpenJsonTableReference struct {
+	Variable               ScalarExpression             `json:"Variable,omitempty"`
+	RowPattern             ScalarExpression             `json:"RowPattern,omitempty"`
+	SchemaDeclarationItems []*SchemaDeclarationItemOpenjson `json:"SchemaDeclarationItems,omitempty"`
+	Alias                  *Identifier                  `json:"Alias,omitempty"`
+	ForPath                bool                         `json:"ForPath,omitempty"`
+}
+
+func (*OpenJsonTableReference) node()           {}
+func (*OpenJsonTableReference) tableReference() {}
+
+// SchemaDeclarationItemOpenjson represents a column definition in OPENJSON WITH clause.
+type SchemaDeclarationItemOpenjson struct {
+	AsJson           bool                  `json:"AsJson,omitempty"`
+	ColumnDefinition *ColumnDefinitionBase `json:"ColumnDefinition,omitempty"`
+	Mapping          ScalarExpression      `json:"Mapping,omitempty"`
+}
+
+func (*SchemaDeclarationItemOpenjson) node() {}

parser/marshal.go

@@ -2749,6 +2749,50 @@ func tableReferenceToJSON(ref ast.TableReference) jsonNode {
 		}
 		node["ForPath"] = r.ForPath
 		return node
+	case *ast.OpenJsonTableReference:
+		node := jsonNode{
+			"$type": "OpenJsonTableReference",
+		}
+		if r.Variable != nil {
+			node["Variable"] = scalarExpressionToJSON(r.Variable)
+		}
+		if r.RowPattern != nil {
+			node["RowPattern"] = scalarExpressionToJSON(r.RowPattern)
+		}
+		if len(r.SchemaDeclarationItems) > 0 {
+			items := make([]jsonNode, len(r.SchemaDeclarationItems))
+			for i, item := range r.SchemaDeclarationItems {
+				itemNode := jsonNode{
+					"$type": "SchemaDeclarationItemOpenjson",
+				}
+				itemNode["AsJson"] = item.AsJson
+				if item.ColumnDefinition != nil {
+					colDef := jsonNode{
+						"$type": "ColumnDefinitionBase",
+					}
+					if item.ColumnDefinition.ColumnIdentifier != nil {
+						colDef["ColumnIdentifier"] = identifierToJSON(item.ColumnDefinition.ColumnIdentifier)
+					}
+					if item.ColumnDefinition.DataType != nil {
+						colDef["DataType"] = dataTypeReferenceToJSON(item.ColumnDefinition.DataType)
+					}
+					if item.ColumnDefinition.Collation != nil {
+						colDef["Collation"] = identifierToJSON(item.ColumnDefinition.Collation)
+					}
+					itemNode["ColumnDefinition"] = colDef
+				}
+				if item.Mapping != nil {
+					itemNode["Mapping"] = scalarExpressionToJSON(item.Mapping)
+				}
+				items[i] = itemNode
+			}
+			node["SchemaDeclarationItems"] = items
+		}
+		if r.Alias != nil {
+			node["Alias"] = identifierToJSON(r.Alias)
+		}
+		node["ForPath"] = r.ForPath
+		return node
 	case *ast.BuiltInFunctionTableReference:
 		node := jsonNode{
 			"$type": "BuiltInFunctionTableReference",

parser/parse_select.go

@@ -2512,6 +2512,10 @@ func (p *Parser) parseSingleTableReference() (ast.TableReference, error) {
 					ForPath:    false,
 				}, nil
 			}
+			// Handle OPENJSON specially
+			if upper == "OPENJSON" {
+				return p.parseOpenJsonTableReference(params, alias)
+			}
 		}
 
 		ref := &ast.SchemaObjectFunctionTableReference{
@@ -2528,6 +2532,113 @@ func (p *Parser) parseSingleTableReference() (ast.TableReference, error) {
 	return p.parseNamedTableReferenceWithName(son)
 }
 
+// parseOpenJsonTableReference parses OPENJSON function with optional WITH clause
+func (p *Parser) parseOpenJsonTableReference(params []ast.ScalarExpression, alias *ast.Identifier) (ast.TableReference, error) {
+	ref := &ast.OpenJsonTableReference{
+		ForPath: false,
+		Alias:   alias,
+	}
+
+	// First parameter is the Variable (JSON expression)
+	if len(params) > 0 {
+		ref.Variable = params[0]
+	}
+
+	// Second parameter is the RowPattern (optional path expression)
+	if len(params) > 1 {
+		ref.RowPattern = params[1]
+	}
+
+	// Check for WITH clause (schema declaration)
+	if p.curTok.Type == TokenWith {
+		p.nextToken() // consume WITH
+		if p.curTok.Type != TokenLParen {
+			return nil, fmt.Errorf("expected ( after OPENJSON WITH, got %s", p.curTok.Literal)
+		}
+		p.nextToken() // consume (
+
+		// Parse schema declaration items
+		for p.curTok.Type != TokenRParen && p.curTok.Type != TokenEOF {
+			item, err := p.parseSchemaDeclarationItemOpenjson()
+			if err != nil {
+				return nil, err
+			}
+			ref.SchemaDeclarationItems = append(ref.SchemaDeclarationItems, item)
+
+			if p.curTok.Type == TokenComma {
+				p.nextToken()
+			} else {
+				break
+			}
+		}
+
+		if p.curTok.Type == TokenRParen {
+			p.nextToken() // consume )
+		}
+	}
+
+	// Parse optional alias after WITH clause
+	if ref.Alias == nil {
+		if p.curTok.Type == TokenAs {
+			p.nextToken()
+			ref.Alias = p.parseIdentifier()
+		} else if p.curTok.Type == TokenIdent {
+			upper := strings.ToUpper(p.curTok.Literal)
+			if upper != "WHERE" && upper != "GROUP" && upper != "HAVING" && upper != "WINDOW" && 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()
+			}
+		}
+	}
+
+	return ref, nil
+}
+
+// parseSchemaDeclarationItemOpenjson parses a column definition in OPENJSON WITH clause
+func (p *Parser) parseSchemaDeclarationItemOpenjson() (*ast.SchemaDeclarationItemOpenjson, error) {
+	item := &ast.SchemaDeclarationItemOpenjson{
+		ColumnDefinition: &ast.ColumnDefinitionBase{},
+	}
+
+	// Parse column name
+	item.ColumnDefinition.ColumnIdentifier = p.parseIdentifier()
+
+	// Parse data type
+	dataType, err := p.parseDataTypeReference()
+	if err != nil {
+		return nil, err
+	}
+	item.ColumnDefinition.DataType = dataType
+
+	// Parse optional COLLATE
+	if strings.ToUpper(p.curTok.Literal) == "COLLATE" {
+		p.nextToken() // consume COLLATE
+		item.ColumnDefinition.Collation = p.parseIdentifier()
+	}
+
+	// Parse optional path mapping (string literal) or AS JSON
+	if p.curTok.Type == TokenString || p.curTok.Type == TokenNationalString {
+		mapping, err := p.parseScalarExpression()
+		if err != nil {
+			return nil, err
+		}
+		item.Mapping = mapping
+	}
+
+	// Parse optional AS JSON
+	if p.curTok.Type == TokenAs {
+		p.nextToken() // consume AS
+		if strings.ToUpper(p.curTok.Literal) == "JSON" {
+			item.AsJson = true
+			p.nextToken() // consume JSON
+		}
+	}
+
+	return item, nil
+}
+
 // parseDerivedTableReference parses a derived table (parenthesized query) like (SELECT ...) AS alias
 // or an inline derived table (VALUES clause) like (VALUES (...), (...)) AS alias(cols)
 // or a data modification table reference (DML with OUTPUT) like (INSERT ... OUTPUT ...) AS alias

parser/testdata/Baselines130_FromClauseTests130/metadata.json

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

parser/testdata/FromClauseTests130/metadata.json

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