Add CREATE FULLTEXT INDEX column parsing with LANGUAGE support

- Parse FullTextIndexColumns including TYPE COLUMN and LANGUAGE options
- Handle binary/hex literals (0x...) in LANGUAGE clause
- Handle integer and string literals in LANGUAGE clause
- Change DropFulltextIndexStatement.OnName to TableName to match expected output
- Add FullTextIndexColumns marshaling to JSON output

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

Author: kyleconroy

ast/create_simple_statements.go

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

ast/fulltext_stoplist_statement.go

@@ -51,7 +51,7 @@ func (s *DropFullTextCatalogStatement) statement() {}
 
 // DropFulltextIndexStatement represents DROP FULLTEXT INDEX statement
 type DropFulltextIndexStatement struct {
-	OnName *SchemaObjectName `json:"OnName,omitempty"`
+	TableName *SchemaObjectName `json:"TableName,omitempty"`
 }
 
 func (s *DropFulltextIndexStatement) node()      {}

parser/marshal.go

@@ -17512,8 +17512,8 @@ func dropFulltextIndexStatementToJSON(s *ast.DropFulltextIndexStatement) jsonNod
 	node := jsonNode{
 		"$type": "DropFullTextIndexStatement",
 	}
-	if s.OnName != nil {
-		node["OnName"] = schemaObjectNameToJSON(s.OnName)
+	if s.TableName != nil {
+		node["TableName"] = schemaObjectNameToJSON(s.TableName)
 	}
 	return node
 }
@@ -18568,6 +18568,13 @@ func createFulltextIndexStatementToJSON(s *ast.CreateFulltextIndexStatement) jso
 	if s.OnName != nil {
 		node["OnName"] = schemaObjectNameToJSON(s.OnName)
 	}
+	if len(s.FullTextIndexColumns) > 0 {
+		cols := make([]jsonNode, len(s.FullTextIndexColumns))
+		for i, col := range s.FullTextIndexColumns {
+			cols[i] = fullTextIndexColumnToJSON(col)
+		}
+		node["FullTextIndexColumns"] = cols
+	}
 	if s.KeyIndexName != nil {
 		node["KeyIndexName"] = identifierToJSON(s.KeyIndexName)
 	}

parser/parse_ddl.go

@@ -204,7 +204,7 @@ func (p *Parser) parseDropFulltextStatement() (ast.Statement, error) {
 		}
 		name, _ := p.parseSchemaObjectName()
 		stmt := &ast.DropFulltextIndexStatement{
-			OnName: name,
+			TableName: name,
 		}
 		// Skip optional semicolon
 		if p.curTok.Type == TokenSemicolon {

parser/parse_statements.go

@@ -12796,11 +12796,79 @@ func (p *Parser) parseCreateFulltextStatement() (ast.Statement, error) {
 			OnName: onName,
 		}
 
-		// Parse optional (column_list) - skip for now
+		// Parse optional (column_list)
 		if p.curTok.Type == TokenLParen {
 			p.nextToken() // consume (
 			for p.curTok.Type != TokenRParen && p.curTok.Type != TokenEOF {
-				p.nextToken()
+				col := &ast.FullTextIndexColumn{}
+				col.Name = p.parseIdentifier()
+
+				// Parse optional TYPE COLUMN type_column_name
+				if strings.ToUpper(p.curTok.Literal) == "TYPE" {
+					p.nextToken() // consume TYPE
+					if strings.ToUpper(p.curTok.Literal) == "COLUMN" {
+						p.nextToken() // consume COLUMN
+					}
+					col.TypeColumn = p.parseIdentifier()
+				}
+
+				// Parse optional LANGUAGE language_term
+				if p.curTok.Type == TokenLanguage {
+					p.nextToken() // consume LANGUAGE
+					col.LanguageTerm = &ast.IdentifierOrValueExpression{}
+					if p.curTok.Type == TokenString {
+						strLit, _ := p.parseStringLiteral()
+						col.LanguageTerm.Value = strLit.Value
+						col.LanguageTerm.ValueExpression = strLit
+					} else if p.curTok.Type == TokenNumber {
+						// Check for hex literal (0x...)
+						if strings.HasPrefix(strings.ToLower(p.curTok.Literal), "0x") {
+							lit := &ast.BinaryLiteral{
+								LiteralType:   "Binary",
+								IsLargeObject: false,
+								Value:         p.curTok.Literal,
+							}
+							col.LanguageTerm.Value = p.curTok.Literal
+							col.LanguageTerm.ValueExpression = lit
+						} else {
+							// Parse integer literal directly
+							lit := &ast.IntegerLiteral{
+								LiteralType: "Integer",
+								Value:       p.curTok.Literal,
+							}
+							col.LanguageTerm.Value = p.curTok.Literal
+							col.LanguageTerm.ValueExpression = lit
+						}
+						p.nextToken()
+					} else if p.curTok.Type == TokenBinary {
+						// Handle binary/hex literal
+						lit := &ast.BinaryLiteral{
+							LiteralType:   "Binary",
+							IsLargeObject: false,
+							Value:         p.curTok.Literal,
+						}
+						col.LanguageTerm.Value = p.curTok.Literal
+						col.LanguageTerm.ValueExpression = lit
+						p.nextToken()
+					} else {
+						col.LanguageTerm.Identifier = p.parseIdentifier()
+						col.LanguageTerm.Value = col.LanguageTerm.Identifier.Value
+					}
+				}
+
+				// Parse optional STATISTICAL_SEMANTICS
+				if strings.ToUpper(p.curTok.Literal) == "STATISTICAL_SEMANTICS" {
+					col.StatisticalSemantics = true
+					p.nextToken()
+				}
+
+				stmt.FullTextIndexColumns = append(stmt.FullTextIndexColumns, col)
+
+				if p.curTok.Type == TokenComma {
+					p.nextToken() // consume comma
+				} else {
+					break
+				}
 			}
 			if p.curTok.Type == TokenRParen {
 				p.nextToken() // consume )

parser/testdata/Baselines90_FulltextIndexStatementTests/metadata.json

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

parser/testdata/FulltextIndexStatementTests/metadata.json

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