Use parallel terminology for registration helpers

Author: mlafeldt

crates/duckdb/src/r2d2.rs

@@ -92,7 +92,7 @@ impl DuckdbConnectionManager {
     #[cfg(feature = "vscalar")]
     pub fn register_scalar_function<S: VScalar>(&self, name: &str) -> Result<()>
     where
-        S::State: Debug + Default,
+        S::ExtraInfo: Debug + Default,
     {
         let conn = self.connection.lock().unwrap();
         conn.register_scalar_function::<S>(name)

crates/duckdb/src/vscalar/arrow.rs

@@ -73,13 +73,13 @@ impl ArrowFunctionSignature {
 
 /// A trait for scalar functions that accept and return arrow types that can be registered with DuckDB
 pub trait VArrowScalar: Sized {
-    /// State set at registration time. Persists for the lifetime of the catalog entry.
+    /// Extra info set at registration time. Persists for the lifetime of the catalog entry.
     /// Shared across worker threads and invocations — must not be modified during execution.
     /// Must be `'static` as it is stored in DuckDB and may outlive the current stack frame.
-    type State: Default + Sized + Send + Sync + 'static;
+    type ExtraInfo: Default + Sized + Send + Sync + 'static;
 
     /// The actual function that is called by DuckDB
-    fn invoke(state: &Self::State, input: RecordBatch) -> Result<Arc<dyn Array>, Box<dyn std::error::Error>>;
+    fn invoke(extra_info: &Self::ExtraInfo, input: RecordBatch) -> Result<Arc<dyn Array>, Box<dyn std::error::Error>>;
 
     /// The possible signatures of the scalar function. These will result in DuckDB scalar function overloads.
     /// The invoke method should be able to handle all of these signatures.
@@ -90,14 +90,14 @@ impl<T> VScalar for T
 where
     T: VArrowScalar,
 {
-    type State = T::State;
+    type ExtraInfo = T::ExtraInfo;
 
     unsafe fn invoke(
-        state: &Self::State,
+        extra_info: &Self::ExtraInfo,
         input: &mut DataChunkHandle,
         out: &mut dyn WritableVector,
     ) -> Result<(), Box<dyn std::error::Error>> {
-        let array = T::invoke(state, data_chunk_to_arrow(input)?)?;
+        let array = T::invoke(extra_info, data_chunk_to_arrow(input)?)?;
         write_arrow_array_to_vector(&array, out)
     }
 
@@ -129,9 +129,9 @@ mod test {
     struct HelloScalarArrow {}
 
     impl VArrowScalar for HelloScalarArrow {
-        type State = ();
+        type ExtraInfo = ();
 
-        fn invoke(_: &Self::State, input: RecordBatch) -> Result<Arc<dyn Array>, Box<dyn std::error::Error>> {
+        fn invoke(_: &Self::ExtraInfo, input: RecordBatch) -> Result<Arc<dyn Array>, Box<dyn std::error::Error>> {
             let name = input.column(0).as_any().downcast_ref::<StringArray>().unwrap();
             let result = name.iter().map(|v| format!("Hello {}", v.unwrap())).collect::<Vec<_>>();
             Ok(Arc::new(StringArray::from(result)))
@@ -164,9 +164,9 @@ mod test {
     struct ArrowMultiplyScalar {}
 
     impl VArrowScalar for ArrowMultiplyScalar {
-        type State = MockState;
+        type ExtraInfo = MockState;
 
-        fn invoke(_: &Self::State, input: RecordBatch) -> Result<Arc<dyn Array>, Box<dyn std::error::Error>> {
+        fn invoke(_: &Self::ExtraInfo, input: RecordBatch) -> Result<Arc<dyn Array>, Box<dyn std::error::Error>> {
             let a = input
                 .column(0)
                 .as_any()
@@ -199,10 +199,13 @@ mod test {
     struct ArrowOverloaded {}
 
     impl VArrowScalar for ArrowOverloaded {
-        type State = MockState;
+        type ExtraInfo = MockState;
 
-        fn invoke(state: &Self::State, input: RecordBatch) -> Result<Arc<dyn Array>, Box<dyn std::error::Error>> {
-            assert_eq!("some meta", state.info);
+        fn invoke(
+            extra_info: &Self::ExtraInfo,
+            input: RecordBatch,
+        ) -> Result<Arc<dyn Array>, Box<dyn std::error::Error>> {
+            assert_eq!("some meta", extra_info.info);
 
             let a = input.column(0);
             let b = input.column(1);
@@ -336,9 +339,9 @@ mod test {
         struct SplitFunction {}
 
         impl VArrowScalar for SplitFunction {
-            type State = ();
+            type ExtraInfo = ();
 
-            fn invoke(_: &Self::State, input: RecordBatch) -> Result<Arc<dyn Array>, Box<dyn std::error::Error>> {
+            fn invoke(_: &Self::ExtraInfo, input: RecordBatch) -> Result<Arc<dyn Array>, Box<dyn std::error::Error>> {
                 let strings = input.column(0).as_any().downcast_ref::<StringArray>().unwrap();
 
                 let mut builder = arrow::array::ListBuilder::new(arrow::array::StringBuilder::with_capacity(

crates/duckdb/src/vscalar/mod.rs

@@ -23,10 +23,10 @@ pub use arrow::{ArrowFunctionSignature, ArrowScalarParams, VArrowScalar};
 
 /// Duckdb scalar function trait
 pub trait VScalar: Sized {
-    /// State set at registration time. Persists for the lifetime of the catalog entry.
+    /// Extra info set at registration time. Persists for the lifetime of the catalog entry.
     /// Shared across worker threads and invocations — must not be modified during execution.
     /// Must be `'static` as it is stored in DuckDB and may outlive the current stack frame.
-    type State: Sized + Send + Sync + 'static;
+    type ExtraInfo: Sized + Send + Sync + 'static;
     /// The actual function
     ///
     /// # Safety
@@ -36,7 +36,7 @@ pub trait VScalar: Sized {
     /// - Dereferences multiple raw pointers (`func`).
     ///
     unsafe fn invoke(
-        state: &Self::State,
+        extra_info: &Self::ExtraInfo,
         input: &mut DataChunkHandle,
         output: &mut dyn WritableVector,
     ) -> Result<(), Box<dyn std::error::Error>>;
@@ -110,7 +110,7 @@ impl From<duckdb_function_info> for ScalarFunctionInfo {
 }
 
 impl ScalarFunctionInfo {
-    pub unsafe fn get_scalar_extra_info<T>(&self) -> &T {
+    pub unsafe fn get_extra_info<T>(&self) -> &T {
         &*(duckdb_scalar_function_get_extra_info(self.0).cast())
     }
 
@@ -126,44 +126,48 @@ where
 {
     let info = ScalarFunctionInfo::from(info);
     let mut input = DataChunkHandle::new_unowned(input);
-    let result = T::invoke(info.get_scalar_extra_info(), &mut input, &mut output);
+    let result = T::invoke(info.get_extra_info(), &mut input, &mut output);
     if let Err(e) = result {
         info.set_error(&e.to_string());
     }
 }
 
 impl Connection {
-    /// Register the given ScalarFunction with default state.
+    /// Register the given ScalarFunction with default extra info.
     #[inline]
     pub fn register_scalar_function<S: VScalar>(&self, name: &str) -> crate::Result<()>
     where
-        S::State: Default,
+        S::ExtraInfo: Default,
     {
         let set = ScalarFunctionSet::new(name);
         for signature in S::signatures() {
             let scalar_function = ScalarFunction::new(name)?;
             signature.register_with_scalar(&scalar_function);
             scalar_function.set_function(Some(scalar_func::<S>));
-            scalar_function.set_extra_info(S::State::default());
+            scalar_function.set_extra_info(S::ExtraInfo::default());
             set.add_function(scalar_function)?;
         }
         self.db.borrow_mut().register_scalar_function_set(set)
     }
 
-    /// Register the given ScalarFunction with custom state.
+    /// Register the given ScalarFunction with custom extra info.
     ///
-    /// The state is cloned once per function signature (overload) and stored in DuckDB's catalog.
+    /// The extra info is cloned once per function signature (overload) and stored in DuckDB's catalog.
     #[inline]
-    pub fn register_scalar_function_with_state<S: VScalar>(&self, name: &str, state: &S::State) -> crate::Result<()>
+    pub fn register_scalar_function_with_extra_info<S: VScalar>(
+        &self,
+        name: &str,
+        extra_info: &S::ExtraInfo,
+    ) -> crate::Result<()>
     where
-        S::State: Clone,
+        S::ExtraInfo: Clone,
     {
         let set = ScalarFunctionSet::new(name);
         for signature in S::signatures() {
             let scalar_function = ScalarFunction::new(name)?;
             signature.register_with_scalar(&scalar_function);
             scalar_function.set_function(Some(scalar_func::<S>));
-            scalar_function.set_extra_info(state.clone());
+            scalar_function.set_extra_info(extra_info.clone());
             set.add_function(scalar_function)?;
         }
         self.db.borrow_mut().register_scalar_function_set(set)
@@ -196,10 +200,10 @@ mod test {
     struct ErrorScalar {}
 
     impl VScalar for ErrorScalar {
-        type State = ();
+        type ExtraInfo = ();
 
         unsafe fn invoke(
-            _: &Self::State,
+            _: &Self::ExtraInfo,
             input: &mut DataChunkHandle,
             _: &mut dyn WritableVector,
         ) -> Result<(), Box<dyn std::error::Error>> {
@@ -234,10 +238,10 @@ mod test {
     struct EchoScalar {}
 
     impl VScalar for EchoScalar {
-        type State = TestState;
+        type ExtraInfo = TestState;
 
         unsafe fn invoke(
-            state: &Self::State,
+            extra_info: &Self::ExtraInfo,
             input: &mut DataChunkHandle,
             output: &mut dyn WritableVector,
         ) -> Result<(), Box<dyn std::error::Error>> {
@@ -250,7 +254,7 @@ mod test {
             let output = output.flat_vector();
 
             for s in strings {
-                let res = format!("{}: {}", state.prefix, s.repeat(state.multiplier));
+                let res = format!("{}: {}", extra_info.prefix, s.repeat(extra_info.multiplier));
                 output.insert(0, res.as_str());
             }
             Ok(())
@@ -267,10 +271,10 @@ mod test {
     struct Repeat {}
 
     impl VScalar for Repeat {
-        type State = ();
+        type ExtraInfo = ();
 
         unsafe fn invoke(
-            _: &Self::State,
+            _: &Self::ExtraInfo,
             input: &mut DataChunkHandle,
             output: &mut dyn WritableVector,
         ) -> Result<(), Box<dyn std::error::Error>> {
@@ -317,9 +321,9 @@ mod test {
             }
         }
 
-        // Test with custom state
+        // Test with custom extra info
         {
-            conn.register_scalar_function_with_state::<EchoScalar>(
+            conn.register_scalar_function_with_extra_info::<EchoScalar>(
                 "echo2",
                 &TestState {
                     multiplier: 5,

crates/duckdb/src/vtab/function.rs

@@ -111,7 +111,7 @@ impl BindInfo {
     pub fn set_cardinality(&self, cardinality: idx_t, is_exact: bool) {
         unsafe { duckdb_bind_set_cardinality(self.ptr, cardinality, is_exact) }
     }
-    /// Retrieves the extra info of the function as set in [`TableFunction::with_extra_info`].
+    /// Retrieves the extra info of the function as set in [`TableFunction::set_extra_info`].
     pub fn get_extra_info<T>(&self) -> *const T {
         unsafe { duckdb_bind_get_extra_info(self.ptr).cast() }
     }
@@ -163,7 +163,7 @@ impl InitInfo {
         indices
     }
 
-    /// Retrieves the extra info of the function as set in [`TableFunction::with_extra_info`].
+    /// Retrieves the extra info of the function as set in [`TableFunction::set_extra_info`].
     pub fn get_extra_info<T>(&self) -> *const T {
         unsafe { duckdb_init_get_extra_info(self.0).cast() }
     }
@@ -306,35 +306,33 @@ impl TableFunction {
         self
     }
 
-    /// Assigns extra information to the table function that can be fetched during binding, etc.
+    /// Assigns extra information to the table function using raw pointers.
     ///
-    /// For most use cases, prefer [`with_extra_info`](Self::with_extra_info) which handles memory management automatically.
+    /// For most use cases, prefer [`set_extra_info`](Self::set_extra_info) which handles memory management automatically.
     ///
     /// # Arguments
-    /// * `extra_info`: The extra information
-    /// * `destroy`: The callback that will be called to destroy the bind data (if any)
+    /// * `extra_info`: The extra information as a raw pointer
+    /// * `destroy`: The callback that will be called to destroy the data (if any)
     ///
     /// # Safety
     /// The caller must ensure that `extra_info` is a valid pointer and that `destroy`
     /// properly cleans up the data when called.
-    pub unsafe fn set_extra_info(&self, extra_info: *mut c_void, destroy: duckdb_delete_callback_t) {
+    pub unsafe fn set_extra_info_raw(&self, extra_info: *mut c_void, destroy: duckdb_delete_callback_t) {
         duckdb_table_function_set_extra_info(self.ptr, extra_info, destroy);
     }
 
     /// Assigns extra information to the table function that can be fetched during binding, init, and execution.
     ///
-    /// This is a safe wrapper around [`set_extra_info`](Self::set_extra_info) that handles memory management automatically.
-    ///
     /// # Arguments
     /// * `info`: The extra information to store
-    pub fn with_extra_info<T>(&self, info: T) -> &Self
+    pub fn set_extra_info<T>(&self, info: T) -> &Self
     where
         T: Send + Sync + 'static,
     {
         unsafe {
             let boxed = Box::new(info);
             let ptr = Box::into_raw(boxed) as *mut c_void;
-            self.set_extra_info(ptr, Some(drop_boxed::<T>));
+            self.set_extra_info_raw(ptr, Some(drop_boxed::<T>));
         }
         self
     }
@@ -404,7 +402,7 @@ impl<V: VTab> TableFunctionInfo<V> {
         }
     }
 
-    /// Retrieves the extra info of the function as set in [`TableFunction::with_extra_info`].
+    /// Retrieves the extra info of the function as set in [`TableFunction::set_extra_info`].
     pub fn get_extra_info<T>(&self) -> *mut T {
         unsafe { duckdb_function_get_extra_info(self.ptr).cast() }
     }

crates/duckdb/src/vtab/mod.rs

@@ -169,7 +169,7 @@ impl Connection {
             .set_bind(Some(bind::<T>))
             .set_init(Some(init::<T>))
             .set_function(Some(func::<T>))
-            .with_extra_info(extra_info.clone());
+            .set_extra_info(extra_info.clone());
         for ty in T::parameters().unwrap_or_default() {
             table_function.add_parameter(&ty);
         }