Reverted public API breaking changes

mlafeldt · mlafeldt · commit b96eda5d9cbb · 2025-12-03T09:25:29.000+01:00
diff --git a/crates/duckdb/src/r2d2.rs b/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::ExtraInfo: Debug + Default,
+        S::State: Debug + Default,
     {
         let conn = self.connection.lock().unwrap();
         conn.register_scalar_function::<S>(name)
diff --git a/crates/duckdb/src/vscalar/arrow.rs b/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 {
-    /// Extra info set at registration time. Persists for the lifetime of the catalog entry.
+    /// State 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 ExtraInfo: Default + Sized + Send + Sync + 'static;
+    type State: Default + Sized + Send + Sync + 'static;
 
     /// The actual function that is called by DuckDB
-    fn invoke(extra_info: &Self::ExtraInfo, input: RecordBatch) -> Result<Arc<dyn Array>, Box<dyn std::error::Error>>;
+    fn invoke(state: &Self::State, 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 ExtraInfo = T::ExtraInfo;
+    type State = T::State;
 
     unsafe fn invoke(
-        extra_info: &Self::ExtraInfo,
+        state: &Self::State,
         input: &mut DataChunkHandle,
         out: &mut dyn WritableVector,
     ) -> Result<(), Box<dyn std::error::Error>> {
-        let array = T::invoke(extra_info, data_chunk_to_arrow(input)?)?;
+        let array = T::invoke(state, 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 ExtraInfo = ();
+        type State = ();
 
-        fn invoke(_: &Self::ExtraInfo, input: RecordBatch) -> Result<Arc<dyn Array>, Box<dyn std::error::Error>> {
+        fn invoke(_: &Self::State, 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 ExtraInfo = MockState;
+        type State = MockState;
 
-        fn invoke(_: &Self::ExtraInfo, input: RecordBatch) -> Result<Arc<dyn Array>, Box<dyn std::error::Error>> {
+        fn invoke(_: &Self::State, input: RecordBatch) -> Result<Arc<dyn Array>, Box<dyn std::error::Error>> {
             let a = input
                 .column(0)
                 .as_any()
@@ -199,13 +199,10 @@ mod test {
     struct ArrowOverloaded {}
 
     impl VArrowScalar for ArrowOverloaded {
-        type ExtraInfo = MockState;
+        type State = MockState;
 
-        fn invoke(
-            extra_info: &Self::ExtraInfo,
-            input: RecordBatch,
-        ) -> Result<Arc<dyn Array>, Box<dyn std::error::Error>> {
-            assert_eq!("some meta", extra_info.info);
+        fn invoke(state: &Self::State, input: RecordBatch) -> Result<Arc<dyn Array>, Box<dyn std::error::Error>> {
+            assert_eq!("some meta", state.info);
 
             let a = input.column(0);
             let b = input.column(1);
@@ -339,9 +336,9 @@ mod test {
         struct SplitFunction {}
 
         impl VArrowScalar for SplitFunction {
-            type ExtraInfo = ();
+            type State = ();
 
-            fn invoke(_: &Self::ExtraInfo, input: RecordBatch) -> Result<Arc<dyn Array>, Box<dyn std::error::Error>> {
+            fn invoke(_: &Self::State, 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(
diff --git a/crates/duckdb/src/vscalar/mod.rs b/crates/duckdb/src/vscalar/mod.rs
@@ -23,10 +23,10 @@ pub use arrow::{ArrowFunctionSignature, ArrowScalarParams, VArrowScalar};
 
 /// Duckdb scalar function trait
 pub trait VScalar: Sized {
-    /// Extra info set at registration time. Persists for the lifetime of the catalog entry.
+    /// State 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 ExtraInfo: Sized + Send + Sync + 'static;
+    type State: Sized + Send + Sync + 'static;
     /// The actual function
     ///
     /// # Safety
@@ -36,7 +36,7 @@ pub trait VScalar: Sized {
     /// - Dereferences multiple raw pointers (`func`).
     ///
     unsafe fn invoke(
-        extra_info: &Self::ExtraInfo,
+        state: &Self::State,
         input: &mut DataChunkHandle,
         output: &mut dyn WritableVector,
     ) -> Result<(), Box<dyn std::error::Error>>;
@@ -133,41 +133,37 @@ where
 }
 
 impl Connection {
-    /// Register the given ScalarFunction with default extra info.
+    /// Register the given ScalarFunction with default state.
     #[inline]
     pub fn register_scalar_function<S: VScalar>(&self, name: &str) -> crate::Result<()>
     where
-        S::ExtraInfo: Default,
+        S::State: 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::ExtraInfo::default());
+            scalar_function.set_extra_info(S::State::default());
             set.add_function(scalar_function)?;
         }
         self.db.borrow_mut().register_scalar_function_set(set)
     }
 
-    /// Register the given ScalarFunction with custom extra info.
+    /// Register the given ScalarFunction with custom state.
     ///
-    /// The extra info is cloned once per function signature (overload) and stored in DuckDB's catalog.
+    /// The state is cloned once per function signature (overload) and stored in DuckDB's catalog.
     #[inline]
-    pub fn register_scalar_function_with_extra_info<S: VScalar>(
-        &self,
-        name: &str,
-        extra_info: &S::ExtraInfo,
-    ) -> crate::Result<()>
+    pub fn register_scalar_function_with_state<S: VScalar>(&self, name: &str, state: &S::State) -> crate::Result<()>
     where
-        S::ExtraInfo: Clone,
+        S::State: 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(extra_info.clone());
+            scalar_function.set_extra_info(state.clone());
             set.add_function(scalar_function)?;
         }
         self.db.borrow_mut().register_scalar_function_set(set)
@@ -200,10 +196,10 @@ mod test {
     struct ErrorScalar {}
 
     impl VScalar for ErrorScalar {
-        type ExtraInfo = ();
+        type State = ();
 
         unsafe fn invoke(
-            _: &Self::ExtraInfo,
+            _: &Self::State,
             input: &mut DataChunkHandle,
             _: &mut dyn WritableVector,
         ) -> Result<(), Box<dyn std::error::Error>> {
@@ -238,10 +234,10 @@ mod test {
     struct EchoScalar {}
 
     impl VScalar for EchoScalar {
-        type ExtraInfo = TestState;
+        type State = TestState;
 
         unsafe fn invoke(
-            extra_info: &Self::ExtraInfo,
+            state: &Self::State,
             input: &mut DataChunkHandle,
             output: &mut dyn WritableVector,
         ) -> Result<(), Box<dyn std::error::Error>> {
@@ -254,7 +250,7 @@ mod test {
             let output = output.flat_vector();
 
             for s in strings {
-                let res = format!("{}: {}", extra_info.prefix, s.repeat(extra_info.multiplier));
+                let res = format!("{}: {}", state.prefix, s.repeat(state.multiplier));
                 output.insert(0, res.as_str());
             }
             Ok(())
@@ -271,10 +267,10 @@ mod test {
     struct Repeat {}
 
     impl VScalar for Repeat {
-        type ExtraInfo = ();
+        type State = ();
 
         unsafe fn invoke(
-            _: &Self::ExtraInfo,
+            _: &Self::State,
             input: &mut DataChunkHandle,
             output: &mut dyn WritableVector,
         ) -> Result<(), Box<dyn std::error::Error>> {
@@ -321,9 +317,9 @@ mod test {
             }
         }
 
-        // Test with custom extra info
+        // Test with custom state
         {
-            conn.register_scalar_function_with_extra_info::<EchoScalar>(
+            conn.register_scalar_function_with_state::<EchoScalar>(
                 "echo2",
                 &TestState {
                     multiplier: 5,

Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,7 @@ impl DuckdbConnectionManager {`
`92`	`92`	`#[cfg(feature = "vscalar")]`
`93`	`93`	`pub fn register_scalar_function<S: VScalar>(&self, name: &str) -> Result<()>`
`94`	`94`	`where`
`95`		`- S::ExtraInfo: Debug + Default,`
	`95`	`+ S::State: Debug + Default,`
`96`	`96`	`{`
`97`	`97`	`let conn = self.connection.lock().unwrap();`
`98`	`98`	`conn.register_scalar_function::<S>(name)`