fix_api

Author: coderfender

Cargo.lock

@@ -44,11 +44,9 @@ crate-type = ["cdylib", "rlib"]
 # It increases build times and library binary size for users.
 
 [dependencies]
-abi_stable = "0.11.3"
-stabby = "72.1.1"
 arrow = { workspace = true, features = ["ffi"] }
 arrow-schema = { workspace = true }
-async-ffi = { version = "0.5.0", features = ["abi_stable"] }
+async-ffi = { version = "0.5.0" }
 async-trait = { workspace = true }
 datafusion-catalog = { workspace = true }
 datafusion-common = { workspace = true }
@@ -70,6 +68,7 @@ futures = { workspace = true }
 log = { workspace = true }
 prost = { workspace = true }
 semver = "1.0.27"
+stabby = "72.1.1"
 tokio = { workspace = true }
 
 [dev-dependencies]

datafusion/ffi/Cargo.toml

@@ -17,7 +17,6 @@
 
 use std::sync::Arc;
 
-use abi_stable::StableAbi;
 use arrow::array::{ArrayRef, make_array};
 use arrow::datatypes::{Schema, SchemaRef};
 use arrow::error::ArrowError;
@@ -26,10 +25,10 @@ use datafusion_common::{DataFusionError, ScalarValue};
 use log::error;
 
 /// This is a wrapper struct around FFI_ArrowSchema simply to indicate
-/// to the StableAbi macros that the underlying struct is FFI safe.
+/// that the underlying struct is FFI safe.
 #[repr(C)]
-#[derive(Debug, StableAbi)]
-pub struct WrappedSchema(#[sabi(unsafe_opaque_field)] pub FFI_ArrowSchema);
+#[derive(Debug)]
+pub struct WrappedSchema(pub FFI_ArrowSchema);
 
 impl From<SchemaRef> for WrappedSchema {
     fn from(value: SchemaRef) -> Self {
@@ -66,15 +65,13 @@ impl From<WrappedSchema> for SchemaRef {
     }
 }
 
-/// This is a wrapper struct for FFI_ArrowArray to indicate to StableAbi
+/// This is a wrapper struct for FFI_ArrowArray to indicate
 /// that the struct is FFI Safe. For convenience, we also include the
 /// schema needed to create a record batch from the array.
 #[repr(C)]
-#[derive(Debug, StableAbi)]
+#[derive(Debug)]
 pub struct WrappedArray {
-    #[sabi(unsafe_opaque_field)]
     pub array: FFI_ArrowArray,
-
     pub schema: WrappedSchema,
 }
 

datafusion/ffi/src/arrow_wrappers.rs

@@ -19,13 +19,15 @@ use std::any::Any;
 use std::ffi::c_void;
 use std::sync::Arc;
 
-use abi_stable::StableAbi;
-use abi_stable::std_types::{ROption, RResult, RString, RVec};
 use datafusion_catalog::{CatalogProvider, SchemaProvider};
 use datafusion_common::error::Result;
 use datafusion_proto::logical_plan::{
     DefaultLogicalExtensionCodec, LogicalExtensionCodec,
 };
+use stabby::option::Option as StabbyOption;
+use stabby::result::Result as StabbyResult;
+use stabby::string::String as StabbyString;
+use stabby::vec::Vec as StabbyVec;
 use tokio::runtime::Handle;
 
 use crate::execution::FFI_TaskContextProvider;
@@ -36,28 +38,28 @@ use crate::{df_result, rresult_return};
 
 /// A stable struct for sharing [`CatalogProvider`] across FFI boundaries.
 #[repr(C)]
-#[derive(Debug, StableAbi)]
+#[derive(Debug)]
 pub struct FFI_CatalogProvider {
-    pub schema_names: unsafe extern "C" fn(provider: &Self) -> RVec<RString>,
+    pub schema_names: unsafe extern "C" fn(provider: &Self) -> StabbyVec<StabbyString>,
 
     pub schema: unsafe extern "C" fn(
         provider: &Self,
-        name: RString,
-    ) -> ROption<FFI_SchemaProvider>,
-
-    pub register_schema: unsafe extern "C" fn(
-        provider: &Self,
-        name: RString,
-        schema: &FFI_SchemaProvider,
-    )
-        -> FFIResult<ROption<FFI_SchemaProvider>>,
-
-    pub deregister_schema: unsafe extern "C" fn(
-        provider: &Self,
-        name: RString,
-        cascade: bool,
-    )
-        -> FFIResult<ROption<FFI_SchemaProvider>>,
+        name: StabbyString,
+    ) -> StabbyOption<FFI_SchemaProvider>,
+
+    pub register_schema:
+        unsafe extern "C" fn(
+            provider: &Self,
+            name: StabbyString,
+            schema: &FFI_SchemaProvider,
+        ) -> FFIResult<StabbyOption<FFI_SchemaProvider>>,
+
+    pub deregister_schema:
+        unsafe extern "C" fn(
+            provider: &Self,
+            name: StabbyString,
+            cascade: bool,
+        ) -> FFIResult<StabbyOption<FFI_SchemaProvider>>,
 
     pub logical_codec: FFI_LogicalExtensionCodec,
 
@@ -107,7 +109,7 @@ impl FFI_CatalogProvider {
 
 unsafe extern "C" fn schema_names_fn_wrapper(
     provider: &FFI_CatalogProvider,
-) -> RVec<RString> {
+) -> StabbyVec<StabbyString> {
     unsafe {
         let names = provider.inner().schema_names();
         names.into_iter().map(|s| s.into()).collect()
@@ -116,8 +118,8 @@ unsafe extern "C" fn schema_names_fn_wrapper(
 
 unsafe extern "C" fn schema_fn_wrapper(
     provider: &FFI_CatalogProvider,
-    name: RString,
-) -> ROption<FFI_SchemaProvider> {
+    name: StabbyString,
+) -> StabbyOption<FFI_SchemaProvider> {
     unsafe {
         let maybe_schema = provider.inner().schema(name.as_str());
         maybe_schema
@@ -134,9 +136,9 @@ unsafe extern "C" fn schema_fn_wrapper(
 
 unsafe extern "C" fn register_schema_fn_wrapper(
     provider: &FFI_CatalogProvider,
-    name: RString,
+    name: StabbyString,
     schema: &FFI_SchemaProvider,
-) -> FFIResult<ROption<FFI_SchemaProvider>> {
+) -> FFIResult<StabbyOption<FFI_SchemaProvider>> {
     unsafe {
         let runtime = provider.runtime();
         let inner_provider = provider.inner();
@@ -153,23 +155,23 @@ unsafe extern "C" fn register_schema_fn_wrapper(
                 })
                 .into();
 
-        RResult::ROk(returned_schema)
+        StabbyResult::Ok(returned_schema)
     }
 }
 
 unsafe extern "C" fn deregister_schema_fn_wrapper(
     provider: &FFI_CatalogProvider,
-    name: RString,
+    name: StabbyString,
     cascade: bool,
-) -> FFIResult<ROption<FFI_SchemaProvider>> {
+) -> FFIResult<StabbyOption<FFI_SchemaProvider>> {
     unsafe {
         let runtime = provider.runtime();
         let inner_provider = provider.inner();
 
         let maybe_schema =
             rresult_return!(inner_provider.deregister_schema(name.as_str(), cascade));
 
-        RResult::ROk(
+        StabbyResult::Ok(
             maybe_schema
                 .map(|schema| {
                     FFI_SchemaProvider::new_with_ffi_codec(

datafusion/ffi/src/catalog_provider.rs

@@ -19,12 +19,13 @@ use std::any::Any;
 use std::ffi::c_void;
 use std::sync::Arc;
 
-use abi_stable::StableAbi;
-use abi_stable::std_types::{ROption, RString, RVec};
 use datafusion_catalog::{CatalogProvider, CatalogProviderList};
 use datafusion_proto::logical_plan::{
     DefaultLogicalExtensionCodec, LogicalExtensionCodec,
 };
+use stabby::option::Option as StabbyOption;
+use stabby::string::String as StabbyString;
+use stabby::vec::Vec as StabbyVec;
 use tokio::runtime::Handle;
 
 use crate::catalog_provider::{FFI_CatalogProvider, ForeignCatalogProvider};
@@ -33,21 +34,23 @@ use crate::proto::logical_extension_codec::FFI_LogicalExtensionCodec;
 
 /// A stable struct for sharing [`CatalogProviderList`] across FFI boundaries.
 #[repr(C)]
-#[derive(Debug, StableAbi)]
+#[derive(Debug)]
 pub struct FFI_CatalogProviderList {
     /// Register a catalog
     pub register_catalog: unsafe extern "C" fn(
         &Self,
-        name: RString,
+        name: StabbyString,
         catalog: &FFI_CatalogProvider,
-    ) -> ROption<FFI_CatalogProvider>,
+    ) -> StabbyOption<FFI_CatalogProvider>,
 
     /// List of existing catalogs
-    pub catalog_names: unsafe extern "C" fn(&Self) -> RVec<RString>,
+    pub catalog_names: unsafe extern "C" fn(&Self) -> StabbyVec<StabbyString>,
 
     /// Access a catalog
-    pub catalog:
-        unsafe extern "C" fn(&Self, name: RString) -> ROption<FFI_CatalogProvider>,
+    pub catalog: unsafe extern "C" fn(
+        &Self,
+        name: StabbyString,
+    ) -> StabbyOption<FFI_CatalogProvider>,
 
     pub logical_codec: FFI_LogicalExtensionCodec,
 
@@ -97,7 +100,7 @@ impl FFI_CatalogProviderList {
 
 unsafe extern "C" fn catalog_names_fn_wrapper(
     provider: &FFI_CatalogProviderList,
-) -> RVec<RString> {
+) -> StabbyVec<StabbyString> {
     unsafe {
         let names = provider.inner().catalog_names();
         names.into_iter().map(|s| s.into()).collect()
@@ -106,9 +109,9 @@ unsafe extern "C" fn catalog_names_fn_wrapper(
 
 unsafe extern "C" fn register_catalog_fn_wrapper(
     provider: &FFI_CatalogProviderList,
-    name: RString,
+    name: StabbyString,
     catalog: &FFI_CatalogProvider,
-) -> ROption<FFI_CatalogProvider> {
+) -> StabbyOption<FFI_CatalogProvider> {
     unsafe {
         let runtime = provider.runtime();
         let inner_provider = provider.inner();
@@ -129,8 +132,8 @@ unsafe extern "C" fn register_catalog_fn_wrapper(
 
 unsafe extern "C" fn catalog_fn_wrapper(
     provider: &FFI_CatalogProviderList,
-    name: RString,
-) -> ROption<FFI_CatalogProvider> {
+    name: StabbyString,
+) -> StabbyOption<FFI_CatalogProvider> {
     unsafe {
         let runtime = provider.runtime();
         let inner_provider = provider.inner();

datafusion/ffi/src/catalog_provider_list.rs

@@ -19,10 +19,12 @@ use std::any::Any;
 use std::collections::HashMap;
 use std::ffi::c_void;
 
-use abi_stable::StableAbi;
-use abi_stable::std_types::{RResult, RStr, RString, RVec, Tuple2};
 use datafusion_common::config::{ConfigEntry, ConfigExtension, ExtensionOptions};
 use datafusion_common::{Result, exec_err};
+use stabby::result::Result as StabbyResult;
+use stabby::str::Str as StabbyStr;
+use stabby::string::String as StabbyString;
+use stabby::vec::Vec as StabbyVec;
 
 use crate::df_result;
 
@@ -38,17 +40,20 @@ use crate::df_result;
 /// are stored with the full path prefix to avoid overwriting values when using
 /// multiple extensions.
 #[repr(C)]
-#[derive(Debug, StableAbi)]
+#[derive(Debug)]
 pub struct FFI_ExtensionOptions {
     /// Return a deep clone of this [`ExtensionOptions`]
     pub cloned: unsafe extern "C" fn(&Self) -> FFI_ExtensionOptions,
 
     /// Set the given `key`, `value` pair
-    pub set:
-        unsafe extern "C" fn(&mut Self, key: RStr, value: RStr) -> RResult<(), RString>,
+    pub set: unsafe extern "C" fn(
+        &mut Self,
+        key: StabbyStr,
+        value: StabbyStr,
+    ) -> StabbyResult<(), StabbyString>,
 
     /// Returns the [`ConfigEntry`] stored in this [`ExtensionOptions`]
-    pub entries: unsafe extern "C" fn(&Self) -> RVec<Tuple2<RString, RString>>,
+    pub entries: unsafe extern "C" fn(&Self) -> StabbyVec<(StabbyString, StabbyString)>,
 
     /// Release the memory of the private data when it is no longer being used.
     pub release: unsafe extern "C" fn(&mut Self),
@@ -91,20 +96,22 @@ unsafe extern "C" fn cloned_fn_wrapper(
 
 unsafe extern "C" fn set_fn_wrapper(
     options: &mut FFI_ExtensionOptions,
-    key: RStr,
-    value: RStr,
-) -> RResult<(), RString> {
-    let _ = options.inner_mut().insert(key.into(), value.into());
-    RResult::ROk(())
+    key: StabbyStr,
+    value: StabbyStr,
+) -> StabbyResult<(), StabbyString> {
+    let _ = options
+        .inner_mut()
+        .insert(key.as_str().into(), value.as_str().into());
+    StabbyResult::Ok(())
 }
 
 unsafe extern "C" fn entries_fn_wrapper(
     options: &FFI_ExtensionOptions,
-) -> RVec<Tuple2<RString, RString>> {
+) -> StabbyVec<(StabbyString, StabbyString)> {
     options
         .inner()
         .iter()
-        .map(|(key, value)| (key.to_owned().into(), value.to_owned().into()).into())
+        .map(|(key, value)| (key.to_owned().into(), value.to_owned().into()))
         .collect()
 }