Add macro_rules for partiql-types and remove partiql from value macro_rules (#398)

Adds first iteration of PartiqlType macro_rules and renames the existing
value macro_rules to make shorter.

Author: am357

CHANGELOG.md

@@ -8,6 +8,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 ### Changed
 - *BREAKING:* partiql-logical-planner: moves `NameResolver` to `partiql-ast-passes`
+- *BREAKING:* partiql-values: removes `partiql` from value macro_rules; e.g. `partiql_bag` renames to `bag`.
 
 ### Added
 - Add ability for partiql-extension-ion extension encoding/decoding of `Value` to/from Ion `Element`

extension/partiql-extension-ion-functions/src/lib.rs

@@ -158,7 +158,7 @@ mod tests {
     use partiql_catalog::{Catalog, Extension, PartiqlCatalog};
     use partiql_eval::env::basic::MapBindings;
     use partiql_parser::{Parsed, ParserResult};
-    use partiql_value::{partiql_bag, partiql_tuple, Value};
+    use partiql_value::{bag, tuple, Value};
 
     #[track_caller]
     #[inline]
@@ -217,12 +217,12 @@ mod tests {
 
     #[test]
     fn custom_ion_scan() {
-        let value = partiql_bag![
-            partiql_tuple![("Program", "p1"), ("Operation", "get")],
-            partiql_tuple![("Program", "p1"), ("Operation", "put")],
-            partiql_tuple![("Program", "p2"), ("Operation", "get")],
-            partiql_tuple![("Program", "p2"), ("Operation", "put")],
-            partiql_tuple![("Program", "p3"), ("Operation", "update")],
+        let value = bag![
+            tuple![("Program", "p1"), ("Operation", "get")],
+            tuple![("Program", "p1"), ("Operation", "put")],
+            tuple![("Program", "p2"), ("Operation", "get")],
+            tuple![("Program", "p2"), ("Operation", "put")],
+            tuple![("Program", "p3"), ("Operation", "update")],
         ]
         .into();
 

extension/partiql-extension-ion/src/lib.rs

@@ -16,7 +16,7 @@ mod tests {
     use ion_rs::types::{Bytes, Sequence, Struct};
     use ion_rs::{Decimal, Int, IonType, Str, Timestamp};
 
-    use partiql_value::{partiql_bag, partiql_list, partiql_tuple, DateTime, Value};
+    use partiql_value::{bag, list, tuple, DateTime, Value};
     use rust_decimal_macros::dec;
     use std::num::NonZeroU8;
 
@@ -221,7 +221,7 @@ mod tests {
                 ion_rs::element::Value::Int(Int::I64(2)),
                 ion_rs::element::Value::String(Str::from("3")),
             ])),
-            partiql_list![1, 2, "3"],
+            list![1, 2, "3"],
         );
 
         // struct
@@ -232,7 +232,7 @@ mod tests {
                     .with_field("k", ion_rs::element::List(Sequence::new([1, 2, 3])))
                     .build(),
             ),
-            partiql_tuple![("k", partiql_list![1, 2, 3])],
+            tuple![("k", list![1, 2, 3])],
         );
     }
 
@@ -377,7 +377,7 @@ mod tests {
                 ion_rs::element::Value::Int(Int::I64(2)),
                 ion_rs::element::Value::String(Str::from("3")),
             ])),
-            partiql_list![1, 2, "3"],
+            list![1, 2, "3"],
         );
 
         // bag
@@ -391,7 +391,7 @@ mod tests {
                 ion_rs::element::Value::Null(IonType::Null).with_annotations(["$missing"]),
             ]))
             .with_annotations(["$bag"]),
-            partiql_bag![1, 2, "3", Value::Null, Value::Missing],
+            bag![1, 2, "3", Value::Null, Value::Missing],
         );
 
         // struct
@@ -402,7 +402,7 @@ mod tests {
                     .with_field("k", ion_rs::element::List(Sequence::new::<Element, _>([])))
                     .build(),
             ),
-            partiql_tuple![("k", partiql_list![])],
+            tuple![("k", list![])],
         );
         assert_partiql_encoded_ion(
             "{\"k\": [1,2,3]}",
@@ -411,7 +411,7 @@ mod tests {
                     .with_field("k", ion_rs::element::List(Sequence::new([1, 2, 3])))
                     .build(),
             ),
-            partiql_tuple![("k", partiql_list![1, 2, 3])],
+            tuple![("k", list![1, 2, 3])],
         );
     }
 }

partiql-ast-passes/src/partiql_typer.rs

@@ -8,17 +8,17 @@ use partiql_types::{ArrayType, BagType, PartiqlType, StructType, TypeKind};
 
 #[derive(Debug, Clone)]
 #[allow(dead_code)]
-pub struct AstStaticTyper<'c> {
+pub struct AstPartiqlTyper<'c> {
     id_stack: Vec<NodeId>,
     container_stack: Vec<Vec<PartiqlType>>,
     errors: Vec<AstTransformError>,
     type_map: AstTypeMap<PartiqlType>,
     catalog: &'c dyn Catalog,
 }
 
-impl<'c> AstStaticTyper<'c> {
+impl<'c> AstPartiqlTyper<'c> {
     pub fn new(catalog: &'c dyn Catalog) -> Self {
-        AstStaticTyper {
+        AstPartiqlTyper {
             id_stack: Default::default(),
             container_stack: Default::default(),
             errors: Default::default(),
@@ -47,7 +47,7 @@ impl<'c> AstStaticTyper<'c> {
     }
 }
 
-impl<'c, 'ast> Visitor<'ast> for AstStaticTyper<'c> {
+impl<'c, 'ast> Visitor<'ast> for AstPartiqlTyper<'c> {
     fn enter_ast_node(&mut self, id: NodeId) -> Traverse {
         self.id_stack.push(id);
         Traverse::Continue
@@ -116,9 +116,9 @@ impl<'c, 'ast> Visitor<'ast> for AstStaticTyper<'c> {
             Lit::NationalCharStringLit(_) => TypeKind::String,
             Lit::BitStringLit(_) => todo!(),
             Lit::HexStringLit(_) => todo!(),
-            Lit::StructLit(_) => TypeKind::Struct(StructType::unconstrained()),
-            Lit::ListLit(_) => TypeKind::Array(ArrayType::array()),
-            Lit::BagLit(_) => TypeKind::Bag(BagType::bag()),
+            Lit::StructLit(_) => TypeKind::Struct(StructType::new_any()),
+            Lit::ListLit(_) => TypeKind::Array(ArrayType::new_any()),
+            Lit::BagLit(_) => TypeKind::Bag(BagType::new_any()),
             Lit::TypedLit(_, _) => todo!(),
         };
 
@@ -161,7 +161,7 @@ impl<'c, 'ast> Visitor<'ast> for AstStaticTyper<'c> {
             }
         }
 
-        let ty = PartiqlType::new_struct(StructType::unconstrained());
+        let ty = PartiqlType::new_struct(StructType::new_any());
         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 = PartiqlType::new_bag(BagType::bag());
+        let ty = PartiqlType::new_bag(BagType::new_any());
 
         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 = PartiqlType::new_array(ArrayType::array());
+        let ty = PartiqlType::new_array(ArrayType::new_any());
 
         self.type_map.insert(id, ty.clone());
         if let Some(s) = self.container_stack.last_mut() {
@@ -221,8 +221,8 @@ mod tests {
     use super::*;
     use assert_matches::assert_matches;
     use partiql_ast::ast;
-    use partiql_catalog::PartiqlCatalog;
-    use partiql_types::{PartiqlType, TypeKind};
+    use partiql_catalog::{PartiqlCatalog, TypeEnvEntry};
+    use partiql_types::{PartiqlType, StructConstraint, StructField, TypeKind};
 
     #[test]
     fn simple_test() {
@@ -244,22 +244,24 @@ mod tests {
 
     #[test]
     fn simple_err_test() {
-        assert!(type_statement("{'a': 1, a.b: 3}").is_err());
+        assert!(type_statement("{'a': 1, a.b: 3}", &PartiqlCatalog::default()).is_err());
     }
 
     fn run_literal_test(q: &str) -> TypeKind {
-        let out = type_statement(q).expect("type map");
+        let out = type_statement(q, &PartiqlCatalog::default()).expect("type map");
         let values: Vec<&PartiqlType> = out.values().collect();
         values.last().unwrap().kind().clone()
     }
 
-    fn type_statement(q: &str) -> Result<AstTypeMap<PartiqlType>, AstTransformationError> {
+    fn type_statement(
+        q: &str,
+        catalog: &dyn Catalog,
+    ) -> Result<AstTypeMap<PartiqlType>, AstTransformationError> {
         let parsed = partiql_parser::Parser::default()
             .parse(q)
             .expect("Expect successful parse");
 
-        let catalog = PartiqlCatalog::default();
-        let typer = AstStaticTyper::new(&catalog);
+        let typer = AstPartiqlTyper::new(catalog);
         if let ast::Expr::Query(q) = parsed.ast.as_ref() {
             typer.type_nodes(&q)
         } else {

partiql-catalog/src/lib.rs

@@ -118,6 +118,16 @@ pub struct TypeEnvEntry<'a> {
     ty: PartiqlType,
 }
 
+impl<'a> TypeEnvEntry<'a> {
+    pub fn new(name: &str, aliases: &[&'a str], ty: PartiqlType) -> Self {
+        TypeEnvEntry {
+            name: UniCase::from(name.to_string()),
+            aliases: aliases.to_vec(),
+            ty,
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct TypeEntry {
     id: ObjectId,

partiql-conformance-tests/tests/test_value.rs

@@ -37,7 +37,7 @@ fn parse_test_value_str(contents: &str) -> Value {
 mod tests {
     use super::parse_test_value_str;
 
-    use partiql_value::{partiql_bag, partiql_list, partiql_tuple, Value};
+    use partiql_value::{bag, list, tuple, Value};
 
     #[track_caller]
     fn parse(test: &str, expected: Value) {
@@ -64,7 +64,7 @@ mod tests {
                 s: 1
             }
         ]";
-        let expected = Value::from(partiql_bag![partiql_tuple![
+        let expected = Value::from(bag![tuple![
             ("f", 1),
             ("d", Value::Real(2.0.into())),
             ("s", 1)
@@ -79,7 +79,7 @@ mod tests {
                     sensor: 1,
                     reading: 42
                   }",
-            Value::Tuple(Box::new(partiql_tuple![("sensor", 1), ("reading", 42)])),
+            Value::Tuple(Box::new(tuple![("sensor", 1), ("reading", 42)])),
         );
     }
 
@@ -110,17 +110,17 @@ mod tests {
                         }
                     ]
                 }",
-            Value::Tuple(Box::new(partiql_tuple![
+            Value::Tuple(Box::new(tuple![
                 (
                     "sensors",
-                    partiql_list![partiql_tuple![("sensor", 1)], partiql_tuple![("sensor", 2)]]
+                    list![tuple![("sensor", 1)], tuple![("sensor", 2)]]
                 ),
                 (
                     "logs",
-                    partiql_list![
-                        partiql_tuple![("sensor", 1), ("co", rust_decimal::Decimal::new(4, 1))],
-                        partiql_tuple![("sensor", 1), ("co", rust_decimal::Decimal::new(2, 1))],
-                        partiql_tuple![("sensor", 2), ("co", rust_decimal::Decimal::new(3, 1))]
+                    list![
+                        tuple![("sensor", 1), ("co", rust_decimal::Decimal::new(4, 1))],
+                        tuple![("sensor", 1), ("co", rust_decimal::Decimal::new(2, 1))],
+                        tuple![("sensor", 2), ("co", rust_decimal::Decimal::new(3, 1))]
                     ]
                 )
             ])),
@@ -136,7 +136,7 @@ mod tests {
                 s: 1
             }
         ]";
-        let expected = Value::from(partiql_list![partiql_tuple![
+        let expected = Value::from(list![tuple![
             ("f", 1),
             ("d", Value::Real(2.0.into())),
             ("s", 1)

partiql-eval/benches/bench_eval.rs

@@ -10,36 +10,36 @@ use partiql_eval::plan;
 use partiql_logical as logical;
 use partiql_logical::BindingsOp::{Project, ProjectAll};
 use partiql_logical::{BinaryOp, BindingsOp, JoinKind, LogicalPlan, PathComponent, ValueExpr};
-use partiql_value::{partiql_bag, partiql_list, partiql_tuple, BindingsName, Value};
+use partiql_value::{bag, list, tuple, BindingsName, Value};
 
 fn data() -> MapBindings<Value> {
-    let hr = partiql_tuple![(
+    let hr = tuple![(
         "employeesNestScalars",
-        partiql_bag![
-            partiql_tuple![
+        bag![
+            tuple![
                 ("id", 3),
                 ("name", "Bob Smith"),
                 ("title", Value::Null),
                 (
                     "projects",
-                    partiql_list![
+                    list![
                         "AWS Redshift Spectrum querying",
                         "AWS Redshift security",
                         "AWS Aurora security",
                     ]
                 ),
             ],
-            partiql_tuple![
+            tuple![
                 ("id", 4),
                 ("name", "Susan Smith"),
                 ("title", "Dev Mgr"),
-                ("projects", partiql_list![]),
+                ("projects", list![]),
             ],
-            partiql_tuple![
+            tuple![
                 ("id", 6),
                 ("name", "Jane Smith"),
                 ("title", "Software Eng 2"),
-                ("projects", partiql_list!["AWS Redshift security"]),
+                ("projects", list!["AWS Redshift security"]),
             ],
         ]
     )];
@@ -50,14 +50,14 @@ fn data() -> MapBindings<Value> {
 }
 
 fn join_data() -> MapBindings<Value> {
-    let customers = partiql_list![
-        partiql_tuple![("id", 5), ("name", "Joe")],
-        partiql_tuple![("id", 7), ("name", "Mary")],
+    let customers = list![
+        tuple![("id", 5), ("name", "Joe")],
+        tuple![("id", 7), ("name", "Mary")],
     ];
 
-    let orders = partiql_list![
-        partiql_tuple![("custId", 7), ("productId", 101)],
-        partiql_tuple![("custId", 7), ("productId", 523)],
+    let orders = list![
+        tuple![("custId", 7), ("productId", 101)],
+        tuple![("custId", 7), ("productId", 523)],
     ];
 
     let mut bindings = MapBindings::default();