fix_clippy_naming_issues

Author: coderfender

datafusion/ffi/src/insert_op.rs

@@ -19,28 +19,28 @@ use datafusion_expr::logical_plan::dml::InsertOp;
 
 /// FFI safe version of [`InsertOp`].
 #[repr(u8)]
-pub enum FFI_InsertOp {
+pub enum FFiInsertOp {
     Append,
     Overwrite,
     Replace,
 }
 
-impl From<FFI_InsertOp> for InsertOp {
-    fn from(value: FFI_InsertOp) -> Self {
+impl From<FFiInsertOp> for InsertOp {
+    fn from(value: FFiInsertOp) -> Self {
         match value {
-            FFI_InsertOp::Append => InsertOp::Append,
-            FFI_InsertOp::Overwrite => InsertOp::Overwrite,
-            FFI_InsertOp::Replace => InsertOp::Replace,
+            FFiInsertOp::Append => InsertOp::Append,
+            FFiInsertOp::Overwrite => InsertOp::Overwrite,
+            FFiInsertOp::Replace => InsertOp::Replace,
         }
     }
 }
 
-impl From<InsertOp> for FFI_InsertOp {
+impl From<InsertOp> for FFiInsertOp {
     fn from(value: InsertOp) -> Self {
         match value {
-            InsertOp::Append => FFI_InsertOp::Append,
-            InsertOp::Overwrite => FFI_InsertOp::Overwrite,
-            InsertOp::Replace => FFI_InsertOp::Replace,
+            InsertOp::Append => FFiInsertOp::Append,
+            InsertOp::Overwrite => FFiInsertOp::Overwrite,
+            InsertOp::Replace => FFiInsertOp::Replace,
         }
     }
 }
@@ -49,10 +49,10 @@ impl From<InsertOp> for FFI_InsertOp {
 mod tests {
     use datafusion::logical_expr::dml::InsertOp;
 
-    use super::FFI_InsertOp;
+    use super::FFiInsertOp;
 
     fn test_round_trip_insert_op(insert_op: InsertOp) {
-        let ffi_insert_op: FFI_InsertOp = insert_op.into();
+        let ffi_insert_op: FFiInsertOp = insert_op.into();
         let round_trip: InsertOp = ffi_insert_op.into();
 
         assert_eq!(insert_op, round_trip);

datafusion/ffi/src/physical_expr/sort.rs

@@ -26,7 +26,6 @@ use crate::physical_expr::FFI_PhysicalExpr;
 
 /// A stable struct for sharing [`PhysicalSortExpr`] across FFI boundaries.
 /// See [`PhysicalSortExpr`] for the meaning of each field.
-
 #[repr(C)]
 #[derive(Debug)]
 pub struct FFI_PhysicalSortExpr {

datafusion/ffi/src/plan_properties.rs

@@ -40,7 +40,7 @@ pub struct FFI_PlanProperties {
     pub output_partitioning: unsafe extern "C" fn(plan: &Self) -> FFI_Partitioning,
 
     /// Return the emission type of the plan.
-    pub emission_type: unsafe extern "C" fn(plan: &Self) -> FFI_EmissionType,
+    pub emission_type: unsafe extern "C" fn(plan: &Self) -> FfiEmissionType,
 
     /// Indicate boundedness of the plan and its memory requirements.
     pub boundedness: unsafe extern "C" fn(plan: &Self) -> FFI_Boundedness,
@@ -86,7 +86,7 @@ unsafe extern "C" fn output_partitioning_fn_wrapper(
 
 unsafe extern "C" fn emission_type_fn_wrapper(
     properties: &FFI_PlanProperties,
-) -> FFI_EmissionType {
+) -> FfiEmissionType {
     properties.inner().emission_type.into()
 }
 
@@ -233,28 +233,28 @@ impl From<FFI_Boundedness> for Boundedness {
 /// FFI safe version of [`EmissionType`].
 #[repr(u8)]
 #[derive(Clone)]
-pub enum FFI_EmissionType {
+pub enum FfiEmissionType {
     Incremental,
     Final,
     Both,
 }
 
-impl From<EmissionType> for FFI_EmissionType {
+impl From<EmissionType> for FfiEmissionType {
     fn from(value: EmissionType) -> Self {
         match value {
-            EmissionType::Incremental => FFI_EmissionType::Incremental,
-            EmissionType::Final => FFI_EmissionType::Final,
-            EmissionType::Both => FFI_EmissionType::Both,
+            EmissionType::Incremental => FfiEmissionType::Incremental,
+            EmissionType::Final => FfiEmissionType::Final,
+            EmissionType::Both => FfiEmissionType::Both,
         }
     }
 }
 
-impl From<FFI_EmissionType> for EmissionType {
-    fn from(value: FFI_EmissionType) -> Self {
+impl From<FfiEmissionType> for EmissionType {
+    fn from(value: FfiEmissionType) -> Self {
         match value {
-            FFI_EmissionType::Incremental => EmissionType::Incremental,
-            FFI_EmissionType::Final => EmissionType::Final,
-            FFI_EmissionType::Both => EmissionType::Both,
+            FfiEmissionType::Incremental => EmissionType::Incremental,
+            FfiEmissionType::Final => EmissionType::Final,
+            FfiEmissionType::Both => EmissionType::Both,
         }
     }
 }

datafusion/ffi/src/table_provider.rs

@@ -41,12 +41,12 @@ use stabby::vec::Vec as StabbyVec;
 use tokio::runtime::Handle;
 
 use super::execution_plan::FFI_ExecutionPlan;
-use super::insert_op::FFI_InsertOp;
+use super::insert_op::FFiInsertOp;
 use crate::arrow_wrappers::WrappedSchema;
 use crate::execution::FFI_TaskContextProvider;
 use crate::proto::logical_extension_codec::FFI_LogicalExtensionCodec;
 use crate::session::{FFI_SessionRef, ForeignSession};
-use crate::table_source::{FFI_TableProviderFilterPushDown, FFI_TableType};
+use crate::table_source::{FfiTableProviderFilterPushDown, FFI_TableType};
 use crate::util::{FFIResult, FfiOption, FfiResult};
 use crate::{df_result, rresult_return};
 
@@ -125,14 +125,14 @@ pub struct FFI_TableProvider {
             provider: &FFI_TableProvider,
             filters_serialized: StabbyVec<u8>,
         )
-            -> FFIResult<StabbyVec<FFI_TableProviderFilterPushDown>>,
+            -> FFIResult<StabbyVec<FfiTableProviderFilterPushDown>>,
     >,
 
     insert_into: unsafe extern "C" fn(
         provider: &Self,
         session: FFI_SessionRef,
         input: &FFI_ExecutionPlan,
-        insert_op: FFI_InsertOp,
+        insert_op: FFiInsertOp,
     ) -> FfiFuture<FFIResult<FFI_ExecutionPlan>>,
 
     pub logical_codec: FFI_LogicalExtensionCodec,
@@ -192,7 +192,7 @@ fn supports_filters_pushdown_internal(
     filters_serialized: &[u8],
     task_ctx: &Arc<TaskContext>,
     codec: &dyn LogicalExtensionCodec,
-) -> Result<StabbyVec<FFI_TableProviderFilterPushDown>> {
+) -> Result<StabbyVec<FfiTableProviderFilterPushDown>> {
     let filters = match filters_serialized.is_empty() {
         true => vec![],
         false => {
@@ -216,7 +216,7 @@ fn supports_filters_pushdown_internal(
 unsafe extern "C" fn supports_filters_pushdown_fn_wrapper(
     provider: &FFI_TableProvider,
     filters_serialized: StabbyVec<u8>,
-) -> FFIResult<StabbyVec<FFI_TableProviderFilterPushDown>> {
+) -> FFIResult<StabbyVec<FfiTableProviderFilterPushDown>> {
     let logical_codec: Arc<dyn LogicalExtensionCodec> = (&provider.logical_codec).into();
     let task_ctx = rresult_return!(<Arc<TaskContext>>::try_from(
         &provider.logical_codec.task_ctx_provider
@@ -289,7 +289,7 @@ unsafe extern "C" fn insert_into_fn_wrapper(
     provider: &FFI_TableProvider,
     session: FFI_SessionRef,
     input: &FFI_ExecutionPlan,
-    insert_op: FFI_InsertOp,
+    insert_op: FFiInsertOp,
 ) -> FfiFuture<FFIResult<FFI_ExecutionPlan>> {
     let runtime = provider.runtime().clone();
     let internal_provider = Arc::clone(provider.inner());
@@ -533,7 +533,7 @@ impl TableProvider for ForeignTableProvider {
 
         let rc = Handle::try_current().ok();
         let input = FFI_ExecutionPlan::new(input, rc);
-        let insert_op: FFI_InsertOp = insert_op.into();
+        let insert_op: FFiInsertOp = insert_op.into();
 
         let plan = unsafe {
             let maybe_plan =

datafusion/ffi/src/table_source.rs

@@ -19,36 +19,36 @@ use datafusion_expr::{TableProviderFilterPushDown, TableType};
 
 /// FFI safe version of [`TableProviderFilterPushDown`].
 #[repr(u8)]
-pub enum FFI_TableProviderFilterPushDown {
+pub enum FfiTableProviderFilterPushDown {
     Unsupported,
     Inexact,
     Exact,
 }
 
-impl From<&FFI_TableProviderFilterPushDown> for TableProviderFilterPushDown {
-    fn from(value: &FFI_TableProviderFilterPushDown) -> Self {
+impl From<&FfiTableProviderFilterPushDown> for TableProviderFilterPushDown {
+    fn from(value: &FfiTableProviderFilterPushDown) -> Self {
         match value {
-            FFI_TableProviderFilterPushDown::Unsupported => {
+            FfiTableProviderFilterPushDown::Unsupported => {
                 TableProviderFilterPushDown::Unsupported
             }
-            FFI_TableProviderFilterPushDown::Inexact => {
+            FfiTableProviderFilterPushDown::Inexact => {
                 TableProviderFilterPushDown::Inexact
             }
-            FFI_TableProviderFilterPushDown::Exact => TableProviderFilterPushDown::Exact,
+            FfiTableProviderFilterPushDown::Exact => TableProviderFilterPushDown::Exact,
         }
     }
 }
 
-impl From<&TableProviderFilterPushDown> for FFI_TableProviderFilterPushDown {
+impl From<&TableProviderFilterPushDown> for FfiTableProviderFilterPushDown {
     fn from(value: &TableProviderFilterPushDown) -> Self {
         match value {
             TableProviderFilterPushDown::Unsupported => {
-                FFI_TableProviderFilterPushDown::Unsupported
+                FfiTableProviderFilterPushDown::Unsupported
             }
             TableProviderFilterPushDown::Inexact => {
-                FFI_TableProviderFilterPushDown::Inexact
+                FfiTableProviderFilterPushDown::Inexact
             }
-            TableProviderFilterPushDown::Exact => FFI_TableProviderFilterPushDown::Exact,
+            TableProviderFilterPushDown::Exact => FfiTableProviderFilterPushDown::Exact,
         }
     }
 }
@@ -89,7 +89,7 @@ mod tests {
     use super::*;
 
     fn round_trip_filter_pushdown(pushdown: TableProviderFilterPushDown) -> Result<()> {
-        let ffi_pushdown: FFI_TableProviderFilterPushDown = (&pushdown).into();
+        let ffi_pushdown: FfiTableProviderFilterPushDown = (&pushdown).into();
         let round_trip: TableProviderFilterPushDown = (&ffi_pushdown).into();
 
         assert_eq!(pushdown, round_trip);

datafusion/ffi/src/udaf/mod.rs

@@ -47,7 +47,7 @@ use crate::util::{
     FFIResult, FfiOption, FfiResult, rvec_wrapped_to_vec_datatype, rvec_wrapped_to_vec_fieldref,
     vec_datatype_to_rvec_wrapped, vec_fieldref_to_rvec_wrapped,
 };
-use crate::volatility::FFI_Volatility;
+use crate::volatility::FfiVolatility;
 use crate::{df_result, rresult, rresult_return};
 
 mod accumulator;
@@ -65,7 +65,7 @@ pub struct FFI_AggregateUDF {
     pub aliases: StabbyVec<StabbyString>,
 
     /// FFI equivalent to the `volatility` of a [`AggregateUDF`]
-    pub volatility: FFI_Volatility,
+    pub volatility: FfiVolatility,
 
     /// Determines the return field of the underlying [`AggregateUDF`] based on the
     /// argument fields.

datafusion/ffi/src/udf/mod.rs

@@ -45,7 +45,7 @@ use crate::expr::columnar_value::FFI_ColumnarValue;
 use crate::util::{
     FFIResult, rvec_wrapped_to_vec_datatype, vec_datatype_to_rvec_wrapped,
 };
-use crate::volatility::FFI_Volatility;
+use crate::volatility::FfiVolatility;
 use crate::{df_result, rresult, rresult_return};
 
 pub mod return_type_args;
@@ -55,13 +55,13 @@ pub mod return_type_args;
 #[derive(Debug)]
 pub struct FFI_ScalarUDF {
     /// FFI equivalent to the `name` of a [`ScalarUDF`]
-    pub name: String,
+    pub name: StabbyString,
 
     /// FFI equivalent to the `aliases` of a [`ScalarUDF`]
     pub aliases: StabbyVec<StabbyString>,
 
     /// FFI equivalent to the `volatility` of a [`ScalarUDF`]
-    pub volatility: FFI_Volatility,
+    pub volatility: FfiVolatility,
 
     /// Determines the return info of the underlying [`ScalarUDF`].
     pub return_field_from_args: unsafe extern "C" fn(
@@ -314,7 +314,7 @@ impl From<&FFI_ScalarUDF> for Arc<dyn ScalarUDFImpl> {
         if (udf.library_marker_id)() == crate::get_library_marker_id() {
             Arc::clone(udf.inner().inner())
         } else {
-            let name = udf.name.to_owned();
+            let name = udf.name.to_string();
             let signature = Signature::user_defined((&udf.volatility).into());
 
             let aliases = udf.aliases.iter().map(|s| s.to_string()).collect();

datafusion/ffi/src/udwf/mod.rs

@@ -48,7 +48,7 @@ use crate::util::{
     rvec_wrapped_to_vec_fieldref, vec_datatype_to_rvec_wrapped,
     vec_fieldref_to_rvec_wrapped,
 };
-use crate::volatility::FFI_Volatility;
+use crate::volatility::FfiVolatility;
 use crate::{df_result, rresult, rresult_return};
 
 /// A stable struct for sharing a [`WindowUDF`] across FFI boundaries.
@@ -62,7 +62,7 @@ pub struct FFI_WindowUDF {
     pub aliases: StabbyVec<StabbyString>,
 
     /// FFI equivalent to the `volatility` of a [`WindowUDF`]
-    pub volatility: FFI_Volatility,
+    pub volatility: FfiVolatility,
 
     pub partition_evaluator: unsafe extern "C" fn(
         udwf: &Self,

datafusion/ffi/src/volatility.rs

@@ -19,13 +19,13 @@ use datafusion_expr::Volatility;
 
 #[repr(u8)]
 #[derive(Debug, Clone)]
-pub enum FFI_Volatility {
+pub enum FfiVolatility {
     Immutable,
     Stable,
     Volatile,
 }
 
-impl From<Volatility> for FFI_Volatility {
+impl From<Volatility> for FfiVolatility {
     fn from(value: Volatility) -> Self {
         match value {
             Volatility::Immutable => Self::Immutable,
@@ -35,12 +35,12 @@ impl From<Volatility> for FFI_Volatility {
     }
 }
 
-impl From<&FFI_Volatility> for Volatility {
-    fn from(value: &FFI_Volatility) -> Self {
+impl From<&FfiVolatility> for Volatility {
+    fn from(value: &FfiVolatility) -> Self {
         match value {
-            FFI_Volatility::Immutable => Self::Immutable,
-            FFI_Volatility::Stable => Self::Stable,
-            FFI_Volatility::Volatile => Self::Volatile,
+            FfiVolatility::Immutable => Self::Immutable,
+            FfiVolatility::Stable => Self::Stable,
+            FfiVolatility::Volatile => Self::Volatile,
         }
     }
 }
@@ -49,10 +49,10 @@ impl From<&FFI_Volatility> for Volatility {
 mod tests {
     use datafusion::logical_expr::Volatility;
 
-    use super::FFI_Volatility;
+    use super::FfiVolatility;
 
     fn test_round_trip_volatility(volatility: Volatility) {
-        let ffi_volatility: FFI_Volatility = volatility.into();
+        let ffi_volatility: FfiVolatility = volatility.into();
         let round_trip: Volatility = (&ffi_volatility).into();
 
         assert_eq!(volatility, round_trip);