Add SQL140 CREATE TABLE features: SUPPRESS_MESSAGES, ENCRYPTED, HIDDEN, TIME type

- Add SUPPRESS_MESSAGES sub-option for IGNORE_DUP_KEY index options
- Add ENCRYPTED WITH column encryption parsing
- Add MaskingFunction and Encryption fields to ColumnDefinition AST
- Accept TIME token as valid data type in parseDataTypeReference
- Use parseSystemVersioningTableOption for nested SYSTEM_VERSIONING options
- Treat hierarchyid, geometry, geography as UserDataTypeReference (CLR types)

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

Author: kyleconroy

ast/create_table_statement.go

@@ -69,6 +69,8 @@ type ColumnDefinition struct {
 	IsRowGuidCol             bool
 	IsHidden                 bool
 	IsMasked                 bool
+	MaskingFunction          ScalarExpression
+	Encryption               *ColumnEncryptionDefinition
 	Nullable                 *NullableConstraintDefinition
 	StorageOptions           *ColumnStorageOptions
 }

parser/marshal.go

@@ -5614,20 +5614,11 @@ func (p *Parser) parseCreateTableStatement() (*ast.CreateTableStatement, error)
 						}
 						stmt.Options = append(stmt.Options, opt)
 					} else if optionName == "SYSTEM_VERSIONING" {
-						if p.curTok.Type == TokenEquals {
-							p.nextToken() // consume =
-						}
-						stateUpper := strings.ToUpper(p.curTok.Literal)
-						state := "On"
-						if stateUpper == "OFF" {
-							state = "Off"
+						opt, err := p.parseSystemVersioningTableOption()
+						if err != nil {
+							return nil, err
 						}
-						p.nextToken() // consume ON/OFF
-						stmt.Options = append(stmt.Options, &ast.SystemVersioningTableOption{
-							OptionKind:              "LockEscalation",
-							OptionState:             state,
-							ConsistencyCheckEnabled: "NotSet",
-						})
+						stmt.Options = append(stmt.Options, opt)
 					} else if optionName == "CLUSTERED" {
 						// Could be CLUSTERED INDEX or CLUSTERED COLUMNSTORE INDEX
 						if strings.ToUpper(p.curTok.Literal) == "COLUMNSTORE" {
@@ -7664,22 +7655,40 @@ func (p *Parser) parseColumnDefinition() (*ast.ColumnDefinition, error) {
 		} else if upperLit == "MASKED" {
 			p.nextToken() // consume MASKED
 			col.IsMasked = true
-			// Skip optional WITH clause
+			// Parse optional WITH clause for masking function
 			if strings.ToUpper(p.curTok.Literal) == "WITH" {
-				p.nextToken()
+				p.nextToken() // consume WITH
 				if p.curTok.Type == TokenLParen {
-					depth := 1
-					p.nextToken()
-					for depth > 0 && p.curTok.Type != TokenEOF {
-						if p.curTok.Type == TokenLParen {
-							depth++
-						} else if p.curTok.Type == TokenRParen {
-							depth--
+					p.nextToken() // consume (
+					if strings.ToUpper(p.curTok.Literal) == "FUNCTION" {
+						p.nextToken() // consume FUNCTION
+						if p.curTok.Type == TokenEquals {
+							p.nextToken() // consume =
+						}
+						if p.curTok.Type == TokenString {
+							maskFunc, err := p.parseStringLiteral()
+							if err == nil {
+								col.MaskingFunction = maskFunc
+							}
 						}
-						p.nextToken()
+					}
+					if p.curTok.Type == TokenRParen {
+						p.nextToken() // consume )
 					}
 				}
 			}
+		} else if upperLit == "ENCRYPTED" {
+			p.nextToken() // consume ENCRYPTED
+			if strings.ToUpper(p.curTok.Literal) == "WITH" {
+				p.nextToken() // consume WITH
+			}
+			// Parse encryption specification: (COLUMN_ENCRYPTION_KEY = key1, ENCRYPTION_TYPE = ..., ALGORITHM = ...)
+			if p.curTok.Type == TokenLParen {
+				encSpec, err := p.parseColumnEncryptionSpecification()
+				if err == nil {
+					col.Encryption = encSpec
+				}
+			}
 		} else if upperLit == "IDENTITY" && col.IdentityOptions == nil {
 			// IDENTITY can appear after DEFAULT or other constraints
 			p.nextToken() // consume IDENTITY
@@ -7975,6 +7984,22 @@ func (p *Parser) parseConstraintIndexOptions() []ast.IndexOption {
 				OptionKind:  "IgnoreDupKey",
 				OptionState: p.capitalizeFirst(strings.ToLower(valueStr)),
 			}
+			// Check for optional (SUPPRESS_MESSAGES = ON/OFF)
+			if valueStr == "ON" && p.curTok.Type == TokenLParen {
+				p.nextToken() // consume (
+				if strings.ToUpper(p.curTok.Literal) == "SUPPRESS_MESSAGES" {
+					p.nextToken() // consume SUPPRESS_MESSAGES
+					if p.curTok.Type == TokenEquals {
+						p.nextToken() // consume =
+					}
+					suppressVal := strings.ToUpper(p.curTok.Literal) == "ON"
+					opt.SuppressMessagesOption = &suppressVal
+					p.nextToken() // consume ON/OFF
+				}
+				if p.curTok.Type == TokenRParen {
+					p.nextToken() // consume )
+				}
+			}
 			options = append(options, opt)
 		} else if valueStr == "ON" || valueStr == "OFF" {
 			opt := &ast.IndexStateOption{
@@ -9609,6 +9634,12 @@ func columnDefinitionToJSON(c *ast.ColumnDefinition) jsonNode {
 	if c.Index != nil {
 		node["Index"] = indexDefinitionToJSON(c.Index)
 	}
+	if c.Encryption != nil {
+		node["Encryption"] = columnEncryptionDefinitionToJSON(c.Encryption)
+	}
+	if c.MaskingFunction != nil {
+		node["MaskingFunction"] = scalarExpressionToJSON(c.MaskingFunction)
+	}
 	return node
 }
 

parser/parse_statements.go

@@ -911,7 +911,9 @@ func (p *Parser) parseDataTypeReference() (ast.DataTypeReference, error) {
 		p.nextToken() // consume NATIONAL
 	}
 
-	if p.curTok.Type != TokenIdent {
+	// Accept both identifiers and keyword tokens that are also valid data types
+	// TIME is both a keyword (WAITFOR TIME, AT TIME ZONE) and a data type
+	if p.curTok.Type != TokenIdent && p.curTok.Type != TokenTime {
 		return nil, fmt.Errorf("expected data type, got %s", p.curTok.Literal)
 	}
 
@@ -1253,9 +1255,6 @@ func getSqlDataTypeOption(typeName string) (string, bool) {
 		"UNIQUEIDENTIFIER":  "UniqueIdentifier",
 		"XML":               "Xml",
 		"JSON":              "Json",
-		"GEOGRAPHY":         "Geography",
-		"GEOMETRY":          "Geometry",
-		"HIERARCHYID":       "HierarchyId",
 		"ROWVERSION":        "Rowversion",
 		"TIMESTAMP":         "Timestamp",
 		"CONNECTION":        "Connection",

parser/testdata/Baselines140_CreateTableTests140/metadata.json

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

parser/testdata/CreateTableTests140/metadata.json

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