Reduce wasm size by trimming parser and serialization deps

Cargo.toml

@@ -66,9 +66,8 @@ rust_decimal          = { version = "1" }
 serde                 = { version = "1", features = ["derive", "rc"] }
 kite_sql_serde_macros = { version = "0.2.0", path = "kite_sql_serde_macros" }
 siphasher             = { version = "1", features = ["serde"] }
-sqlparser             = { version = "0.61", features = ["serde"] }
+sqlparser             = { version = "0.61", default-features = false, features = ["std"] }
 thiserror             = { version = "1" }
-typetag               = { version = "0.2" }
 ulid                  = { version = "1", features = ["serde"] }
 
 # Feature: net

kite_sql_serde_macros/src/reference_serialization.rs

@@ -142,7 +142,7 @@ pub(crate) fn handle(ast: DeriveInput) -> Result<TokenStream, Error> {
 
                     fn decode<T: crate::storage::Transaction, R: std::io::Read>(
                         reader: &mut R,
-                        drive: Option<(&T, &crate::storage::TableCache)>,
+                        drive: Option<&crate::serdes::ReferenceDecodeContext<'_, T>>,
                         reference_tables: &crate::serdes::ReferenceTables,
                     ) -> Result<Self, crate::errors::DatabaseError> {
                         #(#decode_fields)*
@@ -221,7 +221,7 @@ pub(crate) fn handle(ast: DeriveInput) -> Result<TokenStream, Error> {
 
                     fn decode<T: crate::storage::Transaction, R: std::io::Read>(
                         reader: &mut R,
-                        drive: Option<(&T, &crate::storage::TableCache)>,
+                        drive: Option<&crate::serdes::ReferenceDecodeContext<'_, T>>,
                         reference_tables: &crate::serdes::ReferenceTables,
                     ) -> Result<Self, crate::errors::DatabaseError> {
                         let mut type_bytes = [0u8; 1];

src/binder/create_table.rs

@@ -187,9 +187,9 @@ mod tests {
     use crate::catalog::ColumnDesc;
     use crate::storage::rocksdb::RocksStorage;
     use crate::storage::Storage;
+    use crate::types::CharLengthUnits;
     use crate::types::LogicalType;
     use crate::utils::lru::SharedLruCache;
-    use sqlparser::ast::CharLengthUnits;
     use std::hash::RandomState;
     use std::sync::atomic::AtomicUsize;
     use tempfile::TempDir;

src/binder/expr.rs

@@ -18,8 +18,8 @@ use crate::expression;
 use crate::expression::agg::AggKind;
 use itertools::Itertools;
 use sqlparser::ast::{
-    BinaryOperator, CharLengthUnits, DataType, DuplicateTreatment, Expr, Function, FunctionArg,
-    FunctionArgExpr, FunctionArguments, Ident, Query, TypedString, UnaryOperator, Value,
+    BinaryOperator, DataType, DuplicateTreatment, Expr, Function, FunctionArg, FunctionArgExpr,
+    FunctionArguments, Ident, Query, TypedString, UnaryOperator, Value,
 };
 use std::borrow::Cow;
 use std::collections::HashMap;
@@ -39,7 +39,7 @@ use crate::planner::{LogicalPlan, SchemaOutput};
 use crate::storage::Transaction;
 use crate::types::tuple::SchemaRef;
 use crate::types::value::{DataValue, Utf8Type};
-use crate::types::{ColumnId, LogicalType};
+use crate::types::{CharLengthUnits, ColumnId, LogicalType};
 
 macro_rules! try_alias {
     ($context:expr, $full_name:expr) => {
@@ -242,7 +242,7 @@ impl<'a, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'a, '_, T
                 Ok(ScalarExpression::Trim {
                     expr: Box::new(self.bind_expr(expr)?),
                     trim_what_expr,
-                    trim_where: *trim_where,
+                    trim_where: trim_where.map(Into::into),
                 })
             }
             Expr::Exists { subquery, negated } => {

src/binder/mod.rs

@@ -340,11 +340,21 @@ impl<'a, T: Transaction> BinderContext<'a, T> {
 
     pub fn view(&self, view_name: TableName) -> Result<Option<&View>, DatabaseError> {
         if let Some(real_name) = self.table_aliases.get(view_name.as_ref()) {
-            self.transaction
-                .view(self.table_cache, self.view_cache, real_name.clone())
+            self.transaction.view(
+                self.table_cache,
+                self.view_cache,
+                self.scala_functions,
+                self.table_functions,
+                real_name.clone(),
+            )
         } else {
-            self.transaction
-                .view(self.table_cache, self.view_cache, view_name.clone())
+            self.transaction.view(
+                self.table_cache,
+                self.view_cache,
+                self.scala_functions,
+                self.table_functions,
+                view_name.clone(),
+            )
         }
     }
 
@@ -367,11 +377,21 @@ impl<'a, T: Transaction> BinderContext<'a, T> {
 
         if source.is_none() && !only_table {
             source = if let Some(real_name) = self.table_aliases.get(table_name.as_ref()) {
-                self.transaction
-                    .view(self.table_cache, self.view_cache, real_name.clone())
+                self.transaction.view(
+                    self.table_cache,
+                    self.view_cache,
+                    self.scala_functions,
+                    self.table_functions,
+                    real_name.clone(),
+                )
             } else {
-                self.transaction
-                    .view(self.table_cache, self.view_cache, table_name.clone())
+                self.transaction.view(
+                    self.table_cache,
+                    self.view_cache,
+                    self.scala_functions,
+                    self.table_functions,
+                    table_name.clone(),
+                )
             }?
             .map(Source::View);
         }
@@ -396,11 +416,21 @@ impl<'a, T: Transaction> BinderContext<'a, T> {
 
         if source.is_none() {
             source = if let Some(real_name) = self.table_aliases.get(table_name.as_ref()) {
-                self.transaction
-                    .view(self.table_cache, self.view_cache, real_name.clone())
+                self.transaction.view(
+                    self.table_cache,
+                    self.view_cache,
+                    self.scala_functions,
+                    self.table_functions,
+                    real_name.clone(),
+                )
             } else {
-                self.transaction
-                    .view(self.table_cache, self.view_cache, table_name.clone())
+                self.transaction.view(
+                    self.table_cache,
+                    self.view_cache,
+                    self.scala_functions,
+                    self.table_functions,
+                    table_name.clone(),
+                )
             }?
             .map(Source::View);
         }

src/catalog/column.rs

@@ -17,9 +17,9 @@ use crate::errors::DatabaseError;
 use crate::expression::ScalarExpression;
 use crate::types::tuple::Tuple;
 use crate::types::value::DataValue;
+use crate::types::CharLengthUnits;
 use crate::types::{ColumnId, LogicalType};
 use kite_sql_serde_macros::ReferenceSerialization;
-use sqlparser::ast::CharLengthUnits;
 use std::hash::Hash;
 use std::ops::Deref;
 use std::sync::Arc;

src/catalog/table.rs

@@ -349,7 +349,7 @@ mod tests {
                         "name".into(),
                         true,
                         ColumnDesc::new(
-                            LogicalType::Varchar(None, sqlparser::ast::CharLengthUnits::Characters),
+                            LogicalType::Varchar(None, crate::types::CharLengthUnits::Characters),
                             None,
                             false,
                             None,

src/db.rs

@@ -540,7 +540,13 @@ impl<S: Storage> State<S> {
             let root = build_write(
                 &mut arena,
                 plan,
-                (&self.table_cache, &self.view_cache, &self.meta_cache),
+                (
+                    &self.table_cache,
+                    &self.view_cache,
+                    &self.meta_cache,
+                    &self.scala_functions,
+                    &self.table_functions,
+                ),
                 transaction,
             );
             let executor = Executor::new(arena, root);

src/execution/ddl/drop_view.rs

@@ -53,11 +53,10 @@ impl DropView {
             return Ok(());
         };
 
-        let table_cache = arena.table_cache();
         let view_cache = arena.view_cache();
         arena
             .transaction_mut()
-            .drop_view(view_cache, table_cache, view_name.clone(), if_exists)?;
+            .drop_view(view_cache, view_name.clone(), if_exists)?;
 
         TupleBuilder::build_result_into(arena.result_tuple_mut(), format!("{view_name}"));
         arena.resume();

src/execution/dml/analyze.rs

@@ -24,8 +24,8 @@ use crate::planner::LogicalPlan;
 use crate::storage::{StatisticsMetaCache, Transaction};
 use crate::types::index::IndexId;
 use crate::types::value::{DataValue, Utf8Type};
+use crate::types::CharLengthUnits;
 use itertools::Itertools;
-use sqlparser::ast::CharLengthUnits;
 use std::fmt::{self, Formatter};
 use std::sync::Arc;
 

src/execution/dml/copy_from_file.rs

@@ -158,8 +158,8 @@ mod tests {
     use crate::db::DataBaseBuilder;
     use crate::errors::DatabaseError;
     use crate::storage::Storage;
+    use crate::types::CharLengthUnits;
     use crate::types::LogicalType;
-    use sqlparser::ast::CharLengthUnits;
     use std::io::Write;
     use std::sync::Arc;
     use tempfile::TempDir;

src/execution/dml/copy_to_file.rs

@@ -118,8 +118,8 @@ mod tests {
     use crate::errors::DatabaseError;
     use crate::planner::operator::table_scan::TableScanOperator;
     use crate::storage::Storage;
+    use crate::types::CharLengthUnits;
     use crate::types::LogicalType;
-    use sqlparser::ast::CharLengthUnits;
     use std::sync::Arc;
     use tempfile::TempDir;
     use ulid::Ulid;

src/execution/dql/aggregate/avg.rs

@@ -71,6 +71,6 @@ impl Accumulator for AvgAccumulator {
             value = value.cast(&quantity_ty)?
         }
         let evaluator = binary_create(Cow::Owned(quantity_ty), BinaryOperator::Divide)?;
-        evaluator.0.binary_eval(&value, &quantity)
+        evaluator.binary_eval(&value, &quantity)
     }
 }

src/execution/dql/aggregate/min_max.rs

@@ -41,7 +41,7 @@ impl Accumulator for MinMaxAccumulator {
         if !value.is_null() {
             if let Some(inner_value) = &self.inner {
                 let evaluator = binary_create(Cow::Owned(value.logical_type()), self.op)?;
-                if let DataValue::Boolean(result) = evaluator.0.binary_eval(inner_value, value)? {
+                if let DataValue::Boolean(result) = evaluator.binary_eval(inner_value, value)? {
                     result
                 } else {
                     return Err(DatabaseError::InvalidType);

src/execution/dql/aggregate/sum.rs

@@ -44,7 +44,7 @@ impl Accumulator for SumAccumulator {
             if self.result.is_null() {
                 self.result = value.clone();
             } else {
-                self.result = self.evaluator.0.binary_eval(&self.result, value)?;
+                self.result = self.evaluator.binary_eval(&self.result, value)?;
             }
         }
 

src/execution/dql/describe.rs

@@ -18,7 +18,7 @@ use crate::execution::{ExecArena, ExecId, ExecNode, ExecutionCaches, ExecutorNod
 use crate::planner::operator::describe::DescribeOperator;
 use crate::storage::Transaction;
 use crate::types::value::{DataValue, Utf8Type};
-use sqlparser::ast::CharLengthUnits;
+use crate::types::CharLengthUnits;
 use std::sync::LazyLock;
 
 static PRIMARY_KEY_TYPE: LazyLock<DataValue> = LazyLock::new(|| DataValue::Utf8 {

src/execution/dql/explain.rs

@@ -17,7 +17,7 @@ use crate::execution::{ExecArena, ExecId, ExecNode, ExecutionCaches, ExecutorNod
 use crate::planner::LogicalPlan;
 use crate::storage::Transaction;
 use crate::types::value::{DataValue, Utf8Type};
-use sqlparser::ast::CharLengthUnits;
+use crate::types::CharLengthUnits;
 
 pub struct Explain {
     plan: LogicalPlan,