Merge remote-tracking branch 'origin/main' into feat/snowflake-time-travel-483

# Conflicts:
#	pkg/sql/parser/select_subquery.go

Author: Ajit Pratap Singh

pkg/sql/parser/clickhouse_with_fill_test.go

@@ -0,0 +1,34 @@
+// Copyright 2026 GoSQLX Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+
+package parser_test
+
+import (
+	"testing"
+
+	"github.com/ajitpratap0/GoSQLX/pkg/gosqlx"
+	"github.com/ajitpratap0/GoSQLX/pkg/sql/keywords"
+)
+
+// TestClickHouseOrderByWithFill verifies ClickHouse's `ORDER BY expr WITH
+// FILL [FROM..] [TO..] [STEP..]` modifier parses. Previously the WITH token
+// after ORDER BY items was mis-routed to the WITH-CTE parser. Regression
+// for #482.
+func TestClickHouseOrderByWithFill(t *testing.T) {
+	queries := map[string]string{
+		"bare":          `SELECT id FROM t ORDER BY id WITH FILL`,
+		"step_only":     `SELECT id FROM t ORDER BY id WITH FILL STEP 1`,
+		"from_to_step":  `SELECT day, count() FROM events GROUP BY day ORDER BY day WITH FILL FROM '2024-01-01' TO '2024-12-31' STEP INTERVAL 1 DAY`,
+		"multiple_cols": `SELECT a, b FROM t ORDER BY a WITH FILL STEP 1, b`,
+		"with_desc":     `SELECT id FROM t ORDER BY id DESC WITH FILL STEP 1`,
+	}
+	for name, q := range queries {
+		q := q
+		t.Run(name, func(t *testing.T) {
+			if _, err := gosqlx.ParseWithDialect(q, keywords.DialectClickHouse); err != nil {
+				t.Fatalf("parse failed: %v", err)
+			}
+		})
+	}
+}

pkg/sql/parser/minus_set_op_test.go

@@ -0,0 +1,62 @@
+// Copyright 2026 GoSQLX Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+
+package parser_test
+
+import (
+	"testing"
+
+	"github.com/ajitpratap0/GoSQLX/pkg/gosqlx"
+	"github.com/ajitpratap0/GoSQLX/pkg/sql/ast"
+	"github.com/ajitpratap0/GoSQLX/pkg/sql/keywords"
+)
+
+// TestMinusAsExceptSynonym verifies MINUS is accepted as a set operator
+// (synonym for EXCEPT) in Snowflake and Oracle dialects, and that it is
+// normalized to "EXCEPT" on the AST. Regression for #483.
+func TestMinusAsExceptSynonym(t *testing.T) {
+	dialects := []keywords.SQLDialect{
+		keywords.DialectSnowflake,
+		keywords.DialectOracle,
+	}
+	q := `SELECT id FROM a MINUS SELECT id FROM b`
+	for _, d := range dialects {
+		d := d
+		t.Run(string(d), func(t *testing.T) {
+			tree, err := gosqlx.ParseWithDialect(q, d)
+			if err != nil {
+				t.Fatalf("parse failed: %v", err)
+			}
+			if len(tree.Statements) != 1 {
+				t.Fatalf("want 1 statement, got %d", len(tree.Statements))
+			}
+			so, ok := tree.Statements[0].(*ast.SetOperation)
+			if !ok {
+				t.Fatalf("want *ast.SetOperation, got %T", tree.Statements[0])
+			}
+			if so.Operator != "EXCEPT" {
+				t.Fatalf("Operator: want %q, got %q", "EXCEPT", so.Operator)
+			}
+		})
+	}
+}
+
+// TestMinusNotSetOpInOtherDialects verifies that MINUS is still treated as
+// a table alias (not a set operator) in dialects that do not support it.
+// This protects against accidental hijacking in e.g. MySQL/PostgreSQL.
+func TestMinusNotSetOpInOtherDialects(t *testing.T) {
+	q := `SELECT id FROM a MINUS SELECT id FROM b`
+	// In dialects without MINUS-as-EXCEPT, the MINUS identifier is consumed
+	// as a table alias ("a AS MINUS") and "SELECT ..." starts a new statement.
+	// We expect either success with 2 statements, or at minimum no panic.
+	tree, err := gosqlx.ParseWithDialect(q, keywords.DialectPostgreSQL)
+	if err != nil {
+		return // error is acceptable; we only verify no hijacking
+	}
+	if len(tree.Statements) == 1 {
+		if _, isSetOp := tree.Statements[0].(*ast.SetOperation); isSetOp {
+			t.Fatal("PostgreSQL should not parse MINUS as a set operator")
+		}
+	}
+}

pkg/sql/parser/select_clauses.go

@@ -548,6 +548,17 @@ func (p *Parser) parseOrderByClause() ([]ast.OrderByExpression, error) {
 		}
 		entry.NullsFirst = nullsFirst
 
+		// ClickHouse WITH FILL per-entry tail:
+		//   ORDER BY expr [ASC|DESC] WITH FILL [FROM x] [TO y] [STEP z]
+		// Consume permissively; the clause is not modeled on the AST yet.
+		if p.dialect == string(keywords.DialectClickHouse) &&
+			p.isType(models.TokenTypeWith) &&
+			strings.EqualFold(p.peekToken().Token.Value, "FILL") {
+			p.advance() // WITH
+			p.advance() // FILL
+			p.skipClickHouseWithFillTail()
+		}
+
 		orderByExprs = append(orderByExprs, entry)
 
 		if !p.isType(models.TokenTypeComma) {
@@ -558,6 +569,26 @@ func (p *Parser) parseOrderByClause() ([]ast.OrderByExpression, error) {
 	return orderByExprs, nil
 }
 
+// skipClickHouseWithFillTail consumes the optional FROM / TO / STEP arguments
+// of a ClickHouse "ORDER BY expr WITH FILL" modifier. Each argument is a
+// single expression (possibly an INTERVAL). The tail ends at the next comma
+// (more ORDER BY items), next clause keyword, ';', or EOF.
+func (p *Parser) skipClickHouseWithFillTail() {
+	for {
+		val := strings.ToUpper(p.currentToken.Token.Value)
+		if val != "FROM" && val != "TO" && val != "STEP" {
+			return
+		}
+		p.advance() // FROM / TO / STEP
+		// Consume one expression; ignore parse errors so unusual forms
+		// (INTERVAL '1 day', expressions with function calls, etc.) don't
+		// surface as parser errors for this permissive skip.
+		if _, err := p.parseExpression(); err != nil {
+			return
+		}
+	}
+}
+
 // parseLimitOffsetClause parses optional LIMIT and/or OFFSET clauses.
 // Supports standard "LIMIT n OFFSET m", MySQL "LIMIT offset, count", and
 // SQL-99 "OFFSET n ROWS" (ROW/ROWS consumed but value stored).

pkg/sql/parser/select_set_ops.go

@@ -19,10 +19,12 @@ package parser
 
 import (
 	"fmt"
+	"strings"
 
 	goerrors "github.com/ajitpratap0/GoSQLX/pkg/errors"
 	"github.com/ajitpratap0/GoSQLX/pkg/models"
 	"github.com/ajitpratap0/GoSQLX/pkg/sql/ast"
+	"github.com/ajitpratap0/GoSQLX/pkg/sql/keywords"
 )
 
 // parseSelectWithSetOperations parses SELECT statements that may have set operations.
@@ -41,10 +43,16 @@ func (p *Parser) parseSelectWithSetOperations() (ast.Statement, error) {
 		return nil, err
 	}
 
-	// Check for set operations (UNION, EXCEPT, INTERSECT)
-	for p.isAnyType(models.TokenTypeUnion, models.TokenTypeExcept, models.TokenTypeIntersect) {
+	// Check for set operations (UNION, EXCEPT, INTERSECT). MINUS is a
+	// Snowflake / Oracle synonym for EXCEPT; it tokenizes as a plain
+	// identifier, so match it by value.
+	for p.isAnyType(models.TokenTypeUnion, models.TokenTypeExcept, models.TokenTypeIntersect) ||
+		p.isMinusSetOp() {
 		// Parse the set operation type
 		operationLiteral := p.currentToken.Token.Value
+		if p.isMinusSetOp() {
+			operationLiteral = "EXCEPT" // normalize to canonical name
+		}
 		p.advance()
 
 		// Check for ALL keyword
@@ -83,3 +91,18 @@ func (p *Parser) parseSelectWithSetOperations() (ast.Statement, error) {
 
 	return leftStmt, nil
 }
+
+// isMinusSetOp returns true if the current token is the Snowflake / Oracle
+// MINUS keyword used as a set operator (synonym for EXCEPT). MINUS tokenizes
+// as an identifier; gate by dialect so that MINUS as a legitimate column
+// alias in other dialects is not hijacked.
+func (p *Parser) isMinusSetOp() bool {
+	if p.dialect != string(keywords.DialectSnowflake) &&
+		p.dialect != string(keywords.DialectOracle) {
+		return false
+	}
+	if !p.isIdentifier() {
+		return false
+	}
+	return strings.EqualFold(p.currentToken.Token.Value, "MINUS")
+}

pkg/sql/parser/select_subquery.go

@@ -113,7 +113,7 @@ func (p *Parser) parseFromTableReference() (ast.TableReference, error) {
 	// Similarly, START followed by WITH is a hierarchical query seed, not an alias.
 	// Don't consume PIVOT/UNPIVOT as a table alias — they are contextual
 	// keywords in SQL Server/Oracle and must reach the pivot-clause parser below.
-	if (p.isIdentifier() || p.isType(models.TokenTypeAs)) && !p.isMariaDBClauseStart() && !p.isPivotKeyword() && !p.isUnpivotKeyword() && !p.isQualifyKeyword() && !p.isSnowflakeTimeTravelStart() {
+	if (p.isIdentifier() || p.isType(models.TokenTypeAs)) && !p.isMariaDBClauseStart() && !p.isPivotKeyword() && !p.isUnpivotKeyword() && !p.isQualifyKeyword() && !p.isMinusSetOp() && !p.isSnowflakeTimeTravelStart() {
 		if p.isType(models.TokenTypeAs) {
 			p.advance() // Consume AS
 			if !p.isIdentifier() {
@@ -227,7 +227,7 @@ func (p *Parser) parseJoinedTableRef(joinType string) (ast.TableReference, error
 	// Similarly, START followed by WITH is a hierarchical query seed, not an alias.
 	// Don't consume PIVOT/UNPIVOT as a table alias — they are contextual
 	// keywords in SQL Server/Oracle and must reach the pivot-clause parser below.
-	if (p.isIdentifier() || p.isType(models.TokenTypeAs)) && !p.isMariaDBClauseStart() && !p.isPivotKeyword() && !p.isUnpivotKeyword() && !p.isQualifyKeyword() && !p.isSnowflakeTimeTravelStart() {
+	if (p.isIdentifier() || p.isType(models.TokenTypeAs)) && !p.isMariaDBClauseStart() && !p.isPivotKeyword() && !p.isUnpivotKeyword() && !p.isQualifyKeyword() && !p.isMinusSetOp() && !p.isSnowflakeTimeTravelStart() {
 		if p.isType(models.TokenTypeAs) {
 			p.advance()
 			if !p.isIdentifier() {