feat(parser): MINUS as EXCEPT synonym in Snowflake/Oracle (#483) (#494)

Co-authored-by: Ajit Pratap Singh <ajitpratapsingh@Ajits-Mac-mini-2655.local>

Author: ajitpratap0

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_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

@@ -101,7 +101,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() {
+	if (p.isIdentifier() || p.isType(models.TokenTypeAs)) && !p.isMariaDBClauseStart() && !p.isPivotKeyword() && !p.isUnpivotKeyword() && !p.isQualifyKeyword() && !p.isMinusSetOp() {
 		if p.isType(models.TokenTypeAs) {
 			p.advance() // Consume AS
 			if !p.isIdentifier() {
@@ -215,7 +215,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() {
+	if (p.isIdentifier() || p.isType(models.TokenTypeAs)) && !p.isMariaDBClauseStart() && !p.isPivotKeyword() && !p.isUnpivotKeyword() && !p.isQualifyKeyword() && !p.isMinusSetOp() {
 		if p.isType(models.TokenTypeAs) {
 			p.advance()
 			if !p.isIdentifier() {