Add expression parsing improvements for T-SQL features

- Add bitwise operators (&, |, ^) with correct T-SQL precedence
- Add ODBC function call parsing ({ FN convert(...) }, { FN extract(...) }, etc.)
- Add ODBC date/time literal parsing ({ T '...' }, { D '...' }, { TS '...' })
- Add parenthesized subquery with UNION support (parseRestOfBinaryQueryExpression)
- Add IDENTITY clause parsing after DEFAULT in column definitions
- Add large integer detection (>INT range) to use NumericLiteral
- Add NULLIF and COALESCE as distinct expression types
- Add ExtractFromExpression for ODBC extract function

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

Author: kyleconroy

ast/nullif_coalesce.go

@@ -0,0 +1,18 @@
+package ast
+
+// NullIfExpression represents a NULLIF(expr1, expr2) expression.
+type NullIfExpression struct {
+	FirstExpression  ScalarExpression
+	SecondExpression ScalarExpression
+}
+
+func (*NullIfExpression) node()             {}
+func (*NullIfExpression) scalarExpression() {}
+
+// CoalesceExpression represents a COALESCE(expr1, expr2, ...) expression.
+type CoalesceExpression struct {
+	Expressions []ScalarExpression
+}
+
+func (*CoalesceExpression) node()             {}
+func (*CoalesceExpression) scalarExpression() {}

ast/odbc_literal.go

@@ -10,3 +10,30 @@ type OdbcLiteral struct {
 
 func (*OdbcLiteral) node()             {}
 func (*OdbcLiteral) scalarExpression() {}
+
+// OdbcFunctionCall represents an ODBC scalar function call like {fn convert(...)}.
+type OdbcFunctionCall struct {
+	Name           *Identifier
+	ParametersUsed bool
+	Parameters     []ScalarExpression
+}
+
+func (*OdbcFunctionCall) node()             {}
+func (*OdbcFunctionCall) scalarExpression() {}
+
+// OdbcConvertSpecification represents the target type in an ODBC convert function.
+type OdbcConvertSpecification struct {
+	Identifier *Identifier
+}
+
+func (*OdbcConvertSpecification) node()             {}
+func (*OdbcConvertSpecification) scalarExpression() {}
+
+// ExtractFromExpression represents an EXTRACT(element FROM expression) construct.
+type ExtractFromExpression struct {
+	ExtractedElement *Identifier
+	Expression       ScalarExpression
+}
+
+func (*ExtractFromExpression) node()             {}
+func (*ExtractFromExpression) scalarExpression() {}

parser/marshal.go

@@ -2275,6 +2275,29 @@ func scalarExpressionToJSON(expr ast.ScalarExpression) jsonNode {
 			node["Collation"] = identifierToJSON(e.Collation)
 		}
 		return node
+	case *ast.NullIfExpression:
+		node := jsonNode{
+			"$type": "NullIfExpression",
+		}
+		if e.FirstExpression != nil {
+			node["FirstExpression"] = scalarExpressionToJSON(e.FirstExpression)
+		}
+		if e.SecondExpression != nil {
+			node["SecondExpression"] = scalarExpressionToJSON(e.SecondExpression)
+		}
+		return node
+	case *ast.CoalesceExpression:
+		node := jsonNode{
+			"$type": "CoalesceExpression",
+		}
+		if len(e.Expressions) > 0 {
+			exprs := make([]jsonNode, len(e.Expressions))
+			for i, expr := range e.Expressions {
+				exprs[i] = scalarExpressionToJSON(expr)
+			}
+			node["Expressions"] = exprs
+		}
+		return node
 	case *ast.IdentityFunctionCall:
 		node := jsonNode{
 			"$type": "IdentityFunctionCall",
@@ -2444,6 +2467,41 @@ func scalarExpressionToJSON(expr ast.ScalarExpression) jsonNode {
 			node["Value"] = e.Value
 		}
 		return node
+	case *ast.OdbcFunctionCall:
+		node := jsonNode{
+			"$type": "OdbcFunctionCall",
+		}
+		if e.Name != nil {
+			node["Name"] = identifierToJSON(e.Name)
+		}
+		node["ParametersUsed"] = e.ParametersUsed
+		if len(e.Parameters) > 0 {
+			params := make([]jsonNode, len(e.Parameters))
+			for i, param := range e.Parameters {
+				params[i] = scalarExpressionToJSON(param)
+			}
+			node["Parameters"] = params
+		}
+		return node
+	case *ast.OdbcConvertSpecification:
+		node := jsonNode{
+			"$type": "OdbcConvertSpecification",
+		}
+		if e.Identifier != nil {
+			node["Identifier"] = identifierToJSON(e.Identifier)
+		}
+		return node
+	case *ast.ExtractFromExpression:
+		node := jsonNode{
+			"$type": "ExtractFromExpression",
+		}
+		if e.Expression != nil {
+			node["Expression"] = scalarExpressionToJSON(e.Expression)
+		}
+		if e.ExtractedElement != nil {
+			node["ExtractedElement"] = identifierToJSON(e.ExtractedElement)
+		}
+		return node
 	case *ast.NullLiteral:
 		node := jsonNode{
 			"$type": "NullLiteral",
@@ -7538,6 +7596,51 @@ func (p *Parser) parseColumnDefinition() (*ast.ColumnDefinition, error) {
 					}
 				}
 			}
+		} else if upperLit == "IDENTITY" && col.IdentityOptions == nil {
+			// IDENTITY can appear after DEFAULT or other constraints
+			p.nextToken() // consume IDENTITY
+			identityOpts := &ast.IdentityOptions{}
+
+			// Check for optional (seed, increment)
+			if p.curTok.Type == TokenLParen {
+				p.nextToken() // consume (
+
+				// Parse seed
+				seed, err := p.parseScalarExpression()
+				if err == nil {
+					identityOpts.IdentitySeed = seed
+				}
+
+				// Expect comma
+				if p.curTok.Type == TokenComma {
+					p.nextToken() // consume ,
+
+					// Parse increment
+					increment, err := p.parseScalarExpression()
+					if err == nil {
+						identityOpts.IdentityIncrement = increment
+					}
+				}
+
+				// Expect closing paren
+				if p.curTok.Type == TokenRParen {
+					p.nextToken() // consume )
+				}
+			}
+
+			// Check for NOT FOR REPLICATION
+			if p.curTok.Type == TokenNot {
+				p.nextToken() // consume NOT
+				if strings.ToUpper(p.curTok.Literal) == "FOR" {
+					p.nextToken() // consume FOR
+					if strings.ToUpper(p.curTok.Literal) == "REPLICATION" {
+						p.nextToken() // consume REPLICATION
+						identityOpts.NotForReplication = true
+					}
+				}
+			}
+
+			col.IdentityOptions = identityOpts
 		} else {
 			break
 		}