chore: TableName use Arc<str>

.github/workflows/ci.yml

@@ -18,7 +18,7 @@ jobs:
       - name: Install latest nightly
         uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-10-10
+          toolchain: stable
           override: true
           components: rustfmt, clippy
 
@@ -54,7 +54,7 @@ jobs:
       - name: Install latest nightly
         uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-10-10
+          toolchain: stable
           override: true
           components: rustfmt, clippy
 
@@ -75,7 +75,7 @@ jobs:
       - name: Install latest nightly
         uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-10-10
+          toolchain: stable
           override: true
           components: rustfmt, clippy
 

src/binder/alter_table.rs

@@ -19,7 +19,7 @@ impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A>
         name: &ObjectName,
         operation: &AlterTableOperation,
     ) -> Result<LogicalPlan, DatabaseError> {
-        let table_name: Arc<String> = Arc::new(lower_case_name(name)?);
+        let table_name: Arc<str> = lower_case_name(name)?.into();
         let table = self
             .context
             .table(table_name.clone())?

src/binder/analyze.rs

@@ -11,7 +11,7 @@ use std::sync::Arc;
 
 impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A> {
     pub(crate) fn bind_analyze(&mut self, name: &ObjectName) -> Result<LogicalPlan, DatabaseError> {
-        let table_name = Arc::new(lower_case_name(name)?);
+        let table_name: Arc<str> = lower_case_name(name)?.into();
 
         let table = self
             .context

src/binder/copy.rs

@@ -81,7 +81,7 @@ impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A>
                 return Err(DatabaseError::UnsupportedStmt("'COPY SOURCE'".to_string()));
             }
         };
-        let table_name = Arc::new(lower_case_name(&table_name)?);
+        let table_name: Arc<str> = lower_case_name(&table_name)?.into();
 
         if let Some(table) = self.context.table(table_name.clone())? {
             let schema_ref = table.schema_ref().clone();

src/binder/create_index.rs

@@ -20,7 +20,7 @@ impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A>
         if_not_exists: bool,
         is_unique: bool,
     ) -> Result<LogicalPlan, DatabaseError> {
-        let table_name = Arc::new(lower_case_name(table_name)?);
+        let table_name: Arc<str> = lower_case_name(table_name)?.into();
         let index_name = lower_case_name(name)?;
         let ty = if is_unique {
             IndexType::Unique

src/binder/create_table.rs

@@ -23,7 +23,7 @@ impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A>
         constraints: &[TableConstraint],
         if_not_exists: bool,
     ) -> Result<LogicalPlan, DatabaseError> {
-        let table_name = Arc::new(lower_case_name(name)?);
+        let table_name: Arc<str> = lower_case_name(name)?.into();
 
         if !is_valid_identifier(&table_name) {
             return Err(DatabaseError::InvalidTable(
@@ -196,7 +196,7 @@ mod tests {
 
         match plan1.operator {
             Operator::CreateTable(op) => {
-                assert_eq!(op.table_name, Arc::new("t1".to_string()));
+                assert_eq!(op.table_name.as_ref(), "t1");
                 assert_eq!(op.columns[0].name(), "id");
                 assert_eq!(op.columns[0].nullable(), false);
                 assert_eq!(

src/binder/create_view.rs

@@ -21,7 +21,7 @@ impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A>
         columns: &[Ident],
         query: &Query,
     ) -> Result<LogicalPlan, DatabaseError> {
-        let view_name = Arc::new(lower_case_name(name)?);
+        let view_name: Arc<str> = lower_case_name(name)?.into();
         let mut plan = self.bind_query(query)?;
 
         let mapping_schema = plan.output_schema();

src/binder/delete.rs

@@ -17,12 +17,12 @@ impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A>
         selection: &Option<Expr>,
     ) -> Result<LogicalPlan, DatabaseError> {
         if let TableFactor::Table { name, alias, .. } = &from.relation {
-            let table_name = Arc::new(lower_case_name(name)?);
+            let table_name: Arc<str> = lower_case_name(name)?.into();
             let mut table_alias = None;
             let mut alias_idents = None;
 
             if let Some(TableAlias { name, columns }) = alias {
-                table_alias = Some(Arc::new(name.value.to_lowercase()));
+                table_alias = Some(name.value.to_lowercase().into());
                 alias_idents = Some(columns);
             }
             let Source::Table(table) = self

src/binder/describe.rs

@@ -13,7 +13,7 @@ impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A>
         &mut self,
         name: &ObjectName,
     ) -> Result<LogicalPlan, DatabaseError> {
-        let table_name = Arc::new(lower_case_name(name)?);
+        let table_name: Arc<str> = lower_case_name(name)?.into();
 
         Ok(LogicalPlan::new(
             Operator::Describe(DescribeOperator { table_name }),

src/binder/drop_index.rs

@@ -6,7 +6,6 @@ use crate::planner::{Childrens, LogicalPlan};
 use crate::storage::Transaction;
 use crate::types::value::DataValue;
 use sqlparser::ast::ObjectName;
-use std::sync::Arc;
 
 impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A> {
     pub(crate) fn bind_drop_index(
@@ -20,7 +19,7 @@ impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A>
             .ok_or(DatabaseError::InvalidTable(name.to_string()))?;
         let index_name = name.0.get(1).ok_or(DatabaseError::InvalidIndex)?;
 
-        let table_name = Arc::new(lower_ident(table_name));
+        let table_name = lower_ident(table_name).into();
         let index_name = lower_ident(index_name);
 
         Ok(LogicalPlan::new(

src/binder/drop_table.rs

@@ -14,7 +14,7 @@ impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A>
         name: &ObjectName,
         if_exists: &bool,
     ) -> Result<LogicalPlan, DatabaseError> {
-        let table_name = Arc::new(lower_case_name(name)?);
+        let table_name: Arc<str> = lower_case_name(name)?.into();
 
         Ok(LogicalPlan::new(
             Operator::DropTable(DropTableOperator {

src/binder/drop_view.rs

@@ -6,15 +6,14 @@ use crate::planner::{Childrens, LogicalPlan};
 use crate::storage::Transaction;
 use crate::types::value::DataValue;
 use sqlparser::ast::ObjectName;
-use std::sync::Arc;
 
 impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A> {
     pub(crate) fn bind_drop_view(
         &mut self,
         name: &ObjectName,
         if_exists: &bool,
     ) -> Result<LogicalPlan, DatabaseError> {
-        let view_name = Arc::new(lower_case_name(name)?);
+        let view_name = lower_case_name(name)?.into();
 
         Ok(LogicalPlan::new(
             Operator::DropView(DropViewOperator {

src/binder/expr.rs

@@ -9,7 +9,6 @@ use sqlparser::ast::{
 };
 use std::collections::HashMap;
 use std::slice;
-use std::sync::Arc;
 
 use super::{lower_ident, Binder, BinderContext, QueryBindStep, SubQueryType};
 use crate::expression::function::scala::{ArcScalarFunctionImpl, ScalarFunction};
@@ -369,7 +368,7 @@ impl<'a, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'a, '_, T
         }
         if let Some(table) = full_name.0.or(bind_table_name) {
             let source = self.context.bind_source(&table)?;
-            let schema_buf = self.table_schema_buf.entry(Arc::new(table)).or_default();
+            let schema_buf = self.table_schema_buf.entry(table.into()).or_default();
 
             Ok(ScalarExpression::column_expr(
                 source
@@ -649,7 +648,7 @@ impl<'a, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'a, '_, T
         }
         let arg_types = args.iter().map(ScalarExpression::return_type).collect_vec();
         let summary = FunctionSummary {
-            name: function_name,
+            name: function_name.into(),
             arg_types,
         };
         if let Some(function) = self.context.scala_functions.get(&summary) {
@@ -665,7 +664,7 @@ impl<'a, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'a, '_, T
             }));
         }
 
-        Err(DatabaseError::FunctionNotFound(summary.name))
+        Err(DatabaseError::FunctionNotFound(summary.name.to_string()))
     }
 
     fn return_type(

src/binder/insert.rs

@@ -25,7 +25,7 @@ impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A>
     ) -> Result<LogicalPlan, DatabaseError> {
         // FIXME: Make it better to detect the current BindStep
         self.context.allow_default = true;
-        let table_name = Arc::new(lower_case_name(name)?);
+        let table_name: Arc<str> = lower_case_name(name)?.into();
 
         let source = self
             .context

src/binder/mod.rs

@@ -193,10 +193,11 @@ impl<'a, T: Transaction> BinderContext<'a, T> {
     }
 
     pub fn temp_table(&mut self) -> TableName {
-        Arc::new(format!(
+        format!(
             "_temp_table_{}_",
             self.temp_table_id.fetch_add(1, Ordering::SeqCst)
-        ))
+        )
+        .into()
     }
 
     pub fn step(&mut self, bind_step: QueryBindStep) {
@@ -247,7 +248,7 @@ impl<'a, T: Transaction> BinderContext<'a, T> {
         alias: Option<&TableName>,
         join_type: Option<JoinType>,
         only_table: bool,
-    ) -> Result<Option<Source>, DatabaseError> {
+    ) -> Result<Option<Source<'_>>, DatabaseError> {
         let mut source = None;
 
         source = if let Some(real_name) = self.table_aliases.get(table_name.as_ref()) {
@@ -276,10 +277,10 @@ impl<'a, T: Transaction> BinderContext<'a, T> {
         Ok(source)
     }
 
-    pub fn bind_source<'b: 'a>(&self, table_name: &str) -> Result<&Source, DatabaseError> {
+    pub fn bind_source<'b: 'a>(&self, table_name: &str) -> Result<&Source<'_>, DatabaseError> {
         if let Some(source) = self.bind_table.iter().find(|((t, alias, _), _)| {
-            t.as_str() == table_name
-                || matches!(alias.as_ref().map(|a| a.as_str() == table_name), Some(true))
+            t.as_ref() == table_name
+                || matches!(alias.as_ref().map(|a| a.as_ref() == table_name), Some(true))
         }) {
             Ok(source.1)
         } else {
@@ -582,7 +583,7 @@ pub mod test {
         let table = {
             let transaction = storage.transaction()?;
             transaction
-                .table(&table_cache, Arc::new("t1".to_string()))?
+                .table(&table_cache, "t1".to_string().into())?
                 .unwrap()
                 .clone()
         };
@@ -604,7 +605,7 @@ pub mod test {
 
         let _ = transaction.create_table(
             table_cache,
-            Arc::new("t1".to_string()),
+            "t1".to_string().into(),
             vec![
                 ColumnCatalog::new(
                     "c1".to_string(),
@@ -622,7 +623,7 @@ pub mod test {
 
         let _ = transaction.create_table(
             table_cache,
-            Arc::new("t2".to_string()),
+            "t2".to_string().into(),
             vec![
                 ColumnCatalog::new(
                     "c3".to_string(),

src/binder/select.rs

@@ -146,7 +146,7 @@ impl<'a: 'b, 'b, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'
         if let Some(SelectInto { name, .. }) = &select.into {
             plan = LogicalPlan::new(
                 Operator::Insert(InsertOperator {
-                    table_name: Arc::new(lower_case_name(name)?),
+                    table_name: lower_case_name(name)?.into(),
                     is_overwrite: false,
                     is_mapping_by_name: true,
                 }),
@@ -411,7 +411,7 @@ impl<'a: 'b, 'b, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'
                             "Implement virtual tables for multiple table aliases".to_string(),
                         ));
                     }
-                    let table_alias = Arc::new(name.value.to_lowercase());
+                    let table_alias: Arc<str> = name.value.to_lowercase().into();
                     let table = tables.pop().unwrap_or_else(|| self.context.temp_table());
 
                     plan = self.bind_alias(plan, alias_column, table_alias, table)?;
@@ -421,7 +421,7 @@ impl<'a: 'b, 'b, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'
             TableFactor::TableFunction { expr, alias } => {
                 if let ScalarExpression::TableFunction(function) = self.bind_expr(expr)? {
                     let mut table_alias = None;
-                    let table_name = Arc::new(function.summary().name.clone());
+                    let table_name: TableName = function.summary().name.clone();
                     let table = function.table();
                     let mut plan = FunctionScanOperator::build(function);
 
@@ -430,7 +430,7 @@ impl<'a: 'b, 'b, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'
                         columns: alias_column,
                     }) = alias
                     {
-                        table_alias = Some(Arc::new(name.value.to_lowercase()));
+                        table_alias = Some(name.value.to_lowercase().into());
 
                         plan = self.bind_alias(
                             plan,
@@ -512,12 +512,12 @@ impl<'a: 'b, 'b, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'
         table: &str,
         alias: Option<&TableAlias>,
     ) -> Result<LogicalPlan, DatabaseError> {
-        let table_name = Arc::new(table.to_string());
-        let mut table_alias = None;
+        let table_name = table.into();
+        let mut table_alias: Option<TableName> = None;
         let mut alias_idents = None;
 
         if let Some(TableAlias { name, columns }) = alias {
-            table_alias = Some(Arc::new(name.value.to_lowercase()));
+            table_alias = Some(name.value.to_lowercase().into());
             alias_idents = Some(columns);
         }
 
@@ -585,7 +585,7 @@ impl<'a: 'b, 'b, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'
                     }
                 }
                 SelectItem::QualifiedWildcard(table_name, _) => {
-                    let table_name = Arc::new(lower_case_name(table_name)?);
+                    let table_name: Arc<str> = lower_case_name(table_name)?.into();
                     let schema_buf = self.table_schema_buf.entry(table_name.clone()).or_default();
 
                     Self::bind_table_column_refs(

src/binder/truncate.rs

@@ -13,7 +13,7 @@ impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A>
         &mut self,
         name: &ObjectName,
     ) -> Result<LogicalPlan, DatabaseError> {
-        let table_name = Arc::new(lower_case_name(name)?);
+        let table_name: Arc<str> = lower_case_name(name)?.into();
 
         Ok(LogicalPlan::new(
             Operator::Truncate(TruncateOperator { table_name }),

src/binder/update.rs

@@ -20,7 +20,7 @@ impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A>
         // FIXME: Make it better to detect the current BindStep
         self.context.allow_default = true;
         if let TableFactor::Table { name, .. } = &to.relation {
-            let table_name = Arc::new(lower_case_name(name)?);
+            let table_name: Arc<str> = lower_case_name(name)?.into();
             self.with_pk(table_name.clone());
 
             let mut plan = self.bind_table_ref(to)?;

src/catalog/table.rs

@@ -10,7 +10,7 @@ use std::sync::Arc;
 use std::{slice, vec};
 use ulid::Generator;
 
-pub type TableName = Arc<String>;
+pub type TableName = Arc<str>;
 pub type PrimaryKeyIndices = Arc<Vec<usize>>;
 
 #[derive(Debug, Clone, PartialEq)]
@@ -293,18 +293,14 @@ mod tests {
             ColumnDesc::new(LogicalType::Boolean, None, false, None).unwrap(),
         );
         let col_catalogs = vec![col0, col1];
-        let table_catalog = TableCatalog::new(Arc::new("test".to_string()), col_catalogs).unwrap();
-
-        assert_eq!(table_catalog.contains_column(&"a".to_string()), true);
-        assert_eq!(table_catalog.contains_column(&"b".to_string()), true);
-        assert_eq!(table_catalog.contains_column(&"c".to_string()), false);
-
-        let col_a_id = table_catalog
-            .get_column_id_by_name(&"a".to_string())
-            .unwrap();
-        let col_b_id = table_catalog
-            .get_column_id_by_name(&"b".to_string())
-            .unwrap();
+        let table_catalog = TableCatalog::new("test".to_string().into(), col_catalogs).unwrap();
+
+        assert_eq!(table_catalog.contains_column("a"), true);
+        assert_eq!(table_catalog.contains_column("b"), true);
+        assert_eq!(table_catalog.contains_column("c"), false);
+
+        let col_a_id = table_catalog.get_column_id_by_name("a").unwrap();
+        let col_b_id = table_catalog.get_column_id_by_name("b").unwrap();
         assert!(col_a_id < col_b_id);
 
         let column_catalog = table_catalog.get_column_by_id(&col_a_id).unwrap();