refactor: stable kitesql

Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name          = "kite_sql"
-version       = "0.1.2"
+version       = "0.1.3"
 edition       = "2021"
 authors       = ["Kould <[email protected]>", "Xwg <[email protected]>"]
 description   = "SQL as a Function for Rust"
@@ -60,6 +60,8 @@ sqlparser             = { version = "0.34", features = ["serde"] }
 thiserror             = { version = "1" }
 typetag               = { version = "0.2" }
 ulid                  = { version = "1", features = ["serde"] }
+genawaiter            = { version = "0.99" }
+rand                  = { version = "0.8" }
 
 # Feature: net
 async-trait           = { version = "0.1", optional = true }

kite_sql_serde_macros/src/reference_serialization.rs

@@ -92,7 +92,7 @@ pub(crate) fn handle(ast: DeriveInput) -> Result<TokenStream, Error> {
 
                 let field_name = field_opts
                     .ident
-                    .unwrap_or_else(|| Ident::new(&format!("field_{}", i), Span::call_site()));
+                    .unwrap_or_else(|| Ident::new(&format!("field_{i}"), Span::call_site()));
                 let ty = process_type(&field_opts.ty);
 
                 encode_fields.push(quote! {
@@ -155,7 +155,7 @@ pub(crate) fn handle(ast: DeriveInput) -> Result<TokenStream, Error> {
 
                     let field_name = field_opts
                         .ident
-                        .unwrap_or_else(|| Ident::new(&format!("field_{}", i), Span::call_site()));
+                        .unwrap_or_else(|| Ident::new(&format!("field_{i}"), Span::call_site()));
                     let ty = process_type(&field_opts.ty);
 
                     encode_fields.push(quote! {

rust-toolchain

@@ -1 +1 @@
-nightly-2024-10-10
+stable

src/binder/aggregate.rs

@@ -83,8 +83,8 @@ impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A>
 
                 return_orderby.push(SortField::new(
                     expr,
-                    asc.map_or(true, |asc| asc),
-                    nulls_first.map_or(false, |first| first),
+                    asc.is_none_or(|asc| asc),
+                    nulls_first.is_some_and(|first| first),
                 ));
             }
             Some(return_orderby)
@@ -251,8 +251,7 @@ impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A>
 
             if !group_raw_exprs.iter().contains(&expr) {
                 return Err(DatabaseError::AggMiss(format!(
-                    "`{}` must appear in the GROUP BY clause or be used in an aggregate function",
-                    expr
+                    "`{expr}` must appear in the GROUP BY clause or be used in an aggregate function"
                 )));
             }
         }
@@ -306,12 +305,9 @@ impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A>
                     return Ok(());
                 }
 
-                Err(DatabaseError::AggMiss(
-                    format!(
-                        "expression '{}' must appear in the GROUP BY clause or be used in an aggregate function",
-                        expr
-                    )
-                ))
+                Err(DatabaseError::AggMiss(format!(
+                    "expression '{expr}' must appear in the GROUP BY clause or be used in an aggregate function"
+                )))
             }
             ScalarExpression::ColumnRef { .. } | ScalarExpression::Alias { .. } => {
                 if self.context.group_by_exprs.contains(expr) {
@@ -321,12 +317,9 @@ impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A>
                     return self.validate_having_orderby(expr.unpack_alias_ref());
                 }
 
-                Err(DatabaseError::AggMiss(
-                    format!(
-                        "expression '{}' must appear in the GROUP BY clause or be used in an aggregate function",
-                        expr
-                    )
-                ))
+                Err(DatabaseError::AggMiss(format!(
+                    "expression '{expr}' must appear in the GROUP BY clause or be used in an aggregate function"
+                )))
             }
 
             ScalarExpression::TypeCast { expr, .. } => self.validate_having_orderby(expr),

src/binder/alter_table.rs

@@ -44,7 +44,7 @@ impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A>
                         if_not_exists: *if_not_exists,
                         column,
                     }),
-                    Childrens::Only(plan),
+                    Childrens::Only(Box::new(plan)),
                 )
             }
             AlterTableOperation::DropColumn {
@@ -61,13 +61,12 @@ impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A>
                         if_exists: *if_exists,
                         column_name,
                     }),
-                    Childrens::Only(plan),
+                    Childrens::Only(Box::new(plan)),
                 )
             }
             op => {
                 return Err(DatabaseError::UnsupportedStmt(format!(
-                    "AlertOperation: {:?}",
-                    op
+                    "AlertOperation: {op:?}"
                 )))
             }
         };

src/binder/analyze.rs

@@ -32,7 +32,7 @@ impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A>
                 table_name,
                 index_metas,
             }),
-            Childrens::Only(scan_op),
+            Childrens::Only(Box::new(scan_op)),
         ))
     }
 }

src/binder/copy.rs

@@ -90,8 +90,7 @@ impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A>
                     CopyTarget::File { filename } => filename.into(),
                     t => {
                         return Err(DatabaseError::UnsupportedStmt(format!(
-                            "copy target: {:?}",
-                            t
+                            "copy target: {t:?}"
                         )))
                     }
                 },
@@ -105,7 +104,7 @@ impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A>
                         target: ext_source,
                         schema_ref,
                     }),
-                    Childrens::Only(TableScanOperator::build(table_name, table, false)),
+                    Childrens::Only(Box::new(TableScanOperator::build(table_name, table, false))),
                 ))
             } else {
                 // COPY <dest_table> FROM <source_file>
@@ -140,7 +139,7 @@ impl FileFormat {
                 CopyOption::Header(b) => header = *b,
                 CopyOption::Quote(c) => quote = *c,
                 CopyOption::Escape(c) => escape = Some(*c),
-                o => panic!("unsupported copy option: {:?}", o),
+                o => panic!("unsupported copy option: {o:?}"),
             }
         }
         FileFormat::Csv {

src/binder/create_index.rs

@@ -46,8 +46,7 @@ impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A>
                 ScalarExpression::ColumnRef { column, .. } => columns.push(column),
                 expr => {
                     return Err(DatabaseError::UnsupportedStmt(format!(
-                        "'CREATE INDEX' by {}",
-                        expr
+                        "'CREATE INDEX' by {expr}"
                     )))
                 }
             }
@@ -61,7 +60,7 @@ impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A>
                 if_not_exists,
                 ty,
             }),
-            Childrens::Only(plan),
+            Childrens::Only(Box::new(plan)),
         ))
     }
 }

src/binder/create_table.rs

@@ -76,8 +76,7 @@ impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A>
                 }
                 constraint => {
                     return Err(DatabaseError::UnsupportedStmt(format!(
-                        "`CreateTable` does not currently support this constraint: {:?}",
-                        constraint
+                        "`CreateTable` does not currently support this constraint: {constraint:?}"
                     )))?
                 }
             }
@@ -145,8 +144,7 @@ impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A>
                 }
                 option => {
                     return Err(DatabaseError::UnsupportedStmt(format!(
-                        "`Column` does not currently support this option: {:?}",
-                        option
+                        "`Column` does not currently support this option: {option:?}"
                     )))
                 }
             }

src/binder/delete.rs

@@ -53,7 +53,7 @@ impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A>
                     table_name,
                     primary_keys,
                 }),
-                Childrens::Only(plan),
+                Childrens::Only(Box::new(plan)),
             ))
         } else {
             unreachable!("only table")

src/binder/explain.rs

@@ -7,6 +7,9 @@ use crate::types::value::DataValue;
 
 impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A> {
     pub(crate) fn bind_explain(&mut self, plan: LogicalPlan) -> Result<LogicalPlan, DatabaseError> {
-        Ok(LogicalPlan::new(Operator::Explain, Childrens::Only(plan)))
+        Ok(LogicalPlan::new(
+            Operator::Explain,
+            Childrens::Only(Box::new(plan)),
+        ))
     }
 }

src/binder/expr.rs

@@ -454,7 +454,7 @@ impl<'a, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'a, '_, T
             | BinaryOperator::Or
             | BinaryOperator::Xor => LogicalType::Boolean,
             BinaryOperator::StringConcat => LogicalType::Varchar(None, CharLengthUnits::Characters),
-            op => return Err(DatabaseError::UnsupportedStmt(format!("{}", op))),
+            op => return Err(DatabaseError::UnsupportedStmt(format!("{op}"))),
         };
 
         Ok(ScalarExpression::Binary {
@@ -504,8 +504,7 @@ impl<'a, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'a, '_, T
                 FunctionArgExpr::Wildcard => args.push(Self::wildcard_expr()),
                 expr => {
                     return Err(DatabaseError::UnsupportedStmt(format!(
-                        "function arg: {:#?}",
-                        expr
+                        "function arg: {expr:#?}"
                     )))
                 }
             }

src/binder/insert.rs

@@ -105,7 +105,7 @@ impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A>
                 is_overwrite,
                 is_mapping_by_name,
             }),
-            Childrens::Only(values_plan),
+            Childrens::Only(Box::new(values_plan)),
         ))
     }
 

src/binder/mod.rs

@@ -487,8 +487,7 @@ impl<'a, 'b, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'a, '
                 right,
             } => self.bind_set_operation(op, set_quantifier, left, right),
             expr => Err(DatabaseError::UnsupportedStmt(format!(
-                "set expression: {:?}",
-                expr
+                "set expression: {expr:?}"
             ))),
         }
     }