refactor: stable kitesql (#292)

* refactor: stable kitesql

* chore: fix nested_loop_join unit test

Author: KKould

Cargo.lock

@@ -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 }

Cargo.toml

@@ -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! {

kite_sql_serde_macros/src/reference_serialization.rs

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

rust-toolchain

@@ -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/aggregate.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/alter_table.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/analyze.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/copy.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_index.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:?}"
                     )))
                 }
             }