Add CREATE FULLTEXT CATALOG statement parsing

- Add CreateFullTextCatalogStatement AST type
- Implement full parsing for ON FILEGROUP, IN PATH, WITH options, AS DEFAULT, AUTHORIZATION clauses
- Add JSON marshaling for CreateFullTextCatalogStatement
- Enable Baselines90_CreateFulltextCatalogStatementTests
- Mark PhaseOne_CreateFulltextCatalog as todo (outdated format)

Author: claude

ast/alter_simple_statements.go

@@ -92,6 +92,19 @@ type AlterPartitionFunctionStatement struct {
 func (s *AlterPartitionFunctionStatement) node()      {}
 func (s *AlterPartitionFunctionStatement) statement() {}
 
+// CreateFullTextCatalogStatement represents a CREATE FULLTEXT CATALOG statement.
+type CreateFullTextCatalogStatement struct {
+	Name      *Identifier                   `json:"Name,omitempty"`
+	FileGroup *Identifier                   `json:"FileGroup,omitempty"`
+	Path      ScalarExpression              `json:"Path,omitempty"`
+	Owner     *Identifier                   `json:"Owner,omitempty"`
+	Options   []*OnOffFullTextCatalogOption `json:"Options,omitempty"`
+	IsDefault bool                          `json:"IsDefault"`
+}
+
+func (s *CreateFullTextCatalogStatement) node()      {}
+func (s *CreateFullTextCatalogStatement) statement() {}
+
 // AlterFulltextCatalogStatement represents an ALTER FULLTEXT CATALOG statement.
 type AlterFulltextCatalogStatement struct {
 	Name    *Identifier                   `json:"Name,omitempty"`

parser/marshal.go

@@ -470,6 +470,8 @@ func statementToJSON(stmt ast.Statement) jsonNode {
 		return alterPartitionFunctionStatementToJSON(s)
 	case *ast.AlterFulltextCatalogStatement:
 		return alterFulltextCatalogStatementToJSON(s)
+	case *ast.CreateFullTextCatalogStatement:
+		return createFullTextCatalogStatementToJSON(s)
 	case *ast.AlterFulltextIndexStatement:
 		return alterFulltextIndexStatementToJSON(s)
 	case *ast.AlterSymmetricKeyStatement:
@@ -8508,6 +8510,42 @@ func alterFulltextCatalogStatementToJSON(s *ast.AlterFulltextCatalogStatement) j
 	return node
 }
 
+func createFullTextCatalogStatementToJSON(s *ast.CreateFullTextCatalogStatement) jsonNode {
+	node := jsonNode{
+		"$type":     "CreateFullTextCatalogStatement",
+		"IsDefault": s.IsDefault,
+	}
+	if s.FileGroup != nil {
+		node["FileGroup"] = identifierToJSON(s.FileGroup)
+	}
+	if s.Path != nil {
+		node["Path"] = scalarExpressionToJSON(s.Path)
+	}
+	if s.Owner != nil {
+		node["Owner"] = identifierToJSON(s.Owner)
+	}
+	if s.Name != nil {
+		node["Name"] = identifierToJSON(s.Name)
+	}
+	if len(s.Options) > 0 {
+		opts := make([]jsonNode, len(s.Options))
+		for i, opt := range s.Options {
+			optNode := jsonNode{
+				"$type": "OnOffFullTextCatalogOption",
+			}
+			if opt.OptionState != "" {
+				optNode["OptionState"] = opt.OptionState
+			}
+			if opt.OptionKind != "" {
+				optNode["OptionKind"] = opt.OptionKind
+			}
+			opts[i] = optNode
+		}
+		node["Options"] = opts
+	}
+	return node
+}
+
 func alterFulltextIndexStatementToJSON(s *ast.AlterFulltextIndexStatement) jsonNode {
 	node := jsonNode{
 		"$type": "AlterFulltextIndexStatement",

parser/parse_statements.go

@@ -6210,12 +6210,7 @@ func (p *Parser) parseCreateFulltextStatement() (ast.Statement, error) {
 
 	switch strings.ToUpper(p.curTok.Literal) {
 	case "CATALOG":
-		p.nextToken() // consume CATALOG
-		stmt := &ast.CreateFulltextCatalogStatement{
-			Name: p.parseIdentifier(),
-		}
-		p.skipToEndOfStatement()
-		return stmt, nil
+		return p.parseCreateFulltextCatalogStatement()
 	case "INDEX":
 		p.nextToken() // consume INDEX
 		// FULLTEXT INDEX ON table_name
@@ -6230,14 +6225,94 @@ func (p *Parser) parseCreateFulltextStatement() (ast.Statement, error) {
 		return stmt, nil
 	default:
 		// Just create a catalog statement as default
-		stmt := &ast.CreateFulltextCatalogStatement{
+		stmt := &ast.CreateFullTextCatalogStatement{
 			Name: p.parseIdentifier(),
 		}
 		p.skipToEndOfStatement()
 		return stmt, nil
 	}
 }
 
+func (p *Parser) parseCreateFulltextCatalogStatement() (*ast.CreateFullTextCatalogStatement, error) {
+	p.nextToken() // consume CATALOG
+
+	stmt := &ast.CreateFullTextCatalogStatement{
+		Name: p.parseIdentifier(),
+	}
+
+	// Parse optional clauses
+	for p.curTok.Type != TokenEOF && p.curTok.Type != TokenSemicolon && !p.isBatchSeparator() {
+		switch strings.ToUpper(p.curTok.Literal) {
+		case "ON":
+			p.nextToken() // consume ON
+			if strings.ToUpper(p.curTok.Literal) == "FILEGROUP" {
+				p.nextToken() // consume FILEGROUP
+				stmt.FileGroup = p.parseIdentifier()
+			}
+		case "IN":
+			p.nextToken() // consume IN
+			if strings.ToUpper(p.curTok.Literal) == "PATH" {
+				p.nextToken() // consume PATH
+				path, err := p.parseScalarExpression()
+				if err != nil {
+					return nil, err
+				}
+				stmt.Path = path
+			}
+		case "WITH":
+			p.nextToken() // consume WITH
+			// Parse options like ACCENT_SENSITIVITY = ON/OFF
+			for {
+				if strings.ToUpper(p.curTok.Literal) == "ACCENT_SENSITIVITY" {
+					p.nextToken() // consume ACCENT_SENSITIVITY
+					if p.curTok.Type == TokenEquals {
+						p.nextToken() // consume =
+					}
+					opt := &ast.OnOffFullTextCatalogOption{
+						OptionKind: "AccentSensitivity",
+					}
+					if strings.ToUpper(p.curTok.Literal) == "ON" {
+						opt.OptionState = "On"
+					} else {
+						opt.OptionState = "Off"
+					}
+					p.nextToken() // consume ON/OFF
+					stmt.Options = append(stmt.Options, opt)
+				} else {
+					break
+				}
+				if p.curTok.Type == TokenComma {
+					p.nextToken()
+				} else {
+					break
+				}
+			}
+		case "AS":
+			p.nextToken() // consume AS
+			if strings.ToUpper(p.curTok.Literal) == "DEFAULT" {
+				p.nextToken() // consume DEFAULT
+				stmt.IsDefault = true
+			}
+		case "AUTHORIZATION":
+			p.nextToken() // consume AUTHORIZATION
+			stmt.Owner = p.parseIdentifier()
+		default:
+			// Unknown clause, skip this token
+			if p.curTok.Type == TokenSemicolon || p.isBatchSeparator() {
+				break
+			}
+			p.nextToken()
+		}
+	}
+
+	// Skip optional semicolon
+	if p.curTok.Type == TokenSemicolon {
+		p.nextToken()
+	}
+
+	return stmt, nil
+}
+
 func (p *Parser) parseCreateRemoteServiceBindingStatement() (*ast.CreateRemoteServiceBindingStatement, error) {
 	p.nextToken() // consume REMOTE
 	if strings.ToUpper(p.curTok.Literal) == "SERVICE" {

parser/testdata/Baselines90_CreateFulltextCatalogStatementTests/metadata.json

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

parser/testdata/PhaseOne_CreateFulltextCatalog/metadata.json

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