Simpler Catalog implementation

Cargo.toml

@@ -1,5 +1,3 @@
-
-
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [package]
@@ -10,7 +8,6 @@ edition = "2021"
 [lib]
 doctest = false
 
-
 [dependencies]
 log = "^0.4"
 sqlparser = "0.34.0"
@@ -33,6 +30,7 @@ tokio-process = "0.2.5"
 serde = { version = "1", features = ["derive", "rc"] }
 serde_json = "1"
 async-trait = "0.1.68"
+integer-encoding = "3.0.4"
 
 [dev-dependencies]
 ctor = "0.2.0"

src/binder/mod.rs

@@ -6,17 +6,18 @@ mod select;
 use std::collections::HashMap;
 
 use crate::{
-    catalog::{CatalogRef, TableRefId},
+    catalog::CatalogRef,
     expression::ScalarExpression,
     planner::LogicalPlan,
 };
 
 use anyhow::Result;
 use sqlparser::ast::Statement;
+use crate::types::TableId;
 
 pub struct BinderContext {
     catalog: CatalogRef,
-    bind_table: HashMap<String, TableRefId>,
+    bind_table: HashMap<String, TableId>,
     aliases: HashMap<String, ScalarExpression>,
     group_by_exprs: Vec<ScalarExpression>,
     agg_calls: Vec<ScalarExpression>,

src/binder/select.rs

@@ -1,7 +1,7 @@
 use std::{borrow::Borrow, sync::Arc};
 
 use crate::{
-    catalog::{ColumnRefId, DEFAULT_DATABASE_NAME, DEFAULT_SCHEMA_NAME},
+    catalog::ColumnRefId,
     expression::ScalarExpression,
     planner::{
         logical_select_plan::LogicalSelectPlan,
@@ -22,6 +22,7 @@ use sqlparser::ast::{
     Expr, Ident, Join, JoinConstraint, JoinOperator, Offset, OrderByExpr, Query, Select,
     SelectItem, SetExpr, TableFactor, TableWithJoins,
 };
+use crate::catalog::{DEFAULT_DATABASE_NAME, DEFAULT_SCHEMA_NAME};
 
 impl Binder {
     pub(super) fn bind_query(&mut self, query: &Query) -> Result<LogicalSelectPlan> {
@@ -127,7 +128,7 @@ impl Binder {
                     .map(|ident| Ident::new(ident.value.to_lowercase()))
                     .collect_vec();
 
-                let (database, schema, mut table): (&str, &str, &str) = match obj_name.as_slice() {
+                let (_database, _schema, mut table): (&str, &str, &str) = match obj_name.as_slice() {
                     [table] => (DEFAULT_DATABASE_NAME, DEFAULT_SCHEMA_NAME, &table.value),
                     [schema, table] => (DEFAULT_DATABASE_NAME, &schema.value, &table.value),
                     [database, schema, table] => (&database.value, &schema.value, &table.value),
@@ -147,7 +148,7 @@ impl Binder {
                 let table_ref_id = self
                     .context
                     .catalog
-                    .get_table_id_by_name(database, schema, table)
+                    .get_table_id_by_name(table)
                     .ok_or_else(|| anyhow::Error::msg(format!("bind table {}", table)))?;
 
                 self.context.bind_table.insert(table.into(), table_ref_id);
@@ -198,7 +199,7 @@ impl Binder {
     fn bind_all_column_refs(&mut self) -> Result<Vec<ScalarExpression>> {
         let mut exprs = vec![];
         for ref_id in self.context.bind_table.values().cloned().collect_vec() {
-            let table = self.context.catalog.get_table(&ref_id).unwrap();
+            let table = self.context.catalog.get_table(ref_id).unwrap();
             for (col_id, col) in &table.get_all_columns() {
                 let column_ref_id = ColumnRefId::from_table(ref_id, *col_id);
                 // self.record_regular_table_column(
@@ -209,8 +210,8 @@ impl Binder {
                 // );
                 let expr = ScalarExpression::ColumnRef {
                     column_ref_id,
-                    primary_key: col.is_primary(),
-                    desc: col.desc().clone(),
+                    primary_key: col.desc.is_primary(),
+                    desc: col.desc.clone(),
                 };
                 exprs.push(expr);
             }

src/catalog/column.rs

@@ -1,34 +1,26 @@
-use crate::types::{ColumnIdT, DataType};
+use crate::types::{ColumnId, DataType, IdGenerator};
 
-/// The descriptor of a column.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ColumnDesc {
-    column_datatype: DataType,
-    is_primary: bool,
+#[derive(Clone)]
+pub struct Column {
+    pub id: ColumnId,
+    pub name: String,
+    pub desc: ColumnDesc,
 }
 
-impl ColumnDesc {
-    pub(crate) const fn new(column_datatype: DataType, is_primary: bool) -> ColumnDesc {
-        ColumnDesc {
-            column_datatype,
-            is_primary,
+impl Column {
+    pub(crate) fn new(
+        column_name: String,
+        column_desc: ColumnDesc,
+    ) -> Column {
+        Column {
+            id: IdGenerator::build(),
+            name: column_name,
+            desc: column_desc,
         }
     }
 
-    pub(crate) fn is_primary(&self) -> bool {
-        self.is_primary
-    }
-
-    pub(crate) fn set_primary(&mut self, is_primary: bool) {
-        self.is_primary = is_primary;
-    }
-
-    pub(crate) fn is_nullable(&self) -> bool {
-        self.column_datatype.is_nullable()
-    }
-
-    pub(crate) fn get_datatype(&self) -> DataType {
-        self.column_datatype.clone()
+    pub(crate) fn datatype(&self) -> &DataType {
+        &self.desc.column_datatype
     }
 }
 
@@ -43,56 +35,31 @@ impl DataType {
     }
 }
 
-/// Column catalog
+/// The descriptor of a column.
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Column {
-    id: ColumnIdT,
-    name: String,
-    desc: ColumnDesc,
+pub struct ColumnDesc {
+    column_datatype: DataType,
+    is_primary: bool,
 }
 
-impl Column {
-    pub(crate) fn new(
-        column_id: ColumnIdT,
-        column_name: String,
-        column_desc: ColumnDesc,
-    ) -> Column {
-        Column {
-            id: column_id,
-            name: column_name,
-            desc: column_desc,
+impl ColumnDesc {
+    pub(crate) const fn new(column_datatype: DataType, is_primary: bool) -> ColumnDesc {
+        ColumnDesc {
+            column_datatype,
+            is_primary,
         }
     }
 
-    pub(crate) fn id(&self) -> ColumnIdT {
-        self.id
-    }
-    pub fn set_id(&mut self, column_id: ColumnIdT) {
-        self.id = column_id
-    }
-
-    pub(crate) fn name(&self) -> &str {
-        &self.name
-    }
-
-    pub fn desc(&self) -> &ColumnDesc {
-        &self.desc
-    }
-
-    pub fn datatype(&self) -> DataType {
-        self.desc.column_datatype.clone()
-    }
-
-    pub(crate) fn set_primary(&mut self, is_primary: bool) {
-        self.desc.set_primary(is_primary)
-    }
-
     pub(crate) fn is_primary(&self) -> bool {
-        self.desc.is_primary()
+        self.is_primary
     }
 
     pub(crate) fn is_nullable(&self) -> bool {
-        self.desc.is_nullable()
+        self.column_datatype.is_nullable()
+    }
+
+    pub(crate) fn get_datatype(&self) -> DataType {
+        self.column_datatype.clone()
     }
 }
 
@@ -104,16 +71,12 @@ mod tests {
     #[test]
     fn test_column_catalog() {
         let mut col_catalog = Column::new(
-            0,
             "test".to_string(),
             DataTypeKind::Int(None).not_null().to_column(),
         );
 
-        assert_eq!(col_catalog.id(), 0);
-        assert_eq!(col_catalog.is_primary(), false);
-        assert_eq!(col_catalog.is_nullable(), false);
-        assert_eq!(col_catalog.name(), "test");
-        col_catalog.set_primary(true);
-        assert_eq!(col_catalog.is_primary(), true);
+        assert_eq!(col_catalog.desc.is_primary(), false);
+        assert_eq!(col_catalog.desc.is_nullable(), false);
+        assert_eq!(col_catalog.name, "test");
     }
 }