fix: revert "feat(daft-ext): scalar daft_func macro with overloading (#6844)" (#6925)

## Changes Made

This reverts commit afb30af. It's an
immediate fix for an extension regression which is blocking the 0.7.11
release. After the release is fixed, we can reintroduce this with a
longer-term fix. We could also just remove the overloading things for
now and leave the proc macro as an immediate follow-up.

## Related Issues

#6922


This hasn't been verified, but a patch would be this. That being said,
I'd prefer the longer term fix which uses interior mutability with a
scalar function factory to fix the overload registration and allow for
overloads for both extensions and daft internal.

```rs
if self.variants.len() == 1 {
    return Ok(BuiltinScalarFnVariant::Sync(Arc::new(
        self.variants[0].as_ref().clone(),
    )));
}
```

Author: rchowell

examples/hello/hello/__init__.py

@@ -13,11 +13,6 @@ def greet(name: Expression) -> Expression:
     return daft.get_function("greet", name)
 
 
-def byte_length(input: Expression) -> Expression:
-    """Return the byte length of a string or binary column."""
-    return daft.get_function("byte_length", input)
-
-
 def string_count(name: Expression) -> Expression:
     """Count non-null strings."""
     return daft.get_aggregate_function("string_count", name)

examples/hello/src/lib.rs

@@ -1,6 +1,6 @@
 use std::{ffi::CStr, sync::Arc};
 
-use arrow_array::{Array, ArrayRef};
+use arrow_array::{Array, ArrayRef, builder::StringBuilder, cast::AsArray};
 use arrow_schema::{DataType, Field};
 use daft_ext::prelude::*;
 
@@ -12,31 +12,24 @@ struct HelloExtension;
 impl DaftExtension for HelloExtension {
     fn install(session: &mut dyn DaftSession) {
         session.define_function(Arc::new(Greet));
-        session.define_function(Arc::new(ByteLengthStr));
-        session.define_function(Arc::new(ByteLengthBin));
         session.define_aggregate_function(Arc::new(StringCount));
     }
 }
 
-// ── Scalar Function (row-level macro) ──────────────────────────────
-
-#[daft_func]
-fn greet(name: &str) -> String {
-    format!("Hello, {}!", name)
-}
-
-// ── Overloaded Function ────────────────────────────────────────────
-// Two variants registered under the same name "byte_length".
-// The host selects the right one at plan time based on input types.
-
-#[daft_func(name = "byte_length")]
-fn byte_length_str(input: &str) -> i64 {
-    input.len() as i64
-}
-
-#[daft_func(name = "byte_length")]
-fn byte_length_bin(input: &[u8]) -> i64 {
-    input.len() as i64
+// ── Scalar Function ────────────────────────────────────────────────
+
+#[daft_func_batch(return_dtype = DataType::Utf8)]
+fn greet(input: ArrayRef) -> DaftResult<ArrayRef> {
+    let names = input.as_string::<i64>();
+    let mut builder = StringBuilder::with_capacity(names.len(), names.len() * 16);
+    for i in 0..names.len() {
+        if names.is_null(i) {
+            builder.append_null();
+        } else {
+            builder.append_value(format!("Hello, {}!", names.value(i)));
+        }
+    }
+    Ok(Arc::new(builder.finish()))
 }
 
 // ── Aggregate Function ─────────────────────────────────────────────

examples/hello/tests/test_hello.py

@@ -2,7 +2,7 @@
 
 import hello
 import pytest
-from hello import byte_length, greet, string_count
+from hello import greet, string_count
 
 import daft
 from daft import col
@@ -57,36 +57,6 @@ def test_greet_show(capsys):
     print(captured)
 
 
-def test_byte_length_string():
-    sess = Session()
-    sess.load_extension(hello)
-
-    df = daft.from_pydict({"data": ["hello", "hi", None]})
-
-    with sess:
-        result = df.select(byte_length(col("data"))).collect().to_pydict()
-
-    values = result["byte_length"]
-    assert values[0] == 5
-    assert values[1] == 2
-    assert values[2] is None
-
-
-def test_byte_length_binary():
-    sess = Session()
-    sess.load_extension(hello)
-
-    df = daft.from_pydict({"data": [b"\x00\x01\x02", b"\xff", None]})
-
-    with sess:
-        result = df.select(byte_length(col("data"))).collect().to_pydict()
-
-    values = result["byte_length"]
-    assert values[0] == 3
-    assert values[1] == 1
-    assert values[2] is None
-
-
 def test_string_count():
     sess = Session()
     sess.load_extension(hello)

src/daft-catalog/src/bindings.rs

@@ -90,11 +90,6 @@ impl<T> Bindings<T> {
             .unwrap_or_default()
     }
 
-    /// Mutable lookup by exact name.
-    pub fn get_mut(&mut self, name: &str) -> Option<&mut T> {
-        self.bindings.get_mut(name)
-    }
-
     /// Removes the binding if it exists (exact-case).
     pub fn remove(&mut self, name: &str) {
         self.bindings.remove(name);

src/daft-dsl/src/functions/scalar.rs

@@ -176,7 +176,7 @@ impl From<BuiltinScalarFn> for ExprRef {
 ///   the ability for *type* resolution during planning via get_function. We can
 ///   build rule-based type resolution at a later time.
 ///
-pub trait ScalarFunctionFactory: Send + Sync + 'static {
+pub trait ScalarFunctionFactory: Send + Sync {
     /// The name of this function.
     fn name(&self) -> &'static str;
 
@@ -198,12 +198,6 @@ pub trait ScalarFunctionFactory: Send + Sync + 'static {
         args: FunctionArgs<ExprRef>,
         schema: &Schema,
     ) -> DaftResult<BuiltinScalarFnVariant>;
-
-    /// Enables downcasting to concrete types for overload resolution.
-    fn as_any(&self) -> &dyn std::any::Any;
-
-    /// Mutable downcasting for overload accumulation.
-    fn as_any_mut(&mut self) -> &mut dyn std::any::Any;
 }
 
 /// This is a concrete implementation of a ScalarFunction.
@@ -365,12 +359,4 @@ impl ScalarFunctionFactory for DynamicScalarFunction {
     ) -> DaftResult<BuiltinScalarFnVariant> {
         Ok(self.0.clone())
     }
-
-    fn as_any(&self) -> &dyn std::any::Any {
-        self
-    }
-
-    fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
-        self
-    }
 }

src/daft-ext-internal/src/function.rs

@@ -248,14 +248,6 @@ impl ScalarFunctionFactory for ScalarFunctionHandle {
     ) -> DaftResult<BuiltinScalarFnVariant> {
         Ok(BuiltinScalarFnVariant::Sync(Arc::new(self.clone())))
     }
-
-    fn as_any(&self) -> &dyn std::any::Any {
-        self
-    }
-
-    fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
-        self
-    }
 }
 
 /// Create a [`ScalarFunctionFactory`] from an `FFI_ScalarFunction` vtable.
@@ -269,74 +261,6 @@ pub fn into_scalar_function_factory(
     Arc::new(ScalarFunctionHandle::new(ffi, module))
 }
 
-/// Create a concrete [`ScalarFunctionHandle`] from an `FFI_ScalarFunction` vtable.
-///
-/// Unlike [`into_scalar_function_factory`], this returns the concrete type so callers
-/// can build [`OverloadedScalarFunctionFactory`] from multiple handles.
-pub fn into_scalar_function_handle(
-    ffi: FFI_ScalarFunction,
-    module: Arc<ModuleHandle>,
-) -> Arc<ScalarFunctionHandle> {
-    Arc::new(ScalarFunctionHandle::new(ffi, module))
-}
-
-/// Overloaded function factory holding multiple type-signature variants.
-///
-/// At plan time, probes each variant's `get_return_field` with the actual input
-/// types — the first variant whose arguments are an exact match is selected.
-/// No implicit coercions are attempted.
-#[derive(Clone)]
-pub struct OverloadedScalarFunctionFactory {
-    name: &'static str,
-    variants: Vec<Arc<ScalarFunctionHandle>>,
-}
-
-impl OverloadedScalarFunctionFactory {
-    pub fn new(name: &'static str, first: Arc<ScalarFunctionHandle>) -> Self {
-        Self {
-            name,
-            variants: vec![first],
-        }
-    }
-
-    pub fn add_variant(&mut self, variant: Arc<ScalarFunctionHandle>) {
-        self.variants.push(variant);
-    }
-}
-
-impl ScalarFunctionFactory for OverloadedScalarFunctionFactory {
-    fn name(&self) -> &'static str {
-        self.name
-    }
-
-    fn get_function(
-        &self,
-        args: FunctionArgs<ExprRef>,
-        schema: &Schema,
-    ) -> DaftResult<BuiltinScalarFnVariant> {
-        for variant in &self.variants {
-            if variant.get_return_field(args.clone(), schema).is_ok() {
-                return Ok(BuiltinScalarFnVariant::Sync(Arc::new(
-                    variant.as_ref().clone(),
-                )));
-            }
-        }
-        Err(DaftError::TypeError(format!(
-            "no matching overload for function '{}' ({} variant(s) available)",
-            self.name,
-            self.variants.len(),
-        )))
-    }
-
-    fn as_any(&self) -> &dyn std::any::Any {
-        self
-    }
-
-    fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
-        self
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use std::ffi::{CString, c_int, c_void};