rename_traits

Author: B Vadlamani

datafusion/ffi/README.md

@@ -90,8 +90,8 @@ We intentionally use `#[repr(C)]` for our struct definitions instead of stabby's
 3. **Arrow types**: Arrow's FFI types like `FFI_ArrowSchema` do not implement
    `IStable`, and adding such implementations would be laborious and error-prone.
 
-4. **FFI_Option and FFIResult**: We provide our own `FFI_Option<T>` and
-   `FFIResult<T>` types using `#[repr(C, u8)]` because stabby's `Option`
+4. **FFI_Option and FFI_Result**: We provide our own `FFI_Option<T>` and
+   `FFI_Result<T>` types using `#[repr(C, u8)]` because stabby's `Option`
    and `Result` require inner types to be `IStable`.
 
 Instead, we use stabby for its convenient ABI-stable collection types like

datafusion/ffi/src/catalog_provider.rs

@@ -30,7 +30,7 @@ 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::{FFI_Option, FFIResult};
+use crate::util::{FFI_Option, FFI_Result};
 use crate::{df_result, sresult_return};
 
 /// A stable struct for sharing [`CatalogProvider`] across FFI boundaries.
@@ -49,14 +49,14 @@ pub struct FFI_CatalogProvider {
             provider: &Self,
             name: SString,
             schema: &FFI_SchemaProvider,
-        ) -> FFIResult<FFI_Option<FFI_SchemaProvider>>,
+        ) -> FFI_Result<FFI_Option<FFI_SchemaProvider>>,
 
     pub deregister_schema:
         unsafe extern "C" fn(
             provider: &Self,
             name: SString,
             cascade: bool,
-        ) -> FFIResult<FFI_Option<FFI_SchemaProvider>>,
+        ) -> FFI_Result<FFI_Option<FFI_SchemaProvider>>,
 
     pub logical_codec: FFI_LogicalExtensionCodec,
 
@@ -135,7 +135,7 @@ unsafe extern "C" fn register_schema_fn_wrapper(
     provider: &FFI_CatalogProvider,
     name: SString,
     schema: &FFI_SchemaProvider,
-) -> FFIResult<FFI_Option<FFI_SchemaProvider>> {
+) -> FFI_Result<FFI_Option<FFI_SchemaProvider>> {
     unsafe {
         let runtime = provider.runtime();
         let inner_provider = provider.inner();
@@ -152,23 +152,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<FFI_Option<FFI_SchemaProvider>> {
+) -> FFI_Result<FFI_Option<FFI_SchemaProvider>> {
     unsafe {
         let runtime = provider.runtime();
         let inner_provider = provider.inner();
 
         let maybe_schema =
             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/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;
+use crate::util::FFI_Result;
 
 /// A stable struct for sharing [`ExtensionOptions`] across FFI boundaries.
 ///
@@ -47,7 +47,7 @@ pub struct FFI_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: SStr, value: SStr) -> FFIResult<()>,
+    pub set: unsafe extern "C" fn(&mut Self, key: SStr, value: SStr) -> FFI_Result<()>,
 
     /// Returns the [`ConfigEntry`] stored in this [`ExtensionOptions`]
     pub entries: unsafe extern "C" fn(&Self) -> SVec<(SString, SString)>,
@@ -95,11 +95,11 @@ unsafe extern "C" fn set_fn_wrapper(
     options: &mut FFI_ExtensionOptions,
     key: SStr,
     value: SStr,
-) -> FFIResult<()> {
+) -> FFI_Result<()> {
     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_provider.rs

@@ -22,7 +22,7 @@ use datafusion_common::{DataFusionError, ffi_datafusion_err};
 use datafusion_execution::{TaskContext, TaskContextProvider};
 
 use crate::execution::task_ctx::FFI_TaskContext;
-use crate::util::FFIResult;
+use crate::util::FFI_Result;
 use crate::{df_result, sresult};
 
 /// Struct for accessing the [`TaskContext`]. This method contains a weak
@@ -37,7 +37,7 @@ pub struct FFI_TaskContextProvider {
     /// gone out of scope. This function will return an error if the weakly
     /// held reference to the underlying [`TaskContextProvider`] is no longer
     /// available.
-    pub task_ctx: unsafe extern "C" fn(&Self) -> FFIResult<FFI_TaskContext>,
+    pub task_ctx: unsafe extern "C" fn(&Self) -> FFI_Result<FFI_TaskContext>,
 
     /// Used to create a clone on the task context accessor. This should
     /// only need to be called by the receiver of the plan.
@@ -74,7 +74,7 @@ impl FFI_TaskContextProvider {
 
 unsafe extern "C" fn task_ctx_fn_wrapper(
     ctx_provider: &FFI_TaskContextProvider,
-) -> FFIResult<FFI_TaskContext> {
+) -> FFI_Result<FFI_TaskContext> {
     unsafe {
         sresult!(
             ctx_provider

datafusion/ffi/src/execution_plan.rs

@@ -34,7 +34,7 @@ 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::{FFI_Option, FFIResult};
+use crate::util::{FFI_Option, FFI_Result};
 use crate::{df_result, sresult, sresult_return};
 
 /// A stable struct for sharing a [`ExecutionPlan`] across FFI boundaries.
@@ -48,7 +48,7 @@ pub struct FFI_ExecutionPlan {
     pub children: unsafe extern "C" fn(plan: &Self) -> SVec<FFI_ExecutionPlan>,
 
     pub with_new_children:
-        unsafe extern "C" fn(plan: &Self, children: SVec<Self>) -> FFIResult<Self>,
+        unsafe extern "C" fn(plan: &Self, children: SVec<Self>) -> FFI_Result<Self>,
 
     /// Return the plan name.
     pub name: unsafe extern "C" fn(plan: &Self) -> SString,
@@ -59,14 +59,14 @@ pub struct FFI_ExecutionPlan {
         plan: &Self,
         partition: usize,
         context: FFI_TaskContext,
-    ) -> FFIResult<FFI_RecordBatchStream>,
+    ) -> FFI_Result<FFI_RecordBatchStream>,
 
     pub repartitioned: unsafe extern "C" fn(
         plan: &Self,
         target_partitions: usize,
         config: FFI_ConfigOptions,
     )
-        -> FFIResult<FFI_Option<FFI_ExecutionPlan>>,
+        -> FFI_Result<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.
@@ -125,7 +125,7 @@ unsafe extern "C" fn children_fn_wrapper(
 unsafe extern "C" fn with_new_children_fn_wrapper(
     plan: &FFI_ExecutionPlan,
     children: SVec<FFI_ExecutionPlan>,
-) -> FFIResult<FFI_ExecutionPlan> {
+) -> FFI_Result<FFI_ExecutionPlan> {
     let runtime = plan.runtime();
     let inner_plan = Arc::clone(plan.inner());
 
@@ -137,14 +137,14 @@ unsafe extern "C" fn with_new_children_fn_wrapper(
     let children = sresult_return!(children);
     let new_plan = sresult_return!(inner_plan.with_new_children(children));
 
-    FFIResult::Ok(FFI_ExecutionPlan::new(new_plan, runtime))
+    FFI_Result::Ok(FFI_ExecutionPlan::new(new_plan, runtime))
 }
 
 unsafe extern "C" fn execute_fn_wrapper(
     plan: &FFI_ExecutionPlan,
     partition: usize,
     context: FFI_TaskContext,
-) -> FFIResult<FFI_RecordBatchStream> {
+) -> FFI_Result<FFI_RecordBatchStream> {
     let ctx = context.into();
     let runtime = plan.runtime();
     let plan = plan.inner();
@@ -161,7 +161,7 @@ unsafe extern "C" fn repartitioned_fn_wrapper(
     plan: &FFI_ExecutionPlan,
     target_partitions: usize,
     config: FFI_ConfigOptions,
-) -> FFIResult<FFI_Option<FFI_ExecutionPlan>> {
+) -> FFI_Result<FFI_Option<FFI_ExecutionPlan>> {
     let maybe_config: Result<ConfigOptions, DataFusionError> = config.try_into();
     let config = sresult_return!(maybe_config);
     let runtime = plan.runtime();

datafusion/ffi/src/ffi_option.rs

@@ -73,31 +73,31 @@ impl<T> FFI_Option<T> {
 /// An FFI-safe result type with SString as the error type.
 #[repr(C, u8)]
 #[derive(Debug, Clone)]
-pub enum FFIResult<T> {
+pub enum FFI_Result<T> {
     Ok(T),
     Err(SString),
 }
 
-impl<T> FFIResult<T> {
+impl<T> FFI_Result<T> {
     pub fn is_ok(&self) -> bool {
-        matches!(self, FFIResult::Ok(_))
+        matches!(self, FFI_Result::Ok(_))
     }
 
     pub fn is_err(&self) -> bool {
-        matches!(self, FFIResult::Err(_))
+        matches!(self, FFI_Result::Err(_))
     }
 
     pub fn unwrap_err(self) -> SString {
         match self {
-            FFIResult::Err(e) => e,
-            FFIResult::Ok(_) => panic!("called unwrap_err on Ok"),
+            FFI_Result::Err(e) => e,
+            FFI_Result::Ok(_) => panic!("called unwrap_err on Ok"),
         }
     }
 
-    pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> FFIResult<U> {
+    pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> FFI_Result<U> {
         match self {
-            FFIResult::Ok(v) => FFIResult::Ok(f(v)),
-            FFIResult::Err(e) => FFIResult::Err(e),
+            FFI_Result::Ok(v) => FFI_Result::Ok(f(v)),
+            FFI_Result::Err(e) => FFI_Result::Err(e),
         }
     }
 
@@ -106,29 +106,29 @@ impl<T> FFIResult<T> {
     }
 }
 
-impl<T> From<FFIResult<T>> for Result<T, SString> {
-    fn from(res: FFIResult<T>) -> Self {
+impl<T> From<FFI_Result<T>> for Result<T, SString> {
+    fn from(res: FFI_Result<T>) -> Self {
         match res {
-            FFIResult::Ok(v) => Ok(v),
-            FFIResult::Err(e) => Err(e),
+            FFI_Result::Ok(v) => Ok(v),
+            FFI_Result::Err(e) => Err(e),
         }
     }
 }
 
-impl<T, E: ToString> From<Result<T, E>> for FFIResult<T> {
+impl<T, E: ToString> From<Result<T, E>> for FFI_Result<T> {
     fn from(res: Result<T, E>) -> Self {
         match res {
-            Ok(v) => FFIResult::Ok(v),
-            Err(e) => FFIResult::Err(SString::from(e.to_string().as_str())),
+            Ok(v) => FFI_Result::Ok(v),
+            Err(e) => FFI_Result::Err(SString::from(e.to_string().as_str())),
         }
     }
 }
 
-impl<T: PartialEq> PartialEq for FFIResult<T> {
+impl<T: PartialEq> PartialEq for FFI_Result<T> {
     fn eq(&self, other: &Self) -> bool {
         match (self, other) {
-            (FFIResult::Ok(a), FFIResult::Ok(b)) => a == b,
-            (FFIResult::Err(a), FFIResult::Err(b)) => a == b,
+            (FFI_Result::Ok(a), FFI_Result::Ok(b)) => a == b,
+            (FFI_Result::Err(a), FFI_Result::Err(b)) => a == b,
             _ => false,
         }
     }