Rename StaticType and add TypeEnv to the Catalog (#396)

- Adds TypeEnv to the Catalog
- Renames StaticType to refrain from conveying an inaccurate message that this type is only used for Static typing. with PartiQL b/c seemingly, we need to do a combination of Static And Dynamic Typing.

Author: am357

partiql-ast-passes/src/lib.rs

@@ -6,4 +6,4 @@
 
 pub mod error;
 pub mod name_resolver;
-pub mod static_typer;
+pub mod partiql_typer;

partiql-ast-passes/src/static_typer.rs renamed to partiql-ast-passes/src/partiql_typer.rs

@@ -4,15 +4,15 @@ use partiql_ast::ast::{
 };
 use partiql_ast::visit::{Traverse, Visit, Visitor};
 use partiql_catalog::Catalog;
-use partiql_types::{ArrayType, BagType, StaticType, StaticTypeKind, StructType};
+use partiql_types::{ArrayType, BagType, PartiqlType, StructType, TypeKind};
 
 #[derive(Debug, Clone)]
 #[allow(dead_code)]
 pub struct AstStaticTyper<'c> {
     id_stack: Vec<NodeId>,
-    container_stack: Vec<Vec<StaticType>>,
+    container_stack: Vec<Vec<PartiqlType>>,
     errors: Vec<AstTransformError>,
-    type_map: AstTypeMap<StaticType>,
+    type_map: AstTypeMap<PartiqlType>,
     catalog: &'c dyn Catalog,
 }
 
@@ -30,7 +30,7 @@ impl<'c> AstStaticTyper<'c> {
     pub fn type_nodes(
         mut self,
         query: &AstNode<Query>,
-    ) -> Result<AstTypeMap<StaticType>, AstTransformationError> {
+    ) -> Result<AstTypeMap<PartiqlType>, AstTransformationError> {
         query.visit(&mut self);
         if self.errors.is_empty() {
             Ok(self.type_map)
@@ -99,30 +99,30 @@ impl<'c, 'ast> Visitor<'ast> for AstStaticTyper<'c> {
         // Currently we're assuming no-schema, hence typing to arbitrary sized scalars.
         // TODO type to the corresponding scalar with the introduction of schema
         let kind = match _lit {
-            Lit::Null => StaticTypeKind::Null,
-            Lit::Missing => StaticTypeKind::Missing,
-            Lit::Int8Lit(_) => StaticTypeKind::Int,
-            Lit::Int16Lit(_) => StaticTypeKind::Int,
-            Lit::Int32Lit(_) => StaticTypeKind::Int,
-            Lit::Int64Lit(_) => StaticTypeKind::Int,
-            Lit::DecimalLit(_) => StaticTypeKind::Decimal,
-            Lit::NumericLit(_) => StaticTypeKind::Decimal,
-            Lit::RealLit(_) => StaticTypeKind::Float64,
-            Lit::FloatLit(_) => StaticTypeKind::Float64,
-            Lit::DoubleLit(_) => StaticTypeKind::Float64,
-            Lit::BoolLit(_) => StaticTypeKind::Bool,
+            Lit::Null => TypeKind::Null,
+            Lit::Missing => TypeKind::Missing,
+            Lit::Int8Lit(_) => TypeKind::Int,
+            Lit::Int16Lit(_) => TypeKind::Int,
+            Lit::Int32Lit(_) => TypeKind::Int,
+            Lit::Int64Lit(_) => TypeKind::Int,
+            Lit::DecimalLit(_) => TypeKind::Decimal,
+            Lit::NumericLit(_) => TypeKind::Decimal,
+            Lit::RealLit(_) => TypeKind::Float64,
+            Lit::FloatLit(_) => TypeKind::Float64,
+            Lit::DoubleLit(_) => TypeKind::Float64,
+            Lit::BoolLit(_) => TypeKind::Bool,
             Lit::IonStringLit(_) => todo!(),
-            Lit::CharStringLit(_) => StaticTypeKind::String,
-            Lit::NationalCharStringLit(_) => StaticTypeKind::String,
+            Lit::CharStringLit(_) => TypeKind::String,
+            Lit::NationalCharStringLit(_) => TypeKind::String,
             Lit::BitStringLit(_) => todo!(),
             Lit::HexStringLit(_) => todo!(),
-            Lit::StructLit(_) => StaticTypeKind::Struct(StructType::unconstrained()),
-            Lit::ListLit(_) => StaticTypeKind::Array(ArrayType::array()),
-            Lit::BagLit(_) => StaticTypeKind::Bag(BagType::bag()),
+            Lit::StructLit(_) => TypeKind::Struct(StructType::unconstrained()),
+            Lit::ListLit(_) => TypeKind::Array(ArrayType::array()),
+            Lit::BagLit(_) => TypeKind::Bag(BagType::bag()),
             Lit::TypedLit(_, _) => todo!(),
         };
 
-        let ty = StaticType::new(kind);
+        let ty = PartiqlType::new(kind);
         let id = *self.current_node();
         if let Some(c) = self.container_stack.last_mut() {
             c.push(ty.clone())
@@ -161,7 +161,7 @@ impl<'c, 'ast> Visitor<'ast> for AstStaticTyper<'c> {
             }
         }
 
-        let ty = StaticType::new_struct(StructType::unconstrained());
+        let ty = PartiqlType::new_struct(StructType::unconstrained());
         self.type_map.insert(id, ty.clone());
 
         if let Some(c) = self.container_stack.last_mut() {
@@ -184,7 +184,7 @@ impl<'c, 'ast> Visitor<'ast> for AstStaticTyper<'c> {
         self.container_stack.pop();
 
         let id = *self.current_node();
-        let ty = StaticType::new_bag(BagType::bag());
+        let ty = PartiqlType::new_bag(BagType::bag());
 
         self.type_map.insert(id, ty.clone());
         if let Some(s) = self.container_stack.last_mut() {
@@ -206,7 +206,7 @@ impl<'c, 'ast> Visitor<'ast> for AstStaticTyper<'c> {
         self.container_stack.pop();
 
         let id = *self.current_node();
-        let ty = StaticType::new_array(ArrayType::array());
+        let ty = PartiqlType::new_array(ArrayType::array());
 
         self.type_map.insert(id, ty.clone());
         if let Some(s) = self.container_stack.last_mut() {
@@ -222,29 +222,23 @@ mod tests {
     use assert_matches::assert_matches;
     use partiql_ast::ast;
     use partiql_catalog::PartiqlCatalog;
-    use partiql_types::{StaticType, StaticTypeKind};
+    use partiql_types::{PartiqlType, TypeKind};
 
     #[test]
     fn simple_test() {
-        assert_matches!(run_literal_test("NULL"), StaticTypeKind::Null);
-        assert_matches!(run_literal_test("MISSING"), StaticTypeKind::Missing);
-        assert_matches!(run_literal_test("Missing"), StaticTypeKind::Missing);
-        assert_matches!(run_literal_test("true"), StaticTypeKind::Bool);
-        assert_matches!(run_literal_test("false"), StaticTypeKind::Bool);
-        assert_matches!(run_literal_test("1"), StaticTypeKind::Int);
-        assert_matches!(run_literal_test("1.5"), StaticTypeKind::Decimal);
-        assert_matches!(run_literal_test("'hello world!'"), StaticTypeKind::String);
-        assert_matches!(
-            run_literal_test("[1, 2 , {'a': 2}]"),
-            StaticTypeKind::Array(_)
-        );
-        assert_matches!(
-            run_literal_test("<<'1', {'a': 11}>>"),
-            StaticTypeKind::Bag(_)
-        );
+        assert_matches!(run_literal_test("NULL"), TypeKind::Null);
+        assert_matches!(run_literal_test("MISSING"), TypeKind::Missing);
+        assert_matches!(run_literal_test("Missing"), TypeKind::Missing);
+        assert_matches!(run_literal_test("true"), TypeKind::Bool);
+        assert_matches!(run_literal_test("false"), TypeKind::Bool);
+        assert_matches!(run_literal_test("1"), TypeKind::Int);
+        assert_matches!(run_literal_test("1.5"), TypeKind::Decimal);
+        assert_matches!(run_literal_test("'hello world!'"), TypeKind::String);
+        assert_matches!(run_literal_test("[1, 2 , {'a': 2}]"), TypeKind::Array(_));
+        assert_matches!(run_literal_test("<<'1', {'a': 11}>>"), TypeKind::Bag(_));
         assert_matches!(
             run_literal_test("{'a': 1, 'b': 3, 'c': [1, 2]}"),
-            StaticTypeKind::Struct(_)
+            TypeKind::Struct(_)
         );
     }
 
@@ -253,13 +247,13 @@ mod tests {
         assert!(type_statement("{'a': 1, a.b: 3}").is_err());
     }
 
-    fn run_literal_test(q: &str) -> StaticTypeKind {
+    fn run_literal_test(q: &str) -> TypeKind {
         let out = type_statement(q).expect("type map");
-        let values: Vec<&StaticType> = out.values().collect();
+        let values: Vec<&PartiqlType> = out.values().collect();
         values.last().unwrap().kind().clone()
     }
 
-    fn type_statement(q: &str) -> Result<AstTypeMap<StaticType>, AstTransformationError> {
+    fn type_statement(q: &str) -> Result<AstTypeMap<PartiqlType>, AstTransformationError> {
         let parsed = partiql_parser::Parser::default()
             .parse(q)
             .expect("Expect successful parse");

partiql-catalog/Cargo.toml

@@ -24,6 +24,7 @@ bench = false
 partiql-value = { path = "../partiql-value", version = "0.5.*" }
 partiql-parser = { path = "../partiql-parser", version = "0.5.*" }
 partiql-logical = { path = "../partiql-logical", version = "0.5.*" }
+partiql-types = { path = "../partiql-types", version = "0.5.*" }
 
 thiserror = "1.0"
 ordered-float = "3.*"

partiql-catalog/src/lib.rs

@@ -1,5 +1,6 @@
 use crate::call_defs::CallDef;
 
+use partiql_types::PartiqlType;
 use partiql_value::Value;
 use std::borrow::Cow;
 
@@ -103,7 +104,24 @@ pub enum CatalogErrorKind {
 pub trait Catalog: Debug {
     fn add_table_function(&mut self, info: TableFunction) -> Result<ObjectId, CatalogError>;
 
+    fn add_type_entry(&mut self, entry: TypeEnvEntry) -> Result<ObjectId, CatalogError>;
+
     fn get_function(&self, name: &str) -> Option<FunctionEntry>;
+
+    fn resolve_type(&self, name: &str) -> Option<TypeEntry>;
+}
+
+#[derive(Debug)]
+pub struct TypeEnvEntry<'a> {
+    name: UniCase<String>,
+    aliases: Vec<&'a str>,
+    ty: PartiqlType,
+}
+
+#[derive(Debug)]
+pub struct TypeEntry {
+    id: ObjectId,
+    ty: PartiqlType,
 }
 
 #[derive(Debug)]
@@ -140,13 +158,15 @@ impl<'a> FunctionEntry<'a> {
 #[derive(Debug)]
 pub struct PartiqlCatalog {
     functions: CatalogEntrySet<FunctionEntryFunction>,
+    types: CatalogEntrySet<PartiqlType>,
     id: CatalogId,
 }
 
 impl Default for PartiqlCatalog {
     fn default() -> Self {
         PartiqlCatalog {
             functions: Default::default(),
+            types: Default::default(),
             id: CatalogId(1),
         }
     }
@@ -173,6 +193,20 @@ impl Catalog for PartiqlCatalog {
         }
     }
 
+    fn add_type_entry(&mut self, entry: TypeEnvEntry) -> Result<ObjectId, CatalogError> {
+        let id = self
+            .types
+            .add(entry.name.as_ref(), entry.aliases.as_slice(), entry.ty);
+
+        match id {
+            Ok(id) => Ok(ObjectId {
+                catalog_id: self.id,
+                entry_id: id,
+            }),
+            Err(e) => Err(e),
+        }
+    }
+
     fn get_function(&self, name: &str) -> Option<FunctionEntry> {
         self.functions
             .find_by_name(name)
@@ -184,6 +218,16 @@ impl Catalog for PartiqlCatalog {
                 function: entry,
             })
     }
+
+    fn resolve_type(&self, name: &str) -> Option<TypeEntry> {
+        self.types.find_by_name(name).map(|(eid, entry)| TypeEntry {
+            id: ObjectId {
+                catalog_id: self.id,
+                entry_id: eid,
+            },
+            ty: entry.clone(),
+        })
+    }
 }
 
 #[derive(Debug)]