Add rowset table reference parsing support

- Add OPENXML table reference parsing with WITH clause schema declarations
- Add OPENQUERY table reference parsing for linked server queries
- Add OPENDATASOURCE/AdHoc table reference parsing
- Update OPENROWSET to handle semicolon-separated syntax (DataSource;UserId;Password)
- Add Alias support to FullTextTableReference marshaling
- Add Mapping field to SchemaDeclarationItem for XPath mappings

Enables: BaselinesCommon_RowsetsInSelectTests, RowsetsInSelectTests

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

Author: kyleconroy

ast/adhoc_table_reference.go

@@ -0,0 +1,20 @@
+package ast
+
+// AdHocTableReference represents a table accessed via OPENDATASOURCE
+// Syntax: OPENDATASOURCE('provider', 'connstr').'object'
+// Uses AdHocDataSource from execute_statement.go
+type AdHocTableReference struct {
+	DataSource *AdHocDataSource                   `json:"DataSource,omitempty"`
+	Object     *SchemaObjectNameOrValueExpression `json:"Object,omitempty"`
+	Alias      *Identifier                        `json:"Alias,omitempty"`
+	ForPath    bool                               `json:"ForPath"`
+}
+
+func (*AdHocTableReference) node()           {}
+func (*AdHocTableReference) tableReference() {}
+
+// SchemaObjectNameOrValueExpression represents either a schema object name or a value expression
+type SchemaObjectNameOrValueExpression struct {
+	SchemaObjectName *SchemaObjectName `json:"SchemaObjectName,omitempty"`
+	ValueExpression  ScalarExpression  `json:"ValueExpression,omitempty"`
+}

ast/openquery_table_reference.go

@@ -0,0 +1,12 @@
+package ast
+
+// OpenQueryTableReference represents OPENQUERY(linked_server, 'query') table reference
+type OpenQueryTableReference struct {
+	LinkedServer *Identifier      `json:"LinkedServer,omitempty"`
+	Query        ScalarExpression `json:"Query,omitempty"`
+	Alias        *Identifier      `json:"Alias,omitempty"`
+	ForPath      bool             `json:"ForPath"`
+}
+
+func (*OpenQueryTableReference) node()           {}
+func (*OpenQueryTableReference) tableReference() {}

ast/openrowset.go

@@ -24,10 +24,16 @@ type LiteralOpenRowsetCosmosOption struct {
 
 func (l *LiteralOpenRowsetCosmosOption) openRowsetCosmosOption() {}
 
-// OpenRowsetTableReference represents a traditional OPENROWSET('provider', 'connstr', object) syntax.
+// OpenRowsetTableReference represents OPENROWSET with various syntaxes:
+// - OPENROWSET('provider', 'connstr', object)
+// - OPENROWSET('provider', 'server'; 'user'; 'password', 'query')
 type OpenRowsetTableReference struct {
 	ProviderName   ScalarExpression              `json:"ProviderName,omitempty"`
 	ProviderString ScalarExpression              `json:"ProviderString,omitempty"`
+	DataSource     ScalarExpression              `json:"DataSource,omitempty"`
+	UserId         ScalarExpression              `json:"UserId,omitempty"`
+	Password       ScalarExpression              `json:"Password,omitempty"`
+	Query          ScalarExpression              `json:"Query,omitempty"`
 	Object         *SchemaObjectName             `json:"Object,omitempty"`
 	WithColumns    []*OpenRowsetColumnDefinition `json:"WithColumns,omitempty"`
 	Alias          *Identifier                   `json:"Alias,omitempty"`

ast/openxml_table_reference.go

@@ -0,0 +1,16 @@
+package ast
+
+// OpenXmlTableReference represents an OPENXML table-valued function
+// Syntax: OPENXML(variable, rowpattern [, flags]) [WITH (schema) | WITH table_name | AS alias]
+type OpenXmlTableReference struct {
+	Variable               ScalarExpression         `json:"Variable,omitempty"`
+	RowPattern             ScalarExpression         `json:"RowPattern,omitempty"`
+	Flags                  ScalarExpression         `json:"Flags,omitempty"`
+	SchemaDeclarationItems []*SchemaDeclarationItem `json:"SchemaDeclarationItems,omitempty"`
+	TableName              *SchemaObjectName        `json:"TableName,omitempty"`
+	Alias                  *Identifier              `json:"Alias,omitempty"`
+	ForPath                bool                     `json:"ForPath"`
+}
+
+func (*OpenXmlTableReference) node()           {}
+func (*OpenXmlTableReference) tableReference() {}

ast/predict_table_reference.go

@@ -13,9 +13,10 @@ type PredictTableReference struct {
 func (*PredictTableReference) node()           {}
 func (*PredictTableReference) tableReference() {}
 
-// SchemaDeclarationItem represents a column definition in PREDICT WITH clause
+// SchemaDeclarationItem represents a column definition in PREDICT/OPENXML WITH clause
 type SchemaDeclarationItem struct {
 	ColumnDefinition *ColumnDefinitionBase `json:"ColumnDefinition,omitempty"`
+	Mapping          ScalarExpression      `json:"Mapping,omitempty"` // Optional XPath mapping for OPENXML
 }
 
 func (*SchemaDeclarationItem) node() {}

parser/marshal.go

@@ -2943,6 +2943,18 @@ func tableReferenceToJSON(ref ast.TableReference) jsonNode {
 		if r.ProviderString != nil {
 			node["ProviderString"] = scalarExpressionToJSON(r.ProviderString)
 		}
+		if r.DataSource != nil {
+			node["DataSource"] = scalarExpressionToJSON(r.DataSource)
+		}
+		if r.UserId != nil {
+			node["UserId"] = scalarExpressionToJSON(r.UserId)
+		}
+		if r.Password != nil {
+			node["Password"] = scalarExpressionToJSON(r.Password)
+		}
+		if r.Query != nil {
+			node["Query"] = scalarExpressionToJSON(r.Query)
+		}
 		if r.Object != nil {
 			node["Object"] = schemaObjectNameToJSON(r.Object)
 		}
@@ -2958,6 +2970,73 @@ func tableReferenceToJSON(ref ast.TableReference) jsonNode {
 		}
 		node["ForPath"] = r.ForPath
 		return node
+	case *ast.AdHocTableReference:
+		node := jsonNode{
+			"$type": "AdHocTableReference",
+		}
+		if r.DataSource != nil {
+			node["DataSource"] = adHocDataSourceToJSON(r.DataSource)
+		}
+		if r.Object != nil {
+			objNode := jsonNode{
+				"$type": "SchemaObjectNameOrValueExpression",
+			}
+			if r.Object.SchemaObjectName != nil {
+				objNode["SchemaObjectName"] = schemaObjectNameToJSON(r.Object.SchemaObjectName)
+			}
+			if r.Object.ValueExpression != nil {
+				objNode["ValueExpression"] = scalarExpressionToJSON(r.Object.ValueExpression)
+			}
+			node["Object"] = objNode
+		}
+		if r.Alias != nil {
+			node["Alias"] = identifierToJSON(r.Alias)
+		}
+		node["ForPath"] = r.ForPath
+		return node
+	case *ast.OpenXmlTableReference:
+		node := jsonNode{
+			"$type": "OpenXmlTableReference",
+		}
+		if r.Variable != nil {
+			node["Variable"] = scalarExpressionToJSON(r.Variable)
+		}
+		if r.RowPattern != nil {
+			node["RowPattern"] = scalarExpressionToJSON(r.RowPattern)
+		}
+		if r.Flags != nil {
+			node["Flags"] = scalarExpressionToJSON(r.Flags)
+		}
+		if len(r.SchemaDeclarationItems) > 0 {
+			items := make([]jsonNode, len(r.SchemaDeclarationItems))
+			for i, item := range r.SchemaDeclarationItems {
+				items[i] = schemaDeclarationItemToJSON(item)
+			}
+			node["SchemaDeclarationItems"] = items
+		}
+		if r.TableName != nil {
+			node["TableName"] = schemaObjectNameToJSON(r.TableName)
+		}
+		if r.Alias != nil {
+			node["Alias"] = identifierToJSON(r.Alias)
+		}
+		node["ForPath"] = r.ForPath
+		return node
+	case *ast.OpenQueryTableReference:
+		node := jsonNode{
+			"$type": "OpenQueryTableReference",
+		}
+		if r.LinkedServer != nil {
+			node["LinkedServer"] = identifierToJSON(r.LinkedServer)
+		}
+		if r.Query != nil {
+			node["Query"] = scalarExpressionToJSON(r.Query)
+		}
+		if r.Alias != nil {
+			node["Alias"] = identifierToJSON(r.Alias)
+		}
+		node["ForPath"] = r.ForPath
+		return node
 	case *ast.PredictTableReference:
 		node := jsonNode{
 			"$type": "PredictTableReference",
@@ -3091,6 +3170,9 @@ func tableReferenceToJSON(ref ast.TableReference) jsonNode {
 		if r.PropertyName != nil {
 			node["PropertyName"] = scalarExpressionToJSON(r.PropertyName)
 		}
+		if r.Alias != nil {
+			node["Alias"] = identifierToJSON(r.Alias)
+		}
 		node["ForPath"] = r.ForPath
 		return node
 	case *ast.SemanticTableReference:
@@ -3136,6 +3218,9 @@ func schemaDeclarationItemToJSON(item *ast.SchemaDeclarationItem) jsonNode {
 	if item.ColumnDefinition != nil {
 		node["ColumnDefinition"] = columnDefinitionBaseToJSON(item.ColumnDefinition)
 	}
+	if item.Mapping != nil {
+		node["Mapping"] = scalarExpressionToJSON(item.Mapping)
+	}
 	return node
 }
 

parser/parse_dml.go

@@ -642,24 +642,72 @@ func (p *Parser) parseOpenRowsetTableReference() (*ast.OpenRowsetTableReference,
 	}
 	p.nextToken() // consume ,
 
-	// Parse provider string (string literal)
-	providerString, err := p.parseScalarExpression()
+	// Parse the second argument - could be:
+	// - ProviderString (connection string) followed by comma and object
+	// - DataSource followed by semicolons for UserId and Password, then comma and Query
+	secondArg, err := p.parseScalarExpression()
 	if err != nil {
 		return nil, err
 	}
-	result.ProviderString = providerString
 
-	if p.curTok.Type != TokenComma {
-		return nil, fmt.Errorf("expected , after provider string, got %s", p.curTok.Literal)
-	}
-	p.nextToken() // consume ,
+	// Check if next token is semicolon (DataSource; UserId; Password format)
+	if p.curTok.Type == TokenSemicolon {
+		result.DataSource = secondArg
+		p.nextToken() // consume ;
 
-	// Parse object (schema object name or expression)
-	obj, err := p.parseSchemaObjectName()
-	if err != nil {
-		return nil, err
+		// Parse UserId
+		userId, err := p.parseScalarExpression()
+		if err != nil {
+			return nil, err
+		}
+		result.UserId = userId
+
+		if p.curTok.Type != TokenSemicolon {
+			return nil, fmt.Errorf("expected ; after UserId, got %s", p.curTok.Literal)
+		}
+		p.nextToken() // consume ;
+
+		// Parse Password
+		password, err := p.parseScalarExpression()
+		if err != nil {
+			return nil, err
+		}
+		result.Password = password
+
+		if p.curTok.Type != TokenComma {
+			return nil, fmt.Errorf("expected , after Password, got %s", p.curTok.Literal)
+		}
+		p.nextToken() // consume ,
+
+		// Parse Query
+		query, err := p.parseScalarExpression()
+		if err != nil {
+			return nil, err
+		}
+		result.Query = query
+	} else if p.curTok.Type == TokenComma {
+		// ProviderString, object format
+		result.ProviderString = secondArg
+		p.nextToken() // consume ,
+
+		// Parse object (schema object name or string expression)
+		if p.curTok.Type == TokenString {
+			// Could be a query string instead of object name
+			query, err := p.parseScalarExpression()
+			if err != nil {
+				return nil, err
+			}
+			result.Query = query
+		} else {
+			obj, err := p.parseSchemaObjectName()
+			if err != nil {
+				return nil, err
+			}
+			result.Object = obj
+		}
+	} else {
+		return nil, fmt.Errorf("expected , or ; after second argument, got %s", p.curTok.Literal)
 	}
-	result.Object = obj
 
 	if p.curTok.Type != TokenRParen {
 		return nil, fmt.Errorf("expected ) in OPENROWSET, got %s", p.curTok.Literal)