Add FileGroupDefinition parsing for CREATE DATABASE ON clause

Implements support for parsing CREATE DATABASE with ON clause including:
- FileGroupDefinition with FILEGROUP, PRIMARY, CONTAINS FILESTREAM/MEMORY_OPTIMIZED_DATA
- FileDeclaration with NAME, FILENAME, SIZE, MAXSIZE, FILEGROWTH options
- LOG ON clause for log file declarations
- COLLATE clause
- FOR ATTACH mode

Enables 2 previously failing tests:
- AlterCreateDatabaseStatementTests120
- Baselines120_AlterCreateDatabaseStatementTests120

Author: claude

ast/create_simple_statements.go

@@ -2,10 +2,13 @@ package ast
 
 // CreateDatabaseStatement represents a CREATE DATABASE statement.
 type CreateDatabaseStatement struct {
-	DatabaseName *Identifier            `json:"DatabaseName,omitempty"`
-	Options      []CreateDatabaseOption `json:"Options,omitempty"`
-	AttachMode   string                 `json:"AttachMode,omitempty"` // "None", "Attach", "AttachRebuildLog"
-	CopyOf       *MultiPartIdentifier   `json:"CopyOf,omitempty"`     // For AS COPY OF syntax
+	DatabaseName *Identifier              `json:"DatabaseName,omitempty"`
+	Options      []CreateDatabaseOption   `json:"Options,omitempty"`
+	AttachMode   string                   `json:"AttachMode,omitempty"` // "None", "Attach", "AttachRebuildLog"
+	CopyOf       *MultiPartIdentifier     `json:"CopyOf,omitempty"`     // For AS COPY OF syntax
+	FileGroups   []*FileGroupDefinition   `json:"FileGroups,omitempty"`
+	LogOn        []*FileDeclaration       `json:"LogOn,omitempty"`
+	Collation    *Identifier              `json:"Collation,omitempty"`
 }
 
 func (s *CreateDatabaseStatement) node()      {}

ast/file_declaration.go

@@ -0,0 +1,76 @@
+package ast
+
+// FileGroupDefinition represents a FILEGROUP definition in CREATE DATABASE
+type FileGroupDefinition struct {
+	Name                        *Identifier
+	FileDeclarations            []*FileDeclaration
+	IsDefault                   bool
+	ContainsFileStream          bool
+	ContainsMemoryOptimizedData bool
+}
+
+func (f *FileGroupDefinition) node() {}
+
+// FileDeclaration represents a file declaration within a filegroup
+type FileDeclaration struct {
+	Options   []FileDeclarationOption
+	IsPrimary bool
+}
+
+func (f *FileDeclaration) node() {}
+
+// FileDeclarationOption is an interface for file declaration options
+type FileDeclarationOption interface {
+	Node
+	fileDeclarationOption()
+}
+
+// NameFileDeclarationOption represents the NAME option for a file
+type NameFileDeclarationOption struct {
+	LogicalFileName *IdentifierOrValueExpression
+	IsNewName       bool
+	OptionKind      string // "Name" or "NewName"
+}
+
+func (n *NameFileDeclarationOption) node()                  {}
+func (n *NameFileDeclarationOption) fileDeclarationOption() {}
+
+// FileNameFileDeclarationOption represents the FILENAME option for a file
+type FileNameFileDeclarationOption struct {
+	OSFileName *StringLiteral
+	OptionKind string // "FileName"
+}
+
+func (f *FileNameFileDeclarationOption) node()                  {}
+func (f *FileNameFileDeclarationOption) fileDeclarationOption() {}
+
+// SizeFileDeclarationOption represents the SIZE option for a file
+type SizeFileDeclarationOption struct {
+	Size       ScalarExpression
+	Units      string // "KB", "MB", "GB", "TB", "Unspecified"
+	OptionKind string // "Size"
+}
+
+func (s *SizeFileDeclarationOption) node()                  {}
+func (s *SizeFileDeclarationOption) fileDeclarationOption() {}
+
+// MaxSizeFileDeclarationOption represents the MAXSIZE option for a file
+type MaxSizeFileDeclarationOption struct {
+	MaxSize    ScalarExpression
+	Units      string // "KB", "MB", "GB", "TB", "Unspecified"
+	Unlimited  bool
+	OptionKind string // "MaxSize"
+}
+
+func (m *MaxSizeFileDeclarationOption) node()                  {}
+func (m *MaxSizeFileDeclarationOption) fileDeclarationOption() {}
+
+// FileGrowthFileDeclarationOption represents the FILEGROWTH option for a file
+type FileGrowthFileDeclarationOption struct {
+	GrowthIncrement ScalarExpression
+	Units           string // "KB", "MB", "GB", "TB", "Percent", "Unspecified"
+	OptionKind      string // "FileGrowth"
+}
+
+func (f *FileGrowthFileDeclarationOption) node()                  {}
+func (f *FileGrowthFileDeclarationOption) fileDeclarationOption() {}

parser/marshal.go

@@ -8985,16 +8985,125 @@ func createDatabaseStatementToJSON(s *ast.CreateDatabaseStatement) jsonNode {
 		}
 		node["Options"] = opts
 	}
-	// AttachMode is output when there are Options or CopyOf
-	if (len(s.Options) > 0 || s.CopyOf != nil) && s.AttachMode != "" {
+	if len(s.FileGroups) > 0 {
+		fgs := make([]jsonNode, len(s.FileGroups))
+		for i, fg := range s.FileGroups {
+			fgs[i] = fileGroupDefinitionToJSON(fg)
+		}
+		node["FileGroups"] = fgs
+	}
+	if len(s.LogOn) > 0 {
+		logs := make([]jsonNode, len(s.LogOn))
+		for i, fd := range s.LogOn {
+			logs[i] = fileDeclarationToJSON(fd)
+		}
+		node["LogOn"] = logs
+	}
+	// AttachMode is output when there are FileGroups, Options, Collation, or CopyOf
+	if len(s.FileGroups) > 0 || len(s.Options) > 0 || s.Collation != nil || s.CopyOf != nil {
 		node["AttachMode"] = s.AttachMode
 	}
 	if s.CopyOf != nil {
 		node["CopyOf"] = multiPartIdentifierToJSON(s.CopyOf)
 	}
+	if s.Collation != nil {
+		node["Collation"] = identifierToJSON(s.Collation)
+	}
 	return node
 }
 
+func fileGroupDefinitionToJSON(fg *ast.FileGroupDefinition) jsonNode {
+	node := jsonNode{
+		"$type": "FileGroupDefinition",
+	}
+	if fg.Name != nil {
+		node["Name"] = identifierToJSON(fg.Name)
+	}
+	if len(fg.FileDeclarations) > 0 {
+		decls := make([]jsonNode, len(fg.FileDeclarations))
+		for i, fd := range fg.FileDeclarations {
+			decls[i] = fileDeclarationToJSON(fd)
+		}
+		node["FileDeclarations"] = decls
+	}
+	node["IsDefault"] = fg.IsDefault
+	node["ContainsFileStream"] = fg.ContainsFileStream
+	node["ContainsMemoryOptimizedData"] = fg.ContainsMemoryOptimizedData
+	return node
+}
+
+func fileDeclarationToJSON(fd *ast.FileDeclaration) jsonNode {
+	node := jsonNode{
+		"$type": "FileDeclaration",
+	}
+	if len(fd.Options) > 0 {
+		opts := make([]jsonNode, len(fd.Options))
+		for i, opt := range fd.Options {
+			opts[i] = fileDeclarationOptionToJSON(opt)
+		}
+		node["Options"] = opts
+	}
+	node["IsPrimary"] = fd.IsPrimary
+	return node
+}
+
+func fileDeclarationOptionToJSON(opt ast.FileDeclarationOption) jsonNode {
+	switch o := opt.(type) {
+	case *ast.NameFileDeclarationOption:
+		node := jsonNode{
+			"$type":      "NameFileDeclarationOption",
+			"IsNewName":  o.IsNewName,
+			"OptionKind": o.OptionKind,
+		}
+		if o.LogicalFileName != nil {
+			node["LogicalFileName"] = identifierOrValueExpressionToJSON(o.LogicalFileName)
+		}
+		return node
+	case *ast.FileNameFileDeclarationOption:
+		node := jsonNode{
+			"$type":      "FileNameFileDeclarationOption",
+			"OptionKind": o.OptionKind,
+		}
+		if o.OSFileName != nil {
+			node["OSFileName"] = stringLiteralToJSON(o.OSFileName)
+		}
+		return node
+	case *ast.SizeFileDeclarationOption:
+		node := jsonNode{
+			"$type":      "SizeFileDeclarationOption",
+			"Units":      o.Units,
+			"OptionKind": o.OptionKind,
+		}
+		if o.Size != nil {
+			node["Size"] = scalarExpressionToJSON(o.Size)
+		}
+		return node
+	case *ast.MaxSizeFileDeclarationOption:
+		node := jsonNode{
+			"$type":      "MaxSizeFileDeclarationOption",
+			"Units":      o.Units,
+			"Unlimited":  o.Unlimited,
+			"OptionKind": o.OptionKind,
+		}
+		if o.MaxSize != nil {
+			node["MaxSize"] = scalarExpressionToJSON(o.MaxSize)
+		}
+		return node
+	case *ast.FileGrowthFileDeclarationOption:
+		node := jsonNode{
+			"$type":      "FileGrowthFileDeclarationOption",
+			"Units":      o.Units,
+			"OptionKind": o.OptionKind,
+		}
+		if o.GrowthIncrement != nil {
+			node["GrowthIncrement"] = scalarExpressionToJSON(o.GrowthIncrement)
+		}
+		return node
+	default:
+		return jsonNode{"$type": "FileDeclarationOption"}
+	}
+}
+
 func createDatabaseOptionToJSON(opt ast.CreateDatabaseOption) jsonNode {
 	switch o := opt.(type) {
 	case *ast.OnOffDatabaseOption: