diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index a2520f74..46f82937 100644
--- a/.github/workflows/ci.yml
+++ b/.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
 
diff --git a/src/binder/alter_table.rs b/src/binder/alter_table.rs
index 3f829700..413abc6f 100644
--- a/src/binder/alter_table.rs
+++ b/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())?
diff --git a/src/binder/analyze.rs b/src/binder/analyze.rs
index 727fdab3..4eb06237 100644
--- a/src/binder/analyze.rs
+++ b/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
diff --git a/src/binder/copy.rs b/src/binder/copy.rs
index 9cac0fd4..6e4be3e4 100644
--- a/src/binder/copy.rs
+++ b/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();
diff --git a/src/binder/create_index.rs b/src/binder/create_index.rs
index f5a10df3..dce2b07f 100644
--- a/src/binder/create_index.rs
+++ b/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
diff --git a/src/binder/create_table.rs b/src/binder/create_table.rs
index 14c79b85..a35528eb 100644
--- a/src/binder/create_table.rs
+++ b/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!(
diff --git a/src/binder/create_view.rs b/src/binder/create_view.rs
index 28ce33bf..dc162c4d 100644
--- a/src/binder/create_view.rs
+++ b/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();
diff --git a/src/binder/delete.rs b/src/binder/delete.rs
index 05bad2c6..61e12fd2 100644
--- a/src/binder/delete.rs
+++ b/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
diff --git a/src/binder/describe.rs b/src/binder/describe.rs
index e8677077..d32809a8 100644
--- a/src/binder/describe.rs
+++ b/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 }),
diff --git a/src/binder/drop_index.rs b/src/binder/drop_index.rs
index 17bd2c45..7d625c2e 100644
--- a/src/binder/drop_index.rs
+++ b/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(
diff --git a/src/binder/drop_table.rs b/src/binder/drop_table.rs
index 5666ee88..173c9cd2 100644
--- a/src/binder/drop_table.rs
+++ b/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 {
diff --git a/src/binder/drop_view.rs b/src/binder/drop_view.rs
index 4cb40442..9c32f84b 100644
--- a/src/binder/drop_view.rs
+++ b/src/binder/drop_view.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_view(
@@ -14,7 +13,7 @@ impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A>
         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 {
diff --git a/src/binder/expr.rs b/src/binder/expr.rs
index 50e9c479..1c6ed721 100644
--- a/src/binder/expr.rs
+++ b/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(
diff --git a/src/binder/insert.rs b/src/binder/insert.rs
index d548de0f..b9d718dc 100644
--- a/src/binder/insert.rs
+++ b/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
diff --git a/src/binder/mod.rs b/src/binder/mod.rs
index ef2cb20f..43d5af57 100644
--- a/src/binder/mod.rs
+++ b/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(),
diff --git a/src/binder/select.rs b/src/binder/select.rs
index b49ab8d5..3db10633 100644
--- a/src/binder/select.rs
+++ b/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(
diff --git a/src/binder/truncate.rs b/src/binder/truncate.rs
index ac382d47..4a6beb84 100644
--- a/src/binder/truncate.rs
+++ b/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 }),
diff --git a/src/binder/update.rs b/src/binder/update.rs
index 90c82639..a6460e1d 100644
--- a/src/binder/update.rs
+++ b/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)?;
diff --git a/src/catalog/table.rs b/src/catalog/table.rs
index 4ee9d6a1..2ace0d0f 100644
--- a/src/catalog/table.rs
+++ b/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();
diff --git a/src/db.rs b/src/db.rs
index 9c05bc7c..142cdf46 100644
--- a/src/db.rs
+++ b/src/db.rs
@@ -324,7 +324,7 @@ impl<S: Storage> Database<S> {
         &self,
         statement: &Statement,
         params: A,
-    ) -> Result<DatabaseIter<S>, DatabaseError> {
+    ) -> Result<DatabaseIter<'_, S>, DatabaseError> {
         let _guard = if matches!(command_type(statement)?, CommandType::DDL) {
             MetaDataLock::Write(self.mdl.write_arc())
         } else {
@@ -338,7 +338,7 @@ impl<S: Storage> Database<S> {
         Ok(DatabaseIter { transaction, inner })
     }
 
-    pub fn new_transaction(&self) -> Result<DBTransaction<S>, DatabaseError> {
+    pub fn new_transaction(&self) -> Result<DBTransaction<'_, S>, DatabaseError> {
         let guard = self.mdl.read_arc();
         let transaction = self.storage.transaction()?;
         let state = self.state.clone();
@@ -418,7 +418,7 @@ impl<S: Storage> DBTransaction<'_, S> {
         &mut self,
         statement: &Statement,
         params: A,
-    ) -> Result<TransactionIter, DatabaseError> {
+    ) -> Result<TransactionIter<'_>, DatabaseError> {
         if matches!(command_type(statement)?, CommandType::DDL) {
             return Err(DatabaseError::UnsupportedStmt(
                 "`DDL` is not allowed to execute within a transaction".to_string(),
@@ -500,8 +500,7 @@ pub(crate) mod test {
                 ColumnDesc::new(LogicalType::Integer, None, false, None).unwrap(),
             ),
         ];
-        let _ =
-            transaction.create_table(table_cache, Arc::new("t1".to_string()), columns, false)?;
+        let _ = transaction.create_table(table_cache, "t1".to_string().into(), columns, false)?;
 
         Ok(())
     }
@@ -563,7 +562,7 @@ pub(crate) mod test {
             ColumnDesc::new(LogicalType::Integer, None, false, None).unwrap(),
         );
         let number_column_id = iter.schema()[0].id().unwrap();
-        column.set_ref_table(Arc::new("a".to_string()), number_column_id, false);
+        column.set_ref_table("a".to_string().into(), number_column_id, false);
 
         assert_eq!(iter.schema(), &Arc::new(vec![ColumnRef::from(column)]));
         assert_eq!(
diff --git a/src/execution/ddl/create_index.rs b/src/execution/ddl/create_index.rs
index f9f1a100..0e8c47b5 100644
--- a/src/execution/ddl/create_index.rs
+++ b/src/execution/ddl/create_index.rs
@@ -92,7 +92,7 @@ impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for CreateIndex {
                 let index = Index::new(index_id, &value, ty);
                 throw!(
                     co,
-                    unsafe { &mut (*transaction) }.add_index(table_name.as_str(), index, tuple_id)
+                    unsafe { &mut (*transaction) }.add_index(table_name.as_ref(), index, tuple_id)
                 );
             }
             co.yield_(Ok(TupleBuilder::build_result("1".to_string())))
diff --git a/src/execution/ddl/drop_column.rs b/src/execution/ddl/drop_column.rs
index a44ef09b..b27f4a29 100644
--- a/src/execution/ddl/drop_column.rs
+++ b/src/execution/ddl/drop_column.rs
@@ -89,9 +89,7 @@ impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for DropColumn {
 
                 co.yield_(Ok(TupleBuilder::build_result("1".to_string())))
                     .await;
-            } else if if_exists {
-                return;
-            } else {
+            } else if !if_exists {
                 co.yield_(Err(DatabaseError::ColumnNotFound(column_name)))
                     .await;
             }
diff --git a/src/execution/dml/analyze.rs b/src/execution/dml/analyze.rs
index cdcabc95..d9d9d7a0 100644
--- a/src/execution/dml/analyze.rs
+++ b/src/execution/dml/analyze.rs
@@ -184,7 +184,7 @@ impl Analyze {
         dirs::home_dir()
             .expect("Your system does not have a Config directory!")
             .join(DEFAULT_STATISTICS_META_PATH)
-            .join(table_name.as_str())
+            .join(table_name.as_ref())
     }
 }
 
diff --git a/src/execution/dml/copy_from_file.rs b/src/execution/dml/copy_from_file.rs
index 1e9fd27f..4dce8e36 100644
--- a/src/execution/dml/copy_from_file.rs
+++ b/src/execution/dml/copy_from_file.rs
@@ -155,7 +155,7 @@ mod tests {
                     name: "a".to_string(),
                     relation: ColumnRelation::Table {
                         column_id: Ulid::new(),
-                        table_name: Arc::new("t1".to_string()),
+                        table_name: "t1".to_string().into(),
                         is_temp: false,
                     },
                 },
@@ -168,7 +168,7 @@ mod tests {
                     name: "b".to_string(),
                     relation: ColumnRelation::Table {
                         column_id: Ulid::new(),
-                        table_name: Arc::new("t1".to_string()),
+                        table_name: "t1".to_string().into(),
                         is_temp: false,
                     },
                 },
@@ -181,7 +181,7 @@ mod tests {
                     name: "c".to_string(),
                     relation: ColumnRelation::Table {
                         column_id: Ulid::new(),
-                        table_name: Arc::new("t1".to_string()),
+                        table_name: "t1".to_string().into(),
                         is_temp: false,
                     },
                 },
@@ -197,7 +197,7 @@ mod tests {
         ];
 
         let op = CopyFromFileOperator {
-            table: Arc::new("test_copy".to_string()),
+            table: "test_copy".to_string().into(),
             source: ExtSource {
                 path: file.path().into(),
                 format: FileFormat::Csv {
diff --git a/src/execution/dml/copy_to_file.rs b/src/execution/dml/copy_to_file.rs
index 5fed5e7e..0eddd8dc 100644
--- a/src/execution/dml/copy_to_file.rs
+++ b/src/execution/dml/copy_to_file.rs
@@ -108,7 +108,7 @@ mod tests {
                     name: "a".to_string(),
                     relation: ColumnRelation::Table {
                         column_id: Ulid::new(),
-                        table_name: Arc::new("t1".to_string()),
+                        table_name: "t1".to_string().into(),
                         is_temp: false,
                     },
                 },
@@ -121,7 +121,7 @@ mod tests {
                     name: "b".to_string(),
                     relation: ColumnRelation::Table {
                         column_id: Ulid::new(),
-                        table_name: Arc::new("t1".to_string()),
+                        table_name: "t1".to_string().into(),
                         is_temp: false,
                     },
                 },
@@ -134,7 +134,7 @@ mod tests {
                     name: "c".to_string(),
                     relation: ColumnRelation::Table {
                         column_id: Ulid::new(),
-                        table_name: Arc::new("t1".to_string()),
+                        table_name: "t1".to_string().into(),
                         is_temp: false,
                     },
                 },
@@ -176,12 +176,12 @@ mod tests {
         let storage = db.storage;
         let mut transaction = storage.transaction()?;
         let table = transaction
-            .table(&db.state.table_cache(), Arc::new("t1".to_string()))?
+            .table(&db.state.table_cache(), "t1".to_string().into())?
             .unwrap();
 
         let executor = CopyToFile {
             op: op.clone(),
-            input: TableScanOperator::build(Arc::new("t1".to_string()), table, true),
+            input: TableScanOperator::build("t1".to_string().into(), table, true),
         };
         let mut executor = executor.execute(
             (
diff --git a/src/execution/dml/insert.rs b/src/execution/dml/insert.rs
index 3ea405bf..41a03b3e 100644
--- a/src/execution/dml/insert.rs
+++ b/src/execution/dml/insert.rs
@@ -50,7 +50,7 @@ enum MappingKey<'a> {
 }
 
 impl ColumnCatalog {
-    fn key(&self, is_mapping_by_name: bool) -> MappingKey {
+    fn key(&self, is_mapping_by_name: bool) -> MappingKey<'_> {
         if is_mapping_by_name {
             MappingKey::Name(self.name())
         } else {
diff --git a/src/expression/function/mod.rs b/src/expression/function/mod.rs
index 85e515b0..e9d1276f 100644
--- a/src/expression/function/mod.rs
+++ b/src/expression/function/mod.rs
@@ -1,11 +1,12 @@
 use crate::types::LogicalType;
 use serde::{Deserialize, Serialize};
+use std::sync::Arc;
 
 pub mod scala;
 pub mod table;
 
 #[derive(Debug, Eq, PartialEq, Hash, Clone, Serialize, Deserialize)]
 pub struct FunctionSummary {
-    pub name: String,
+    pub name: Arc<str>,
     pub arg_types: Vec<LogicalType>,
 }
diff --git a/src/expression/mod.rs b/src/expression/mod.rs
index 488a9bcf..2ab903a5 100644
--- a/src/expression/mod.rs
+++ b/src/expression/mod.rs
@@ -846,7 +846,7 @@ mod test {
         let mut reference_tables = ReferenceTables::new();
         let c3_column_id = {
             let table = transaction
-                .table(&table_cache, Arc::new("t1".to_string()))?
+                .table(&table_cache, "t1".to_string().into())?
                 .unwrap();
             *table.get_column_id_by_name("c3").unwrap()
         };
@@ -880,7 +880,7 @@ mod test {
                     name: "c3".to_string(),
                     relation: ColumnRelation::Table {
                         column_id: c3_column_id,
-                        table_name: Arc::new("t1".to_string()),
+                        table_name: "t1".to_string().into(),
                         is_temp: false,
                     },
                 },
diff --git a/src/expression/range_detacher.rs b/src/expression/range_detacher.rs
index e93a8594..d304fdf0 100644
--- a/src/expression/range_detacher.rs
+++ b/src/expression/range_detacher.rs
@@ -218,7 +218,7 @@ impl<'a> RangeDetacher<'a> {
             ScalarExpression::IsNull { expr, negated, .. } => match expr.as_ref() {
                 ScalarExpression::ColumnRef { column, .. } => {
                     if let (Some(col_id), Some(col_table)) = (column.id(), column.table_name()) {
-                        if &col_id == self.column_id && col_table.as_str() == self.table_name {
+                        if &col_id == self.column_id && col_table.as_ref() == self.table_name {
                             return if *negated {
                                 // Range::NotEq(NULL_VALUE.clone())
                                 Ok(None)
@@ -669,7 +669,7 @@ impl<'a> RangeDetacher<'a> {
 
     fn _is_belong(table_name: &str, col: &ColumnRef) -> bool {
         matches!(
-            col.table_name().map(|name| table_name == name.as_str()),
+            col.table_name().map(|name| table_name == name.as_ref()),
             Some(true)
         )
     }
diff --git a/src/expression/simplify.rs b/src/expression/simplify.rs
index b1ca1749..40964768 100644
--- a/src/expression/simplify.rs
+++ b/src/expression/simplify.rs
@@ -416,7 +416,7 @@ impl Simplify {
 
     fn _is_belong(table_name: &str, col: &ColumnRef) -> bool {
         matches!(
-            col.table_name().map(|name| table_name == name.as_str()),
+            col.table_name().map(|name| table_name == name.as_ref()),
             Some(true)
         )
     }
diff --git a/src/function/char_length.rs b/src/function/char_length.rs
index 724887ec..2c3c9f75 100644
--- a/src/function/char_length.rs
+++ b/src/function/char_length.rs
@@ -21,7 +21,7 @@ impl CharLength {
         let arg_types = vec![LogicalType::Varchar(None, CharLengthUnits::Characters)];
         Arc::new(Self {
             summary: FunctionSummary {
-                name: function_name,
+                name: function_name.into(),
                 arg_types,
             },
         })
diff --git a/src/function/current_date.rs b/src/function/current_date.rs
index 293e4541..05bae5b8 100644
--- a/src/function/current_date.rs
+++ b/src/function/current_date.rs
@@ -19,11 +19,11 @@ pub(crate) struct CurrentDate {
 impl CurrentDate {
     #[allow(unused_mut)]
     pub(crate) fn new() -> Arc<Self> {
-        let function_name = "current_date".to_lowercase();
+        let function_name = "current_date".to_string();
 
         Arc::new(Self {
             summary: FunctionSummary {
-                name: function_name,
+                name: function_name.into(),
                 arg_types: Vec::new(),
             },
         })
diff --git a/src/function/current_timestamp.rs b/src/function/current_timestamp.rs
index 333fa0a9..592ca047 100644
--- a/src/function/current_timestamp.rs
+++ b/src/function/current_timestamp.rs
@@ -19,11 +19,11 @@ pub(crate) struct CurrentTimeStamp {
 impl CurrentTimeStamp {
     #[allow(unused_mut)]
     pub(crate) fn new() -> Arc<Self> {
-        let function_name = "current_timestamp".to_lowercase();
+        let function_name = "current_timestamp".to_string();
 
         Arc::new(Self {
             summary: FunctionSummary {
-                name: function_name,
+                name: function_name.into(),
                 arg_types: Vec::new(),
             },
         })
diff --git a/src/function/lower.rs b/src/function/lower.rs
index cc3505ce..b5659974 100644
--- a/src/function/lower.rs
+++ b/src/function/lower.rs
@@ -19,11 +19,11 @@ pub(crate) struct Lower {
 impl Lower {
     #[allow(unused_mut)]
     pub(crate) fn new() -> Arc<Self> {
-        let function_name = "lower".to_lowercase();
+        let function_name = "lower".to_string();
         let arg_types = vec![LogicalType::Varchar(None, CharLengthUnits::Characters)];
         Arc::new(Self {
             summary: FunctionSummary {
-                name: function_name,
+                name: function_name.into(),
                 arg_types,
             },
         })
diff --git a/src/function/numbers.rs b/src/function/numbers.rs
index 4aceca9d..920a19e7 100644
--- a/src/function/numbers.rs
+++ b/src/function/numbers.rs
@@ -16,9 +16,9 @@ use std::sync::LazyLock;
 
 static NUMBERS: LazyLock<TableCatalog> = LazyLock::new(|| {
     TableCatalog::new(
-        Arc::new("numbers".to_lowercase()),
+        "numbers".to_string().into(),
         vec![ColumnCatalog::new(
-            "number".to_lowercase(),
+            "number".to_string(),
             true,
             ColumnDesc::new(LogicalType::Integer, None, false, None).unwrap(),
         )],
@@ -34,11 +34,11 @@ pub(crate) struct Numbers {
 impl Numbers {
     #[allow(unused_mut)]
     pub(crate) fn new() -> Arc<Self> {
-        let function_name = "numbers".to_lowercase();
+        let function_name = "numbers".to_string();
 
         Arc::new(Self {
             summary: FunctionSummary {
-                name: function_name,
+                name: function_name.into(),
                 arg_types: vec![LogicalType::Integer],
             },
         })
diff --git a/src/function/octet_length.rs b/src/function/octet_length.rs
index dafacaf9..fac19e44 100644
--- a/src/function/octet_length.rs
+++ b/src/function/octet_length.rs
@@ -18,11 +18,11 @@ pub(crate) struct OctetLength {
 
 impl OctetLength {
     pub(crate) fn new() -> Arc<Self> {
-        let function_name = "octet_length".to_lowercase();
+        let function_name = "octet_length".to_string();
         let arg_types = vec![LogicalType::Varchar(None, CharLengthUnits::Characters)];
         Arc::new(Self {
             summary: FunctionSummary {
-                name: function_name,
+                name: function_name.into(),
                 arg_types,
             },
         })
diff --git a/src/function/upper.rs b/src/function/upper.rs
index 71adcd4f..b0018b9e 100644
--- a/src/function/upper.rs
+++ b/src/function/upper.rs
@@ -19,11 +19,11 @@ pub(crate) struct Upper {
 impl Upper {
     #[allow(unused_mut)]
     pub(crate) fn new() -> Arc<Self> {
-        let function_name = "upper".to_lowercase();
+        let function_name = "upper".to_string();
         let arg_types = vec![LogicalType::Varchar(None, CharLengthUnits::Characters)];
         Arc::new(Self {
             summary: FunctionSummary {
-                name: function_name,
+                name: function_name.into(),
                 arg_types,
             },
         })
diff --git a/src/macros/mod.rs b/src/macros/mod.rs
index 6a271540..e4dd570d 100644
--- a/src/macros/mod.rs
+++ b/src/macros/mod.rs
@@ -83,7 +83,7 @@ macro_rules! scala_function {
 
                 Arc::new(Self {
                     summary: ::kite_sql::expression::function::FunctionSummary {
-                        name: function_name,
+                        name: function_name.into(),
                         arg_types
                     }
                 })
@@ -150,7 +150,7 @@ macro_rules! table_function {
             $({
                 columns.push(::kite_sql::catalog::column::ColumnCatalog::new(stringify!($output_name).to_lowercase(), true, ::kite_sql::catalog::column::ColumnDesc::new($output_ty, None, false, None).unwrap()));
             })*
-            ::kite_sql::catalog::table::TableCatalog::new(Arc::new(stringify!($function_name).to_lowercase()), columns).unwrap()
+            ::kite_sql::catalog::table::TableCatalog::new(stringify!($function_name).to_lowercase().into(), columns).unwrap()
         });
 
         #[derive(Debug, ::serde::Serialize, ::serde::Deserialize)]
@@ -170,7 +170,7 @@ macro_rules! table_function {
 
                 Arc::new(Self {
                     summary: ::kite_sql::expression::function::FunctionSummary {
-                        name: function_name,
+                        name: function_name.into(),
                         arg_types
                     }
                 })
diff --git a/src/optimizer/core/histogram.rs b/src/optimizer/core/histogram.rs
index a8011bf6..7c2d3219 100644
--- a/src/optimizer/core/histogram.rs
+++ b/src/optimizer/core/histogram.rs
@@ -131,7 +131,7 @@ impl HistogramBuilder {
         let mut values = values.unwrap();
         let mut sort_keys = sort_keys.unwrap();
         let mut buckets = Vec::with_capacity(number_of_buckets);
-        let bucket_len = if values_len % number_of_buckets == 0 {
+        let bucket_len = if values_len.is_multiple_of(number_of_buckets) {
             values_len / number_of_buckets
         } else {
             (values_len + number_of_buckets) / number_of_buckets
@@ -518,14 +518,13 @@ mod tests {
     use crate::types::value::DataValue;
     use crate::types::LogicalType;
     use std::ops::Bound;
-    use std::sync::Arc;
     use ulid::Ulid;
 
     fn index_meta() -> IndexMeta {
         IndexMeta {
             id: 0,
             column_ids: vec![Ulid::new()],
-            table_name: Arc::new("t1".to_string()),
+            table_name: "t1".to_string().into(),
             pk_ty: LogicalType::Integer,
             value_ty: LogicalType::Integer,
             name: "pk_c1".to_string(),
diff --git a/src/optimizer/core/memo.rs b/src/optimizer/core/memo.rs
index 5324b1e5..6f764652 100644
--- a/src/optimizer/core/memo.rs
+++ b/src/optimizer/core/memo.rs
@@ -123,7 +123,7 @@ mod tests {
         let transaction = database.storage.transaction()?;
         let c1_column_id = {
             transaction
-                .table(database.state.table_cache(), Arc::new("t1".to_string()))?
+                .table(database.state.table_cache(), "t1".to_string().into())?
                 .unwrap()
                 .get_column_id_by_name("c1")
                 .unwrap()
@@ -199,7 +199,7 @@ mod tests {
                 meta: Arc::new(IndexMeta {
                     id: 0,
                     column_ids: vec![*c1_column_id],
-                    table_name: Arc::new("t1".to_string()),
+                    table_name: "t1".to_string().into(),
                     pk_ty: LogicalType::Integer,
                     value_ty: LogicalType::Integer,
                     name: "pk_index".to_string(),
diff --git a/src/optimizer/core/statistics_meta.rs b/src/optimizer/core/statistics_meta.rs
index 0a89ecdf..b3b6a485 100644
--- a/src/optimizer/core/statistics_meta.rs
+++ b/src/optimizer/core/statistics_meta.rs
@@ -34,7 +34,7 @@ impl<'a, T: Transaction> StatisticMetaLoader<'a, T> {
         if let Some(statistics_meta) = option {
             return Ok(Some(statistics_meta));
         }
-        if let Some(path) = self.tx.table_meta_path(table_name.as_str(), index_id)? {
+        if let Some(path) = self.tx.table_meta_path(table_name.as_ref(), index_id)? {
             Ok(Some(self.cache.get_or_insert(key, |_| {
                 StatisticsMeta::from_file::<T>(path)
             })?))
@@ -121,7 +121,7 @@ mod tests {
         let index = IndexMeta {
             id: 0,
             column_ids: vec![Ulid::new()],
-            table_name: Arc::new("t1".to_string()),
+            table_name: "t1".to_string().into(),
             pk_ty: LogicalType::Integer,
             value_ty: LogicalType::Integer,
             name: "pk_c1".to_string(),
diff --git a/src/optimizer/heuristic/graph.rs b/src/optimizer/heuristic/graph.rs
index 9aab5f47..e60487ef 100644
--- a/src/optimizer/heuristic/graph.rs
+++ b/src/optimizer/heuristic/graph.rs
@@ -178,7 +178,7 @@ impl HepGraph {
     }
 
     /// Use bfs to traverse the graph and return node ids
-    pub fn nodes_iter(&self, start_option: Option<HepNodeId>) -> HepGraphIter {
+    pub fn nodes_iter(&self, start_option: Option<HepNodeId>) -> HepGraphIter<'_> {
         let inner = Bfs::new(&self.graph, start_option.unwrap_or(self.root_index));
         HepGraphIter {
             inner,
diff --git a/src/optimizer/rule/normalization/pushdown_predicates.rs b/src/optimizer/rule/normalization/pushdown_predicates.rs
index da457b24..49e156e7 100644
--- a/src/optimizer/rule/normalization/pushdown_predicates.rs
+++ b/src/optimizer/rule/normalization/pushdown_predicates.rs
@@ -225,7 +225,7 @@ impl NormalizationRule for PushPredicateIntoScan {
                             IndexType::PrimaryKey { is_multiple: false }
                             | IndexType::Unique
                             | IndexType::Normal => {
-                                RangeDetacher::new(meta.table_name.as_str(), &meta.column_ids[0])
+                                RangeDetacher::new(meta.table_name.as_ref(), &meta.column_ids[0])
                                     .detach(&op.predicate)?
                             }
                             IndexType::PrimaryKey { is_multiple: true } | IndexType::Composite => {
@@ -252,7 +252,7 @@ impl PushPredicateIntoScan {
 
         for column_id in meta.column_ids.iter() {
             if let Some(range) =
-                RangeDetacher::new(meta.table_name.as_str(), column_id).detach(&op.predicate)?
+                RangeDetacher::new(meta.table_name.as_ref(), column_id).detach(&op.predicate)?
             {
                 apply_column_count += 1;
 
diff --git a/src/optimizer/rule/normalization/simplification.rs b/src/optimizer/rule/normalization/simplification.rs
index 01c59822..0adb7cc3 100644
--- a/src/optimizer/rule/normalization/simplification.rs
+++ b/src/optimizer/rule/normalization/simplification.rs
@@ -130,7 +130,6 @@ mod test {
     use crate::types::value::DataValue;
     use crate::types::{ColumnId, LogicalType};
     use std::collections::Bound;
-    use std::sync::Arc;
 
     #[test]
     fn test_constant_calculation_omitted() -> Result<(), DatabaseError> {
@@ -265,7 +264,7 @@ mod test {
                     name: "c1".to_string(),
                     relation: ColumnRelation::Table {
                         column_id: *table_state.column_id_by_name("c1"),
-                        table_name: Arc::new("t1".to_string()),
+                        table_name: "t1".to_string().into(),
                         is_temp: false,
                     },
                 },
@@ -278,7 +277,7 @@ mod test {
                     name: "c2".to_string(),
                     relation: ColumnRelation::Table {
                         column_id: *table_state.column_id_by_name("c2"),
-                        table_name: Arc::new("t1".to_string()),
+                        table_name: "t1".to_string().into(),
                         is_temp: false,
                     },
                 },
diff --git a/src/planner/mod.rs b/src/planner/mod.rs
index 84c81e55..0bc8da9e 100644
--- a/src/planner/mod.rs
+++ b/src/planner/mod.rs
@@ -28,7 +28,7 @@ pub enum Childrens {
 }
 
 impl Childrens {
-    pub fn iter(&self) -> ChildrensIter {
+    pub fn iter(&self) -> ChildrensIter<'_> {
         ChildrensIter {
             inner: self,
             pos: 0,
diff --git a/src/serdes/column.rs b/src/serdes/column.rs
index 134504a6..5971c5e0 100644
--- a/src/serdes/column.rs
+++ b/src/serdes/column.rs
@@ -141,7 +141,9 @@ impl ReferenceSerialization for ColumnRelation {
 
 #[cfg(test)]
 pub(crate) mod test {
-    use crate::catalog::{ColumnCatalog, ColumnDesc, ColumnRef, ColumnRelation, ColumnSummary};
+    use crate::catalog::{
+        ColumnCatalog, ColumnDesc, ColumnRef, ColumnRelation, ColumnSummary, TableName,
+    };
     use crate::db::test::build_table;
     use crate::errors::DatabaseError;
     use crate::expression::ScalarExpression;
@@ -166,14 +168,14 @@ pub(crate) mod test {
         let table_cache = Arc::new(SharedLruCache::new(4, 1, RandomState::new())?);
         let meta_cache = StatisticsMetaCache::new(4, 1, RandomState::new())?;
 
-        let table_name = Arc::new("t1".to_string());
+        let table_name: TableName = "t1".to_string().into();
         build_table(&table_cache, &mut transaction)?;
 
         let mut cursor = Cursor::new(Vec::new());
         let mut reference_tables = ReferenceTables::new();
         let c3_column_id = {
             let table = transaction
-                .table(&table_cache, Arc::new("t1".to_string()))?
+                .table(&table_cache, "t1".to_string().into())?
                 .unwrap();
             *table.get_column_id_by_name("c3").unwrap()
         };
@@ -254,7 +256,7 @@ pub(crate) mod test {
             name: "c1".to_string(),
             relation: ColumnRelation::Table {
                 column_id: Ulid::new(),
-                table_name: Arc::new("t1".to_string()),
+                table_name: "t1".to_string().into(),
                 is_temp: false,
             },
         };
@@ -290,7 +292,7 @@ pub(crate) mod test {
         cursor.seek(SeekFrom::Start(0))?;
         let table_relation = ColumnRelation::Table {
             column_id: Ulid::new(),
-            table_name: Arc::new("t1".to_string()),
+            table_name: "t1".to_string().into(),
             is_temp: false,
         };
         table_relation.encode(&mut cursor, false, &mut reference_tables)?;
diff --git a/src/serdes/mod.rs b/src/serdes/mod.rs
index 34d1c041..85ccc855 100644
--- a/src/serdes/mod.rs
+++ b/src/serdes/mod.rs
@@ -25,7 +25,6 @@ use crate::errors::DatabaseError;
 use crate::storage::{TableCache, Transaction};
 use std::io;
 use std::io::{Read, Write};
-use std::sync::Arc;
 
 #[macro_export]
 macro_rules! implement_serialization_by_bincode {
@@ -53,7 +52,7 @@ macro_rules! implement_serialization_by_bincode {
     };
 }
 
-pub trait ReferenceSerialization: Sized {
+pub trait ReferenceSerialization {
     fn encode<W: Write>(
         &self,
         writer: &mut W,
@@ -65,7 +64,9 @@ pub trait ReferenceSerialization: Sized {
         reader: &mut R,
         drive: Option<(&T, &TableCache)>,
         reference_tables: &ReferenceTables,
-    ) -> Result<Self, DatabaseError>;
+    ) -> Result<Self, DatabaseError>
+    where
+        Self: Sized;
 }
 
 #[derive(Debug, Default, Eq, PartialEq)]
@@ -122,7 +123,7 @@ impl ReferenceTables {
             let len = u32::from_le_bytes(bytes) as usize;
             let mut bytes = vec![0u8; len];
             reader.read_exact(&mut bytes)?;
-            tables.push(Arc::new(String::from_utf8(bytes).unwrap()));
+            tables.push(String::from_utf8(bytes).unwrap().into());
         }
 
         Ok(ReferenceTables { tables })
@@ -134,12 +135,11 @@ mod tests {
     use crate::serdes::ReferenceTables;
     use std::io;
     use std::io::{Seek, SeekFrom};
-    use std::sync::Arc;
 
     #[test]
     fn test_to_raw() -> io::Result<()> {
         let reference_tables = ReferenceTables {
-            tables: vec![Arc::new("t1".to_string()), Arc::new("t2".to_string())],
+            tables: vec!["t1".to_string().into(), "t2".to_string().into()],
         };
 
         let mut cursor = io::Cursor::new(Vec::new());
diff --git a/src/serdes/ptr.rs b/src/serdes/ptr.rs
index 539a1e6d..399b7218 100644
--- a/src/serdes/ptr.rs
+++ b/src/serdes/ptr.rs
@@ -25,7 +25,10 @@ macro_rules! implement_ptr_serialization {
                 reader: &mut R,
                 drive: Option<(&T, &TableCache)>,
                 reference_tables: &ReferenceTables,
-            ) -> Result<Self, DatabaseError> {
+            ) -> Result<Self, DatabaseError>
+            where
+                Self: Sized,
+            {
                 Ok($struct_name::from(V::decode(
                     reader,
                     drive,
diff --git a/src/serdes/string.rs b/src/serdes/string.rs
index f0ceb5f4..bcb25179 100644
--- a/src/serdes/string.rs
+++ b/src/serdes/string.rs
@@ -1,7 +1,33 @@
+use crate::errors::DatabaseError;
 use crate::implement_serialization_by_bincode;
+use crate::serdes::{ReferenceSerialization, ReferenceTables};
+use crate::storage::{TableCache, Transaction};
+use std::sync::Arc;
 
 implement_serialization_by_bincode!(String);
 
+impl ReferenceSerialization for Arc<str> {
+    fn encode<W: std::io::Write>(
+        &self,
+        writer: &mut W,
+        _: bool,
+        _: &mut ReferenceTables,
+    ) -> Result<(), DatabaseError> {
+        bincode::serialize_into(writer, self)?;
+
+        Ok(())
+    }
+
+    fn decode<T: Transaction, R: std::io::Read>(
+        reader: &mut R,
+        _: Option<(&T, &TableCache)>,
+        _: &ReferenceTables,
+    ) -> Result<Self, DatabaseError> {
+        let str: String = bincode::deserialize_from(reader)?;
+        Ok(str.into())
+    }
+}
+
 #[cfg(test)]
 pub(crate) mod test {
     use crate::errors::DatabaseError;
diff --git a/src/storage/mod.rs b/src/storage/mod.rs
index bee66192..c515bbb9 100644
--- a/src/storage/mod.rs
+++ b/src/storage/mod.rs
@@ -100,7 +100,7 @@ pub trait Transaction: Sized {
         let table = self
             .table(table_cache, table_name.clone())?
             .ok_or(DatabaseError::TableNotFound)?;
-        let table_name = table.name.as_str();
+        let table_name = table.name.as_ref();
         let offset = offset_option.unwrap_or(0);
 
         if columns.is_empty() || with_pk {
@@ -428,7 +428,7 @@ pub trait Transaction: Sized {
             }
         }
 
-        self.remove(&unsafe { &*self.table_codec() }.encode_view_key(view_name.as_str()))?;
+        self.remove(&unsafe { &*self.table_codec() }.encode_view_key(view_name.as_ref()))?;
         view_cache.remove(&view_name);
 
         Ok(())
@@ -460,15 +460,15 @@ pub trait Transaction: Sized {
 
         let index_id = index_meta.id;
         let index_meta_key =
-            unsafe { &*self.table_codec() }.encode_index_meta_key(table_name.as_str(), index_id)?;
+            unsafe { &*self.table_codec() }.encode_index_meta_key(table_name.as_ref(), index_id)?;
         self.remove(&index_meta_key)?;
 
         let (index_min, index_max) =
-            unsafe { &*self.table_codec() }.index_bound(table_name.as_str(), index_id)?;
+            unsafe { &*self.table_codec() }.index_bound(table_name.as_ref(), index_id)?;
         self._drop_data(index_min, index_max)?;
 
         let statistics_min_key = unsafe { &*self.table_codec() }
-            .encode_statistics_path_key(table_name.as_str(), index_id);
+            .encode_statistics_path_key(table_name.as_ref(), index_id);
         self.remove(&statistics_min_key)?;
 
         table_cache.remove(&table_name);
@@ -491,17 +491,17 @@ pub trait Transaction: Sized {
             }
         }
         self.drop_name_hash(&table_name)?;
-        self.drop_data(table_name.as_str())?;
+        self.drop_data(table_name.as_ref())?;
 
         let (column_min, column_max) =
-            unsafe { &*self.table_codec() }.columns_bound(table_name.as_str());
+            unsafe { &*self.table_codec() }.columns_bound(table_name.as_ref());
         self._drop_data(column_min, column_max)?;
 
         let (index_meta_min, index_meta_max) =
-            unsafe { &*self.table_codec() }.index_meta_bound(table_name.as_str());
+            unsafe { &*self.table_codec() }.index_meta_bound(table_name.as_ref());
         self._drop_data(index_meta_min, index_meta_max)?;
 
-        self.remove(&unsafe { &*self.table_codec() }.encode_root_table_key(table_name.as_str()))?;
+        self.remove(&unsafe { &*self.table_codec() }.encode_root_table_key(table_name.as_ref()))?;
         table_cache.remove(&table_name);
 
         let _ = fs::remove_dir(Analyze::build_statistics_meta_path(&table_name));
@@ -599,7 +599,7 @@ pub trait Transaction: Sized {
         meta_cache.put((table_name.clone(), index_id), statistics_meta);
 
         let (key, value) = unsafe { &*self.table_codec() }.encode_statistics_path(
-            table_name.as_str(),
+            table_name.as_ref(),
             index_id,
             path,
         );
@@ -1273,7 +1273,9 @@ pub trait Iter {
 mod test {
     use crate::binder::test::build_t1_table;
     use crate::catalog::view::View;
-    use crate::catalog::{ColumnCatalog, ColumnDesc, ColumnRef, ColumnRelation, ColumnSummary};
+    use crate::catalog::{
+        ColumnCatalog, ColumnDesc, ColumnRef, ColumnRelation, ColumnSummary, TableName,
+    };
     use crate::db::test::build_table;
     use crate::errors::DatabaseError;
     use crate::expression::range_detacher::Range;
@@ -1363,22 +1365,19 @@ mod test {
                          table_cache: &TableCache|
          -> Result<(), DatabaseError> {
             let table = transaction
-                .table(&table_cache, Arc::new("t1".to_string()))?
+                .table(&table_cache, "t1".to_string().into())?
                 .unwrap();
             let c1_column_id = *table.get_column_id_by_name("c1").unwrap();
             let c2_column_id = *table.get_column_id_by_name("c2").unwrap();
             let c3_column_id = *table.get_column_id_by_name("c3").unwrap();
 
-            assert_eq!(table.name.as_str(), "t1");
+            assert_eq!(table.name.as_ref(), "t1");
             assert_eq!(table.indexes.len(), 1);
 
             let primary_key_index_meta = &table.indexes[0];
             assert_eq!(primary_key_index_meta.id, 0);
             assert_eq!(primary_key_index_meta.column_ids, vec![c1_column_id]);
-            assert_eq!(
-                primary_key_index_meta.table_name,
-                Arc::new("t1".to_string())
-            );
+            assert_eq!(primary_key_index_meta.table_name, "t1".to_string().into());
             assert_eq!(primary_key_index_meta.pk_ty, LogicalType::Integer);
             assert_eq!(primary_key_index_meta.name, "pk_index".to_string());
             assert_eq!(
@@ -1395,7 +1394,7 @@ mod test {
                     name: "c1".to_string(),
                     relation: ColumnRelation::Table {
                         column_id: c1_column_id,
-                        table_name: Arc::new("t1".to_string()),
+                        table_name: "t1".to_string().into(),
                         is_temp: false,
                     },
                 }
@@ -1413,7 +1412,7 @@ mod test {
                     name: "c2".to_string(),
                     relation: ColumnRelation::Table {
                         column_id: c2_column_id,
-                        table_name: Arc::new("t1".to_string()),
+                        table_name: "t1".to_string().into(),
                         is_temp: false,
                     },
                 }
@@ -1431,7 +1430,7 @@ mod test {
                     name: "c3".to_string(),
                     relation: ColumnRelation::Table {
                         column_id: c3_column_id,
-                        table_name: Arc::new("t1".to_string()),
+                        table_name: "t1".to_string().into(),
                         is_temp: false,
                     },
                 }
@@ -1478,7 +1477,7 @@ mod test {
         {
             let mut tuple_iter = transaction.read(
                 &table_cache,
-                Arc::new("t1".to_string()),
+                "t1".to_string().into(),
                 (None, None),
                 full_columns(),
                 true,
@@ -1504,7 +1503,7 @@ mod test {
         {
             let mut tuple_iter = transaction.read(
                 &table_cache,
-                Arc::new("t1".to_string()),
+                "t1".to_string().into(),
                 (None, None),
                 full_columns(),
                 true,
@@ -1537,7 +1536,7 @@ mod test {
         build_table(&table_cache, &mut transaction)?;
         let (c2_column_id, c3_column_id) = {
             let t1_table = transaction
-                .table(&table_cache, Arc::new("t1".to_string()))?
+                .table(&table_cache, "t1".to_string().into())?
                 .unwrap();
 
             (
@@ -1548,14 +1547,14 @@ mod test {
 
         let _ = transaction.add_index_meta(
             &table_cache,
-            &Arc::new("t1".to_string()),
+            &"t1".to_string().into(),
             "i1".to_string(),
             vec![c3_column_id],
             IndexType::Normal,
         )?;
         let _ = transaction.add_index_meta(
             &table_cache,
-            &Arc::new("t1".to_string()),
+            &"t1".to_string().into(),
             "i2".to_string(),
             vec![c3_column_id, c2_column_id],
             IndexType::Composite,
@@ -1565,13 +1564,13 @@ mod test {
                          table_cache: &TableCache|
          -> Result<(), DatabaseError> {
             let table = transaction
-                .table(&table_cache, Arc::new("t1".to_string()))?
+                .table(&table_cache, "t1".to_string().into())?
                 .unwrap();
 
             let i1_meta = table.indexes[1].clone();
             assert_eq!(i1_meta.id, 1);
             assert_eq!(i1_meta.column_ids, vec![c3_column_id]);
-            assert_eq!(i1_meta.table_name, Arc::new("t1".to_string()));
+            assert_eq!(i1_meta.table_name, "t1".to_string().into());
             assert_eq!(i1_meta.pk_ty, LogicalType::Integer);
             assert_eq!(i1_meta.name, "i1".to_string());
             assert_eq!(i1_meta.ty, IndexType::Normal);
@@ -1579,7 +1578,7 @@ mod test {
             let i2_meta = table.indexes[2].clone();
             assert_eq!(i2_meta.id, 2);
             assert_eq!(i2_meta.column_ids, vec![c3_column_id, c2_column_id]);
-            assert_eq!(i2_meta.table_name, Arc::new("t1".to_string()));
+            assert_eq!(i2_meta.table_name, "t1".to_string().into());
             assert_eq!(i2_meta.pk_ty, LogicalType::Integer);
             assert_eq!(i2_meta.name, "i2".to_string());
             assert_eq!(i2_meta.ty, IndexType::Composite);
@@ -1603,19 +1602,19 @@ mod test {
             dbg!(value);
             assert!(iter.try_next()?.is_none());
         }
-        match transaction.drop_index(&table_cache, Arc::new("t1".to_string()), "pk_index", false) {
+        match transaction.drop_index(&table_cache, "t1".to_string().into(), "pk_index", false) {
             Err(DatabaseError::InvalidIndex) => (),
             _ => unreachable!(),
         }
-        transaction.drop_index(&table_cache, Arc::new("t1".to_string()), "i1", false)?;
+        transaction.drop_index(&table_cache, "t1".to_string().into(), "i1", false)?;
         {
             let table = transaction
-                .table(&table_cache, Arc::new("t1".to_string()))?
+                .table(&table_cache, "t1".to_string().into())?
                 .unwrap();
             let i2_meta = table.indexes[1].clone();
             assert_eq!(i2_meta.id, 2);
             assert_eq!(i2_meta.column_ids, vec![c3_column_id, c2_column_id]);
-            assert_eq!(i2_meta.table_name, Arc::new("t1".to_string()));
+            assert_eq!(i2_meta.table_name, "t1".to_string().into());
             assert_eq!(i2_meta.pk_ty, LogicalType::Integer);
             assert_eq!(i2_meta.name, "i2".to_string());
             assert_eq!(i2_meta.ty, IndexType::Composite);
@@ -1642,13 +1641,13 @@ mod test {
         ) -> Result<IndexIter<'a, RocksTransaction<'a>>, DatabaseError> {
             transaction.read_by_index(
                 &table_cache,
-                Arc::new("t1".to_string()),
+                "t1".to_string().into(),
                 (None, None),
                 full_columns(),
                 Arc::new(IndexMeta {
                     id: 1,
                     column_ids: vec![index_column_id],
-                    table_name: Arc::new("t1".to_string()),
+                    table_name: "t1".to_string().into(),
                     pk_ty: LogicalType::Integer,
                     value_ty: LogicalType::Integer,
                     name: "i1".to_string(),
@@ -1670,13 +1669,13 @@ mod test {
 
         build_table(&table_cache, &mut transaction)?;
         let t1_table = transaction
-            .table(&table_cache, Arc::new("t1".to_string()))?
+            .table(&table_cache, "t1".to_string().into())?
             .unwrap();
         let c3_column_id = *t1_table.get_column_id_by_name("c3").unwrap();
 
         let _ = transaction.add_index_meta(
             &table_cache,
-            &Arc::new("t1".to_string()),
+            &"t1".to_string().into(),
             "i1".to_string(),
             vec![c3_column_id],
             IndexType::Normal,
@@ -1758,7 +1757,7 @@ mod test {
         let meta_cache = StatisticsMetaCache::new(4, 1, RandomState::new())?;
 
         build_table(&table_cache, &mut transaction)?;
-        let table_name = Arc::new("t1".to_string());
+        let table_name: TableName = "t1".to_string().into();
 
         let new_column = ColumnCatalog::new(
             "c4".to_string(),
@@ -1813,7 +1812,7 @@ mod test {
     fn test_view_create_drop() -> Result<(), DatabaseError> {
         let table_state = build_t1_table()?;
 
-        let view_name = Arc::new("v1".to_string());
+        let view_name: TableName = "v1".to_string().into();
         let view = View {
             name: view_name.clone(),
             plan: Box::new(
diff --git a/src/storage/rocksdb.rs b/src/storage/rocksdb.rs
index 16c9b496..2bb60a9c 100644
--- a/src/storage/rocksdb.rs
+++ b/src/storage/rocksdb.rs
@@ -223,7 +223,7 @@ fn next(
 
 #[cfg(test)]
 mod test {
-    use crate::catalog::{ColumnCatalog, ColumnDesc, ColumnRef};
+    use crate::catalog::{ColumnCatalog, ColumnDesc, ColumnRef, TableName};
     use crate::db::{DataBaseBuilder, ResultIter};
     use crate::errors::DatabaseError;
     use crate::expression::range_detacher::Range;
@@ -268,12 +268,12 @@ mod test {
             .collect_vec();
         let _ = transaction.create_table(
             &table_cache,
-            Arc::new("test".to_string()),
+            "test".to_string().into(),
             source_columns,
             false,
         )?;
 
-        let table_catalog = transaction.table(&table_cache, Arc::new("test".to_string()))?;
+        let table_catalog = transaction.table(&table_cache, "test".to_string().into())?;
         assert!(table_catalog.is_some());
         assert!(table_catalog
             .unwrap()
@@ -310,7 +310,7 @@ mod test {
 
         let mut iter = transaction.read(
             &table_cache,
-            Arc::new("test".to_string()),
+            "test".to_string().into(),
             (Some(1), Some(1)),
             read_columns,
             true,
@@ -338,7 +338,7 @@ mod test {
             .done()?;
         let transaction = kite_sql.storage.transaction()?;
 
-        let table_name = Arc::new("t1".to_string());
+        let table_name: TableName = "t1".to_string().into();
         let table = transaction
             .table(kite_sql.state.table_cache(), table_name.clone())?
             .unwrap()
@@ -410,14 +410,14 @@ mod test {
         let transaction = kite_sql.storage.transaction().unwrap();
 
         let table = transaction
-            .table(kite_sql.state.table_cache(), Arc::new("t1".to_string()))?
+            .table(kite_sql.state.table_cache(), "t1".to_string().into())?
             .unwrap()
             .clone();
         {
             let mut iter = transaction
                 .read_by_index(
                     kite_sql.state.table_cache(),
-                    Arc::new("t1".to_string()),
+                    "t1".to_string().into(),
                     (Some(0), Some(1)),
                     table.columns().cloned().enumerate().collect(),
                     table.indexes[0].clone(),
@@ -442,7 +442,7 @@ mod test {
             let mut iter = transaction
                 .read_by_index(
                     kite_sql.state.table_cache(),
-                    Arc::new("t1".to_string()),
+                    "t1".to_string().into(),
                     (Some(0), Some(1)),
                     columns,
                     table.indexes[0].clone(),
diff --git a/src/storage/table_codec.rs b/src/storage/table_codec.rs
index 91fca64e..cb3aaca5 100644
--- a/src/storage/table_codec.rs
+++ b/src/storage/table_codec.rs
@@ -94,7 +94,7 @@ impl TableCodec {
     /// Tips:
     /// 1. Root & View & Hash full key = key_prefix
     /// 2. hash table name makes it 4 as a fixed length, and [prefix_extractor](https://github.com/facebook/rocksdb/wiki/Prefix-Seek#defining-a-prefix) can be enabled in rocksdb
-    fn key_prefix(&self, ty: CodecType, name: &str) -> BumpBytes {
+    fn key_prefix(&self, ty: CodecType, name: &str) -> BumpBytes<'_> {
         let mut table_bytes = BumpBytes::new_in(&self.arena);
         table_bytes.extend_from_slice(Self::hash_bytes(name).as_slice());
 
@@ -147,7 +147,7 @@ impl TableCodec {
         table_bytes
     }
 
-    pub fn tuple_bound(&self, table_name: &str) -> (BumpBytes, BumpBytes) {
+    pub fn tuple_bound(&self, table_name: &str) -> (BumpBytes<'_>, BumpBytes<'_>) {
         let op = |bound_id| {
             let mut key_prefix = self.key_prefix(CodecType::Tuple, table_name);
 
@@ -158,7 +158,7 @@ impl TableCodec {
         (op(BOUND_MIN_TAG), op(BOUND_MAX_TAG))
     }
 
-    pub fn index_meta_bound(&self, table_name: &str) -> (BumpBytes, BumpBytes) {
+    pub fn index_meta_bound(&self, table_name: &str) -> (BumpBytes<'_>, BumpBytes<'_>) {
         let op = |bound_id| {
             let mut key_prefix = self.key_prefix(CodecType::IndexMeta, table_name);
 
@@ -173,7 +173,7 @@ impl TableCodec {
         &self,
         table_name: &str,
         index_id: IndexId,
-    ) -> Result<(BumpBytes, BumpBytes), DatabaseError> {
+    ) -> Result<(BumpBytes<'_>, BumpBytes<'_>), DatabaseError> {
         let op = |bound_id| -> Result<BumpBytes, DatabaseError> {
             let mut key_prefix = self.key_prefix(CodecType::Index, table_name);
 
@@ -186,7 +186,7 @@ impl TableCodec {
         Ok((op(BOUND_MIN_TAG)?, op(BOUND_MAX_TAG)?))
     }
 
-    pub fn all_index_bound(&self, table_name: &str) -> (BumpBytes, BumpBytes) {
+    pub fn all_index_bound(&self, table_name: &str) -> (BumpBytes<'_>, BumpBytes<'_>) {
         let op = |bound_id| {
             let mut key_prefix = self.key_prefix(CodecType::Index, table_name);
 
@@ -197,7 +197,7 @@ impl TableCodec {
         (op(BOUND_MIN_TAG), op(BOUND_MAX_TAG))
     }
 
-    pub fn root_table_bound(&self) -> (BumpBytes, BumpBytes) {
+    pub fn root_table_bound(&self) -> (BumpBytes<'_>, BumpBytes<'_>) {
         let op = |bound_id| {
             let mut key_prefix = BumpBytes::new_in(&self.arena);
 
@@ -209,7 +209,7 @@ impl TableCodec {
         (op(BOUND_MIN_TAG), op(BOUND_MAX_TAG))
     }
 
-    pub fn table_bound(&self, table_name: &str) -> (BumpBytes, BumpBytes) {
+    pub fn table_bound(&self, table_name: &str) -> (BumpBytes<'_>, BumpBytes<'_>) {
         let mut column_prefix = self.key_prefix(CodecType::Column, table_name);
         column_prefix.push(BOUND_MIN_TAG);
 
@@ -219,7 +219,7 @@ impl TableCodec {
         (column_prefix, index_prefix)
     }
 
-    pub fn columns_bound(&self, table_name: &str) -> (BumpBytes, BumpBytes) {
+    pub fn columns_bound(&self, table_name: &str) -> (BumpBytes<'_>, BumpBytes<'_>) {
         let op = |bound_id| {
             let mut key_prefix = self.key_prefix(CodecType::Column, table_name);
 
@@ -230,7 +230,7 @@ impl TableCodec {
         (op(BOUND_MIN_TAG), op(BOUND_MAX_TAG))
     }
 
-    pub fn statistics_bound(&self, table_name: &str) -> (BumpBytes, BumpBytes) {
+    pub fn statistics_bound(&self, table_name: &str) -> (BumpBytes<'_>, BumpBytes<'_>) {
         let op = |bound_id| {
             let mut key_prefix = self.key_prefix(CodecType::Statistics, table_name);
 
@@ -241,7 +241,7 @@ impl TableCodec {
         (op(BOUND_MIN_TAG), op(BOUND_MAX_TAG))
     }
 
-    pub fn view_bound(&self) -> (BumpBytes, BumpBytes) {
+    pub fn view_bound(&self) -> (BumpBytes<'_>, BumpBytes<'_>) {
         let op = |bound_id| {
             let mut key_prefix = BumpBytes::new_in(&self.arena);
 
@@ -260,7 +260,7 @@ impl TableCodec {
         table_name: &str,
         tuple: &mut Tuple,
         types: &[TupleValueSerializableImpl],
-    ) -> Result<(BumpBytes, BumpBytes), DatabaseError> {
+    ) -> Result<(BumpBytes<'_>, BumpBytes<'_>), DatabaseError> {
         let tuple_id = tuple.pk.as_ref().ok_or(DatabaseError::PrimaryKeyNotFound)?;
         let key = self.encode_tuple_key(table_name, tuple_id)?;
 
@@ -271,7 +271,7 @@ impl TableCodec {
         &self,
         table_name: &str,
         tuple_id: &TupleId,
-    ) -> Result<BumpBytes, DatabaseError> {
+    ) -> Result<BumpBytes<'_>, DatabaseError> {
         Self::check_primary_key(tuple_id, 0)?;
 
         let mut key_prefix = self.key_prefix(CodecType::Tuple, table_name);
@@ -297,7 +297,7 @@ impl TableCodec {
         &self,
         table_name: &str,
         index_id: IndexId,
-    ) -> Result<BumpBytes, DatabaseError> {
+    ) -> Result<BumpBytes<'_>, DatabaseError> {
         let mut key_prefix = self.key_prefix(CodecType::IndexMeta, table_name);
 
         key_prefix.write_all(&[BOUND_MIN_TAG])?;
@@ -311,7 +311,7 @@ impl TableCodec {
         &self,
         table_name: &str,
         index_meta: &IndexMeta,
-    ) -> Result<(BumpBytes, BumpBytes), DatabaseError> {
+    ) -> Result<(BumpBytes<'_>, BumpBytes<'_>), DatabaseError> {
         let key_bytes = self.encode_index_meta_key(table_name, index_meta.id)?;
 
         let mut value_bytes = BumpBytes::new_in(&self.arena);
@@ -339,7 +339,7 @@ impl TableCodec {
         name: &str,
         index: &Index,
         tuple_id: &TupleId,
-    ) -> Result<(BumpBytes, BumpBytes), DatabaseError> {
+    ) -> Result<(BumpBytes<'_>, BumpBytes<'_>), DatabaseError> {
         let key = self.encode_index_key(name, index, Some(tuple_id))?;
         let mut bytes = BumpBytes::new_in(&self.arena);
 
@@ -353,7 +353,7 @@ impl TableCodec {
         name: &str,
         index: &Index,
         is_upper: bool,
-    ) -> Result<BumpBytes, DatabaseError> {
+    ) -> Result<BumpBytes<'_>, DatabaseError> {
         let mut key_prefix = self.key_prefix(CodecType::Index, name);
         key_prefix.push(BOUND_MIN_TAG);
         key_prefix.extend_from_slice(&index.id.to_le_bytes());
@@ -372,7 +372,7 @@ impl TableCodec {
         name: &str,
         index: &Index,
         tuple_id: Option<&TupleId>,
-    ) -> Result<BumpBytes, DatabaseError> {
+    ) -> Result<BumpBytes<'_>, DatabaseError> {
         let mut key_prefix = self.encode_index_bound_key(name, index, false)?;
 
         if let Some(tuple_id) = tuple_id {
@@ -395,7 +395,7 @@ impl TableCodec {
         &self,
         col: &ColumnRef,
         reference_tables: &mut ReferenceTables,
-    ) -> Result<(BumpBytes, BumpBytes), DatabaseError> {
+    ) -> Result<(BumpBytes<'_>, BumpBytes<'_>), DatabaseError> {
         if let ColumnRelation::Table {
             column_id,
             table_name,
@@ -433,7 +433,7 @@ impl TableCodec {
         table_name: &str,
         index_id: IndexId,
         path: String,
-    ) -> (BumpBytes, BumpBytes) {
+    ) -> (BumpBytes<'_>, BumpBytes<'_>) {
         let key = self.encode_statistics_path_key(table_name, index_id);
 
         let mut value = BumpBytes::new_in(&self.arena);
@@ -442,7 +442,7 @@ impl TableCodec {
         (key, value)
     }
 
-    pub fn encode_statistics_path_key(&self, table_name: &str, index_id: IndexId) -> BumpBytes {
+    pub fn encode_statistics_path_key(&self, table_name: &str, index_id: IndexId) -> BumpBytes<'_> {
         let mut key_prefix = self.key_prefix(CodecType::Statistics, table_name);
 
         key_prefix.push(BOUND_MIN_TAG);
@@ -456,7 +456,10 @@ impl TableCodec {
 
     /// Key: View{BOUND_MIN_TAG}{ViewName}
     /// Value: View
-    pub fn encode_view(&self, view: &View) -> Result<(BumpBytes, BumpBytes), DatabaseError> {
+    pub fn encode_view(
+        &self,
+        view: &View,
+    ) -> Result<(BumpBytes<'_>, BumpBytes<'_>), DatabaseError> {
         let key = self.encode_view_key(&view.name);
 
         let mut reference_tables = ReferenceTables::new();
@@ -474,7 +477,7 @@ impl TableCodec {
         Ok((key, bytes))
     }
 
-    pub fn encode_view_key(&self, view_name: &str) -> BumpBytes {
+    pub fn encode_view_key(&self, view_name: &str) -> BumpBytes<'_> {
         self.key_prefix(CodecType::View, view_name)
     }
 
@@ -500,7 +503,7 @@ impl TableCodec {
     pub fn encode_root_table(
         &self,
         meta: &TableMeta,
-    ) -> Result<(BumpBytes, BumpBytes), DatabaseError> {
+    ) -> Result<(BumpBytes<'_>, BumpBytes<'_>), DatabaseError> {
         let key = self.encode_root_table_key(&meta.table_name);
 
         let mut meta_bytes = BumpBytes::new_in(&self.arena);
@@ -508,7 +511,7 @@ impl TableCodec {
         Ok((key, meta_bytes))
     }
 
-    pub fn encode_root_table_key(&self, table_name: &str) -> BumpBytes {
+    pub fn encode_root_table_key(&self, table_name: &str) -> BumpBytes<'_> {
         self.key_prefix(CodecType::Root, table_name)
     }
 
@@ -518,11 +521,11 @@ impl TableCodec {
         TableMeta::decode::<T, _>(&mut bytes, None, &EMPTY_REFERENCE_TABLES)
     }
 
-    pub fn encode_table_hash_key(&self, table_name: &str) -> BumpBytes {
+    pub fn encode_table_hash_key(&self, table_name: &str) -> BumpBytes<'_> {
         self.key_prefix(CodecType::Hash, table_name)
     }
 
-    pub fn encode_table_hash(&self, table_name: &str) -> (BumpBytes, BumpBytes) {
+    pub fn encode_table_hash(&self, table_name: &str) -> (BumpBytes<'_>, BumpBytes<'_>) {
         (
             self.key_prefix(CodecType::Hash, table_name),
             BumpBytes::new_in(&self.arena),
@@ -567,7 +570,7 @@ mod tests {
                 ColumnDesc::new(LogicalType::Decimal(None, None), None, false, None).unwrap(),
             ),
         ];
-        TableCatalog::new(Arc::new("t1".to_string()), columns).unwrap()
+        TableCatalog::new("t1".to_string().into(), columns).unwrap()
     }
 
     #[test]
@@ -617,7 +620,7 @@ mod tests {
 
         let table_meta = TableCodec::decode_root_table::<RocksTransaction>(&bytes).unwrap();
 
-        assert_eq!(table_meta.table_name.as_str(), table_catalog.name.as_str());
+        assert_eq!(table_meta.table_name.as_ref(), table_catalog.name.as_ref());
     }
 
     #[test]
@@ -640,7 +643,7 @@ mod tests {
         let index_meta = IndexMeta {
             id: 0,
             column_ids: vec![Ulid::new()],
-            table_name: Arc::new("T1".to_string()),
+            table_name: "t1".to_string().into(),
             pk_ty: LogicalType::Integer,
             value_ty: LogicalType::Integer,
             name: "index_1".to_string(),
@@ -681,7 +684,7 @@ mod tests {
         );
         col.summary_mut().relation = ColumnRelation::Table {
             column_id: Ulid::new(),
-            table_name: Arc::new("t1".to_string()),
+            table_name: "t1".to_string().into(),
             is_temp: false,
         };
         let col = ColumnRef::from(col);
@@ -716,7 +719,7 @@ mod tests {
                 .plan("select * from t1 where c1 in (select c1 from t1 where c1 > 1)")?;
             println!("{:#?}", plan);
             let view = View {
-                name: Arc::new("view_subquery".to_string()),
+                name: "view_subquery".to_string().into(),
                 plan: Box::new(plan),
             };
             let (_, bytes) = table_codec.encode_view(&view)?;
@@ -732,7 +735,7 @@ mod tests {
             println!("==== No Join");
             let plan = table_state.plan("select * from t1 where c1 > 1")?;
             let view = View {
-                name: Arc::new("view_filter".to_string()),
+                name: "view_filter".to_string().into(),
                 plan: Box::new(plan),
             };
             let (_, bytes) = table_codec.encode_view(&view)?;
@@ -748,7 +751,7 @@ mod tests {
             println!("==== Join");
             let plan = table_state.plan("select * from t1 left join t2 on c1 = c3")?;
             let view = View {
-                name: Arc::new("view_join".to_string()),
+                name: "view_join".to_string().into(),
                 plan: Box::new(plan),
             };
             let (_, bytes) = table_codec.encode_view(&view)?;
@@ -778,7 +781,7 @@ mod tests {
 
             col.summary_mut().relation = ColumnRelation::Table {
                 column_id: Ulid::from(col_id as u128),
-                table_name: Arc::new(table_name.to_string()),
+                table_name: table_name.to_string().into(),
                 is_temp: false,
             };
 
@@ -800,7 +803,7 @@ mod tests {
         set.insert(op(0, "T2"));
         set.insert(op(0, "T2"));
 
-        let (min, max) = table_codec.columns_bound(&Arc::new("T1".to_string()));
+        let (min, max) = table_codec.columns_bound("T1");
 
         let vec = set
             .range::<BumpBytes, (Bound<&BumpBytes>, Bound<&BumpBytes>)>((
@@ -826,7 +829,7 @@ mod tests {
             let index_meta = IndexMeta {
                 id: index_id as u32,
                 column_ids: vec![],
-                table_name: Arc::new(table_name.to_string()),
+                table_name: table_name.to_string().into(),
                 pk_ty: LogicalType::Integer,
                 value_ty: LogicalType::Integer,
                 name: format!("{}_index", index_id),
@@ -834,7 +837,7 @@ mod tests {
             };
 
             let (key, _) = table_codec
-                .encode_index_meta(&table_name.to_string(), &index_meta)
+                .encode_index_meta(table_name, &index_meta)
                 .unwrap();
             key
         };
@@ -878,9 +881,9 @@ mod tests {
             false,
             ColumnDesc::new(LogicalType::Boolean, None, false, None).unwrap(),
         );
-        let table_catalog = TableCatalog::new(Arc::new("T0".to_string()), vec![column]).unwrap();
+        let table_catalog = TableCatalog::new("T0".to_string().into(), vec![column]).unwrap();
 
-        let op = |value: DataValue, index_id: usize, table_name: &String| {
+        let op = |value: DataValue, index_id: usize, table_name: &str| {
             let value = Arc::new(value);
             let index = Index::new(
                 index_id as u32,
diff --git a/src/types/value.rs b/src/types/value.rs
index 080e88ef..4aa36986 100644
--- a/src/types/value.rs
+++ b/src/types/value.rs
@@ -759,7 +759,7 @@ impl DataValue {
 
         let mut byte_array = Vec::with_capacity(16);
         // Remove trailing zero.
-        while mantissa % 10 == 0 && mantissa != 0 {
+        while mantissa.is_multiple_of(10) && mantissa != 0 {
             mantissa /= 10;
             digit_num -= 1;
         }
diff --git a/src/utils/lru.rs b/src/utils/lru.rs
index e227ad4e..5ebe7b05 100644
--- a/src/utils/lru.rs
+++ b/src/utils/lru.rs
@@ -115,7 +115,7 @@ impl<K: Hash + Eq + PartialEq, V, S: BuildHasher> SharedLruCache<K, V, S> {
     #[inline]
     pub fn new(cap: usize, shared_size: usize, hasher: S) -> Result<Self, DatabaseError> {
         let mut shared_vec = Vec::with_capacity(shared_size);
-        if cap % shared_size != 0 {
+        if !cap.is_multiple_of(shared_size) {
             return Err(DatabaseError::SharedNotAlign);
         }
         let shared_cap = cap / shared_size;
@@ -353,7 +353,7 @@ impl<K: Hash + Eq + PartialEq, V> LruCache<K, V> {
 
     #[allow(dead_code)]
     #[inline]
-    pub fn iter(&self) -> LruCacheIter<K, V> {
+    pub fn iter(&self) -> LruCacheIter<'_, K, V> {
         LruCacheIter {
             inner: self.inner.iter(),
         }
diff --git a/tests/macros-test/src/main.rs b/tests/macros-test/src/main.rs
index df7e7400..af98aa63 100644
--- a/tests/macros-test/src/main.rs
+++ b/tests/macros-test/src/main.rs
@@ -115,7 +115,7 @@ mod test {
         assert_eq!(
             function.summary,
             FunctionSummary {
-                name: "sum".to_string(),
+                name: "sum".to_string().into(),
                 arg_types: vec![LogicalType::Integer, LogicalType::Integer],
             }
         );
@@ -133,7 +133,7 @@ mod test {
         assert_eq!(
             function.summary,
             FunctionSummary {
-                name: "test_numbers".to_string(),
+                name: "test_numbers".to_string().into(),
                 arg_types: vec![LogicalType::Integer],
             }
         );
@@ -148,7 +148,7 @@ mod test {
         assert!(numbers.next().is_none());
 
         let function_schema = function.output_schema();
-        let table_name = Arc::new("test_numbers".to_string());
+        let table_name: Arc<str> = "test_numbers".to_string().into();
         let mut c1 = ColumnCatalog::new(
             "c1".to_string(),
             true,
diff --git a/tpcc/src/main.rs b/tpcc/src/main.rs
index 3c7fd232..df6d9c1d 100644
--- a/tpcc/src/main.rs
+++ b/tpcc/src/main.rs
@@ -24,6 +24,7 @@ mod slev;
 mod utils;
 
 pub(crate) const ALLOW_MULTI_WAREHOUSE_TX: bool = true;
+pub(crate) const CHECK_POINT_COUNT: usize = 1000;
 pub(crate) const RT_LIMITS: [Duration; 5] = [
     Duration::from_millis(500),
     Duration::from_millis(500),
@@ -193,10 +194,10 @@ fn main() -> Result<(), TpccError> {
         if !is_succeed {
             return Err(TpccError::MaxRetry);
         }
-        if round_count != 0 && round_count % 100 == 0 {
+        if round_count != 0 && round_count % CHECK_POINT_COUNT == 0 {
             println!(
                 "[TPCC CheckPoint {} on round {round_count}][{}]: 90th Percentile RT: {:.3}",
-                round_count / 100,
+                round_count / CHECK_POINT_COUNT,
                 tpcc_test.name(),
                 rt_hist.hist_ckp(i)
             );