alter_database_set_statement.go

package ast

// AlterDatabaseSetStatement represents ALTER DATABASE ... SET statement
type AlterDatabaseSetStatement struct {
	DatabaseName      *Identifier
	UseCurrent        bool
	WithManualCutover bool
	Options           []DatabaseOption
	Termination       *AlterDatabaseTermination
}

// AlterDatabaseTermination represents the termination clause (WITH NO_WAIT, WITH ROLLBACK AFTER N, WITH ROLLBACK IMMEDIATE)
type AlterDatabaseTermination struct {
	NoWait            bool
	ImmediateRollback bool
	RollbackAfter     ScalarExpression
}

func (a *AlterDatabaseTermination) node() {}

func (a *AlterDatabaseSetStatement) node()      {}
func (a *AlterDatabaseSetStatement) statement() {}

// DatabaseOption is an interface for database options
type DatabaseOption interface {
	Node
	databaseOption()
}

// AcceleratedDatabaseRecoveryDatabaseOption represents ACCELERATED_DATABASE_RECOVERY option
type AcceleratedDatabaseRecoveryDatabaseOption struct {
	OptionKind  string // "AcceleratedDatabaseRecovery"
	OptionState string // "On" or "Off"
}

func (a *AcceleratedDatabaseRecoveryDatabaseOption) node()           {}
func (a *AcceleratedDatabaseRecoveryDatabaseOption) databaseOption() {}

// OnOffDatabaseOption represents a simple ON/OFF database option
type OnOffDatabaseOption struct {
	OptionKind  string // "TemporalHistoryRetention", etc.
	OptionState string // "On" or "Off"
}

func (o *OnOffDatabaseOption) node()           {}
func (o *OnOffDatabaseOption) databaseOption() {}

// DelayedDurabilityDatabaseOption represents DELAYED_DURABILITY option
type DelayedDurabilityDatabaseOption struct {
	OptionKind string // "DelayedDurability"
	Value      string // "Disabled", "Allowed", "Forced"
}

func (d *DelayedDurabilityDatabaseOption) node()           {}
func (d *DelayedDurabilityDatabaseOption) databaseOption() {}

// AutoCreateStatisticsDatabaseOption represents AUTO_CREATE_STATISTICS option with optional INCREMENTAL
type AutoCreateStatisticsDatabaseOption struct {
	OptionKind       string // "AutoCreateStatistics"
	OptionState      string // "On" or "Off"
	HasIncremental   bool   // Whether INCREMENTAL is specified
	IncrementalState string // "On" or "Off"
}

func (a *AutoCreateStatisticsDatabaseOption) node()           {}
func (a *AutoCreateStatisticsDatabaseOption) databaseOption() {}

// IdentifierDatabaseOption represents a database option with an identifier value
type IdentifierDatabaseOption struct {
	OptionKind string      `json:"OptionKind,omitempty"` // "CatalogCollation"
	Value      *Identifier `json:"Value,omitempty"`
}

func (i *IdentifierDatabaseOption) node()           {}
func (i *IdentifierDatabaseOption) databaseOption() {}

// CreateDatabaseOption is an interface for CREATE DATABASE options (can be DatabaseOption)
type CreateDatabaseOption interface {
	node()
	createDatabaseOption()
}

// Make existing database options implement CreateDatabaseOption
func (o *OnOffDatabaseOption) createDatabaseOption()            {}
func (i *IdentifierDatabaseOption) createDatabaseOption()       {}
func (d *DelayedDurabilityDatabaseOption) createDatabaseOption() {}

// SimpleDatabaseOption represents a simple database option with just OptionKind (e.g., ENABLE_BROKER)
type SimpleDatabaseOption struct {
	OptionKind string `json:"OptionKind,omitempty"`
}

func (d *SimpleDatabaseOption) node()                 {}
func (d *SimpleDatabaseOption) createDatabaseOption() {}
func (d *SimpleDatabaseOption) databaseOption()       {}

// MaxSizeDatabaseOption represents a MAXSIZE option.
type MaxSizeDatabaseOption struct {
	OptionKind string           `json:"OptionKind,omitempty"`
	MaxSize    ScalarExpression `json:"MaxSize,omitempty"`
	Units      string           `json:"Units,omitempty"` // "GB", "TB", etc.
}

func (m *MaxSizeDatabaseOption) node()                 {}
func (m *MaxSizeDatabaseOption) databaseOption()       {}
func (m *MaxSizeDatabaseOption) createDatabaseOption() {}

// LiteralDatabaseOption represents a database option with a literal value (e.g., EDITION).
type LiteralDatabaseOption struct {
	OptionKind string           `json:"OptionKind,omitempty"`
	Value      ScalarExpression `json:"Value,omitempty"`
}

func (l *LiteralDatabaseOption) node()                 {}
func (l *LiteralDatabaseOption) databaseOption()       {}
func (l *LiteralDatabaseOption) createDatabaseOption() {}

// ElasticPoolSpecification represents SERVICE_OBJECTIVE = ELASTIC_POOL(name = poolname)
type ElasticPoolSpecification struct {
	ElasticPoolName *Identifier
	OptionKind      string // "ServiceObjective"
}

func (e *ElasticPoolSpecification) node()                 {}
func (e *ElasticPoolSpecification) databaseOption()       {}
func (e *ElasticPoolSpecification) createDatabaseOption() {}

// AlterDatabaseAddFileStatement represents ALTER DATABASE ... ADD FILE statement
type AlterDatabaseAddFileStatement struct {
	DatabaseName     *Identifier
	FileDeclarations []*FileDeclaration
	FileGroup        *Identifier
	IsLog            bool
	UseCurrent       bool
}

func (a *AlterDatabaseAddFileStatement) node()      {}
func (a *AlterDatabaseAddFileStatement) statement() {}

// AlterDatabaseAddFileGroupStatement represents ALTER DATABASE ... ADD FILEGROUP statement
type AlterDatabaseAddFileGroupStatement struct {
	DatabaseName              *Identifier
	FileGroupName             *Identifier
	ContainsFileStream        bool
	ContainsMemoryOptimizedData bool
	UseCurrent                bool
}

func (a *AlterDatabaseAddFileGroupStatement) node()      {}
func (a *AlterDatabaseAddFileGroupStatement) statement() {}

// AlterDatabaseModifyFileStatement represents ALTER DATABASE ... MODIFY FILE statement
type AlterDatabaseModifyFileStatement struct {
	DatabaseName    *Identifier
	FileDeclaration *FileDeclaration
	UseCurrent      bool
}

func (a *AlterDatabaseModifyFileStatement) node()      {}
func (a *AlterDatabaseModifyFileStatement) statement() {}

// AlterDatabaseModifyFileGroupStatement represents ALTER DATABASE ... MODIFY FILEGROUP statement
type AlterDatabaseModifyFileGroupStatement struct {
	DatabaseName       *Identifier
	FileGroupName      *Identifier
	MakeDefault        bool
	UpdatabilityOption string // "ReadOnly", "ReadWrite", "ReadOnlyOld", "ReadWriteOld", or ""
	NewFileGroupName   *Identifier
	Termination        *AlterDatabaseTermination
	UseCurrent         bool
}

func (a *AlterDatabaseModifyFileGroupStatement) node()      {}
func (a *AlterDatabaseModifyFileGroupStatement) statement() {}

// AlterDatabaseRebuildLogStatement represents ALTER DATABASE ... REBUILD LOG statement
type AlterDatabaseRebuildLogStatement struct {
	DatabaseName    *Identifier
	FileDeclaration *FileDeclaration
	UseCurrent      bool
}

func (a *AlterDatabaseRebuildLogStatement) node()      {}
func (a *AlterDatabaseRebuildLogStatement) statement() {}

// AlterDatabaseModifyNameStatement represents ALTER DATABASE ... MODIFY NAME statement
type AlterDatabaseModifyNameStatement struct {
	DatabaseName *Identifier
	NewName      *Identifier
}

func (a *AlterDatabaseModifyNameStatement) node()      {}
func (a *AlterDatabaseModifyNameStatement) statement() {}

// AlterDatabaseRemoveFileStatement represents ALTER DATABASE ... REMOVE FILE statement
type AlterDatabaseRemoveFileStatement struct {
	DatabaseName *Identifier
	FileName     *Identifier
}

func (a *AlterDatabaseRemoveFileStatement) node()      {}
func (a *AlterDatabaseRemoveFileStatement) statement() {}

// AlterDatabaseRemoveFileGroupStatement represents ALTER DATABASE ... REMOVE FILEGROUP statement
type AlterDatabaseRemoveFileGroupStatement struct {
	DatabaseName  *Identifier
	FileGroupName *Identifier
	UseCurrent    bool
}

func (a *AlterDatabaseRemoveFileGroupStatement) node()      {}
func (a *AlterDatabaseRemoveFileGroupStatement) statement() {}

// AlterDatabaseCollateStatement represents ALTER DATABASE ... COLLATE statement
type AlterDatabaseCollateStatement struct {
	DatabaseName *Identifier
	Collation    *Identifier
}

func (a *AlterDatabaseCollateStatement) node()      {}
func (a *AlterDatabaseCollateStatement) statement() {}

// AlterDatabaseScopedConfigurationClearStatement represents ALTER DATABASE SCOPED CONFIGURATION CLEAR statement
type AlterDatabaseScopedConfigurationClearStatement struct {
	Option    *DatabaseConfigurationClearOption
	Secondary bool
}

func (a *AlterDatabaseScopedConfigurationClearStatement) node()      {}
func (a *AlterDatabaseScopedConfigurationClearStatement) statement() {}

// DatabaseConfigurationClearOption represents a CLEAR option
type DatabaseConfigurationClearOption struct {
	OptionKind string           // "ProcedureCache"
	PlanHandle ScalarExpression // Optional binary plan handle
}

func (d *DatabaseConfigurationClearOption) node() {}

// RemoteDataArchiveDatabaseOption represents REMOTE_DATA_ARCHIVE database option
type RemoteDataArchiveDatabaseOption struct {
	OptionKind  string                       // "RemoteDataArchive"
	OptionState string                       // "On", "Off", "NotSet"
	Settings    []RemoteDataArchiveDbSetting // Settings like SERVER, CREDENTIAL, FEDERATED_SERVICE_ACCOUNT
}

func (r *RemoteDataArchiveDatabaseOption) node()           {}
func (r *RemoteDataArchiveDatabaseOption) databaseOption() {}

// RemoteDataArchiveDbSetting is an interface for Remote Data Archive settings
type RemoteDataArchiveDbSetting interface {
	Node
	remoteDataArchiveDbSetting()
}

// RemoteDataArchiveDbServerSetting represents the SERVER setting
type RemoteDataArchiveDbServerSetting struct {
	SettingKind string           // "Server"
	Server      ScalarExpression // The server string literal
}

func (r *RemoteDataArchiveDbServerSetting) node()                      {}
func (r *RemoteDataArchiveDbServerSetting) remoteDataArchiveDbSetting() {}

// RemoteDataArchiveDbCredentialSetting represents the CREDENTIAL setting
type RemoteDataArchiveDbCredentialSetting struct {
	SettingKind string      // "Credential"
	Credential  *Identifier // The credential name
}

func (r *RemoteDataArchiveDbCredentialSetting) node()                      {}
func (r *RemoteDataArchiveDbCredentialSetting) remoteDataArchiveDbSetting() {}

// RemoteDataArchiveDbFederatedServiceAccountSetting represents the FEDERATED_SERVICE_ACCOUNT setting
type RemoteDataArchiveDbFederatedServiceAccountSetting struct {
	SettingKind string // "FederatedServiceAccount"
	IsOn        bool   // true for ON, false for OFF
}

func (r *RemoteDataArchiveDbFederatedServiceAccountSetting) node()                      {}
func (r *RemoteDataArchiveDbFederatedServiceAccountSetting) remoteDataArchiveDbSetting() {}

// ChangeTrackingDatabaseOption represents the CHANGE_TRACKING database option
type ChangeTrackingDatabaseOption struct {
	OptionKind  string                            // "ChangeTracking"
	OptionState string                            // "On", "Off", "NotSet"
	Details     []ChangeTrackingOptionDetail      // AUTO_CLEANUP, CHANGE_RETENTION
}

func (c *ChangeTrackingDatabaseOption) node()           {}
func (c *ChangeTrackingDatabaseOption) databaseOption() {}

// ChangeTrackingOptionDetail is an interface for change tracking option details
type ChangeTrackingOptionDetail interface {
	Node
	changeTrackingOptionDetail()
}

// AutoCleanupChangeTrackingOptionDetail represents AUTO_CLEANUP option
type AutoCleanupChangeTrackingOptionDetail struct {
	IsOn bool
}

func (a *AutoCleanupChangeTrackingOptionDetail) node()                        {}
func (a *AutoCleanupChangeTrackingOptionDetail) changeTrackingOptionDetail() {}

// ChangeRetentionChangeTrackingOptionDetail represents CHANGE_RETENTION option
type ChangeRetentionChangeTrackingOptionDetail struct {
	RetentionPeriod ScalarExpression
	Unit            string // "Days", "Hours", "Minutes"
}

func (c *ChangeRetentionChangeTrackingOptionDetail) node()                        {}
func (c *ChangeRetentionChangeTrackingOptionDetail) changeTrackingOptionDetail() {}

// RecoveryDatabaseOption represents RECOVERY database option
type RecoveryDatabaseOption struct {
	OptionKind string // "Recovery"
	Value      string // "Full", "BulkLogged", "Simple"
}

func (r *RecoveryDatabaseOption) node()           {}
func (r *RecoveryDatabaseOption) databaseOption() {}

// CursorDefaultDatabaseOption represents CURSOR_DEFAULT database option
type CursorDefaultDatabaseOption struct {
	OptionKind string // "CursorDefault"
	IsLocal    bool   // true for LOCAL, false for GLOBAL
}

func (c *CursorDefaultDatabaseOption) node()           {}
func (c *CursorDefaultDatabaseOption) databaseOption() {}

// PageVerifyDatabaseOption represents PAGE_VERIFY database option
type PageVerifyDatabaseOption struct {
	OptionKind string // "PageVerify"
	Value      string // "Checksum", "None", "TornPageDetection"
}

func (p *PageVerifyDatabaseOption) node()           {}
func (p *PageVerifyDatabaseOption) databaseOption() {}

// PartnerDatabaseOption represents PARTNER database mirroring option
type PartnerDatabaseOption struct {
	OptionKind    string           // "Partner"
	PartnerServer ScalarExpression // For PARTNER = 'server'
	PartnerOption string           // "PartnerServer", "Failover", "ForceServiceAllowDataLoss", "Resume", "SafetyFull", "SafetyOff", "Suspend", "Timeout"
	Timeout       ScalarExpression // For PARTNER TIMEOUT value
}

func (p *PartnerDatabaseOption) node()           {}
func (p *PartnerDatabaseOption) databaseOption() {}

// WitnessDatabaseOption represents WITNESS database mirroring option
type WitnessDatabaseOption struct {
	OptionKind    string           // "Witness"
	WitnessServer ScalarExpression // For WITNESS = 'server'
	IsOff         bool             // For WITNESS OFF
}

func (w *WitnessDatabaseOption) node()           {}
func (w *WitnessDatabaseOption) databaseOption() {}

// ParameterizationDatabaseOption represents PARAMETERIZATION database option
type ParameterizationDatabaseOption struct {
	OptionKind string // "Parameterization"
	IsSimple   bool   // true for SIMPLE, false for FORCED
}

func (p *ParameterizationDatabaseOption) node()           {}
func (p *ParameterizationDatabaseOption) databaseOption() {}

// GenericDatabaseOption represents a simple database option with just OptionKind
type GenericDatabaseOption struct {
	OptionKind string // e.g., "Emergency", "ErrorBrokerConversations", "EnableBroker", etc.
}

func (g *GenericDatabaseOption) node()           {}
func (g *GenericDatabaseOption) databaseOption() {}