fix: dict-form by: rejects alias collisions with input columns

ray_table_add_col appends a new column without dedup'ing schema
names, and ray_table_get_col returns the FIRST matching column by
id.  So when a dict-form by: reused an alias that already existed
in the input table — e.g.

  (table [o G V] ...)
  (select {from: t by: {o: G} s: (sum V)})

my previous commit happily added a second column named 'o, but the
group-by key scanner then returned the ORIGINAL 'o column, silently
grouping on the wrong data.

Two cases to distinguish:

  1. Trivial self-alias  {x: x}: the user just wants the existing
     column as a group key with the same name.  Skip the eval/add
     step entirely and use the input column directly.

  2. Any other collision  {x: <anything-but-x>}: error out with
     a clear domain message.  Users must pick a distinct alias or
     drop the shadowed input column first.

Also guards against within-dict duplicate keys ({x: A x: B}) by
tracking the names added in this loop.

Regression tests:
  - shadow case raises "domain" error
  - trivial self-alias {G: G} groups on G as expected
  - xbar-bucket dict case still passes (no regression)
652/652 tests pass.

Author: singaraiona

src/ops/query.c

@@ -890,6 +890,31 @@ ray_t* ray_select_fn(ray_t** args, int64_t n) {
                 fail_err = ray_error("domain", "by-dict key must be a symbol name");
                 failed = true; break;
             }
+            /* Collision check: if the dict key already exists in the
+             * input table, ray_table_add_col would append a second
+             * column with the same name and ray_table_get_col finds
+             * the ORIGINAL, so the group-by would silently scan the
+             * user's existing column instead of our materialised
+             * one.  Allow two specific exceptions:
+             *   - {x: x} (trivial self-alias — existing col already
+             *      is what we want)
+             *   - a later dict key reusing a name we just added in
+             *     this loop (guarded separately via i_added[]). */
+            bool already_in_tbl = (ray_table_get_col(tbl, k->i64) != NULL);
+            bool trivial_self = (v->type == -RAY_SYM && v->i64 == k->i64);
+            bool we_added_it = false;
+            for (int64_t j = 0; j < i && !we_added_it; j++)
+                if (d_elems[j * 2]->i64 == k->i64) we_added_it = true;
+            if (already_in_tbl && !trivial_self && !we_added_it) {
+                fail_err = ray_error("domain",
+                    "by-dict alias shadows an existing input column");
+                failed = true; break;
+            }
+            if (trivial_self && !we_added_it) {
+                /* No eval / no add: just group on the existing col. */
+                sv_data[i] = k->i64;
+                continue;
+            }
             ray_t* col_vec = ray_eval(v);
             if (!col_vec || RAY_IS_ERR(col_vec)) {
                 fail_err = col_vec ? col_vec : ray_error("domain", "by-dict val eval");

test/test_lang_rf.inc

@@ -5447,6 +5447,25 @@ static MunitResult test_rf_group(const void* params, void* fixture) {
     ASSERT_EQ("(at (at rX 's) 3)", "5");   /* 5    */
     ASSERT_EQ("(at (at rX 's) 4)", "6");   /* 6    */
 
+    /* Shadow protection: a dict alias that already exists as an
+     * input column would cause ray_table_add_col to append a
+     * second column with the same name; ray_table_get_col finds
+     * the original and the group-by would silently scan the
+     * wrong data.  Reject with a clear domain error. */
+    ASSERT_ER(
+        "(set tSh (table [o G V] (list [1 2 3] [a a b] [10 20 30])))"
+        "(select {from: tSh by: {o: G} s: (sum V)})", "domain");
+
+    /* Trivial self-alias {X: X} is a no-op rename onto the column
+     * that's already there — allowed and produces the expected
+     * group-by on the existing column. */
+    ASSERT_EQ(
+        "(set tTS (table [G V] (list [a a b] [1 2 3])))"
+        "(set rTS (select {from: tTS by: {G: G} s: (sum V)}))"
+        "(count rTS)", "2");
+    ASSERT_EQ("(at (at rTS 's) 0)", "3");  /* a: 1+2 */
+    ASSERT_EQ("(at (at rTS 's) 1)", "3");  /* b: 3 */
+
     // ========== GROUP BY STRING COLUMN ==========
     // Tests for grouping by list of strings (TYPE_LIST of TYPE_C8)
     // This tests the fix for parallel radix partitioning bug where identical strings