Type Simple SFW queries using current LogicalPlan as an IR (#399)

Relates to: https://github.com/partiql/partiql-spec/issues/49

Adds the code for typing a query using the current `LogicalPlan` as an `IR`. This PR includes the changes to enable simple SFW queries as the following in both `Strict` and `Permissive` typing modes with `Open` and `Closed` schemas.

#### Closed schema with `Strict` typing mode.
```SQL
-- customers: <<{'id': INT, 'name': STRING, age: ANY}>>
SELECT customers.id, customers.name FROM customers;

-- Output schema: <<{'id': INT, 'name': STRING}>>
```

#### Open schema with `Strict` typing mode and `age` non-existent projection.
```SQL

-- customers: <<{'id': INT, 'name': STRING}>>
SELECT customers.id, customers.name, customers.age FROM customers;

-- Output schema: <<{'id': INT, 'name': STRING, 'age': ANY}>>
```

#### Closed Schema with `Permissive` typing mode and `age` non-existent projection.
```SQL
-- customers: <<{'id': INT, 'name': STRING>>
SELECT customers.id, customers.name, customers.age FROM customers;


-- Output schema: <<{'id': INT, 'name': STRING, 'age': NULL}>>
```

See: partiql/partiql-spec#64

#### Open Schema with `Strict` typing mode and `age` in nested attribute.
```SQL
-- customers: <<{'id': INT, 'name': STRING, 'details': {'age': INT}}>>
SELECT customers.id, customers.name, customers.details.age FROM customers;


-- Output schema: <<{'id': INT, 'name': STRING, 'age': INT}>>
```

#### Open Schema (`customers and details`) with `Strict` typing mode.
```SQL
-- customers: <<{'id': INT, 'name': STRING, 'details': {'age': INT}}>>
SELECT customers.id, customers.name, customers.details.age, customers.details.foo.bar FROM customers;


-- Output schema: <<{'id': INT, 'name': STRING, 'age': INT, 'bar': ANY}>>
```

#### Open Schema (`customers and details`)  with `Strict` typing mode and `age` in nested attribute with Path in `FROM` with alias.
```SQL
-- customers: <<{'id': INT, 'name': STRING, 'details': {'age': INT}}>>
SELECT d.age FROM customers.details AS d;


-- Output schema: <<{'age': INT}>>
```

See: partiql/partiql-spec#65

#### Closed Schema with `Strict` typing mode with `FROM` and `Projection` aliases.
```SQL
-- customers: <<{'id': INT, 'name': STRING, 'age': ANY}>>
SELECT c.id AS my_id, customers.name AS my_name FROM customers AS c;


-- Output schema: <<{'my_id': INT, 'my_name': STRING}>>
```

In addition:
- fixes some issues with the current `partiql_types` macros, changes the model for some of the types, and adds some helper methods to `PartiqlType`.
- moves constraints to set
- uses ` BTreeSet` for constraints and `AnyOf` to be able to support ordering on the these types; since we're not expecting large number of elements for these types the performance hit seems negligible. 

Upon merging this commit we need to add:
- Support for operators (E.g., unary, binary).
- Support for the rest of the Binding Operators (E.g., `Filter`, `OrderBy`).
- Support for functions.
- Related Conformance Tests.

CHANGELOG.md

@@ -35,6 +35,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Add `partiql_ast_passes::static_typer` for type annotating the AST.
 - Add ability to parse `ORDER BY`, `LIMIT`, `OFFSET` in children of set operators
 - Add `OUTER` bag operator (`OUTER UNION`, `OUTER INTERSECT`, `OUTER EXCEPT`) implementation
+- Add experimental `partiql_logical_planner::typer` for typing PartiQL queries with the initial support for simple SFW queries with `SELECT` and `FROM` clauses only with no operators, JOINs, etc.
 - Add `NullSortedValue` to specify ordering null or missing values `partiql_value::Value`s before or after all other values
 - Implements the aggregation functions `ANY`, `SOME`, `EVERY` and their `COLL_` versions
 - Add `COUNT(*)` implementation

partiql-ast-passes/src/name_resolver.rs

@@ -84,6 +84,7 @@ enum EnclosingClause {
 /// AST and collecting variable references. Also partially infers alias if no `AS` alias
 /// was provided in the query.
 #[derive(Debug)]
+#[allow(dead_code)]
 pub struct NameResolver<'c> {
     // environment stack tracking
     id_path_to_root: Vec<ast::NodeId>,

partiql-catalog/src/lib.rs

@@ -128,13 +128,24 @@ impl<'a> TypeEnvEntry<'a> {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct TypeEntry {
     id: ObjectId,
     ty: PartiqlType,
 }
 
+impl TypeEntry {
+    pub fn id(&self) -> &ObjectId {
+        &self.id
+    }
+
+    pub fn ty(&self) -> &PartiqlType {
+        &self.ty
+    }
+}
+
 #[derive(Debug)]
+#[allow(dead_code)]
 pub struct FunctionEntry<'a> {
     id: ObjectId,
     function: &'a FunctionEntryFunction,

partiql-eval/src/eval/eval_expr_wrapper.rs

@@ -37,14 +37,14 @@ pub(crate) fn subsumes(typ: &PartiqlType, value: &Value) -> bool {
         ) => true,
         (TypeKind::Struct(_), Value::Tuple(_)) => true,
         (TypeKind::Bag(b_type), Value::Bag(b_values)) => {
-            let bag_element_type = b_type.element_type.as_ref();
+            let bag_element_type = b_type.element_type();
             let mut b_values = b_values.iter();
             b_values.all(|b_value| subsumes(bag_element_type, b_value))
         }
         (TypeKind::DateTime, Value::DateTime(_)) => true,
 
         (TypeKind::Array(a_type), Value::List(l_values)) => {
-            let array_element_type = a_type.element_type.as_ref();
+            let array_element_type = a_type.element_type();
             let mut l_values = l_values.iter();
             l_values.all(|l_value| subsumes(array_element_type, l_value))
         }

partiql-logical-planner/Cargo.toml

@@ -28,6 +28,7 @@ partiql-ast = { path = "../partiql-ast", version = "0.5.*" }
 partiql-parser = { path = "../partiql-parser", version = "0.5.*" }
 partiql-catalog = { path = "../partiql-catalog", version = "0.5.*" }
 partiql-ast-passes = { path = "../partiql-ast-passes", version = "0.5.*" }
+partiql-types = { path = "../partiql-types", version = "0.5.*" }
 
 ion-rs = "0.18"
 ordered-float = "3.*"

partiql-logical-planner/src/lib.rs

@@ -9,6 +9,7 @@ use partiql_catalog::{Catalog, PartiqlCatalog};
 
 mod builtins;
 mod lower;
+mod typer;
 
 pub struct LogicalPlanner<'c> {
     catalog: &'c dyn Catalog,

partiql-logical-planner/src/lower.rs

@@ -305,14 +305,14 @@ impl<'a> AstToLogical<'a> {
         for id in self.id_stack.iter().rev() {
             if let Some(key_schema) = self.key_registry.schema.get(id) {
                 let key_schema: &name_resolver::KeySchema = key_schema;
+
                 let name_ref: &name_resolver::NameRef = key_schema
                     .consume
                     .iter()
                     .find(|name_ref| name_ref.sym == varref.name)
                     .expect("NameRef");
 
                 let var_binding = symprim_to_binding(&name_ref.sym);
-
                 let mut lookups = vec![];
                 for lookup in &name_ref.lookup {
                     match lookup {
@@ -330,20 +330,21 @@ impl<'a> AstToLogical<'a> {
                                     .filter_map(|scope_id| self.key_registry.schema.get(scope_id))
                                     .collect();
 
-                                let mut exact = scopes.iter().filter(|&scope| {
-                                    scope.produce.contains(&name_resolver::Symbol::Known(
+                                let mut exact = scopes.iter().filter(|key_schema| {
+                                    key_schema.produce.contains(&name_resolver::Symbol::Known(
                                         name_ref.sym.clone(),
                                     ))
                                 });
+
                                 if let Some(_matching) = exact.next() {
                                     let var_ref_expr =
                                         ValueExpr::VarRef(var_binding.clone(), VarRefType::Local);
                                     lookups.push(var_ref_expr);
                                     continue;
                                 }
 
-                                for scope in scopes {
-                                    for produce in &scope.produce {
+                                for schema in scopes {
+                                    for produce in &schema.produce {
                                         if let name_resolver::Symbol::Known(sym) = produce {
                                             if (sym == &varref.name)
                                                 || (sym.value.to_lowercase()
@@ -360,6 +361,7 @@ impl<'a> AstToLogical<'a> {
                                                 if !lookups.contains(&expr) {
                                                     lookups.push(expr);
                                                 }
+
                                                 continue;
                                             } else if let Some(_type_entry) = self
                                                 .catalog
@@ -1280,7 +1282,7 @@ impl<'a, 'ast> Visitor<'ast> for AstToLogical<'a> {
                 }
             }
         };
-        self.aggregate_exprs.push(agg_expr.clone());
+        self.aggregate_exprs.push(agg_expr);
         Traverse::Continue
     }