test: cover ORM variant collapse and reshape AST transforms

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: radim

cluster_test.go

@@ -82,9 +82,9 @@ func TestGroupOrdering(t *testing.T) {
 	}
 }
 
-// Documents MVP behavior: alias stripping is deferred, so ORM variants
-// that differ only in aliases currently produce more than one cluster.
-// When Phase 0.x lands alias-strip, tighten this to `== 1`.
+// Alias-only variants collapse (reshape strips decorative aliases);
+// the LIMIT variant stays in its own cluster because LIMIT changes plan
+// shape and LIMIT subsumption is intentionally out of scope.
 func TestGroupORMVariantsCurrentBehavior(t *testing.T) {
 	in := []Query{
 		{Raw: "SELECT id, name FROM users WHERE id = $1", Calls: 1},
@@ -95,8 +95,8 @@ func TestGroupORMVariantsCurrentBehavior(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if len(out) < 2 {
-		t.Errorf("expected >= 2 clusters in MVP (alias strip deferred), got %d", len(out))
+	if len(out) != 2 {
+		t.Errorf("expected 2 clusters (alias variants collapse, LIMIT stays separate), got %d", len(out))
 	}
 	total := int64(0)
 	for _, c := range out {
@@ -107,6 +107,27 @@ func TestGroupORMVariantsCurrentBehavior(t *testing.T) {
 	}
 }
 
+// Safe ORM variants — alias-only, optional AS, AND-predicate reorder —
+// must collapse to a single canonical fingerprint.
+func TestGroupORMVariantsCollapse(t *testing.T) {
+	in := []Query{
+		{Raw: "SELECT id, name FROM users WHERE id = $1 AND status = $2", Calls: 1},
+		{Raw: "SELECT id, name FROM users WHERE status = $2 AND id = $1", Calls: 1},
+		{Raw: "SELECT u.id, u.name FROM users u WHERE u.id = $1 AND u.status = $2", Calls: 1},
+		{Raw: "SELECT u.id, u.name FROM users AS u WHERE u.status = $2 AND u.id = $1", Calls: 1},
+	}
+	out, err := Group(in)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(out) != 1 {
+		t.Fatalf("expected 1 cluster, got %d: %+v", len(out), out)
+	}
+	if out[0].TotalCalls != int64(len(in)) {
+		t.Errorf("TotalCalls = %d, want %d", out[0].TotalCalls, len(in))
+	}
+}
+
 func TestGroupUnparseable(t *testing.T) {
 	in := []Query{
 		{Raw: "SELECT FROM WHERE", Calls: 5},

normalize_test.go

@@ -43,3 +43,82 @@ func TestNormalizeInvalid(t *testing.T) {
 		t.Error("expected error on invalid SQL")
 	}
 }
+
+// Golden ORM fixtures: each group's variants must normalize to one canonical
+// form (decorative aliases stripped, optional AS absorbed by the deparser,
+// AND-predicates sorted), and distinct groups must not collide.
+func TestNormalizeORMFixtures(t *testing.T) {
+	groups := [][]string{
+		// Rails .where(id: ...) — alias, AS, renamed-alias variants
+		{
+			"SELECT id, name FROM users WHERE id = $1",
+			"SELECT u.id, u.name FROM users u WHERE u.id = $1",
+			"SELECT u.id, u.name FROM users AS u WHERE u.id = $1",
+			"SELECT users_alias.id, users_alias.name FROM users users_alias WHERE users_alias.id = $1",
+		},
+		// Rails/ActiveRecord .joins(:posts) — aliased JOIN + AND reorder
+		{
+			"SELECT u.id, p.title FROM users u JOIN posts p ON p.user_id = u.id WHERE u.id = $1 AND p.published = $2",
+			"SELECT u.id, p.title FROM users u JOIN posts p ON p.user_id = u.id WHERE p.published = $2 AND u.id = $1",
+			"SELECT u.id, p.title FROM users AS u INNER JOIN posts AS p ON p.user_id = u.id WHERE u.id = $1 AND p.published = $2",
+		},
+		// Soft-delete scope with AND reorder
+		{
+			"SELECT id FROM users WHERE tenant_id = $1 AND deleted_at IS NULL",
+			"SELECT u.id FROM users u WHERE u.tenant_id = $1 AND u.deleted_at IS NULL",
+			"SELECT u.id FROM users AS u WHERE u.deleted_at IS NULL AND u.tenant_id = $1",
+		},
+		// UPDATE with AND reorder
+		{
+			"UPDATE users SET name = $1 WHERE id = $2 AND tenant_id = $3",
+			"UPDATE users SET name = $1 WHERE tenant_id = $3 AND id = $2",
+		},
+		// DELETE with alias + AND reorder
+		{
+			"DELETE FROM users WHERE id = $1 AND tenant_id = $2",
+			"DELETE FROM users u WHERE u.id = $1 AND u.tenant_id = $2",
+			"DELETE FROM users WHERE tenant_id = $2 AND id = $1",
+		},
+		// Aggregate with alias + AND reorder (Prisma/Sequelize count pattern)
+		{
+			"SELECT COUNT(*) FROM orders WHERE status = $1 AND user_id = $2",
+			"SELECT COUNT(*) FROM orders o WHERE o.status = $1 AND o.user_id = $2",
+			"SELECT COUNT(*) FROM orders WHERE user_id = $2 AND status = $1",
+		},
+		// INSERT with RETURNING — separate canonical form from plain INSERT
+		{
+			"INSERT INTO users (name, email) VALUES ($1, $2) RETURNING id",
+		},
+		// Prisma findUnique-style alias variants
+		{
+			"SELECT id, email, created_at FROM users WHERE email = $1 LIMIT 1",
+			"SELECT u.id, u.email, u.created_at FROM users u WHERE u.email = $1 LIMIT 1",
+		},
+	}
+
+	canonicals := make(map[string]int)
+	total := 0
+	for gi, group := range groups {
+		var first string
+		for vi, raw := range group {
+			got, err := Normalize(raw)
+			if err != nil {
+				t.Fatalf("group %d variant %d: Normalize(%q) error: %v", gi, vi, raw, err)
+			}
+			if vi == 0 {
+				first = got
+				if prev, dup := canonicals[got]; dup {
+					t.Errorf("group %d canonical %q collides with group %d", gi, got, prev)
+				}
+				canonicals[got] = gi
+			} else if got != first {
+				t.Errorf("group %d variant %d diverged:\n  first:  %q\n  this:   %q\n  input:  %q",
+					gi, vi, first, got, raw)
+			}
+			total++
+		}
+	}
+	if total < 20 {
+		t.Errorf("fixture count = %d, want >= 20 per Phase 0.x target", total)
+	}
+}

reshape_test.go

@@ -0,0 +1,170 @@
+package qshape
+
+import "testing"
+
+func TestReshapeStripsSingleTableAlias(t *testing.T) {
+	got, err := Normalize("SELECT u.id, u.name FROM users u WHERE u.id = $1")
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := "SELECT id, name FROM users WHERE id = $1"
+	if got != want {
+		t.Errorf("got:  %q\nwant: %q", got, want)
+	}
+}
+
+func TestReshapeLeavesUnaliasedUnchanged(t *testing.T) {
+	got, err := Normalize("SELECT id FROM users WHERE id = $1")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != "SELECT id FROM users WHERE id = $1" {
+		t.Errorf("unexpected rewrite: %q", got)
+	}
+}
+
+func TestReshapeORMVariantsCollapse(t *testing.T) {
+	fpA, err := Fingerprint("SELECT id, name FROM users WHERE id = $1")
+	if err != nil {
+		t.Fatal(err)
+	}
+	fpB, err := Fingerprint("SELECT u.id, u.name FROM users u WHERE u.id = $1")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if fpA != fpB {
+		t.Errorf("aliased and unaliased should fingerprint the same:\n  bare:    %s\n  aliased: %s", fpA, fpB)
+	}
+}
+
+func TestReshapeSortsFlatAndTree(t *testing.T) {
+	// The two queries differ only in AND-conjunct ordering; they should
+	// reshape to the same form
+	a, err := Normalize("SELECT id FROM users WHERE a = $1 AND b = $2")
+	if err != nil {
+		t.Fatal(err)
+	}
+	b, err := Normalize("SELECT id FROM users WHERE b = $2 AND a = $1")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if a != b {
+		t.Errorf("reordered AND conjuncts did not collapse:\n  a: %q\n  b: %q", a, b)
+	}
+}
+
+func TestReshapeIdempotent(t *testing.T) {
+	cases := []string{
+		"SELECT u.id FROM users u WHERE u.id = $1 AND u.tenant_id = $2",
+		"SELECT id FROM users",
+		"SELECT id FROM users WHERE b = $1 AND a = $2 AND c = $3",
+		"UPDATE users SET name = $1 WHERE id = $2",
+		"SELECT u.id, o.total FROM users u JOIN orders o ON o.user_id = u.id",
+		"SELECT a.id FROM users a JOIN users b ON a.id = b.parent_id",
+		"WITH recent AS (SELECT id FROM users) SELECT id FROM recent",
+	}
+	for _, in := range cases {
+		first, err := Normalize(in)
+		if err != nil {
+			t.Fatalf("%q: %v", in, err)
+		}
+		second, err := Normalize(first)
+		if err != nil {
+			t.Fatalf("%q (second pass): %v", first, err)
+		}
+		if first != second {
+			t.Errorf("not idempotent for %q:\n  first:  %q\n  second: %q", in, first, second)
+		}
+	}
+}
+
+func TestReshapeJoinStripsDecorativeAliases(t *testing.T) {
+	got, err := Normalize("SELECT u.id, o.total FROM users u INNER JOIN orders o ON o.user_id = u.id WHERE u.tenant = $1")
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := "SELECT id, total FROM users JOIN orders ON user_id = id WHERE tenant = $1"
+	if got != want {
+		t.Errorf("got:  %q\nwant: %q", got, want)
+	}
+}
+
+func TestReshapeSelfJoinPreservesAliases(t *testing.T) {
+	got, err := Normalize("SELECT a.id FROM users a INNER JOIN users b ON a.id = b.parent_id")
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Both aliases must stay — otherwise the join is ambiguous
+	if got != "SELECT a.id FROM users a JOIN users b ON a.id = b.parent_id" {
+		t.Errorf("self-join aliases got stripped: %q", got)
+	}
+}
+
+func TestReshapeRangeSubselectAliasRequired(t *testing.T) {
+	// SQL syntactically requires the alias on a subselect in FROM
+	got, err := Normalize("SELECT s.id FROM (SELECT id FROM users) s")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != "SELECT s.id FROM (SELECT id FROM users) s" {
+		t.Errorf("subselect alias got stripped: %q", got)
+	}
+}
+
+func TestReshapeUpdateStripsAlias(t *testing.T) {
+	got, err := Normalize("UPDATE users u SET name = $1 WHERE u.id = $2")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != "UPDATE users SET name = $1 WHERE id = $2" {
+		t.Errorf("got: %q", got)
+	}
+}
+
+func TestReshapeDeleteStripsAlias(t *testing.T) {
+	got, err := Normalize("DELETE FROM users u WHERE u.id = $1")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != "DELETE FROM users WHERE id = $1" {
+		t.Errorf("got: %q", got)
+	}
+}
+
+func TestReshapeCorrelatedSubqueryRewritesOuterRef(t *testing.T) {
+	got, err := Normalize("SELECT u.id FROM users u WHERE EXISTS (SELECT 1 FROM orders o WHERE o.user_id = u.id)")
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Outer `u` stripped; correlated `u.id` inside subquery must also
+	// be rewritten, or the deparsed SQL references a missing alias
+	want := "SELECT id FROM users WHERE EXISTS (SELECT 1 FROM orders WHERE user_id = id)"
+	if got != want {
+		t.Errorf("got:  %q\nwant: %q", got, want)
+	}
+}
+
+func TestReshapeCTEGetsOwnScope(t *testing.T) {
+	got, err := Normalize("WITH recent AS (SELECT u.id FROM users u WHERE u.created_at > $1) SELECT r.id FROM recent r")
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := "WITH recent AS (SELECT id FROM users WHERE created_at > $1) SELECT id FROM recent"
+	if got != want {
+		t.Errorf("got:  %q\nwant: %q", got, want)
+	}
+}
+
+func TestReshapeUnionBothArms(t *testing.T) {
+	a, err := Normalize("SELECT u.id FROM users u UNION SELECT o.user_id FROM orders o")
+	if err != nil {
+		t.Fatal(err)
+	}
+	b, err := Normalize("SELECT id FROM users UNION SELECT user_id FROM orders")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if a != b {
+		t.Errorf("UNION arms did not collapse to the same form:\n  a: %q\n  b: %q", a, b)
+	}
+}