Fix all remaining tests

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/alter_authorization_statement.go

@@ -0,0 +1,11 @@
+package ast
+
+// AlterAuthorizationStatement represents an ALTER AUTHORIZATION statement
+type AlterAuthorizationStatement struct {
+	SecurityTargetObject *SecurityTargetObject
+	ToSchemaOwner        bool
+	PrincipalName        *Identifier
+}
+
+func (s *AlterAuthorizationStatement) node()      {}
+func (s *AlterAuthorizationStatement) statement() {}

ast/alter_availability_group_statement.go

@@ -0,0 +1,45 @@
+package ast
+
+// AlterAvailabilityGroupStatement represents ALTER AVAILABILITY GROUP statement
+type AlterAvailabilityGroupStatement struct {
+	Name              *Identifier
+	StatementType     string // "Action", "AddDatabase", "RemoveDatabase", "AddReplica", "ModifyReplica", "RemoveReplica", "Set"
+	Action            AvailabilityGroupAction
+	Databases         []*Identifier
+	Replicas          []*AvailabilityReplica
+	Options           []AvailabilityGroupOption
+}
+
+func (s *AlterAvailabilityGroupStatement) node()      {}
+func (s *AlterAvailabilityGroupStatement) statement() {}
+
+// AvailabilityGroupAction is an interface for availability group actions
+type AvailabilityGroupAction interface {
+	node()
+	availabilityGroupAction()
+}
+
+// AlterAvailabilityGroupAction represents simple actions like JOIN, ONLINE, OFFLINE
+type AlterAvailabilityGroupAction struct {
+	ActionType string // "Join", "ForceFailoverAllowDataLoss", "Online", "Offline"
+}
+
+func (a *AlterAvailabilityGroupAction) node()                    {}
+func (a *AlterAvailabilityGroupAction) availabilityGroupAction() {}
+
+// AlterAvailabilityGroupFailoverAction represents FAILOVER action with options
+type AlterAvailabilityGroupFailoverAction struct {
+	ActionType string // "Failover"
+	Options    []*AlterAvailabilityGroupFailoverOption
+}
+
+func (a *AlterAvailabilityGroupFailoverAction) node()                    {}
+func (a *AlterAvailabilityGroupFailoverAction) availabilityGroupAction() {}
+
+// AlterAvailabilityGroupFailoverOption represents an option for failover action
+type AlterAvailabilityGroupFailoverOption struct {
+	OptionKind string           // "Target"
+	Value      ScalarExpression // StringLiteral for target server
+}
+
+func (o *AlterAvailabilityGroupFailoverOption) node() {}

ast/alter_database_set_statement.go

@@ -115,6 +115,58 @@ func (l *LiteralDatabaseOption) node()                 {}
 func (l *LiteralDatabaseOption) databaseOption()       {}
 func (l *LiteralDatabaseOption) createDatabaseOption() {}
 
+// AutomaticTuningDatabaseOption represents AUTOMATIC_TUNING option
+type AutomaticTuningDatabaseOption struct {
+	OptionKind            string                   // "AutomaticTuning"
+	AutomaticTuningState  string                   // "Inherit", "Custom", "Auto", "NotSet"
+	Options               []AutomaticTuningOption  // Sub-options like CREATE_INDEX, DROP_INDEX, etc.
+}
+
+func (a *AutomaticTuningDatabaseOption) node()           {}
+func (a *AutomaticTuningDatabaseOption) databaseOption() {}
+
+// AutomaticTuningOption is an interface for automatic tuning sub-options
+type AutomaticTuningOption interface {
+	Node
+	automaticTuningOption()
+}
+
+// AutomaticTuningCreateIndexOption represents CREATE_INDEX option
+type AutomaticTuningCreateIndexOption struct {
+	OptionKind string // "Create_Index"
+	Value      string // "On", "Off", "Default"
+}
+
+func (a *AutomaticTuningCreateIndexOption) node()                  {}
+func (a *AutomaticTuningCreateIndexOption) automaticTuningOption() {}
+
+// AutomaticTuningDropIndexOption represents DROP_INDEX option
+type AutomaticTuningDropIndexOption struct {
+	OptionKind string // "Drop_Index"
+	Value      string // "On", "Off", "Default"
+}
+
+func (a *AutomaticTuningDropIndexOption) node()                  {}
+func (a *AutomaticTuningDropIndexOption) automaticTuningOption() {}
+
+// AutomaticTuningForceLastGoodPlanOption represents FORCE_LAST_GOOD_PLAN option
+type AutomaticTuningForceLastGoodPlanOption struct {
+	OptionKind string // "Force_Last_Good_Plan"
+	Value      string // "On", "Off", "Default"
+}
+
+func (a *AutomaticTuningForceLastGoodPlanOption) node()                  {}
+func (a *AutomaticTuningForceLastGoodPlanOption) automaticTuningOption() {}
+
+// AutomaticTuningMaintainIndexOption represents MAINTAIN_INDEX option
+type AutomaticTuningMaintainIndexOption struct {
+	OptionKind string // "Maintain_Index"
+	Value      string // "On", "Off", "Default"
+}
+
+func (a *AutomaticTuningMaintainIndexOption) node()                  {}
+func (a *AutomaticTuningMaintainIndexOption) automaticTuningOption() {}
+
 // ElasticPoolSpecification represents SERVICE_OBJECTIVE = ELASTIC_POOL(name = poolname)
 type ElasticPoolSpecification struct {
 	ElasticPoolName *Identifier
@@ -377,3 +429,184 @@ type GenericDatabaseOption struct {
 
 func (g *GenericDatabaseOption) node()           {}
 func (g *GenericDatabaseOption) databaseOption() {}
+
+// HadrDatabaseOption represents ALTER DATABASE SET HADR {SUSPEND|RESUME|OFF}
+type HadrDatabaseOption struct {
+	HadrOption string // "Suspend", "Resume", "Off"
+	OptionKind string // "Hadr"
+}
+
+func (h *HadrDatabaseOption) node()           {}
+func (h *HadrDatabaseOption) databaseOption() {}
+
+// HadrAvailabilityGroupDatabaseOption represents ALTER DATABASE SET HADR AVAILABILITY GROUP = name
+type HadrAvailabilityGroupDatabaseOption struct {
+	GroupName  *Identifier
+	HadrOption string // "AvailabilityGroup"
+	OptionKind string // "Hadr"
+}
+
+func (h *HadrAvailabilityGroupDatabaseOption) node()           {}
+func (h *HadrAvailabilityGroupDatabaseOption) databaseOption() {}
+
+// TargetRecoveryTimeDatabaseOption represents TARGET_RECOVERY_TIME database option
+type TargetRecoveryTimeDatabaseOption struct {
+	OptionKind   string           // "TargetRecoveryTime"
+	RecoveryTime ScalarExpression // Integer literal
+	Unit         string           // "Seconds" or "Minutes"
+}
+
+func (t *TargetRecoveryTimeDatabaseOption) node()           {}
+func (t *TargetRecoveryTimeDatabaseOption) databaseOption() {}
+
+// QueryStoreDatabaseOption represents QUERY_STORE database option
+type QueryStoreDatabaseOption struct {
+	OptionKind  string             // "QueryStore"
+	OptionState string             // "On", "Off", "NotSet"
+	Clear       bool               // QUERY_STORE CLEAR [ALL]
+	ClearAll    bool               // QUERY_STORE CLEAR ALL
+	Options     []QueryStoreOption // Sub-options
+}
+
+func (q *QueryStoreDatabaseOption) node()           {}
+func (q *QueryStoreDatabaseOption) databaseOption() {}
+
+// QueryStoreOption is an interface for query store sub-options
+type QueryStoreOption interface {
+	Node
+	queryStoreOption()
+}
+
+// QueryStoreDesiredStateOption represents DESIRED_STATE option
+type QueryStoreDesiredStateOption struct {
+	OptionKind             string // "Desired_State"
+	Value                  string // "ReadOnly", "ReadWrite", "Off"
+	OperationModeSpecified bool   // Whether OPERATION_MODE was explicitly specified
+}
+
+func (q *QueryStoreDesiredStateOption) node()             {}
+func (q *QueryStoreDesiredStateOption) queryStoreOption() {}
+
+// QueryStoreCapturePolicyOption represents QUERY_CAPTURE_MODE option
+type QueryStoreCapturePolicyOption struct {
+	OptionKind string // "Query_Capture_Mode"
+	Value      string // "ALL", "AUTO", "NONE", "CUSTOM"
+}
+
+func (q *QueryStoreCapturePolicyOption) node()             {}
+func (q *QueryStoreCapturePolicyOption) queryStoreOption() {}
+
+// QueryStoreSizeCleanupPolicyOption represents SIZE_BASED_CLEANUP_MODE option
+type QueryStoreSizeCleanupPolicyOption struct {
+	OptionKind string // "Size_Based_Cleanup_Mode"
+	Value      string // "OFF", "AUTO"
+}
+
+func (q *QueryStoreSizeCleanupPolicyOption) node()             {}
+func (q *QueryStoreSizeCleanupPolicyOption) queryStoreOption() {}
+
+// QueryStoreIntervalLengthOption represents INTERVAL_LENGTH_MINUTES option
+type QueryStoreIntervalLengthOption struct {
+	OptionKind          string           // "Interval_Length_Minutes"
+	StatsIntervalLength ScalarExpression // Integer literal
+}
+
+func (q *QueryStoreIntervalLengthOption) node()             {}
+func (q *QueryStoreIntervalLengthOption) queryStoreOption() {}
+
+// QueryStoreMaxStorageSizeOption represents MAX_STORAGE_SIZE_MB option
+type QueryStoreMaxStorageSizeOption struct {
+	OptionKind string           // "Current_Storage_Size_MB" (note: uses Current_Storage_Size_MB as OptionKind)
+	MaxQdsSize ScalarExpression // Integer literal
+}
+
+func (q *QueryStoreMaxStorageSizeOption) node()             {}
+func (q *QueryStoreMaxStorageSizeOption) queryStoreOption() {}
+
+// QueryStoreMaxPlansPerQueryOption represents MAX_PLANS_PER_QUERY option
+type QueryStoreMaxPlansPerQueryOption struct {
+	OptionKind       string           // "Max_Plans_Per_Query"
+	MaxPlansPerQuery ScalarExpression // Integer literal
+}
+
+func (q *QueryStoreMaxPlansPerQueryOption) node()             {}
+func (q *QueryStoreMaxPlansPerQueryOption) queryStoreOption() {}
+
+// QueryStoreTimeCleanupPolicyOption represents STALE_QUERY_THRESHOLD_DAYS option (in CLEANUP_POLICY)
+type QueryStoreTimeCleanupPolicyOption struct {
+	OptionKind          string           // "Stale_Query_Threshold_Days"
+	StaleQueryThreshold ScalarExpression // Integer literal
+}
+
+func (q *QueryStoreTimeCleanupPolicyOption) node()             {}
+func (q *QueryStoreTimeCleanupPolicyOption) queryStoreOption() {}
+
+// QueryStoreWaitStatsCaptureOption represents WAIT_STATS_CAPTURE_MODE option
+type QueryStoreWaitStatsCaptureOption struct {
+	OptionKind  string // "Wait_Stats_Capture_Mode"
+	OptionState string // "On", "Off"
+}
+
+func (q *QueryStoreWaitStatsCaptureOption) node()             {}
+func (q *QueryStoreWaitStatsCaptureOption) queryStoreOption() {}
+
+// QueryStoreDataFlushIntervalOption represents FLUSH_INTERVAL_SECONDS/DATA_FLUSH_INTERVAL_SECONDS option
+type QueryStoreDataFlushIntervalOption struct {
+	OptionKind    string           // "Flush_Interval_Seconds"
+	FlushInterval ScalarExpression // Integer literal
+}
+
+func (q *QueryStoreDataFlushIntervalOption) node()             {}
+func (q *QueryStoreDataFlushIntervalOption) queryStoreOption() {}
+
+// AlterDatabaseScopedConfigurationSetStatement represents ALTER DATABASE SCOPED CONFIGURATION SET statement
+type AlterDatabaseScopedConfigurationSetStatement struct {
+	Secondary bool
+	Option    DatabaseConfigurationSetOption
+}
+
+func (a *AlterDatabaseScopedConfigurationSetStatement) node()      {}
+func (a *AlterDatabaseScopedConfigurationSetStatement) statement() {}
+
+// DatabaseConfigurationSetOption is an interface for scoped configuration options
+type DatabaseConfigurationSetOption interface {
+	Node
+	databaseConfigurationSetOption()
+}
+
+// MaxDopConfigurationOption represents MAXDOP configuration option
+type MaxDopConfigurationOption struct {
+	OptionKind string           // "MaxDop"
+	Value      ScalarExpression // Integer value
+	Primary    bool             // true if set to PRIMARY
+}
+
+func (m *MaxDopConfigurationOption) node()                         {}
+func (m *MaxDopConfigurationOption) databaseConfigurationSetOption() {}
+
+// OnOffPrimaryConfigurationOption represents ON/OFF/PRIMARY configuration option
+type OnOffPrimaryConfigurationOption struct {
+	OptionKind  string // "LegacyCardinalityEstimate", "ParameterSniffing", "QueryOptimizerHotFixes"
+	OptionState string // "On", "Off", "Primary"
+}
+
+func (o *OnOffPrimaryConfigurationOption) node()                         {}
+func (o *OnOffPrimaryConfigurationOption) databaseConfigurationSetOption() {}
+
+// GenericConfigurationOption represents a generic configuration option
+type GenericConfigurationOption struct {
+	OptionKind         string                       // "MaxDop"
+	GenericOptionKind  *Identifier                  // The custom option name
+	GenericOptionState *IdentifierOrScalarExpression // The value (identifier or scalar)
+}
+
+func (g *GenericConfigurationOption) node()                         {}
+func (g *GenericConfigurationOption) databaseConfigurationSetOption() {}
+
+// IdentifierOrScalarExpression represents either an identifier or a scalar expression
+type IdentifierOrScalarExpression struct {
+	Identifier       *Identifier
+	ScalarExpression ScalarExpression
+}
+
+func (i *IdentifierOrScalarExpression) node() {}

ast/alter_index_statement.go

@@ -20,12 +20,29 @@ type SelectiveXmlIndexPromotedPath struct {
 	Name           *Identifier
 	Path           *StringLiteral
 	XQueryDataType *StringLiteral
+	SQLDataType    *SqlDataTypeReference
 	MaxLength      *IntegerLiteral
 	IsSingleton    bool
 }
 
 func (s *SelectiveXmlIndexPromotedPath) node() {}
 
+// CreateSelectiveXmlIndexStatement represents CREATE SELECTIVE XML INDEX statement
+type CreateSelectiveXmlIndexStatement struct {
+	Name              *Identifier
+	OnName            *SchemaObjectName
+	XmlColumn         *Identifier
+	IsSecondary       bool
+	UsingXmlIndexName *Identifier     // For secondary indexes
+	PathName          *Identifier     // For secondary indexes
+	PromotedPaths     []*SelectiveXmlIndexPromotedPath
+	XmlNamespaces     *XmlNamespaces
+	IndexOptions      []IndexOption
+}
+
+func (s *CreateSelectiveXmlIndexStatement) statement() {}
+func (s *CreateSelectiveXmlIndexStatement) node()      {}
+
 // XmlNamespaces represents a WITH XMLNAMESPACES clause
 type XmlNamespaces struct {
 	XmlNamespacesElements []XmlNamespacesElement