Add missing scalar functions: get_field, union_extract, union_tag, arrow_metadata, version, row

Expose upstream DataFusion scalar functions that were not yet available
in the Python API. Closes #1453.

- get_field: extracts a field from a struct or map by name
- union_extract: extracts a value from a union type by field name
- union_tag: returns the active field name of a union type
- arrow_metadata: returns Arrow field metadata (all or by key)
- version: returns the DataFusion version string
- row: alias for the struct constructor

Note: arrow_try_cast was listed in the issue but does not exist in
DataFusion 53, so it is not included.

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

Author: timsaucer

crates/core/src/functions.rs

@@ -631,8 +631,29 @@ expr_fn_vec!(named_struct);
 expr_fn!(from_unixtime, unixtime);
 expr_fn!(arrow_typeof, arg_1);
 expr_fn!(arrow_cast, arg_1 datatype);
+expr_fn_vec!(arrow_metadata);
+expr_fn!(union_tag, arg1);
 expr_fn!(random);
 
+#[pyfunction]
+fn get_field(expr: PyExpr, name: PyExpr) -> PyExpr {
+    functions::core::get_field()
+        .call(vec![expr.into(), name.into()])
+        .into()
+}
+
+#[pyfunction]
+fn union_extract(union_expr: PyExpr, field_name: PyExpr) -> PyExpr {
+    functions::core::union_extract()
+        .call(vec![union_expr.into(), field_name.into()])
+        .into()
+}
+
+#[pyfunction]
+fn version() -> PyExpr {
+    functions::core::version().call(vec![]).into()
+}
+
 // Array Functions
 array_fn!(array_append, array element);
 array_fn!(array_to_string, array delimiter);
@@ -940,6 +961,7 @@ pub(crate) fn init_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(array_agg))?;
     m.add_wrapped(wrap_pyfunction!(arrow_typeof))?;
     m.add_wrapped(wrap_pyfunction!(arrow_cast))?;
+    m.add_wrapped(wrap_pyfunction!(arrow_metadata))?;
     m.add_wrapped(wrap_pyfunction!(ascii))?;
     m.add_wrapped(wrap_pyfunction!(asin))?;
     m.add_wrapped(wrap_pyfunction!(asinh))?;
@@ -1063,6 +1085,10 @@ pub(crate) fn init_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(trim))?;
     m.add_wrapped(wrap_pyfunction!(trunc))?;
     m.add_wrapped(wrap_pyfunction!(upper))?;
+    m.add_wrapped(wrap_pyfunction!(get_field))?;
+    m.add_wrapped(wrap_pyfunction!(union_extract))?;
+    m.add_wrapped(wrap_pyfunction!(union_tag))?;
+    m.add_wrapped(wrap_pyfunction!(version))?;
     m.add_wrapped(wrap_pyfunction!(self::uuid))?; // Use self to avoid name collision
     m.add_wrapped(wrap_pyfunction!(var_pop))?;
     m.add_wrapped(wrap_pyfunction!(var_sample))?;

python/datafusion/functions.py

@@ -90,6 +90,7 @@
     "array_to_string",
     "array_union",
     "arrow_cast",
+    "arrow_metadata",
     "arrow_typeof",
     "ascii",
     "asin",
@@ -149,6 +150,7 @@
     "floor",
     "from_unixtime",
     "gcd",
+    "get_field",
     "in_list",
     "initcap",
     "isnan",
@@ -242,6 +244,7 @@
     "reverse",
     "right",
     "round",
+    "row",
     "row_number",
     "rpad",
     "rtrim",
@@ -282,12 +285,15 @@
     "translate",
     "trim",
     "trunc",
+    "union_extract",
+    "union_tag",
     "upper",
     "uuid",
     "var",
     "var_pop",
     "var_samp",
     "var_sample",
+    "version",
     "when",
     # Window Functions
     "window",
@@ -2492,6 +2498,86 @@ def arrow_cast(expr: Expr, data_type: Expr) -> Expr:
     return Expr(f.arrow_cast(expr.expr, data_type.expr))
 
 
+def arrow_metadata(*args: Expr) -> Expr:
+    """Returns the metadata of the input expression.
+
+    If called with one argument, returns a Map of all metadata key-value pairs.
+    If called with two arguments, returns the value for the specified metadata key.
+
+    Args:
+        args: An expression, optionally followed by a metadata key string.
+
+    Returns:
+        A Map of metadata or a specific metadata value.
+    """
+    args = [arg.expr for arg in args]
+    return Expr(f.arrow_metadata(*args))
+
+
+def get_field(expr: Expr, name: Expr) -> Expr:
+    """Extracts a field from a struct or map by name.
+
+    Args:
+        expr: A struct or map expression.
+        name: The field name to extract.
+
+    Returns:
+        The value of the named field.
+    """
+    return Expr(f.get_field(expr.expr, name.expr))
+
+
+def union_extract(union_expr: Expr, field_name: Expr) -> Expr:
+    """Extracts a value from a union type by field name.
+
+    Returns the value of the named field if it is the currently selected
+    variant, otherwise returns NULL.
+
+    Args:
+        union_expr: A union-typed expression.
+        field_name: The name of the field to extract.
+
+    Returns:
+        The extracted value or NULL.
+    """
+    return Expr(f.union_extract(union_expr.expr, field_name.expr))
+
+
+def union_tag(union_expr: Expr) -> Expr:
+    """Returns the tag (active field name) of a union type.
+
+    Args:
+        union_expr: A union-typed expression.
+
+    Returns:
+        The name of the currently selected field in the union.
+    """
+    return Expr(f.union_tag(union_expr.expr))
+
+
+def version() -> Expr:
+    """Returns the DataFusion version string.
+
+    Returns:
+        A string describing the DataFusion version.
+    """
+    return Expr(f.version())
+
+
+def row(*args: Expr) -> Expr:
+    """Returns a struct with the given arguments.
+
+    This is an alias for :py:func:`struct`.
+
+    Args:
+        args: The expressions to include in the struct.
+
+    Returns:
+        A struct expression.
+    """
+    return struct(*args)
+
+
 def random() -> Expr:
     """Returns a random value in the range ``0.0 <= x < 1.0``.