Merge pull request #23 from cmu-db/mock-catalog

Add simple mock catalog for cost model

Author: lanlou1554

optd-persistent/src/cost_model/catalog/mock_catalog.rs

@@ -0,0 +1,151 @@
+use crate::cost_model::interface::StatisticType;
+
+use super::IndexType;
+
+pub struct MockDatabaseMetadata {
+    pub id: i32,
+    pub name: String,
+}
+
+pub struct MockNamespaceMetadata {
+    pub id: i32,
+    pub name: String,
+    pub database_id: i32,
+}
+
+pub struct MockTableMetadata {
+    pub id: i32,
+    pub name: String,
+    pub namespace_id: i32,
+}
+
+pub struct MockAttribute {
+    pub id: i32,
+    pub name: String,
+    pub attr_index: i32,
+    pub table_id: i32,
+}
+
+pub struct MockStatistic {
+    pub id: i32,
+    pub stat_type: i32,
+    // TODO(lanlou): what should I use for the value type?
+    pub stat_value: String,
+    pub attr_ids: Vec<i32>,
+    pub table_id: Option<i32>,
+    pub name: String,
+}
+
+pub struct MockIndex {
+    pub id: i32,
+    pub name: String,
+    pub table_id: i32,
+    pub number_of_attributes: i32,
+    pub index_type: i32,
+    pub is_unique: bool,
+    pub nulls_not_distinct: bool,
+    pub is_primary: bool,
+    pub is_clustered: bool,
+    pub is_exclusion: bool,
+    pub attr_ids: Vec<i32>,
+}
+
+pub struct MockTrigger {
+    pub id: i32,
+    pub name: String,
+    pub table_id: i32,
+    pub parent_trigger_id: i32,
+    pub function: String,
+}
+
+pub struct MockCatalog {
+    pub databases: Vec<MockDatabaseMetadata>,
+    pub namespaces: Vec<MockNamespaceMetadata>,
+    pub tables: Vec<MockTableMetadata>,
+    pub attributes: Vec<MockAttribute>,
+    pub statistics: Vec<MockStatistic>,
+    pub indexes: Vec<MockIndex>,
+    pub triggers: Vec<MockTrigger>,
+    // TODO: constraints
+}
+impl MockCatalog {
+    pub fn new() -> Self {
+        let databases: Vec<MockDatabaseMetadata> = vec![MockDatabaseMetadata {
+            id: 1,
+            name: "db1".to_string(),
+        }];
+        let namespaces: Vec<MockNamespaceMetadata> = vec![MockNamespaceMetadata {
+            id: 1,
+            name: "ns1".to_string(),
+            database_id: 1,
+        }];
+        let tables: Vec<MockTableMetadata> = vec![MockTableMetadata {
+            id: 1,
+            name: "table1".to_string(),
+            namespace_id: 1,
+        }];
+        let attributes: Vec<MockAttribute> = vec![
+            MockAttribute {
+                id: 1,
+                name: "attr1".to_string(),
+                attr_index: 1,
+                table_id: 1,
+            },
+            MockAttribute {
+                id: 2,
+                name: "attr2".to_string(),
+                attr_index: 2,
+                table_id: 1,
+            },
+        ];
+        let statistics: Vec<MockStatistic> = vec![
+            MockStatistic {
+                id: 1,
+                stat_type: StatisticType::Count as i32,
+                stat_value: "100".to_string(),
+                attr_ids: vec![1],
+                table_id: None,
+                name: "CountAttr1".to_string(),
+            },
+            MockStatistic {
+                id: 2,
+                stat_type: StatisticType::Count as i32,
+                stat_value: "200".to_string(),
+                attr_ids: vec![2],
+                table_id: None,
+                name: "CountAttr2".to_string(),
+            },
+            MockStatistic {
+                id: 3,
+                stat_type: StatisticType::Count as i32,
+                stat_value: "300".to_string(),
+                attr_ids: vec![],
+                table_id: Some(1),
+                name: "Table1Count".to_string(),
+            },
+        ];
+        let indexes: Vec<MockIndex> = vec![MockIndex {
+            id: 1,
+            name: "index1".to_string(),
+            table_id: 1,
+            number_of_attributes: 1,
+            index_type: IndexType::Hash as i32,
+            is_unique: false,
+            nulls_not_distinct: false,
+            is_primary: true,
+            is_clustered: false,
+            is_exclusion: false,
+            attr_ids: vec![1],
+        }];
+
+        MockCatalog {
+            databases,
+            namespaces,
+            tables,
+            attributes,
+            statistics,
+            indexes,
+            triggers: vec![],
+        }
+    }
+}

optd-persistent/src/cost_model/catalog/mod.rs

@@ -0,0 +1,6 @@
+pub mod mock_catalog;
+
+pub enum IndexType {
+    BTree,
+    Hash,
+}

optd-persistent/src/cost_model/interface.rs

@@ -12,6 +12,13 @@ use std::sync::Arc;
 
 pub enum CatalogSource {
     Iceberg(),
+    Mock,
+}
+
+pub enum StatisticType {
+    Count,
+    Min,
+    Max,
 }
 
 #[trait_variant::make(Send)]

optd-persistent/src/cost_model/mod.rs

@@ -1,2 +1,3 @@
+pub mod catalog;
 pub mod interface;
 pub mod orm;

optd-persistent/src/entities/index.rs

@@ -10,12 +10,13 @@ pub struct Model {
     pub table_id: i32,
     pub name: String,
     pub number_of_attributes: i32,
+    pub variant_tag: i32,
     pub is_unique: bool,
     pub nulls_not_distinct: bool,
     pub is_primary: bool,
     pub is_clustered: bool,
     pub is_exclusion: bool,
-    pub data: Json,
+    pub description: Json,
 }
 
 #[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]

optd-persistent/src/migrator/catalog/m20241029_000001_index.rs

@@ -8,12 +8,13 @@ pub enum Index {
     TableId,
     Name,
     NumberOfAttributes,
+    VariantTag,
     IsUnique,
     NullsNotDistinct,
     IsPrimary,
     IsClustered,
     IsExclusion,
-    Data,
+    Description,
 }
 
 #[derive(DeriveMigrationName)]
@@ -38,12 +39,13 @@ impl MigrationTrait for Migration {
                     )
                     .col(string(Index::Name))
                     .col(integer(Index::NumberOfAttributes))
+                    .col(integer(Index::VariantTag))
                     .col(boolean(Index::IsUnique))
                     .col(boolean(Index::NullsNotDistinct))
                     .col(boolean(Index::IsPrimary))
                     .col(boolean(Index::IsClustered))
                     .col(boolean(Index::IsExclusion))
-                    .col(json(Index::Data))
+                    .col(json(Index::Description))
                     .to_owned(),
             )
             .await