refactor: rename enum params.

Author: jrjrmiih

src/rust/wcdb/src/base/param/enum_basic_expression.rs

@@ -0,0 +1,132 @@
+use crate::base::cpp_object::CppObject;
+use crate::utils::ToCString;
+use crate::winq::column::Column;
+use crate::winq::expression::Expression;
+use crate::winq::expression_convertible::ExpressionConvertibleTrait;
+use crate::winq::expression_operable::ExpressionOperable;
+use crate::winq::identifier::{CPPType, Identifier};
+use libc::c_longlong;
+use std::ffi::{c_double, c_void, CString};
+
+/// 支持 bool, i8, i16, i32, i64, f32, f64, String, &str, Option<&dyn ExpressionConvertibleTrait>
+pub enum BasicExpression<'a> {
+    Bool(bool),
+    Int(i64),
+    Float(f64),
+    String(String),
+    ExpressionConvertible(Option<&'a dyn ExpressionConvertibleTrait>),
+}
+
+impl BasicExpression<'_> {
+    pub(crate) fn get_params(self) -> (CPPType, c_longlong, c_double, Option<CString>) {
+        match self {
+            BasicExpression::Bool(value) => {
+                let value = if value { 1 } else { 0 };
+                (CPPType::Bool, value as c_longlong, 0 as c_double, None)
+            }
+            BasicExpression::Int(value) => {
+                (CPPType::Int, value as c_longlong, 0 as c_double, None)
+            }
+            BasicExpression::Float(value) => {
+                (CPPType::Double, 0 as c_longlong, value as c_double, None)
+            }
+            BasicExpression::String(value) => {
+                let cstr = value.as_str().to_cstring();
+                (CPPType::String, 0 as c_longlong, 0 as c_double, Some(cstr))
+            }
+            BasicExpression::ExpressionConvertible(obj_opt) => {
+                let (cpp_type, cpp_obj) = match obj_opt {
+                    None => (CPPType::Null, 0 as *mut c_void),
+                    Some(obj) => (Identifier::get_cpp_type(obj), CppObject::get(obj)),
+                };
+                (cpp_type, cpp_obj as c_longlong, 0 as c_double, None)
+            }
+        }
+    }
+}
+
+impl<'a> From<bool> for BasicExpression<'a> {
+    fn from(value: bool) -> Self {
+        BasicExpression::Bool(value)
+    }
+}
+
+/// 宏定义：为所有整数类型实现 From trait
+macro_rules! impl_from_int_types {
+    ($($int_type:ty),* $(,)?) => {
+        $(
+            impl<'a> From<$int_type> for BasicExpression<'a> {
+                fn from(value: $int_type) -> Self {
+                    BasicExpression::Int(value as i64)
+                }
+            }
+        )*
+    };
+}
+
+/// 使用宏为所有整数类型实现 From trait
+impl_from_int_types!(i8, i16, i32, i64);
+
+/// 宏定义：为所有浮点类型实现 From trait
+macro_rules! impl_from_float_types {
+    ($($float_type:ty),* $(,)?) => {
+        $(
+            impl<'a> From<$float_type> for BasicExpression<'a> {
+                fn from(value: $float_type) -> Self {
+                    BasicExpression::Float(value as f64)
+                }
+            }
+        )*
+    };
+}
+
+/// 使用宏为所有浮点类型实现 From trait
+impl_from_float_types!(f32, f64);
+
+impl<'a> From<String> for BasicExpression<'a> {
+    fn from(value: String) -> Self {
+        BasicExpression::String(value)
+    }
+}
+
+impl<'a> From<&'a str> for BasicExpression<'a> {
+    fn from(value: &'a str) -> Self {
+        BasicExpression::String(value.to_string())
+    }
+}
+
+impl<'a> From<Option<&'a dyn ExpressionConvertibleTrait>> for BasicExpression<'a> {
+    fn from(value: Option<&'a dyn ExpressionConvertibleTrait>) -> Self {
+        BasicExpression::ExpressionConvertible(value)
+    }
+}
+
+impl<'a> From<Option<&'a ExpressionOperable>> for BasicExpression<'a> {
+    fn from(v: Option<&'a ExpressionOperable>) -> Self {
+        v.map(|x| x as &dyn ExpressionConvertibleTrait).into()
+    }
+}
+
+impl<'a> From<Option<&'a Expression>> for BasicExpression<'a> {
+    fn from(value: Option<&'a Expression>) -> Self {
+        value.map(|x| x as &dyn ExpressionConvertibleTrait).into()
+    }
+}
+
+impl<'a> From<&'a Expression> for BasicExpression<'a> {
+    fn from(value: &'a Expression) -> Self {
+        BasicExpression::ExpressionConvertible(Some(value))
+    }
+}
+
+impl<'a> From<Option<&'a Column>> for BasicExpression<'a> {
+    fn from(value: Option<&'a Column>) -> Self {
+        value.map(|x| x as &dyn ExpressionConvertibleTrait).into()
+    }
+}
+
+impl<'a> From<&'a Column> for BasicExpression<'a> {
+    fn from(value: &'a Column) -> Self {
+        BasicExpression::ExpressionConvertible(Some(value))
+    }
+}

src/rust/wcdb/src/base/param/enum_int_expression.rs

@@ -0,0 +1,29 @@
+use crate::winq::expression_convertible::ExpressionConvertibleTrait;
+
+/// 支持 i8, i16, i32, i64, Option<&dyn ExpressionConvertibleTrait>
+pub enum IntExpression<'a> {
+    Int(i64),
+    ExpressionConvertible(Option<&'a dyn ExpressionConvertibleTrait>),
+}
+
+/// 宏定义：为所有整数类型实现 From trait
+macro_rules! impl_from_int_types {
+    ($($int_type:ty),* $(,)?) => {
+        $(
+            impl<'a> From<$int_type> for IntExpression<'a> {
+                fn from(value: $int_type) -> Self {
+                    IntExpression::Int(value as i64)
+                }
+            }
+        )*
+    };
+}
+
+/// 使用宏为所有整数类型实现 From trait
+impl_from_int_types!(i8, i16, i32, i64);
+
+impl<'a> From<Option<&'a dyn ExpressionConvertibleTrait>> for IntExpression<'a> {
+    fn from(value: Option<&'a dyn ExpressionConvertibleTrait>) -> Self {
+        IntExpression::ExpressionConvertible(value)
+    }
+}

src/rust/wcdb/src/base/param/enum_string_column.rs

@@ -0,0 +1,25 @@
+use crate::winq::column::ColumnTrait;
+
+/// 支持 String, &str, Column
+pub enum StringColumn<'a> {
+    String(String),
+    Column(&'a dyn ColumnTrait),
+}
+
+impl<'a> From<String> for StringColumn<'a> {
+    fn from(value: String) -> Self {
+        StringColumn::String(value)
+    }
+}
+
+impl<'a> From<&str> for StringColumn<'a> {
+    fn from(value: &str) -> Self {
+        StringColumn::String(value.to_string())
+    }
+}
+
+impl<'a, T: ColumnTrait> From<&'a T> for StringColumn<'a> {
+    fn from(value: &'a T) -> Self {
+        StringColumn::Column(value)
+    }
+}

src/rust/wcdb/src/base/param/string_expression_convertible_param.rs renamed to src/rust/wcdb/src/base/param/enum_string_expression.rs

@@ -5,38 +5,38 @@ use crate::winq::identifier::{CPPType, Identifier};
 use std::ffi::{c_void, CString};
 
 /// 支持 String, &str, &dyn ExpressionConvertibleTrait
-pub enum StringExpressionConvertibleParam<'a> {
+pub enum StringExpression<'a> {
     String(String),
     ExpressionConvertible(&'a dyn ExpressionConvertibleTrait),
 }
 
-impl StringExpressionConvertibleParam<'_> {
+impl StringExpression<'_> {
     pub(crate) fn get_params(self) -> (CPPType, *mut c_void, Option<CString>) {
         match self {
-            StringExpressionConvertibleParam::String(str) => {
+            StringExpression::String(str) => {
                 (CPPType::String, 0 as *mut c_void, Some(str.to_cstring()))
             }
-            StringExpressionConvertibleParam::ExpressionConvertible(exp) => {
+            StringExpression::ExpressionConvertible(exp) => {
                 (Identifier::get_cpp_type(exp), CppObject::get(exp), None)
             }
         }
     }
 }
 
-impl<'a> From<String> for StringExpressionConvertibleParam<'a> {
+impl<'a> From<String> for StringExpression<'a> {
     fn from(value: String) -> Self {
-        StringExpressionConvertibleParam::String(value)
+        StringExpression::String(value)
     }
 }
 
-impl<'a> From<&str> for StringExpressionConvertibleParam<'a> {
+impl<'a> From<&str> for StringExpression<'a> {
     fn from(value: &str) -> Self {
-        StringExpressionConvertibleParam::String(value.to_string())
+        StringExpression::String(value.to_string())
     }
 }
 
-impl<'a, T: ExpressionConvertibleTrait> From<&'a T> for StringExpressionConvertibleParam<'a> {
+impl<'a, T: ExpressionConvertibleTrait> From<&'a T> for StringExpression<'a> {
     fn from(value: &'a T) -> Self {
-        StringExpressionConvertibleParam::ExpressionConvertible(value)
+        StringExpression::ExpressionConvertible(value)
     }
 }

src/rust/wcdb/src/base/param/enum_string_indexed_column.rs

@@ -0,0 +1,25 @@
+use crate::winq::indexed_column_convertible::IndexedColumnConvertibleTrait;
+
+/// 支持 String, &str, &dyn IndexedColumnConvertibleTrait
+pub enum StringIndexedColumn<'a> {
+    String(String),
+    IndexedColumnConvertible(&'a dyn IndexedColumnConvertibleTrait),
+}
+
+impl<'a> From<String> for StringIndexedColumn<'a> {
+    fn from(value: String) -> Self {
+        StringIndexedColumn::String(value)
+    }
+}
+
+impl<'a> From<&'a str> for StringIndexedColumn<'a> {
+    fn from(value: &'a str) -> Self {
+        StringIndexedColumn::String(value.to_string())
+    }
+}
+
+impl<'a, T: IndexedColumnConvertibleTrait> From<&'a T> for StringIndexedColumn<'a> {
+    fn from(value: &'a T) -> Self {
+        StringIndexedColumn::IndexedColumnConvertible(value)
+    }
+}

src/rust/wcdb/src/base/param/enum_string_qualified_table.rs

@@ -0,0 +1,25 @@
+use crate::winq::qualified_table::QualifiedTable;
+
+/// 支持 String, &str, &QualifiedTable
+pub enum StringQualifiedTable<'a> {
+    String(String),
+    QualifiedTable(&'a QualifiedTable),
+}
+
+impl<'a> From<String> for StringQualifiedTable<'a> {
+    fn from(value: String) -> Self {
+        StringQualifiedTable::String(value)
+    }
+}
+
+impl<'a> From<&str> for StringQualifiedTable<'a> {
+    fn from(value: &str) -> Self {
+        StringQualifiedTable::String(value.to_string())
+    }
+}
+
+impl<'a> From<&'a QualifiedTable> for StringQualifiedTable<'a> {
+    fn from(value: &'a QualifiedTable) -> Self {
+        StringQualifiedTable::QualifiedTable(value)
+    }
+}

src/rust/wcdb/src/base/param/string_result_column_convertible_param.rs renamed to src/rust/wcdb/src/base/param/enum_string_result_column.rs

@@ -1,25 +1,25 @@
 use crate::winq::result_column_convertible_trait::ResultColumnConvertibleTrait;
 
 /// 支持 String, &str, &dyn ResultColumnConvertibleTrait
-pub enum StringResultColumnConvertibleParam<'a> {
+pub enum StringResultColumn<'a> {
     String(String),
     ResultColumn(&'a dyn ResultColumnConvertibleTrait),
 }
 
-impl<'a> From<String> for StringResultColumnConvertibleParam<'a> {
+impl<'a> From<String> for StringResultColumn<'a> {
     fn from(value: String) -> Self {
-        StringResultColumnConvertibleParam::String(value)
+        StringResultColumn::String(value)
     }
 }
 
-impl<'a> From<&str> for StringResultColumnConvertibleParam<'a> {
+impl<'a> From<&str> for StringResultColumn<'a> {
     fn from(value: &str) -> Self {
-        StringResultColumnConvertibleParam::String(value.to_string())
+        StringResultColumn::String(value.to_string())
     }
 }
 
-impl<'a, T: ResultColumnConvertibleTrait> From<&'a T> for StringResultColumnConvertibleParam<'a> {
+impl<'a, T: ResultColumnConvertibleTrait> From<&'a T> for StringResultColumn<'a> {
     fn from(value: &'a T) -> Self {
-        StringResultColumnConvertibleParam::ResultColumn(value)
+        StringResultColumn::ResultColumn(value)
     }
 }

src/rust/wcdb/src/base/param/string_schema_param.rs renamed to src/rust/wcdb/src/base/param/enum_string_schema.rs

@@ -5,39 +5,39 @@ use crate::winq::schema::Schema;
 use std::ffi::{c_void, CString};
 
 /// 支持 String, &str, Option<&Schema>
-pub enum StringSchemaParam<'a> {
+pub enum StringSchema<'a> {
     String(String),
     Schema(Option<&'a Schema>),
 }
 
-impl StringSchemaParam<'_> {
+impl StringSchema<'_> {
     pub(crate) fn get_params(self) -> (CPPType, *mut c_void, Option<CString>) {
         match self {
-            StringSchemaParam::String(str) => {
+            StringSchema::String(str) => {
                 (CPPType::String, 0 as *mut c_void, Some(str.to_cstring()))
             }
-            StringSchemaParam::Schema(schema_opt) => match schema_opt {
+            StringSchema::Schema(schema_opt) => match schema_opt {
                 None => (CPPType::Null, 0 as *mut c_void, None),
                 Some(sc) => (Identifier::get_cpp_type(sc), CppObject::get(sc), None),
             },
         }
     }
 }
 
-impl<'a> From<String> for StringSchemaParam<'a> {
+impl<'a> From<String> for StringSchema<'a> {
     fn from(value: String) -> Self {
-        StringSchemaParam::String(value)
+        StringSchema::String(value)
     }
 }
 
-impl<'a> From<&str> for StringSchemaParam<'a> {
+impl<'a> From<&str> for StringSchema<'a> {
     fn from(value: &str) -> Self {
-        StringSchemaParam::String(value.to_string())
+        StringSchema::String(value.to_string())
     }
 }
 
-impl<'a> From<Option<&'a Schema>> for StringSchemaParam<'a> {
+impl<'a> From<Option<&'a Schema>> for StringSchema<'a> {
     fn from(value: Option<&'a Schema>) -> Self {
-        StringSchemaParam::Schema(value)
+        StringSchema::Schema(value)
     }
 }