migrate_abi_to_stabby_fix_review_comments

Author: coderfender

datafusion-examples/examples/ffi/ffi_module_loader/src/main.rs

@@ -43,8 +43,14 @@ async fn main() -> Result<()> {
         "so"
     };
 
+    let build_type = if cfg!(debug_assertions) {
+        "debug"
+    } else {
+        "release"
+    };
+
     let library_path = format!(
-        "../../../../target/debug/{lib_prefix}ffi_example_table_provider.{lib_ext}"
+        "../../../../target/{build_type}/{lib_prefix}ffi_example_table_provider.{lib_ext}"
     );
 
     // Load the library using libloading

datafusion/ffi/README.md

@@ -65,7 +65,7 @@ to work across Rust libraries. In general, you can use Rust's [FFI] to
 operate across different programming languages, but that is not the design
 intent of this crate. Instead, we are using external crates that provide
 stable interfaces that closely mirror the Rust native approach. To learn more
-about this approach see the [abi_stable] and [async-ffi] crates.
+about this approach see the [stabby] and [async-ffi] crates.
 
 If you have a library in another language that you wish to interface to
 DataFusion the recommendation is to create a Rust wrapper crate to interface
@@ -197,7 +197,7 @@ and it is easy to implement on any struct that implements `Session`.
 [api docs]: http://docs.rs/datafusion-ffi/latest
 [rust abi]: https://doc.rust-lang.org/reference/abi.html
 [ffi]: https://doc.rust-lang.org/nomicon/ffi.html
-[abi_stable]: https://crates.io/crates/abi_stable
+[stabby]: https://crates.io/crates/stabby
 [async-ffi]: https://crates.io/crates/async-ffi
 [bindgen]: https://crates.io/crates/bindgen
 [`datafusion-python`]: https://datafusion.apache.org/python/

datafusion/ffi/src/catalog_provider.rs

@@ -31,8 +31,8 @@ use tokio::runtime::Handle;
 use crate::execution::FFI_TaskContextProvider;
 use crate::proto::logical_extension_codec::FFI_LogicalExtensionCodec;
 use crate::schema_provider::{FFI_SchemaProvider, ForeignSchemaProvider};
-use crate::util::{FFIResult, FfiOption, FfiResult};
-use crate::{df_result, rresult_return};
+use crate::util::{FFI_Option, FFI_Result, FFIResult};
+use crate::{df_result, sresult_return};
 
 /// A stable struct for sharing [`CatalogProvider`] across FFI boundaries.
 #[repr(C)]
@@ -43,21 +43,21 @@ pub struct FFI_CatalogProvider {
     pub schema: unsafe extern "C" fn(
         provider: &Self,
         name: SString,
-    ) -> FfiOption<FFI_SchemaProvider>,
+    ) -> FFI_Option<FFI_SchemaProvider>,
 
-    pub register_schema: unsafe extern "C" fn(
-        provider: &Self,
-        name: SString,
-        schema: &FFI_SchemaProvider,
-    )
-        -> FFIResult<FfiOption<FFI_SchemaProvider>>,
+    pub register_schema:
+        unsafe extern "C" fn(
+            provider: &Self,
+            name: SString,
+            schema: &FFI_SchemaProvider,
+        ) -> FFIResult<FFI_Option<FFI_SchemaProvider>>,
 
     pub deregister_schema:
         unsafe extern "C" fn(
             provider: &Self,
             name: SString,
             cascade: bool,
-        ) -> FFIResult<FfiOption<FFI_SchemaProvider>>,
+        ) -> FFIResult<FFI_Option<FFI_SchemaProvider>>,
 
     pub logical_codec: FFI_LogicalExtensionCodec,
 
@@ -117,7 +117,7 @@ unsafe extern "C" fn schema_names_fn_wrapper(
 unsafe extern "C" fn schema_fn_wrapper(
     provider: &FFI_CatalogProvider,
     name: SString,
-) -> FfiOption<FFI_SchemaProvider> {
+) -> FFI_Option<FFI_SchemaProvider> {
     unsafe {
         let maybe_schema = provider.inner().schema(name.as_str());
         maybe_schema
@@ -136,14 +136,14 @@ unsafe extern "C" fn register_schema_fn_wrapper(
     provider: &FFI_CatalogProvider,
     name: SString,
     schema: &FFI_SchemaProvider,
-) -> FFIResult<FfiOption<FFI_SchemaProvider>> {
+) -> FFIResult<FFI_Option<FFI_SchemaProvider>> {
     unsafe {
         let runtime = provider.runtime();
         let inner_provider = provider.inner();
         let schema: Arc<dyn SchemaProvider + Send> = schema.into();
 
         let returned_schema =
-            rresult_return!(inner_provider.register_schema(name.as_str(), schema))
+            sresult_return!(inner_provider.register_schema(name.as_str(), schema))
                 .map(|schema| {
                     FFI_SchemaProvider::new_with_ffi_codec(
                         schema,
@@ -153,23 +153,23 @@ unsafe extern "C" fn register_schema_fn_wrapper(
                 })
                 .into();
 
-        FfiResult::Ok(returned_schema)
+        FFI_Result::Ok(returned_schema)
     }
 }
 
 unsafe extern "C" fn deregister_schema_fn_wrapper(
     provider: &FFI_CatalogProvider,
     name: SString,
     cascade: bool,
-) -> FFIResult<FfiOption<FFI_SchemaProvider>> {
+) -> FFIResult<FFI_Option<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));
+            sresult_return!(inner_provider.deregister_schema(name.as_str(), cascade));
 
-        FfiResult::Ok(
+        FFI_Result::Ok(
             maybe_schema
                 .map(|schema| {
                     FFI_SchemaProvider::new_with_ffi_codec(

datafusion/ffi/src/catalog_provider_list.rs

@@ -30,7 +30,7 @@ use tokio::runtime::Handle;
 use crate::catalog_provider::{FFI_CatalogProvider, ForeignCatalogProvider};
 use crate::execution::FFI_TaskContextProvider;
 use crate::proto::logical_extension_codec::FFI_LogicalExtensionCodec;
-use crate::util::FfiOption;
+use crate::util::FFI_Option;
 
 /// A stable struct for sharing [`CatalogProviderList`] across FFI boundaries.
 #[repr(C)]
@@ -41,14 +41,14 @@ pub struct FFI_CatalogProviderList {
         &Self,
         name: SString,
         catalog: &FFI_CatalogProvider,
-    ) -> FfiOption<FFI_CatalogProvider>,
+    ) -> FFI_Option<FFI_CatalogProvider>,
 
     /// List of existing catalogs
     pub catalog_names: unsafe extern "C" fn(&Self) -> SVec<SString>,
 
     /// Access a catalog
     pub catalog:
-        unsafe extern "C" fn(&Self, name: SString) -> FfiOption<FFI_CatalogProvider>,
+        unsafe extern "C" fn(&Self, name: SString) -> FFI_Option<FFI_CatalogProvider>,
 
     pub logical_codec: FFI_LogicalExtensionCodec,
 
@@ -109,7 +109,7 @@ unsafe extern "C" fn register_catalog_fn_wrapper(
     provider: &FFI_CatalogProviderList,
     name: SString,
     catalog: &FFI_CatalogProvider,
-) -> FfiOption<FFI_CatalogProvider> {
+) -> FFI_Option<FFI_CatalogProvider> {
     unsafe {
         let runtime = provider.runtime();
         let inner_provider = provider.inner();
@@ -131,7 +131,7 @@ unsafe extern "C" fn register_catalog_fn_wrapper(
 unsafe extern "C" fn catalog_fn_wrapper(
     provider: &FFI_CatalogProviderList,
     name: SString,
-) -> FfiOption<FFI_CatalogProvider> {
+) -> FFI_Option<FFI_CatalogProvider> {
     unsafe {
         let runtime = provider.runtime();
         let inner_provider = provider.inner();

datafusion/ffi/src/config/extension_options.rs

@@ -27,7 +27,7 @@ use stabby::string::String as SString;
 use stabby::vec::Vec as SVec;
 
 use crate::df_result;
-use crate::util::{FFIResult, FfiResult};
+use crate::util::{FFI_Result, FFIResult};
 
 /// A stable struct for sharing [`ExtensionOptions`] across FFI boundaries.
 ///
@@ -99,7 +99,7 @@ unsafe extern "C" fn set_fn_wrapper(
     let _ = options
         .inner_mut()
         .insert(key.as_str().into(), value.as_str().into());
-    FfiResult::Ok(())
+    FFI_Result::Ok(())
 }
 
 unsafe extern "C" fn entries_fn_wrapper(

datafusion/ffi/src/execution/task_ctx.rs

@@ -32,7 +32,7 @@ use crate::session::config::FFI_SessionConfig;
 use crate::udaf::FFI_AggregateUDF;
 use crate::udf::FFI_ScalarUDF;
 use crate::udwf::FFI_WindowUDF;
-use crate::util::FfiOption;
+use crate::util::FFI_Option;
 
 /// A stable struct for sharing [`TaskContext`] across FFI boundaries.
 #[repr(C)]
@@ -42,7 +42,7 @@ pub struct FFI_TaskContext {
     pub session_id: unsafe extern "C" fn(&Self) -> SString,
 
     /// Return the task ID.
-    pub task_id: unsafe extern "C" fn(&Self) -> FfiOption<SString>,
+    pub task_id: unsafe extern "C" fn(&Self) -> FFI_Option<SString>,
 
     /// Return the session configuration.
     pub session_config: unsafe extern "C" fn(&Self) -> FFI_SessionConfig,
@@ -90,7 +90,7 @@ unsafe extern "C" fn session_id_fn_wrapper(ctx: &FFI_TaskContext) -> SString {
     }
 }
 
-unsafe extern "C" fn task_id_fn_wrapper(ctx: &FFI_TaskContext) -> FfiOption<SString> {
+unsafe extern "C" fn task_id_fn_wrapper(ctx: &FFI_TaskContext) -> FFI_Option<SString> {
     unsafe {
         let ctx = ctx.inner();
         ctx.task_id().map(|s| s.as_str().into()).into()

datafusion/ffi/src/execution/task_ctx_provider.rs

@@ -23,7 +23,7 @@ use datafusion_execution::{TaskContext, TaskContextProvider};
 
 use crate::execution::task_ctx::FFI_TaskContext;
 use crate::util::FFIResult;
-use crate::{df_result, rresult};
+use crate::{df_result, sresult};
 
 /// Struct for accessing the [`TaskContext`]. This method contains a weak
 /// reference, so there are no guarantees that the [`TaskContext`] remains
@@ -76,7 +76,7 @@ unsafe extern "C" fn task_ctx_fn_wrapper(
     ctx_provider: &FFI_TaskContextProvider,
 ) -> FFIResult<FFI_TaskContext> {
     unsafe {
-        rresult!(
+        sresult!(
             ctx_provider
                 .inner()
                 .map(FFI_TaskContext::from)

datafusion/ffi/src/execution_plan.rs

@@ -34,8 +34,8 @@ use crate::config::FFI_ConfigOptions;
 use crate::execution::FFI_TaskContext;
 use crate::plan_properties::FFI_PlanProperties;
 use crate::record_batch_stream::FFI_RecordBatchStream;
-use crate::util::{FFIResult, FfiOption};
-use crate::{df_result, rresult, rresult_return};
+use crate::util::{FFI_Option, FFIResult};
+use crate::{df_result, sresult, sresult_return};
 
 /// A stable struct for sharing a [`ExecutionPlan`] across FFI boundaries.
 #[repr(C)]
@@ -66,7 +66,7 @@ pub struct FFI_ExecutionPlan {
         target_partitions: usize,
         config: FFI_ConfigOptions,
     )
-        -> FFIResult<FfiOption<FFI_ExecutionPlan>>,
+        -> FFIResult<FFI_Option<FFI_ExecutionPlan>>,
 
     /// Used to create a clone on the provider of the execution plan. This should
     /// only need to be called by the receiver of the plan.
@@ -114,16 +114,12 @@ unsafe extern "C" fn properties_fn_wrapper(
 unsafe extern "C" fn children_fn_wrapper(
     plan: &FFI_ExecutionPlan,
 ) -> SVec<FFI_ExecutionPlan> {
-    unsafe {
-        let private_data = plan.private_data as *const ExecutionPlanPrivateData;
-        let plan = &(*private_data).plan;
-        let runtime = &(*private_data).runtime;
-
-        plan.children()
-            .into_iter()
-            .map(|child| FFI_ExecutionPlan::new(Arc::clone(child), runtime.clone()))
-            .collect()
-    }
+    let runtime = plan.runtime();
+    plan.inner()
+        .children()
+        .into_iter()
+        .map(|child| FFI_ExecutionPlan::new(Arc::clone(child), runtime.clone()))
+        .collect()
 }
 
 unsafe extern "C" fn with_new_children_fn_wrapper(
@@ -138,10 +134,10 @@ unsafe extern "C" fn with_new_children_fn_wrapper(
         .map(<Arc<dyn ExecutionPlan>>::try_from)
         .collect();
 
-    let children = rresult_return!(children);
-    let new_plan = rresult_return!(inner_plan.with_new_children(children));
+    let children = sresult_return!(children);
+    let new_plan = sresult_return!(inner_plan.with_new_children(children));
 
-    crate::ffi_option::FfiResult::Ok(FFI_ExecutionPlan::new(new_plan, runtime))
+    crate::ffi_option::FFI_Result::Ok(FFI_ExecutionPlan::new(new_plan, runtime))
 }
 
 unsafe extern "C" fn execute_fn_wrapper(
@@ -155,7 +151,7 @@ unsafe extern "C" fn execute_fn_wrapper(
 
     let _runtime_guard = runtime.as_ref().map(|rt| rt.enter());
 
-    rresult!(
+    sresult!(
         plan.execute(partition, ctx)
             .map(|rbs| FFI_RecordBatchStream::new(rbs, runtime))
     )
@@ -165,13 +161,13 @@ unsafe extern "C" fn repartitioned_fn_wrapper(
     plan: &FFI_ExecutionPlan,
     target_partitions: usize,
     config: FFI_ConfigOptions,
-) -> FFIResult<FfiOption<FFI_ExecutionPlan>> {
+) -> FFIResult<FFI_Option<FFI_ExecutionPlan>> {
     let maybe_config: Result<ConfigOptions, DataFusionError> = config.try_into();
-    let config = rresult_return!(maybe_config);
+    let config = sresult_return!(maybe_config);
     let runtime = plan.runtime();
     let plan = plan.inner();
 
-    rresult!(
+    sresult!(
         plan.repartitioned(target_partitions, &config)
             .map(|maybe_plan| maybe_plan
                 .map(|plan| FFI_ExecutionPlan::new(plan, runtime))