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

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

Implements KQL (Kusto Query Language) parsing for the kql() table function.
The kql() function is transformed to view() with the KQL content parsed
into equivalent SQL. Supports:
- Table names as first pipe segment
- project operator for column selection
- filter operator for WHERE conditions with comparison operators

Fixes 02366_kql_create_table test (3 statements: stmt5, stmt7, stmt11).

* Support dotted identifiers in ALTER TABLE RENAME COLUMN

Add parseDottedIdentifier helper to handle nested column names like n.x
in RENAME COLUMN statements. Previously only single-part identifiers were
captured, causing statements like "RENAME COLUMN n.x TO n.renamed_x" to
lose the dot-separated suffix.

Fixes tests:
- 01213_alter_table_rename_nested (3 statements)
- 01213_alter_rename_nested (2 statements)
- 01278_alter_rename_combination (2 statements)
- 03526_columns_substreams_in_wide_parts (2 statements)

* Add support for multi-word data types in parser

Handle SQL standard multi-word type names:
- DOUBLE PRECISION
- INT/INTEGER/TINYINT/SMALLINT/BIGINT/INT1 with SIGNED/UNSIGNED
- CHAR/CHARACTER/NCHAR with VARYING or LARGE OBJECT
- BINARY with VARYING or LARGE OBJECT
- NATIONAL CHAR/CHARACTER with optional VARYING or LARGE OBJECT

Fixes 01144_multiword_data_types test (3 statements).

* Escape single quotes in alias names in EXPLAIN output

When an alias contains single quotes (e.g., "'String'" as an alias),
they need to be escaped as \' in the EXPLAIN AST output to match
ClickHouse behavior.

Fixes tests:
- 01101_literal_column_clash (3 statements)
- 01950_aliases_bad_cast (1 statement)

* Fix handling of INT64_MIN and very large negative integers in CAST

Two fixes:
1. In formatExprAsString, avoid overflow when formatting INT64_MIN by checking
   if the value is already negative before trying to negate it
2. In parseUnaryMinus, properly handle negative numbers larger than int64 can
   hold (like -9223372036854775809 for Int128) by storing them as strings
   when strconv.ParseInt fails

Fixes 02887_byteswap test (3 statements: stmt27, stmt29, stmt31).

* Add tuple expansion and regex pattern EXCEPT support

- Handle expression.* syntax for tuple expansion in parseDotAccess()
- Add Pattern field to ColumnTransformer for regex-based EXCEPT
- Parse string patterns in EXCEPT clauses (e.g., EXCEPT('hello|world'))
- Output pattern-based EXCEPT as ColumnsExceptTransformer with String node

Fixes test 03101_analyzer_identifiers_4 (stmt7, stmt9, stmt14)
Also fixes 01470_columns_transformers2 (stmt4)

* Add INDEX and SETTINGS support for ATTACH TABLE statements

- Add Indexes field to AttachQuery struct in ast.go
- Add Settings field to AttachQuery struct in ast.go
- Parse INDEX definitions in ATTACH TABLE column lists
- Parse SETTINGS clause in ATTACH TABLE statements
- Update explainAttachQuery to output indexes and settings correctly
- Handle engine parentheses with empty argument list

Fixes test 01249_bad_arguments_for_bloom_filter (stmt10, stmt13, stmt16)
Also fixes 01601_detach_permanently and 02990_rmt_replica_path_uuid

* Handle COMMENT in MODIFY COLUMN without data type

When parsing MODIFY COLUMN col_name COMMENT 'comment', the COMMENT
keyword should not be parsed as a data type. Add COMMENT to the list
of tokens that indicate the type is omitted in parseColumnDeclaration.

Fixes test 00725_comment_columns_long (stmt9, stmt19, stmt21)

* Fix ANY/ALL keyword conflict with any()/all() function calls in expressions

The ANY/ALL subquery modifier check in parseBinaryExpression was
incorrectly triggering for all binary operators. When parsing expressions
like `any(x) >= 1 AND any(y) >= 2`, the parser would see the `any` keyword
after the AND operator and attempt to parse it as `expr >= ANY(subquery)`
pattern, causing incorrect AST structure.

This fix restricts the ANY/ALL check to only comparison operators
(=, ==, !=, <>, <, <=, >, >=) where this pattern is valid, preventing
conflicts with any()/all() function calls in AND/OR expressions.

Also flatten both sides of AND/OR chains in collectLogicalOperands
for correct EXPLAIN output matching ClickHouse format.

* Remove incorrect ln->log function name normalization

ClickHouse's EXPLAIN AST outputs 'ln' for the natural logarithm function,
not 'log'. The previous incorrect mapping was causing test failures.

* Handle boolean literals correctly in CAST expressions

Boolean literals in :: cast syntax should output as Bool_1/Bool_0
format instead of string 'true'/'false' to match ClickHouse EXPLAIN.

* Parse column definitions after TO target in MATERIALIZED VIEW

For MATERIALIZED VIEW ... TO target (columns) AS SELECT syntax,
column definitions can appear after the TO clause. Added parsing
support for this variant.

* Fix IN expression to include :: cast on right side without parentheses

When parsing `expr IN value::Type` (without parentheses around the IN list),
the :: cast was being applied to the entire IN expression instead of just
the value. Changed precedence from CALL to MUL_PREC to ensure :: is consumed
as part of the right-hand expression.

* Add IF NOT EXISTS support for ATTACH TABLE statement

The parser was treating IF as the table name instead of handling
IF NOT EXISTS as a modifier. Added IfNotExists field to AttachQuery
and parsing logic to handle the IF NOT EXISTS clause.

* Add implicit NULL for caseWithExpression without ELSE clause

When a CASE x WHEN form has no ELSE clause, ClickHouse implicitly uses
NULL as the else value. The explain output was missing this implicit NULL
for caseWithExpression (it was already correct for multiIf form).

* Add BACKUP and RESTORE statement support

Implement parsing and explain output for BACKUP and RESTORE statements:
- Add BACKUP and RESTORE tokens
- Add BackupQuery and RestoreQuery AST types
- Add parseBackup() and parseRestore() parser functions
- Add explain handlers for both query types

Fixes tests: 03286_backup_to_null and 03593_backup_with_broken_projection

* Distinguish EXCEPT set operation from column exclusion

When parsing expressions, check if EXCEPT is followed by SELECT to
determine if it's a set operation (SELECT (*) EXCEPT SELECT 1) vs
column exclusion (SELECT * EXCEPT (col1, col2)).

Fixes test: 03457_inconsistent_formatting_except

* Include function arguments in BACKUP/RESTORE explain output

Update explainBackupQuery and explainRestoreQuery to output function
arguments (e.g., Memory('b1') shows the ExpressionList with 'b1').

Fixes tests: 03286_backup_to_memory, 03276_database_backup_merge_tree_table_file_engine,
03278_database_backup_merge_tree_table_disk_engine, 03279_database_backup_database_disk_engine

* Allow keywords as CTE names in WITH clause

Support using keywords like 'table' as CTE names (e.g., WITH table AS
(SELECT 1 AS key)). Exclude NULL/TRUE/FALSE since they have special
literal meanings.

Fixes test: 03518_left_to_cross_incorrect

* Support WITH TIES modifier after TOP clause

Handle `SELECT TOP n WITH TIES *` syntax by consuming the WITH TIES
tokens after parsing the TOP expression.

Fixes test: 03725_empty_tuple_some_limit_with_ties_distinct

* Support SHOW TABLE and SHOW DATABASE as aliases

Treat `SHOW TABLE tablename` as equivalent to `SHOW CREATE TABLE tablename`
and `SHOW DATABASE dbname` as equivalent to `SHOW CREATE DATABASE dbname`.

Fixes tests: 02710_show_table, 03663_parameterized_views_formatting_of_substitutions_excessive_backticks

* Strip session/global prefix from MySQL system variables

For @@session.varname or @@global.varname syntax, strip the session/global
scope qualifier since ClickHouse treats them as just @@varname in EXPLAIN.

Fixes test: 01337_mysql_global_variables

* Add \e escape sequence support for PHP/MySQL style strings

Handle the \e escape sequence (escape character, ASCII 27) in string
literals for MySQL/PHP compatibility.

Fixes test: 01284_escape_sequences_php_mysql_style

* Fix OFFSET ROW parsing to accept both singular and plural forms

The SQL standard OFFSET...FETCH syntax uses singular "ROW" (e.g.,
"OFFSET 1 ROW") but the parser only checked for "ROWS" (plural).
This caused ROW to be incorrectly parsed as a subquery alias.

Fixed by checking for both "ROW" and "ROWS" when consuming the
optional keyword after the OFFSET expression.

* Support empty USING () clause in JOINs

When parsing USING (), distinguish between "no USING clause" (nil) and
"empty USING clause" (empty non-nil slice). This ensures the explain
output correctly shows the ExpressionList node even when empty.

* Fix SYSTEM command parsing for TTL MERGES table names

When parsing SYSTEM STOP/START TTL MERGES commands, the table name
was being consumed as part of the command because isSystemCommandKeyword()
uses case-insensitive matching. A table named 'ttl' would match 'TTL'.

Added check to break command parsing after certain complete command
suffixes (MERGES, MOVES, FETCHES, SENDS, MUTATIONS) so the next token
is correctly parsed as the table name.

* Allow EXISTS keyword as column identifier when not followed by (

In queries like 'WHERE exists' where 'exists' is a column name,
the parser was treating EXISTS as the start of an EXISTS(subquery)
expression and failing when no ( was found.

Now if EXISTS is not followed by (, it's treated as an identifier
(column name) instead of the subquery existence operator.

* Fix table alias parsing order - alias before FINAL

In ClickHouse syntax, table aliases come BEFORE the FINAL keyword:
  FROM table_name t FINAL WHERE ...

The parser was checking for FINAL before alias, which meant FINAL
wasn't being consumed when an alias was present. This caused the
subsequent UNION or WHERE clause to be missed.

Reordered to parse alias first, then FINAL, then SAMPLE.

* Fix ADD CONSTRAINT explain output to show expression

For ALTER TABLE ADD CONSTRAINT, the explain output was showing just
the constraint name as an Identifier. Changed to show the constraint's
expression properly:
  Constraint (children 1)
    Subquery/Function/etc (the expression)

This fixes subquery constraints like CHECK (SELECT 1).

* Fix tuple literal expansion in IN expressions and explain output

- In IN expressions, only expand tuple literals when all elements are
  parenthesized primitives (e.g., `1 IN (((1), (2)))` expands to
  Function tuple with 2 elements)
- Tuples with non-parenthesized elements or nested tuples stay as
  Literal Tuple_ (e.g., `(1, '') IN ((1, ''))` renders as
  Literal Tuple_(...))
- Update explainLiteral to check for parenthesized elements when
  deciding between Function tuple and Literal Tuple_ format

This fixes test 02370_analyzer_in_function and also enables
stmt8 in 03552_inconsistent_formatting_operator_as_table_function.

* Propagate WITH clause to subsequent SELECTs in UNION queries

In ClickHouse's EXPLAIN AST output, the WITH clause from the first
SELECT in a UNION ALL/UNION query is propagated to subsequent SELECTs.
The inherited WITH clause is output at the END of children for those
subsequent SELECT queries.

This fix applies the same WITH clause propagation logic that was
already implemented for INTERSECT/EXCEPT queries to plain UNION queries.

Fixes tests:
- 01515_with_global_and_with_propagation (stmt5, stmt11)
- 03671_pk_in_subquery_context_expired (stmt7)
- 03611_uniqExact_bug (stmt2)
- 03033_analyzer_resolve_from_parent_scope (stmt4)
- 01236_graphite_mt (stmt4)

* Fix database-qualified dictionary names in DETACH/ATTACH statements

The parser was not handling database-qualified dictionary names like
`db.dict` in DETACH DICTIONARY and ATTACH DICTIONARY statements.

Parser changes:
- parseDetach: Allow qualified names for DICTIONARY (database.dict)
- parseAttach: Allow qualified names for DICTIONARY (database.dict)

Explain changes:
- explainDetachQuery: Handle Database + Dictionary case
- explainAttachQuery: Handle Database + Dictionary case

Fixes tests:
- 01110_dictionary_layout_without_arguments (stmt7, stmt8)
- 01575_disable_detach_table_of_dictionary (stmt7, stmt9)
- 01018_ddl_dictionaries_create (stmt17, stmt22)

* Accept keywords as index type names in ALTER ADD INDEX

The parser was only accepting identifiers (token.IDENT) for index type
names like "set" in "ADD INDEX idx c TYPE set(0)". However, "set" is
tokenized as a keyword (token.SET). This fix allows keywords to be used
as index type names and AFTER index names, matching ClickHouse behavior.

Fixes tests:
- 01932_alter_index_with_order (stmt5, stmt6)
- 03629_storage_s3_disallow_index_alter (stmt3)
- 02131_skip_index_not_materialized (stmt4)

* Render arrays with parenthesized elements as Function array

Arrays containing parenthesized elements like [('a')] should be rendered
as Function array with children, not as Literal Array_[...]. This matches
ClickHouse's EXPLAIN AST behavior where parenthesized elements inside
arrays require the expanded function format.

Fixes tests:
- 02354_tuple_element_with_default (stmt5, stmt14)
- 03552_inconsistent_formatting_operator_as_table_function (stmt5)

* Handle LIMIT offset, count syntax after LIMIT BY clause

When parsing LIMIT after LIMIT BY (e.g., LIMIT 1 BY x LIMIT 5, 5), the
parser was only capturing the first value. This fix handles the comma
syntax to correctly parse both offset and count values.

Fixes test:
- 02003_WithMergeableStateAfterAggregationAndLimit_LIMIT_BY_LIMIT_OFFSET
  (stmt2, stmt3)

* Support IN PARTITION clause in DELETE statements

Added Partition field to DeleteQuery AST and parsing for the IN PARTITION
clause in lightweight DELETE statements. The syntax is:
DELETE FROM table IN PARTITION partition_expr WHERE condition

Fixes test:
- 02352_lightweight_delete_in_partition (stmt11, stmt12)

* Support qualified identifiers starting with keywords

When a keyword like SYSTEM is used as the start of a qualified name
(e.g., system.one.*), parseKeywordAsIdentifier was returning just the
keyword as a single-part identifier. Now it continues to parse DOT
sequences to build qualified identifiers and handle qualified asterisks.

Fixes tests:
- 00467_qualified_names (stmt19, stmt21)
- 00502_custom_partitioning_local (stmt17)

* Support TTL elements with WHERE conditions

Added TTLElement struct to store both the TTL expression and the optional
WHERE condition. Updated parser to correctly parse multiple TTL elements
separated by commas, including proper handling of SET clause comma
separation (SET assignments vs new TTL elements).

Fixes tests:
- 01622_multiple_ttls (stmt3, stmt11)
- 03236_create_query_ttl_where (stmt2)
- 03636_empty_projection_block (stmt1)
- 03622_ttl_infos_where (stmt3)
- 02932_set_ttl_where (stmt2)

* Support PARTITION ID syntax in OPTIMIZE TABLE statements

Add PartitionByID field to OptimizeQuery AST to distinguish PARTITION ID
'value' from PARTITION expr. The parser now detects the ID keyword after
PARTITION and sets this flag. The explain output renders Partition_ID with
the inline literal format matching ClickHouse's EXPLAIN AST output.

* Fix ALTER ADD INDEX tuple expression parsing

Simplified the index expression parsing in ALTER ADD INDEX to let
parseExpression handle parentheses naturally. This allows tuple
expressions like (a, b, c) to be parsed correctly, matching how
CREATE TABLE INDEX parsing works.

* Add support for KILL QUERY/MUTATION statements

Adds KillQuery AST type and parser for KILL QUERY/MUTATION statements.
The explain output matches ClickHouse format with the WHERE expression
operator in the header (e.g., Function_and) and SYNC/ASYNC mode.

* Enable duplicate output for RELOAD DICTIONARY in SYSTEM queries

Add RELOAD DICTIONARY to the list of SYSTEM commands that output
database/table identifiers twice in EXPLAIN AST format.

* Handle large number overflow and preserve original source text

- For hex numbers that overflow uint64 (like 0x123456789ABCDEF01), convert to Float64
- For decimal numbers that overflow, try float64 parsing
- Preserve original source text in Literal.Source for formatting in CAST expressions
- Update explain for negated uint64 values that overflow int64 to output Float64
- Use Source field in formatElementAsString to preserve exact text in array/tuple casts

* Add alias support for ArrayAccess and BetweenExpr in WITH clauses

- Add explainBetweenExprWithAlias to support aliases on BETWEEN expressions
- Add ArrayAccess and BetweenExpr cases to explainWithElement
- Enables WITH expr AS name syntax for array subscripts and BETWEEN clauses

* Handle empty PRIMARY KEY () in CREATE TABLE explain output

- Add HasEmptyColumnsPrimaryKey flag to CreateTableQuery and AttachQuery
- Set flag in parser when PRIMARY KEY () has empty parentheses
- Update explain output to show Function tuple with empty ExpressionList

* Support TTL DELETE WHERE clause in ALTER TABLE MODIFY TTL

- Update ALTER MODIFY TTL parsing to use parseTTLElement
- Capture WHERE condition in TTLElement for conditional deletion
- Update explain code to output TTLElement with WHERE as child

* Trim whitespace in query parameter name and type parsing

Parameters like {a1: Int32} with spaces after colon now
correctly parse as name=a1 type=Int32 without leading/trailing spaces

---------

Co-authored-by: Claude <[email protected]>

Author: kyleconroy

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)