feat(native): dispatch struct(...) and make_array(...) construction — TASK-37

native accepted these at fit (DataFusion) but infer() failed: struct(...) raised
'Unsupported expression' and make_array(...) 'Unknown function', on valid SQL the
library accepted at fit time. Two distinct gaps, not one:

- struct(a, b) / struct(a AS x, ...) parse into a first-class SqlExpr::Struct node
  (NOT a Function), so a new convert_expr arm handles it: positional -> c0/c1/...,
  named (Expr::Named) -> the alias, mirroring codegen's _convert_struct and
  DataFusion. The typed STRUCT<...>(...) form is rejected explicitly.
- The struct branch in convert_function was dead (sqlparser never routes
  struct(...) there) and is removed.
- make_array(...) IS a function; it now routes to Expr::List, the same path the
  bracket literal [a, b] already uses.

The three xfail_on_native markers are removed; all three pass on both engines.
array(...) (a DataFusion alias that also fails on native) is deliberately left out
-- not the pinned case, and adding it would be untested surface. Flagged for a
possible follow-up.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: ahrzb

src/expr_build.rs

@@ -80,6 +80,34 @@ pub fn convert_expr(e: &SqlExpr) -> Result<Expr, InterpError> {
         SqlExpr::Array(Array { elem, .. }) => Ok(Expr::List(
             elem.iter().map(convert_expr).collect::<Result<_, _>>()?,
         )),
+        // Authored struct(...) construction. sqlparser parses `struct(...)` into a
+        // first-class SqlExpr::Struct node (NOT a Function), so it never reaches
+        // convert_function -- which is why this must live here. `values` holds the
+        // elements: a bare expr is positional (field name c0, c1, ...), an
+        // `expr AS name` is Expr::Named (explicit field name). `fields` is only
+        // populated by the typed `STRUCT<a INT>(...)` form, which we don't support.
+        // Field naming mirrors codegen's _convert_struct and DataFusion:
+        // positional -> c{i}, named -> the alias as written.
+        SqlExpr::Struct { values, fields } => {
+            if !fields.is_empty() {
+                return Err(InterpError::Build(
+                    "typed STRUCT<...>(...) syntax is not supported; \
+                     use struct(a, b) or struct(a AS x, ...)"
+                        .to_string(),
+                ));
+            }
+            let out_fields = values
+                .iter()
+                .enumerate()
+                .map(|(i, v)| match v {
+                    SqlExpr::Named { expr, name } => {
+                        Ok((name.value.clone(), convert_expr(expr)?))
+                    }
+                    other => Ok((format!("c{i}"), convert_expr(other)?)),
+                })
+                .collect::<Result<Vec<_>, InterpError>>()?;
+            Ok(Expr::Struct(out_fields))
+        }
         SqlExpr::Cast {
             expr, data_type, ..
         } => Ok(Expr::Cast {
@@ -194,14 +222,16 @@ fn convert_function(func: &Function) -> Result<Expr, InterpError> {
         }
         return Ok(Expr::Struct(fields));
     }
-    if name == "struct" {
-        let fields = args
-            .into_iter()
-            .enumerate()
-            .map(|(i, e)| (format!("c{i}"), e))
-            .collect();
-        return Ok(Expr::Struct(fields));
+    // make_array(a, b) is a DataFusion builtin that constructs a list, same as
+    // the bracket literal [a, b] (which parses as SqlExpr::Array). Route it to the
+    // same Expr::List path. The `array(...)` spelling parses as SqlExpr::Array, not
+    // a Function, so it is already handled in convert_expr and not needed here.
+    if name == "make_array" {
+        return Ok(Expr::List(args));
     }
+    // NB: `struct(...)` does NOT reach here -- sqlparser parses it into a
+    // first-class SqlExpr::Struct node, handled in convert_expr. (An earlier
+    // `struct` case here was dead code and was removed.)
     Ok(Expr::Function { name, args })
 }
 

tests/test_diff_types.py

@@ -26,30 +26,31 @@ def test_list_construct():
 # native has no dispatch for them at all -- so they xfail_on_native, the same
 # parity-gap pattern as test_list_construct_mixed_numeric_widens. Codegen
 # correctness is the assertion; the native gaps want their own tickets.
-def test_struct_construct_positional(xfail_on_native):
-    # struct(a, b) names fields positionally c0, c1 (matches DataFusion).
-    xfail_on_native("native has no struct(...) construction dispatch (expr_build.rs)")
+def test_struct_construct_positional():
+    # struct(a, b) names fields positionally c0, c1 (matches DataFusion). Native
+    # handles it via a SqlExpr::Struct arm in convert_expr (TASK-37); struct(...)
+    # parses as a first-class node, not a function.
     check(
         "SELECT struct(a, b) AS s FROM t",
         {"t": rows({"a": "int", "b": "int"}, [{"a": 1, "b": 2}])},
         expect=[{"s": {"c0": 1, "c1": 2}}],
     )
 
 
-def test_struct_construct_named(xfail_on_native):
-    # struct(a AS x, b AS y) parses as exp.PropertyEQ -> explicit field names.
-    xfail_on_native("native has no struct(...) construction dispatch (expr_build.rs)")
+def test_struct_construct_named():
+    # struct(a AS x, b AS y) -> explicit field names (sqlparser Expr::Named,
+    # sqlglot exp.PropertyEQ). Native handles it in convert_expr (TASK-37).
     check(
         "SELECT struct(a AS x, b AS y) AS s FROM t",
         {"t": rows({"a": "int", "b": "int"}, [{"a": 1, "b": 2}])},
         expect=[{"s": {"x": 1, "y": 2}}],
     )
 
 
-def test_make_array_construct(xfail_on_native):
-    # make_array(a, b) is a DataFusion builtin; native doesn't recognize it as a
-    # function (only the bracket literal [a, b] reaches native's list path).
-    xfail_on_native("native has no make_array function dispatch (expr_build.rs)")
+def test_make_array_construct():
+    # make_array(a, b) is a DataFusion builtin. Native routes it to Expr::List in
+    # convert_function -- the same construction path the bracket literal [a, b]
+    # already uses (TASK-37).
     check(
         "SELECT make_array(a, b) AS l FROM t",
         {"t": rows({"a": "int", "b": "int"}, [{"a": 1, "b": 2}])},