Add comprehensive boolean expression parsing support

- Add TSEQUAL predicate parsing for timestamp comparisons
- Add UPDATE() predicate support for triggers
- Add != !< !> T-SQL specific comparison operators
- Add ~ (bitwise NOT) operator support
- Add ODBC escape syntax {ESCAPE 'x'} for LIKE expressions
- Fix CHECK NOT FOR REPLICATION at table level
- Fix FREETEXT/CONTAINS with table.* and table.column syntax
- Fix pseudo column ($identity, $action, etc.) handling in full-text predicates
- Change WildcardColumn to Wildcard for consistency

Enables BooleanExpressionTests and BaselinesCommon_BooleanExpressionTests

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

Author: kyleconroy

ast/tsequal_call.go

@@ -0,0 +1,12 @@
+package ast
+
+// TSEqualCall represents the TSEQUAL(expr1, expr2) predicate
+// used to compare timestamp values
+type TSEqualCall struct {
+	FirstExpression  ScalarExpression
+	SecondExpression ScalarExpression
+}
+
+func (*TSEqualCall) node()              {}
+func (*TSEqualCall) expression()        {}
+func (*TSEqualCall) booleanExpression() {}

ast/update_call.go

@@ -0,0 +1,11 @@
+package ast
+
+// UpdateCall represents the UPDATE(column) predicate used in triggers
+// to check if a column was modified
+type UpdateCall struct {
+	Identifier *Identifier
+}
+
+func (*UpdateCall) node()              {}
+func (*UpdateCall) expression()        {}
+func (*UpdateCall) booleanExpression() {}

parser/marshal.go

@@ -3407,6 +3407,25 @@ func booleanExpressionToJSON(expr ast.BooleanExpression) jsonNode {
 			node["Expression"] = booleanExpressionToJSON(e.Expression)
 		}
 		return node
+	case *ast.UpdateCall:
+		node := jsonNode{
+			"$type": "UpdateCall",
+		}
+		if e.Identifier != nil {
+			node["Identifier"] = identifierToJSON(e.Identifier)
+		}
+		return node
+	case *ast.TSEqualCall:
+		node := jsonNode{
+			"$type": "TSEqualCall",
+		}
+		if e.FirstExpression != nil {
+			node["FirstExpression"] = scalarExpressionToJSON(e.FirstExpression)
+		}
+		if e.SecondExpression != nil {
+			node["SecondExpression"] = scalarExpressionToJSON(e.SecondExpression)
+		}
+		return node
 	case *ast.BooleanIsNullExpression:
 		node := jsonNode{
 			"$type": "BooleanIsNullExpression",
@@ -3547,7 +3566,10 @@ func booleanExpressionToJSON(expr ast.BooleanExpression) jsonNode {
 			"$type": "ExistsPredicate",
 		}
 		if e.Subquery != nil {
-			node["Subquery"] = queryExpressionToJSON(e.Subquery)
+			node["Subquery"] = jsonNode{
+				"$type":           "ScalarSubquery",
+				"QueryExpression": queryExpressionToJSON(e.Subquery),
+			}
 		}
 		return node
 	case *ast.GraphMatchCompositeExpression:
@@ -7018,6 +7040,18 @@ func (p *Parser) parseColumnDefinition() (*ast.ColumnDefinition, error) {
 			col.DefaultConstraint = defaultConstraint
 		} else if upperLit == "CHECK" {
 			p.nextToken() // consume CHECK
+			notForReplication := false
+			// Check for NOT FOR REPLICATION (comes before the condition)
+			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
+						notForReplication = true
+					}
+				}
+			}
 			if p.curTok.Type == TokenLParen {
 				p.nextToken() // consume (
 				cond, err := p.parseBooleanExpression()
@@ -7030,6 +7064,7 @@ func (p *Parser) parseColumnDefinition() (*ast.ColumnDefinition, error) {
 				col.Constraints = append(col.Constraints, &ast.CheckConstraintDefinition{
 					CheckCondition:       cond,
 					ConstraintIdentifier: constraintName,
+					NotForReplication:    notForReplication,
 				})
 				constraintName = nil // clear for next constraint
 			}
@@ -7845,13 +7880,25 @@ func (p *Parser) parseForeignKeyAction() string {
 	}
 }
 
-// parseCheckConstraint parses CHECK (expression)
+// parseCheckConstraint parses CHECK (expression) or CHECK NOT FOR REPLICATION (expression)
 func (p *Parser) parseCheckConstraint() (*ast.CheckConstraintDefinition, error) {
 	// Consume CHECK
 	p.nextToken()
 
 	constraint := &ast.CheckConstraintDefinition{}
 
+	// Check for NOT FOR REPLICATION (comes before the condition)
+	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
+				constraint.NotForReplication = true
+			}
+		}
+	}
+
 	// Parse condition
 	if p.curTok.Type == TokenLParen {
 		p.nextToken() // consume (