Add comprehensive EXECUTE statement parsing support

- Add named parameters (@name = value) support
- Add DEFAULT keyword as parameter value
- Add OUTPUT modifier on parameters
- Add procedure numbers (;1 suffix) parsing
- Add OPENDATASOURCE/OPENROWSET ad-hoc data source support
- Add IdentifierLiteral for bare identifier parameters
- Fix DefaultLiteral to include LiteralType field
- Add AdHocDataSource AST type and JSON marshaling

Enables BaselinesCommon_ExecuteStatementTests

Author: claude

ast/execute_statement.go

@@ -81,6 +81,7 @@ type ExecutableEntity interface {
 type ExecutableProcedureReference struct {
 	ProcedureReference *ProcedureReferenceName `json:"ProcedureReference,omitempty"`
 	Parameters         []*ExecuteParameter     `json:"Parameters,omitempty"`
+	AdHocDataSource    *AdHocDataSource        `json:"AdHocDataSource,omitempty"`
 }
 
 func (e *ExecutableProcedureReference) executableEntity() {}
@@ -102,12 +103,19 @@ type ProcedureReferenceName struct {
 
 // ProcedureReference references a stored procedure by name.
 type ProcedureReference struct {
-	Name *SchemaObjectName `json:"Name,omitempty"`
+	Name   *SchemaObjectName `json:"Name,omitempty"`
+	Number *IntegerLiteral   `json:"Number,omitempty"`
 }
 
 // ExecuteParameter represents a parameter to an EXEC call.
 type ExecuteParameter struct {
-	ParameterValue ScalarExpression `json:"ParameterValue,omitempty"`
+	ParameterValue ScalarExpression   `json:"ParameterValue,omitempty"`
 	Variable       *VariableReference `json:"Variable,omitempty"`
-	IsOutput       bool             `json:"IsOutput"`
+	IsOutput       bool               `json:"IsOutput"`
+}
+
+// AdHocDataSource represents an OPENDATASOURCE or OPENROWSET call for ad-hoc data access.
+type AdHocDataSource struct {
+	ProviderName *StringLiteral `json:"ProviderName,omitempty"`
+	InitString   *StringLiteral `json:"InitString,omitempty"`
 }

parser/marshal.go

@@ -2406,6 +2406,9 @@ func executableEntityToJSON(entity ast.ExecutableEntity) jsonNode {
 			}
 			node["Parameters"] = params
 		}
+		if e.AdHocDataSource != nil {
+			node["AdHocDataSource"] = adHocDataSourceToJSON(e.AdHocDataSource)
+		}
 		return node
 	case *ast.ExecutableStringList:
 		node := jsonNode{
@@ -2451,6 +2454,9 @@ func procedureReferenceToJSON(pr *ast.ProcedureReference) jsonNode {
 	if pr.Name != nil {
 		node["Name"] = schemaObjectNameToJSON(pr.Name)
 	}
+	if pr.Number != nil {
+		node["Number"] = scalarExpressionToJSON(pr.Number)
+	}
 	return node
 }
 
@@ -2468,6 +2474,19 @@ func executeParameterToJSON(ep *ast.ExecuteParameter) jsonNode {
 	return node
 }
 
+func adHocDataSourceToJSON(ds *ast.AdHocDataSource) jsonNode {
+	node := jsonNode{
+		"$type": "AdHocDataSource",
+	}
+	if ds.ProviderName != nil {
+		node["ProviderName"] = scalarExpressionToJSON(ds.ProviderName)
+	}
+	if ds.InitString != nil {
+		node["InitString"] = scalarExpressionToJSON(ds.InitString)
+	}
+	return node
+}
+
 func updateStatementToJSON(s *ast.UpdateStatement) jsonNode {
 	node := jsonNode{
 		"$type": "UpdateStatement",

parser/parse_dml.go

@@ -865,20 +865,77 @@ func (p *Parser) parseExecuteSpecification() (*ast.ExecuteSpecification, error)
 	// Parse procedure reference
 	procRef := &ast.ExecutableProcedureReference{}
 
+	// Check for OPENDATASOURCE or OPENROWSET
+	upperLit := strings.ToUpper(p.curTok.Literal)
+	if upperLit == "OPENDATASOURCE" || upperLit == "OPENROWSET" {
+		p.nextToken() // consume OPENDATASOURCE/OPENROWSET
+		if p.curTok.Type == TokenLParen {
+			p.nextToken() // consume (
+
+			// Parse provider name
+			var providerName *ast.StringLiteral
+			if p.curTok.Type == TokenString {
+				providerName = p.parseStringLiteralValue()
+				p.nextToken()
+			}
+
+			// Expect comma
+			if p.curTok.Type == TokenComma {
+				p.nextToken()
+			}
+
+			// Parse init string
+			var initString *ast.StringLiteral
+			if p.curTok.Type == TokenString {
+				initString = p.parseStringLiteralValue()
+				p.nextToken()
+			}
+
+			// Expect )
+			if p.curTok.Type == TokenRParen {
+				p.nextToken()
+			}
+
+			procRef.AdHocDataSource = &ast.AdHocDataSource{
+				ProviderName: providerName,
+				InitString:   initString,
+			}
+
+			// Expect . and then schema.object.procedure name
+			if p.curTok.Type == TokenDot {
+				p.nextToken() // consume .
+			}
+		}
+	}
+
 	if p.curTok.Type == TokenIdent && strings.HasPrefix(p.curTok.Literal, "@") {
 		// Procedure variable
 		procRef.ProcedureReference = &ast.ProcedureReferenceName{
 			ProcedureVariable: &ast.VariableReference{Name: p.curTok.Literal},
 		}
 		p.nextToken()
-	} else {
+	} else if p.curTok.Type != TokenEOF && p.curTok.Type != TokenSemicolon {
 		// Procedure name
 		son, err := p.parseSchemaObjectName()
 		if err != nil {
 			return nil, err
 		}
+		pr := &ast.ProcedureReference{Name: son}
+
+		// Check for procedure number: ;number
+		if p.curTok.Type == TokenSemicolon {
+			p.nextToken() // consume ;
+			if p.curTok.Type == TokenNumber {
+				pr.Number = &ast.IntegerLiteral{
+					LiteralType: "Integer",
+					Value:       p.curTok.Literal,
+				}
+				p.nextToken()
+			}
+		}
+
 		procRef.ProcedureReference = &ast.ProcedureReferenceName{
-			ProcedureReference: &ast.ProcedureReference{Name: son},
+			ProcedureReference: pr,
 		}
 	}
 
@@ -1015,11 +1072,83 @@ func (p *Parser) parseExecuteContextForSpec() (*ast.ExecuteContext, error) {
 func (p *Parser) parseExecuteParameter() (*ast.ExecuteParameter, error) {
 	param := &ast.ExecuteParameter{IsOutput: false}
 
-	expr, err := p.parseScalarExpression()
-	if err != nil {
-		return nil, err
+	// Check for DEFAULT keyword
+	if strings.ToUpper(p.curTok.Literal) == "DEFAULT" {
+		param.ParameterValue = &ast.DefaultLiteral{LiteralType: "Default", Value: "DEFAULT"}
+		p.nextToken()
+		return param, nil
+	}
+
+	// Check for named parameter: @name = value
+	if p.curTok.Type == TokenIdent && strings.HasPrefix(p.curTok.Literal, "@") {
+		varName := p.curTok.Literal
+		p.nextToken()
+
+		if p.curTok.Type == TokenEquals {
+			// Named parameter
+			p.nextToken() // consume =
+			param.Variable = &ast.VariableReference{Name: varName}
+
+			// Check for DEFAULT keyword as value
+			if strings.ToUpper(p.curTok.Literal) == "DEFAULT" {
+				param.ParameterValue = &ast.DefaultLiteral{LiteralType: "Default", Value: "DEFAULT"}
+				p.nextToken()
+			} else {
+				// Parse the parameter value
+				expr, err := p.parseScalarExpression()
+				if err != nil {
+					return nil, err
+				}
+				param.ParameterValue = expr
+			}
+		} else {
+			// Just a variable as value (not a named parameter)
+			param.ParameterValue = &ast.VariableReference{Name: varName}
+		}
+	} else {
+		// Check for bare identifier as IdentifierLiteral (e.g., EXEC sp_addtype birthday, datetime)
+		// Only if it's not followed by . or ( which would indicate a column/function reference
+		if p.curTok.Type == TokenIdent && !strings.HasPrefix(p.curTok.Literal, "@") {
+			upper := strings.ToUpper(p.curTok.Literal)
+			// Skip keywords that are expression starters
+			isKeyword := upper == "NULL" || upper == "DEFAULT" || upper == "NOT" ||
+				upper == "CASE" || upper == "EXISTS" || upper == "CAST" ||
+				upper == "CONVERT" || upper == "COALESCE" || upper == "NULLIF"
+			if !isKeyword && p.peekTok.Type != TokenDot && p.peekTok.Type != TokenLParen {
+				// Plain identifier - treat as IdentifierLiteral
+				quoteType := "NotQuoted"
+				if strings.HasPrefix(p.curTok.Literal, "[") {
+					quoteType = "SquareBracket"
+				}
+				param.ParameterValue = &ast.IdentifierLiteral{
+					LiteralType: "Identifier",
+					QuoteType:   quoteType,
+					Value:       p.curTok.Literal,
+				}
+				p.nextToken()
+			} else {
+				// Regular value expression
+				expr, err := p.parseScalarExpression()
+				if err != nil {
+					return nil, err
+				}
+				param.ParameterValue = expr
+			}
+		} else {
+			// Regular value expression
+			expr, err := p.parseScalarExpression()
+			if err != nil {
+				return nil, err
+			}
+			param.ParameterValue = expr
+		}
+	}
+
+	// Check for OUTPUT modifier
+	if strings.ToUpper(p.curTok.Literal) == "OUTPUT" || strings.ToUpper(p.curTok.Literal) == "OUT" {
+		param.IsOutput = true
+		p.nextToken()
 	}
-	param.ParameterValue = expr
 
 	return param, nil
 }

parser/testdata/BaselinesCommon_ExecuteStatementTests/metadata.json

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