Add full CREATE/ALTER FULLTEXT INDEX parsing support

- Add SetStopListAlterFullTextIndexAction for SET STOPLIST action
- Add FullTextIndexOption interface with StopListFullTextIndexOption and
  ChangeTrackingFullTextIndexOption implementations
- Add FullTextCatalogAndFileGroup for catalog/filegroup specification
- Implement full CREATE FULLTEXT INDEX parsing with KEY INDEX, ON catalog,
  and WITH options (CHANGE_TRACKING, STOPLIST, NO POPULATION)
- Add SET STOPLIST parsing to ALTER FULLTEXT INDEX
- Fix CreateFullTextIndexStatement $type to match ScriptDOM format

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: kyleconroy

ast/alter_simple_statements.go

@@ -305,6 +305,48 @@ type FullTextIndexColumn struct {
 
 func (*FullTextIndexColumn) node() {}
 
+// SetStopListAlterFullTextIndexAction represents a SET STOPLIST action for fulltext index
+type SetStopListAlterFullTextIndexAction struct {
+	StopListOption   *StopListFullTextIndexOption `json:"StopListOption,omitempty"`
+	WithNoPopulation bool                         `json:"WithNoPopulation"`
+}
+
+func (*SetStopListAlterFullTextIndexAction) node()                     {}
+func (*SetStopListAlterFullTextIndexAction) alterFullTextIndexAction() {}
+
+// FullTextIndexOption is an interface for fulltext index options
+type FullTextIndexOption interface {
+	fullTextIndexOption()
+}
+
+// StopListFullTextIndexOption represents a STOPLIST option for fulltext index
+type StopListFullTextIndexOption struct {
+	IsOff        bool        `json:"IsOff"`
+	StopListName *Identifier `json:"StopListName,omitempty"`
+	OptionKind   string      `json:"OptionKind,omitempty"` // "StopList"
+}
+
+func (*StopListFullTextIndexOption) node()                {}
+func (*StopListFullTextIndexOption) fullTextIndexOption() {}
+
+// ChangeTrackingFullTextIndexOption represents a CHANGE_TRACKING option for fulltext index
+type ChangeTrackingFullTextIndexOption struct {
+	Value      string `json:"Value,omitempty"` // "Auto", "Manual", "Off", "OffNoPopulation"
+	OptionKind string `json:"OptionKind,omitempty"` // "ChangeTracking"
+}
+
+func (*ChangeTrackingFullTextIndexOption) node()                {}
+func (*ChangeTrackingFullTextIndexOption) fullTextIndexOption() {}
+
+// FullTextCatalogAndFileGroup represents catalog and filegroup for fulltext index
+type FullTextCatalogAndFileGroup struct {
+	CatalogName      *Identifier `json:"CatalogName,omitempty"`
+	FileGroupName    *Identifier `json:"FileGroupName,omitempty"`
+	FileGroupIsFirst bool        `json:"FileGroupIsFirst"`
+}
+
+func (*FullTextCatalogAndFileGroup) node() {}
+
 // AlterSymmetricKeyStatement represents an ALTER SYMMETRIC KEY statement.
 type AlterSymmetricKeyStatement struct {
 	Name                 *Identifier        `json:"Name,omitempty"`

ast/create_simple_statements.go

@@ -425,7 +425,10 @@ func (s *CreateFulltextCatalogStatement) statement() {}
 
 // CreateFulltextIndexStatement represents a CREATE FULLTEXT INDEX statement.
 type CreateFulltextIndexStatement struct {
-	OnName *SchemaObjectName `json:"OnName,omitempty"`
+	OnName            *SchemaObjectName            `json:"OnName,omitempty"`
+	KeyIndexName      *Identifier                  `json:"KeyIndexName,omitempty"`
+	CatalogAndFileGroup *FullTextCatalogAndFileGroup `json:"CatalogAndFileGroup,omitempty"`
+	Options           []FullTextIndexOption        `json:"Options,omitempty"`
 }
 
 func (s *CreateFulltextIndexStatement) node()      {}

parser/marshal.go

@@ -16895,10 +16895,31 @@ func alterFullTextIndexActionToJSON(a ast.AlterFullTextIndexActionOption) jsonNo
 			node["Columns"] = cols
 		}
 		return node
+	case *ast.SetStopListAlterFullTextIndexAction:
+		node := jsonNode{
+			"$type":            "SetStopListAlterFullTextIndexAction",
+			"WithNoPopulation": action.WithNoPopulation,
+		}
+		if action.StopListOption != nil {
+			node["StopListOption"] = stopListFullTextIndexOptionToJSON(action.StopListOption)
+		}
+		return node
 	}
 	return nil
 }
 
+func stopListFullTextIndexOptionToJSON(opt *ast.StopListFullTextIndexOption) jsonNode {
+	node := jsonNode{
+		"$type":      "StopListFullTextIndexOption",
+		"IsOff":      opt.IsOff,
+		"OptionKind": opt.OptionKind,
+	}
+	if opt.StopListName != nil {
+		node["StopListName"] = identifierToJSON(opt.StopListName)
+	}
+	return node
+}
+
 func fullTextIndexColumnToJSON(col *ast.FullTextIndexColumn) jsonNode {
 	node := jsonNode{
 		"$type":                "FullTextIndexColumn",
@@ -17873,14 +17894,55 @@ func createFulltextCatalogStatementToJSON(s *ast.CreateFulltextCatalogStatement)
 
 func createFulltextIndexStatementToJSON(s *ast.CreateFulltextIndexStatement) jsonNode {
 	node := jsonNode{
-		"$type": "CreateFulltextIndexStatement",
+		"$type": "CreateFullTextIndexStatement",
 	}
 	if s.OnName != nil {
 		node["OnName"] = schemaObjectNameToJSON(s.OnName)
 	}
+	if s.KeyIndexName != nil {
+		node["KeyIndexName"] = identifierToJSON(s.KeyIndexName)
+	}
+	if s.CatalogAndFileGroup != nil {
+		node["CatalogAndFileGroup"] = fullTextCatalogAndFileGroupToJSON(s.CatalogAndFileGroup)
+	}
+	if len(s.Options) > 0 {
+		opts := make([]jsonNode, len(s.Options))
+		for i, opt := range s.Options {
+			opts[i] = fullTextIndexOptionToJSON(opt)
+		}
+		node["Options"] = opts
+	}
+	return node
+}
+
+func fullTextCatalogAndFileGroupToJSON(cfg *ast.FullTextCatalogAndFileGroup) jsonNode {
+	node := jsonNode{
+		"$type":            "FullTextCatalogAndFileGroup",
+		"FileGroupIsFirst": cfg.FileGroupIsFirst,
+	}
+	if cfg.CatalogName != nil {
+		node["CatalogName"] = identifierToJSON(cfg.CatalogName)
+	}
+	if cfg.FileGroupName != nil {
+		node["FileGroupName"] = identifierToJSON(cfg.FileGroupName)
+	}
 	return node
 }
 
+func fullTextIndexOptionToJSON(opt ast.FullTextIndexOption) jsonNode {
+	switch o := opt.(type) {
+	case *ast.ChangeTrackingFullTextIndexOption:
+		return jsonNode{
+			"$type":      "ChangeTrackingFullTextIndexOption",
+			"Value":      o.Value,
+			"OptionKind": o.OptionKind,
+		}
+	case *ast.StopListFullTextIndexOption:
+		return stopListFullTextIndexOptionToJSON(o)
+	}
+	return nil
+}
+
 func createRemoteServiceBindingStatementToJSON(s *ast.CreateRemoteServiceBindingStatement) jsonNode {
 	node := jsonNode{
 		"$type": "CreateRemoteServiceBindingStatement",

parser/parse_ddl.go

@@ -8313,8 +8313,8 @@ func (p *Parser) tryParseAlterFullTextIndexAction() ast.AlterFullTextIndexAction
 		return &ast.SimpleAlterFullTextIndexAction{ActionKind: "Disable"}
 	case "SET":
 		p.nextToken() // consume SET
-		// Parse CHANGE_TRACKING = MANUAL/AUTO/OFF
 		if strings.ToUpper(p.curTok.Literal) == "CHANGE_TRACKING" {
+			// Parse CHANGE_TRACKING = MANUAL/AUTO/OFF
 			p.nextToken() // consume CHANGE_TRACKING
 			if p.curTok.Type == TokenEquals {
 				p.nextToken() // consume =
@@ -8329,6 +8329,33 @@ func (p *Parser) tryParseAlterFullTextIndexAction() ast.AlterFullTextIndexAction
 			case "OFF":
 				return &ast.SimpleAlterFullTextIndexAction{ActionKind: "SetChangeTrackingOff"}
 			}
+		} else if strings.ToUpper(p.curTok.Literal) == "STOPLIST" {
+			// Parse SET STOPLIST OFF | SYSTEM | name [WITH NO POPULATION]
+			p.nextToken() // consume STOPLIST
+			action := &ast.SetStopListAlterFullTextIndexAction{
+				StopListOption: &ast.StopListFullTextIndexOption{
+					OptionKind: "StopList",
+				},
+			}
+			if strings.ToUpper(p.curTok.Literal) == "OFF" {
+				action.StopListOption.IsOff = true
+				p.nextToken()
+			} else {
+				action.StopListOption.IsOff = false
+				action.StopListOption.StopListName = p.parseIdentifier()
+			}
+			// Check for WITH NO POPULATION
+			if p.curTok.Type == TokenWith {
+				p.nextToken() // consume WITH
+				if strings.ToUpper(p.curTok.Literal) == "NO" {
+					p.nextToken() // consume NO
+					if strings.ToUpper(p.curTok.Literal) == "POPULATION" {
+						p.nextToken() // consume POPULATION
+						action.WithNoPopulation = true
+					}
+				}
+			}
+			return action
 		}
 		return nil
 	case "START":

parser/parse_statements.go

@@ -12767,7 +12767,144 @@ func (p *Parser) parseCreateFulltextStatement() (ast.Statement, error) {
 		stmt := &ast.CreateFulltextIndexStatement{
 			OnName: onName,
 		}
-		p.skipToEndOfStatement()
+
+		// Parse optional (column_list) - skip for now
+		if p.curTok.Type == TokenLParen {
+			p.nextToken() // consume (
+			for p.curTok.Type != TokenRParen && p.curTok.Type != TokenEOF {
+				p.nextToken()
+			}
+			if p.curTok.Type == TokenRParen {
+				p.nextToken() // consume )
+			}
+		}
+
+		// Parse KEY INDEX name
+		if strings.ToUpper(p.curTok.Literal) == "KEY" {
+			p.nextToken() // consume KEY
+			if strings.ToUpper(p.curTok.Literal) == "INDEX" {
+				p.nextToken() // consume INDEX
+			}
+			stmt.KeyIndexName = p.parseIdentifier()
+		}
+
+		// Parse ON clause for catalog/filegroup
+		if p.curTok.Type == TokenOn {
+			p.nextToken() // consume ON
+			stmt.CatalogAndFileGroup = &ast.FullTextCatalogAndFileGroup{}
+
+			if p.curTok.Type == TokenLParen {
+				// (FILEGROUP fg, catalog) or (catalog, FILEGROUP fg) format
+				p.nextToken() // consume (
+
+				// Check first element
+				if strings.ToUpper(p.curTok.Literal) == "FILEGROUP" {
+					p.nextToken() // consume FILEGROUP
+					stmt.CatalogAndFileGroup.FileGroupName = p.parseIdentifier()
+					stmt.CatalogAndFileGroup.FileGroupIsFirst = true
+
+					// Check for comma and catalog
+					if p.curTok.Type == TokenComma {
+						p.nextToken() // consume comma
+						stmt.CatalogAndFileGroup.CatalogName = p.parseIdentifier()
+					}
+				} else {
+					// It's a catalog name first
+					stmt.CatalogAndFileGroup.CatalogName = p.parseIdentifier()
+					stmt.CatalogAndFileGroup.FileGroupIsFirst = false
+
+					// Check for comma and filegroup
+					if p.curTok.Type == TokenComma {
+						p.nextToken() // consume comma
+						if strings.ToUpper(p.curTok.Literal) == "FILEGROUP" {
+							p.nextToken() // consume FILEGROUP
+						}
+						stmt.CatalogAndFileGroup.FileGroupName = p.parseIdentifier()
+					}
+				}
+
+				if p.curTok.Type == TokenRParen {
+					p.nextToken() // consume )
+				}
+			} else {
+				// Just a catalog name without parentheses
+				stmt.CatalogAndFileGroup.CatalogName = p.parseIdentifier()
+				stmt.CatalogAndFileGroup.FileGroupIsFirst = false
+			}
+		}
+
+		// Parse WITH clause
+		if p.curTok.Type == TokenWith {
+			p.nextToken() // consume WITH
+			noPopulation := false
+			for {
+				optLit := strings.ToUpper(p.curTok.Literal)
+				if optLit == "CHANGE_TRACKING" {
+					p.nextToken() // consume CHANGE_TRACKING
+					var trackingValue string
+					if strings.ToUpper(p.curTok.Literal) == "MANUAL" {
+						trackingValue = "Manual"
+						p.nextToken()
+					} else if strings.ToUpper(p.curTok.Literal) == "AUTO" {
+						trackingValue = "Auto"
+						p.nextToken()
+					} else if strings.ToUpper(p.curTok.Literal) == "OFF" {
+						trackingValue = "Off"
+						p.nextToken()
+					}
+					// If we see NO POPULATION after CHANGE_TRACKING OFF, update the value
+					if trackingValue == "Off" && noPopulation {
+						trackingValue = "OffNoPopulation"
+					}
+					stmt.Options = append(stmt.Options, &ast.ChangeTrackingFullTextIndexOption{
+						Value:      trackingValue,
+						OptionKind: "ChangeTracking",
+					})
+				} else if optLit == "STOPLIST" {
+					p.nextToken() // consume STOPLIST
+					opt := &ast.StopListFullTextIndexOption{
+						OptionKind: "StopList",
+					}
+					if strings.ToUpper(p.curTok.Literal) == "OFF" {
+						opt.IsOff = true
+						p.nextToken()
+					} else if strings.ToUpper(p.curTok.Literal) == "SYSTEM" {
+						opt.IsOff = false
+						opt.StopListName = p.parseIdentifier()
+					} else {
+						opt.IsOff = false
+						opt.StopListName = p.parseIdentifier()
+					}
+					stmt.Options = append(stmt.Options, opt)
+				} else if optLit == "NO" {
+					p.nextToken() // consume NO
+					if strings.ToUpper(p.curTok.Literal) == "POPULATION" {
+						p.nextToken() // consume POPULATION
+						noPopulation = true
+						// Update CHANGE_TRACKING OFF to OffNoPopulation
+						for i, opt := range stmt.Options {
+							if ctOpt, ok := opt.(*ast.ChangeTrackingFullTextIndexOption); ok && ctOpt.Value == "Off" {
+								ctOpt.Value = "OffNoPopulation"
+								stmt.Options[i] = ctOpt
+							}
+						}
+					}
+				} else {
+					break
+				}
+
+				if p.curTok.Type == TokenComma {
+					p.nextToken() // consume comma
+				} else if p.curTok.Type == TokenSemicolon || p.curTok.Type == TokenEOF {
+					break
+				}
+			}
+		}
+
+		// Skip optional semicolon
+		if p.curTok.Type == TokenSemicolon {
+			p.nextToken()
+		}
 		return stmt, nil
 	default:
 		// Just create a catalog statement as default

parser/testdata/Baselines100_FulltextIndexStatementTests100/metadata.json

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

parser/testdata/PhaseOne_CreateFulltextIndex/ast.json

@@ -5,7 +5,7 @@
       "$type": "TSqlBatch",
       "Statements": [
         {
-          "$type": "CreateFulltextIndexStatement",
+          "$type": "CreateFullTextIndexStatement",
           "OnName": {
             "$type": "SchemaObjectName",
             "BaseIdentifier": {