Add kql() function transformation to view() in EXPLAIN AST output

ast/ast.go

@@ -282,7 +282,8 @@ type CreateQuery struct {
 	Indexes          []*IndexDefinition   `json:"indexes,omitempty"`
 	Projections      []*Projection        `json:"projections,omitempty"`
 	Constraints         []*Constraint        `json:"constraints,omitempty"`
-	ColumnsPrimaryKey   []Expression         `json:"columns_primary_key,omitempty"` // PRIMARY KEY in column list
+	ColumnsPrimaryKey       []Expression         `json:"columns_primary_key,omitempty"`        // PRIMARY KEY in column list
+	HasEmptyColumnsPrimaryKey bool               `json:"has_empty_columns_primary_key,omitempty"` // TRUE if PRIMARY KEY () was seen with empty parens
 	Engine               *EngineClause        `json:"engine,omitempty"`
 	OrderBy              []Expression         `json:"order_by,omitempty"`
 	OrderByHasModifiers  bool                 `json:"order_by_has_modifiers,omitempty"` // True if ORDER BY has ASC/DESC modifiers
@@ -496,11 +497,22 @@ type TTLClause struct {
 	Position    token.Position `json:"-"`
 	Expression  Expression     `json:"expression"`
 	Expressions []Expression   `json:"expressions,omitempty"` // Additional TTL expressions (for multiple TTL elements)
+	Elements    []*TTLElement  `json:"elements,omitempty"`    // TTL elements with WHERE conditions
 }
 
 func (t *TTLClause) Pos() token.Position { return t.Position }
 func (t *TTLClause) End() token.Position { return t.Position }
 
+// TTLElement represents a single TTL element with optional WHERE condition.
+type TTLElement struct {
+	Position token.Position `json:"-"`
+	Expr     Expression     `json:"expr"`
+	Where    Expression     `json:"where,omitempty"` // WHERE condition for DELETE
+}
+
+func (t *TTLElement) Pos() token.Position { return t.Position }
+func (t *TTLElement) End() token.Position { return t.Position }
+
 // DropQuery represents a DROP statement.
 type DropQuery struct {
 	Position        token.Position     `json:"-"`
@@ -707,11 +719,12 @@ func (t *TruncateQuery) statementNode()      {}
 
 // DeleteQuery represents a lightweight DELETE statement.
 type DeleteQuery struct {
-	Position token.Position `json:"-"`
-	Database string         `json:"database,omitempty"`
-	Table    string         `json:"table"`
-	Where    Expression     `json:"where,omitempty"`
-	Settings []*SettingExpr `json:"settings,omitempty"`
+	Position  token.Position `json:"-"`
+	Database  string         `json:"database,omitempty"`
+	Table     string         `json:"table"`
+	Partition Expression     `json:"partition,omitempty"` // IN PARTITION clause
+	Where     Expression     `json:"where,omitempty"`
+	Settings  []*SettingExpr `json:"settings,omitempty"`
 }
 
 func (d *DeleteQuery) Pos() token.Position { return d.Position }
@@ -743,11 +756,14 @@ func (d *DetachQuery) statementNode()      {}
 // AttachQuery represents an ATTACH statement.
 type AttachQuery struct {
 	Position           token.Position       `json:"-"`
+	IfNotExists        bool                 `json:"if_not_exists,omitempty"`
 	Database           string               `json:"database,omitempty"`
 	Table              string               `json:"table,omitempty"`
 	Dictionary         string               `json:"dictionary,omitempty"`
 	Columns            []*ColumnDeclaration `json:"columns,omitempty"`
-	ColumnsPrimaryKey  []Expression         `json:"columns_primary_key,omitempty"` // PRIMARY KEY in column list
+	ColumnsPrimaryKey       []Expression         `json:"columns_primary_key,omitempty"`        // PRIMARY KEY in column list
+	HasEmptyColumnsPrimaryKey bool               `json:"has_empty_columns_primary_key,omitempty"` // TRUE if PRIMARY KEY () was seen with empty parens
+	Indexes            []*IndexDefinition   `json:"indexes,omitempty"`             // INDEX definitions in column list
 	Engine             *EngineClause        `json:"engine,omitempty"`
 	OrderBy            []Expression         `json:"order_by,omitempty"`
 	PrimaryKey         []Expression         `json:"primary_key,omitempty"`
@@ -756,12 +772,47 @@ type AttachQuery struct {
 	InnerUUID          string               `json:"inner_uuid,omitempty"` // TO INNER UUID clause
 	PartitionBy        Expression           `json:"partition_by,omitempty"`
 	SelectQuery        Statement            `json:"select_query,omitempty"` // AS SELECT clause
+	Settings           []*SettingExpr       `json:"settings,omitempty"`     // SETTINGS clause
 }
 
 func (a *AttachQuery) Pos() token.Position { return a.Position }
 func (a *AttachQuery) End() token.Position { return a.Position }
 func (a *AttachQuery) statementNode()      {}
 
+// BackupQuery represents a BACKUP statement.
+type BackupQuery struct {
+	Position   token.Position `json:"-"`
+	Database   string         `json:"database,omitempty"`
+	Table      string         `json:"table,omitempty"`
+	Dictionary string         `json:"dictionary,omitempty"`
+	All        bool           `json:"all,omitempty"` // BACKUP ALL
+	Temporary  bool           `json:"temporary,omitempty"`
+	Target     *FunctionCall  `json:"target,omitempty"` // Disk('path') or Null
+	Settings   []*SettingExpr `json:"settings,omitempty"`
+	Format     string         `json:"format,omitempty"`
+}
+
+func (b *BackupQuery) Pos() token.Position { return b.Position }
+func (b *BackupQuery) End() token.Position { return b.Position }
+func (b *BackupQuery) statementNode()      {}
+
+// RestoreQuery represents a RESTORE statement.
+type RestoreQuery struct {
+	Position   token.Position `json:"-"`
+	Database   string         `json:"database,omitempty"`
+	Table      string         `json:"table,omitempty"`
+	Dictionary string         `json:"dictionary,omitempty"`
+	All        bool           `json:"all,omitempty"` // RESTORE ALL
+	Temporary  bool           `json:"temporary,omitempty"`
+	Source     *FunctionCall  `json:"source,omitempty"` // Disk('path') or Null
+	Settings   []*SettingExpr `json:"settings,omitempty"`
+	Format     string         `json:"format,omitempty"`
+}
+
+func (r *RestoreQuery) Pos() token.Position { return r.Position }
+func (r *RestoreQuery) End() token.Position { return r.Position }
+func (r *RestoreQuery) statementNode()      {}
+
 // DescribeQuery represents a DESCRIBE statement.
 type DescribeQuery struct {
 	Position      token.Position   `json:"-"`
@@ -860,15 +911,16 @@ func (s *SetQuery) statementNode()      {}
 
 // OptimizeQuery represents an OPTIMIZE statement.
 type OptimizeQuery struct {
-	Position  token.Position `json:"-"`
-	Database  string         `json:"database,omitempty"`
-	Table     string         `json:"table"`
-	Partition Expression     `json:"partition,omitempty"`
-	Final     bool           `json:"final,omitempty"`
-	Cleanup   bool           `json:"cleanup,omitempty"`
-	Dedupe    bool           `json:"dedupe,omitempty"`
-	OnCluster string         `json:"on_cluster,omitempty"`
-	Settings  []*SettingExpr `json:"settings,omitempty"`
+	Position      token.Position `json:"-"`
+	Database      string         `json:"database,omitempty"`
+	Table         string         `json:"table"`
+	Partition     Expression     `json:"partition,omitempty"`
+	PartitionByID bool           `json:"partition_by_id,omitempty"` // PARTITION ID vs PARTITION expr
+	Final         bool           `json:"final,omitempty"`
+	Cleanup       bool           `json:"cleanup,omitempty"`
+	Dedupe        bool           `json:"dedupe,omitempty"`
+	OnCluster     string         `json:"on_cluster,omitempty"`
+	Settings      []*SettingExpr `json:"settings,omitempty"`
 }
 
 func (o *OptimizeQuery) Pos() token.Position { return o.Position }
@@ -995,6 +1047,20 @@ func (s *ShowGrantsQuery) Pos() token.Position { return s.Position }
 func (s *ShowGrantsQuery) End() token.Position { return s.Position }
 func (s *ShowGrantsQuery) statementNode()      {}
 
+// KillQuery represents a KILL QUERY/MUTATION statement.
+type KillQuery struct {
+	Position token.Position `json:"-"`
+	Type     string         `json:"type"`              // "QUERY" or "MUTATION"
+	Where    Expression     `json:"where,omitempty"`   // WHERE condition
+	Sync     bool           `json:"sync,omitempty"`    // SYNC mode (default false = ASYNC)
+	Test     bool           `json:"test,omitempty"`    // TEST mode
+	Format   string         `json:"format,omitempty"`  // FORMAT clause
+}
+
+func (k *KillQuery) Pos() token.Position { return k.Position }
+func (k *KillQuery) End() token.Position { return k.Position }
+func (k *KillQuery) statementNode()      {}
+
 // ShowPrivilegesQuery represents a SHOW PRIVILEGES statement.
 type ShowPrivilegesQuery struct {
 	Position token.Position `json:"-"`
@@ -1360,6 +1426,7 @@ type ColumnTransformer struct {
 	Apply       string         `json:"apply,omitempty"`        // function name for APPLY
 	ApplyLambda Expression     `json:"apply_lambda,omitempty"` // lambda expression for APPLY x -> expr
 	Except      []string       `json:"except,omitempty"`       // column names for EXCEPT
+	Pattern     string         `json:"pattern,omitempty"`      // regex pattern for EXCEPT('pattern')
 	Replaces    []*ReplaceExpr `json:"replaces,omitempty"`     // replacement expressions for REPLACE
 }
 

internal/explain/explain.go

@@ -238,6 +238,10 @@ func Node(sb *strings.Builder, node interface{}, depth int) {
 		explainDetachQuery(sb, n, indent)
 	case *ast.AttachQuery:
 		explainAttachQuery(sb, n, indent, depth)
+	case *ast.BackupQuery:
+		explainBackupQuery(sb, n, indent)
+	case *ast.RestoreQuery:
+		explainRestoreQuery(sb, n, indent)
 	case *ast.AlterQuery:
 		explainAlterQuery(sb, n, indent, depth)
 	case *ast.OptimizeQuery:
@@ -254,6 +258,8 @@ func Node(sb *strings.Builder, node interface{}, depth int) {
 		explainUpdateQuery(sb, n, indent, depth)
 	case *ast.ParallelWithQuery:
 		explainParallelWithQuery(sb, n, indent, depth)
+	case *ast.KillQuery:
+		explainKillQuery(sb, n, indent, depth)
 
 	// Types
 	case *ast.DataType:

internal/explain/expressions.go

@@ -8,9 +8,12 @@ import (
 	"github.com/sqlc-dev/doubleclick/ast"
 )
 
-// escapeAlias escapes backslashes in alias names for EXPLAIN output
+// escapeAlias escapes backslashes and single quotes in alias names for EXPLAIN output
 func escapeAlias(alias string) string {
-	return strings.ReplaceAll(alias, "\\", "\\\\")
+	// Escape backslashes first, then single quotes
+	result := strings.ReplaceAll(alias, "\\", "\\\\")
+	result = strings.ReplaceAll(result, "'", "\\'")
+	return result
 }
 
 func explainIdentifier(sb *strings.Builder, n *ast.Identifier, indent string) {
@@ -53,19 +56,17 @@ func explainLiteral(sb *strings.Builder, n *ast.Literal, indent string, depth in
 				fmt.Fprintf(sb, "%s ExpressionList\n", indent)
 				return
 			}
-			// Single-element tuples (from trailing comma syntax like (1,)) always render as Function tuple
-			if len(exprs) == 1 {
-				fmt.Fprintf(sb, "%sFunction tuple (children %d)\n", indent, 1)
-				fmt.Fprintf(sb, "%s ExpressionList (children %d)\n", indent, len(exprs))
-				for _, e := range exprs {
-					Node(sb, e, depth+2)
-				}
-				return
-			}
+			// Check if any element is parenthesized (e.g., ((1), (2)) vs (1, 2))
+			// Parenthesized elements mean the tuple should render as Function tuple
+			hasParenthesizedElement := false
 			hasComplexExpr := false
 			for _, e := range exprs {
-				// Simple literals (numbers, strings, etc.) are OK
+				// Check for parenthesized literals
 				if lit, isLit := e.(*ast.Literal); isLit {
+					if lit.Parenthesized {
+						hasParenthesizedElement = true
+						break
+					}
 					// Nested tuples that contain only primitive literals are OK
 					if lit.Type == ast.LiteralTuple {
 						if !containsOnlyPrimitiveLiteralsWithUnary(lit) {
@@ -79,7 +80,6 @@ func explainLiteral(sb *strings.Builder, n *ast.Literal, indent string, depth in
 						hasComplexExpr = true
 						break
 					}
-					// Other literals are simple
 					continue
 				}
 				// Unary negation of numeric literals is also simple
@@ -94,8 +94,9 @@ func explainLiteral(sb *strings.Builder, n *ast.Literal, indent string, depth in
 				hasComplexExpr = true
 				break
 			}
-			if hasComplexExpr {
-				// Render as Function tuple instead of Literal
+			// Single-element tuples (from trailing comma syntax like (1,)) always render as Function tuple
+			// Tuples with complex expressions or parenthesized elements also render as Function tuple
+			if len(exprs) == 1 || hasComplexExpr || hasParenthesizedElement {
 				fmt.Fprintf(sb, "%sFunction tuple (children %d)\n", indent, 1)
 				fmt.Fprintf(sb, "%s ExpressionList (children %d)\n", indent, len(exprs))
 				for _, e := range exprs {
@@ -131,6 +132,10 @@ func explainLiteral(sb *strings.Builder, n *ast.Literal, indent string, depth in
 
 			for _, e := range exprs {
 				if lit, ok := e.(*ast.Literal); ok {
+					// Parenthesized elements require Function array format
+					if lit.Parenthesized {
+						shouldUseFunctionArray = true
+					}
 					if lit.Type == ast.LiteralArray {
 						hasNestedArrays = true
 						// Check if inner array needs Function array format:
@@ -395,8 +400,13 @@ func collectLogicalOperands(n *ast.BinaryExpr) []ast.Expression {
 		operands = append(operands, n.Left)
 	}
 
-	// Don't flatten right side - explicit parentheses would be on the left in left-associative parsing
-	operands = append(operands, n.Right)
+	// Also flatten right side if it's the same operator and not parenthesized
+	// This handles both left-associative and right-associative parsing
+	if right, ok := n.Right.(*ast.BinaryExpr); ok && right.Op == n.Op && !right.Parenthesized {
+		operands = append(operands, collectLogicalOperands(right)...)
+	} else {
+		operands = append(operands, n.Right)
+	}
 
 	return operands
 }
@@ -425,8 +435,15 @@ func explainUnaryExpr(sb *strings.Builder, n *ast.UnaryExpr, indent string, dept
 					// ClickHouse normalizes -0 to UInt64_0
 					if val == 0 {
 						fmt.Fprintf(sb, "%sLiteral UInt64_0\n", indent)
-					} else {
+					} else if val <= 9223372036854775808 {
+						// Value fits in int64 when negated
+						// Note: -9223372036854775808 is int64 min, so 9223372036854775808 is included
 						fmt.Fprintf(sb, "%sLiteral Int64_-%d\n", indent, val)
+					} else {
+						// Value too large for int64 - output as Float64
+						f := -float64(val)
+						s := FormatFloat(f)
+						fmt.Fprintf(sb, "%sLiteral Float64_%s\n", indent, s)
 					}
 					return
 				}
@@ -647,7 +664,16 @@ func explainAliasedExpr(sb *strings.Builder, n *ast.AliasedExpr, depth int) {
 						fmt.Fprintf(sb, "%sLiteral Int64_%d (alias %s)\n", indent, -val, escapeAlias(n.Alias))
 						return
 					case uint64:
-						fmt.Fprintf(sb, "%sLiteral Int64_-%d (alias %s)\n", indent, val, escapeAlias(n.Alias))
+						if val <= 9223372036854775808 {
+							// Value fits in int64 when negated
+							// Note: -9223372036854775808 is int64 min, so 9223372036854775808 is included
+							fmt.Fprintf(sb, "%sLiteral Int64_-%d (alias %s)\n", indent, val, escapeAlias(n.Alias))
+						} else {
+							// Value too large for int64 - output as Float64
+							f := -float64(val)
+							s := FormatFloat(f)
+							fmt.Fprintf(sb, "%sLiteral Float64_%s (alias %s)\n", indent, s, escapeAlias(n.Alias))
+						}
 						return
 					}
 				case ast.LiteralFloat:
@@ -789,9 +815,14 @@ func explainSingleTransformer(sb *strings.Builder, t *ast.ColumnTransformer, ind
 	case "apply":
 		fmt.Fprintf(sb, "%s ColumnsApplyTransformer\n", indent)
 	case "except":
-		fmt.Fprintf(sb, "%s ColumnsExceptTransformer (children %d)\n", indent, len(t.Except))
-		for _, col := range t.Except {
-			fmt.Fprintf(sb, "%s  Identifier %s\n", indent, col)
+		// If it's a regex pattern, output without children
+		if t.Pattern != "" {
+			fmt.Fprintf(sb, "%s ColumnsExceptTransformer\n", indent)
+		} else {
+			fmt.Fprintf(sb, "%s ColumnsExceptTransformer (children %d)\n", indent, len(t.Except))
+			for _, col := range t.Except {
+				fmt.Fprintf(sb, "%s  Identifier %s\n", indent, col)
+			}
 		}
 	case "replace":
 		fmt.Fprintf(sb, "%s ColumnsReplaceTransformer (children %d)\n", indent, len(t.Replaces))
@@ -1029,6 +1060,10 @@ func explainWithElement(sb *strings.Builder, n *ast.WithElement, indent string,
 		}
 	case *ast.CastExpr:
 		explainCastExprWithAlias(sb, e, n.Name, indent, depth)
+	case *ast.ArrayAccess:
+		explainArrayAccessWithAlias(sb, e, n.Name, indent, depth)
+	case *ast.BetweenExpr:
+		explainBetweenExprWithAlias(sb, e, n.Name, indent, depth)
 	default:
 		// For other types, just output the expression (alias may be lost)
 		Node(sb, n.Query, depth)