Parse SQL-style typed-literal strings (#163)

* Parse SQL-style typed-literal strings

Co-authored-by: Arash Maymandi <27716912+am357@users.noreply.github.com>

Author: jpschorr

partiql-ast/src/ast.rs

@@ -381,6 +381,8 @@ pub enum Lit {
     HexStringLit(String),
     DateTimeLit(DateTimeLit),
     CollectionLit(CollectionLit),
+    /// E.g. `TIME WITH TIME ZONE` in `SELECT TIME WITH TIME ZONE '12:00' FROM ...`
+    TypedLit(String, Type),
 }
 
 #[derive(Clone, Debug, PartialEq)]
@@ -536,20 +538,6 @@ pub struct Sexp {
     pub values: Vec<Box<Expr>>,
 }
 
-#[derive(Clone, Debug, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct Date {
-    pub year: i32,
-    pub month: i32,
-    pub day: i32,
-}
-
-#[derive(Clone, Debug, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct LitTime {
-    pub value: TimeValue,
-}
-
 #[derive(Clone, Debug, PartialEq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct Call {
@@ -564,11 +552,17 @@ pub enum CallArg {
     Star(),
     /// positional argument to a function call (e.g., all arguments in `foo(1, 'a', 3)`)
     Positional(Box<Expr>),
+
+    /// E.g. `INT` in `foo(INT)`
+    PositionalType(Type),
     /// named argument to a function call (e.g., the `"from" : 2` in `substring(a, "from":2)`
     Named {
         name: SymbolPrimitive,
-        value: Option<Box<Expr>>,
+        value: Box<Expr>,
     },
+
+    /// E.g. `AS: VARCHAR` in `CAST('abc' AS VARCHAR`
+    NamedType { name: SymbolPrimitive, ty: Type },
 }
 
 #[derive(Clone, Debug, PartialEq)]
@@ -579,40 +573,6 @@ pub struct CallAgg {
     pub args: Vec<Box<Expr>>,
 }
 
-#[derive(Clone, Debug, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct Cast {
-    pub value: Box<Expr>,
-    pub as_type: Type,
-}
-
-#[derive(Clone, Debug, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct CanCast {
-    pub value: Box<Expr>,
-    pub as_type: Type,
-}
-
-#[derive(Clone, Debug, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct CanLossLessCast {
-    pub value: Box<Expr>,
-    pub as_type: Type,
-}
-
-#[derive(Clone, Debug, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct NullIf {
-    pub expr1: Box<Expr>,
-    pub expr2: Box<Expr>,
-}
-
-#[derive(Clone, Debug, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct Coalesce {
-    pub args: Vec<Box<Expr>>,
-}
-
 #[derive(Clone, Debug, PartialEq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct Select {
@@ -624,18 +584,6 @@ pub struct Select {
     pub having: Option<Box<Expr>>,
 }
 
-#[derive(Clone, Debug, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct TimeValue {
-    pub hour: i32,
-    pub minute: i32,
-    pub second: i32,
-    pub nano: i32,
-    pub precision: i32,
-    pub with_time_zone: bool,
-    pub tz_minutes: Option<i32>,
-}
-
 #[derive(Clone, Debug, PartialEq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct Path {
@@ -967,20 +915,26 @@ pub enum Type {
 
 #[derive(Clone, Debug, PartialEq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct CharacterType {
-    pub length: Option<LongPrimitive>,
+pub enum CustomTypeParam {
+    /// E.g. `2` in `VARCHAR(2)`
+    Lit(Lit),
+    /// E.g. `INT` in `FooType(INT)`
+    Type(Type),
 }
 
 #[derive(Clone, Debug, PartialEq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct CharacterVaryingType {
-    pub length: Option<LongPrimitive>,
+pub enum CustomTypePart {
+    /// E.g. any of `WITH`, `TIME`, and`ZONE` in `TIME(20) WITH TIME ZONE`
+    Name(SymbolPrimitive),
+    /// E.g. `TIME(20) in `TIME(20) WITH TIME ZONE`
+    Parameterized(SymbolPrimitive, Vec<CustomTypeParam>),
 }
 
 #[derive(Clone, Debug, PartialEq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct CustomType {
-    pub name: SymbolPrimitive,
+    pub parts: Vec<CustomTypePart>,
 }
 
 #[derive(Clone, Debug, PartialEq)]
@@ -990,9 +944,3 @@ pub struct SymbolPrimitive {
     // Optional because string literal symbols don't have case sensitivity
     pub case: Option<CaseSensitivity>,
 }
-
-#[derive(Clone, Debug, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct LongPrimitive {
-    pub value: i32,
-}

partiql-cli/src/visualize/ast_to_dot.rs

@@ -2,6 +2,7 @@ use partiql_ast::ast;
 use std::fmt::Display;
 
 use dot_writer::{Attributes, DotWriter, Node, NodeId, Scope, Shape};
+use partiql_ast::ast::{CallArg, CustomTypeParam, CustomTypePart, Lit, Type};
 
 /*
 subgraph cluster_legend {
@@ -184,37 +185,82 @@ impl ToDot<ast::Expr> for AstToDot {
     }
 }
 
+#[inline]
+fn lit_to_str(ast: &Lit) -> String {
+    match ast {
+        Lit::Null => "NULL".to_string(),
+        Lit::Missing => "MISSING".to_string(),
+        Lit::Int8Lit(l) => l.to_string(),
+        Lit::Int16Lit(l) => l.to_string(),
+        Lit::Int32Lit(l) => l.to_string(),
+        Lit::Int64Lit(l) => l.to_string(),
+        Lit::DecimalLit(l) => l.to_string(),
+        Lit::NumericLit(l) => l.to_string(),
+        Lit::RealLit(l) => l.to_string(),
+        Lit::FloatLit(l) => l.to_string(),
+        Lit::DoubleLit(l) => l.to_string(),
+        Lit::BoolLit(l) => (if *l { "TRUE" } else { "FALSE" }).to_string(),
+        Lit::IonStringLit(l) => format!("`{}`", l),
+        Lit::CharStringLit(l) => format!("'{}'", l),
+        Lit::NationalCharStringLit(l) => format!("'{}'", l),
+        Lit::BitStringLit(l) => format!("b'{}'", l),
+        Lit::HexStringLit(l) => format!("x'{}'", l),
+        Lit::DateTimeLit(l) => match l {
+            ast::DateTimeLit::DateLit(d) => format!("DATE '{}'", d),
+            ast::DateTimeLit::TimeLit(t) => format!("TIME '{}'", t),
+            ast::DateTimeLit::TimestampLit(ts) => format!("TIMESTAMP '{}'", ts),
+        },
+        Lit::CollectionLit(l) => match l {
+            ast::CollectionLit::ArrayLit(al) => format!("[{}]", al),
+            ast::CollectionLit::BagLit(bl) => format!("<<{}>>", bl),
+        },
+        Lit::TypedLit(val_str, ty) => {
+            format!("{} '{}'", type_to_str(ty), val_str)
+        }
+    }
+}
+
+#[inline]
+fn custom_type_param_to_str(param: &ast::CustomTypeParam) -> String {
+    match param {
+        CustomTypeParam::Lit(lit) => lit_to_str(lit),
+        CustomTypeParam::Type(ty) => type_to_str(ty),
+    }
+}
+
+#[inline]
+fn custom_type_part_to_str(part: &ast::CustomTypePart) -> String {
+    match part {
+        CustomTypePart::Name(name) => symbol_primitive_to_label(name),
+        CustomTypePart::Parameterized(name, args) => {
+            let name = symbol_primitive_to_label(name);
+            let args = args
+                .iter()
+                .map(custom_type_param_to_str)
+                .collect::<Vec<_>>()
+                .join(",");
+            format!("{}({})", name, args)
+        }
+    }
+}
+
+#[inline]
+fn type_to_str(ty: &ast::Type) -> String {
+    match ty {
+        Type::CustomType(cty) => cty
+            .parts
+            .iter()
+            .map(custom_type_part_to_str)
+            .collect::<Vec<_>>()
+            .join(" "),
+        _ => format!("{:?}", ty),
+    }
+}
+
 impl ToDot<ast::Lit> for AstToDot {
     fn to_dot(&mut self, out: &mut Scope, ast: &ast::Lit) -> Targets {
         use ast::Lit;
-        let lbl = match ast {
-            Lit::Null => "NULL".to_string(),
-            Lit::Missing => "MISSING".to_string(),
-            Lit::Int8Lit(l) => l.to_string(),
-            Lit::Int16Lit(l) => l.to_string(),
-            Lit::Int32Lit(l) => l.to_string(),
-            Lit::Int64Lit(l) => l.to_string(),
-            Lit::DecimalLit(l) => l.to_string(),
-            Lit::NumericLit(l) => l.to_string(),
-            Lit::RealLit(l) => l.to_string(),
-            Lit::FloatLit(l) => l.to_string(),
-            Lit::DoubleLit(l) => l.to_string(),
-            Lit::BoolLit(l) => (if *l { "TRUE" } else { "FALSE" }).to_string(),
-            Lit::IonStringLit(l) => format!("`{}`", l),
-            Lit::CharStringLit(l) => format!("'{}'", l),
-            Lit::NationalCharStringLit(l) => format!("'{}'", l),
-            Lit::BitStringLit(l) => format!("b'{}'", l),
-            Lit::HexStringLit(l) => format!("x'{}'", l),
-            Lit::DateTimeLit(l) => match l {
-                ast::DateTimeLit::DateLit(d) => format!("DATE '{}'", d),
-                ast::DateTimeLit::TimeLit(t) => format!("TIME '{}'", t),
-                ast::DateTimeLit::TimestampLit(ts) => format!("TIMESTAMP '{}'", ts),
-            },
-            Lit::CollectionLit(l) => match l {
-                ast::CollectionLit::ArrayLit(al) => format!("[{}]", al),
-                ast::CollectionLit::BagLit(bl) => format!("<<{}>>", bl),
-            },
-        };
+        let lbl = lit_to_str(ast);
 
         let mut node = out.node_auto();
         node.set_label(&lbl).set_shape(Shape::Rectangle);
@@ -399,34 +445,29 @@ impl ToDot<ast::ProjectItem> for AstToDot {
     }
 }
 
+fn symbol_primitive_to_label(sym: &ast::SymbolPrimitive) -> String {
+    use ast::CaseSensitivity;
+    let case = sym.case.clone().unwrap_or(CaseSensitivity::CaseInsensitive);
+    match case {
+        CaseSensitivity::CaseSensitive => format!("'{}'", sym.value),
+        CaseSensitivity::CaseInsensitive => format!("{}", sym.value),
+    }
+}
+
 impl ToDot<ast::SymbolPrimitive> for AstToDot {
     fn to_dot(&mut self, out: &mut Scope, ast: &ast::SymbolPrimitive) -> Targets {
-        use ast::CaseSensitivity;
-        let case = ast.case.clone().unwrap_or(CaseSensitivity::CaseInsensitive);
-        let lbl = match case {
-            CaseSensitivity::CaseSensitive => format!("'{}'", ast.value),
-            CaseSensitivity::CaseInsensitive => format!("{}", ast.value),
-        };
+        let lbl = symbol_primitive_to_label(ast);
         let id = out.node_auto_labelled(&lbl).id();
         vec![id]
     }
 }
 
 impl ToDot<ast::VarRef> for AstToDot {
     fn to_dot(&mut self, out: &mut Scope, ast: &ast::VarRef) -> Targets {
-        use ast::CaseSensitivity;
-        let case = ast
-            .name
-            .case
-            .clone()
-            .unwrap_or(CaseSensitivity::CaseInsensitive);
-        let prefix = match &ast.qualifier {
-            ast::ScopeQualifier::Unqualified => "",
-            ast::ScopeQualifier::Qualified => "@",
-        };
-        let lbl = match case {
-            CaseSensitivity::CaseSensitive => format!("{}'{}'", prefix, ast.name.value),
-            CaseSensitivity::CaseInsensitive => format!("{}{}", prefix, ast.name.value),
+        let lbl = symbol_primitive_to_label(&ast.name);
+        let lbl = match &ast.qualifier {
+            ast::ScopeQualifier::Unqualified => lbl,
+            ast::ScopeQualifier::Qualified => format!("@{}", lbl),
         };
         let id = out.node_auto_labelled(&lbl).id();
 
@@ -532,6 +573,24 @@ impl ToDot<ast::CallArg> for AstToDot {
                 self.to_dot(out, value).edges(out, &id, "value");
                 vec![id]
             }
+            CallArg::PositionalType(ty) => {
+                let mut node = out.node_auto_labelled(&type_to_str(ty));
+                node.set("shape", "parallelogram", false);
+                vec![node.id()]
+            }
+            CallArg::NamedType { name, ty } => {
+                let id = out.node_auto_labelled("Named").id();
+                self.to_dot(out, name).edges(out, &id, "name");
+
+                let ty_target = {
+                    let mut ty_node = out.node_auto_labelled(&type_to_str(ty));
+                    ty_node.set("shape", "parallelogram", false);
+                    vec![ty_node.id()]
+                };
+                ty_target.edges(out, &id, "type");
+
+                vec![id]
+            }
         }
     }
 }

partiql-cli/src/visualize/render.rs

@@ -78,6 +78,12 @@ fn render_to_string(format: GraphVizFormat, ast: &Box<ast::Expr>) -> String {
     String::from_utf8(gv_render(format, ast_to_dot(ast))).expect("valid utf8")
 }
 
+/// Convert an AST into an attributed dot graph.
+#[inline]
+pub fn to_dot_raw(ast: &Box<ast::Expr>) -> String {
+    ast_to_dot(ast)
+}
+
 /// Convert an AST into an attributed dot graph.
 #[inline]
 pub fn to_dot(ast: &Box<ast::Expr>) -> String {
@@ -87,7 +93,7 @@ pub fn to_dot(ast: &Box<ast::Expr>) -> String {
 /// Convert an AST into a pretty-printed dot graph.
 #[inline]
 pub fn to_pretty_dot(ast: &Box<ast::Expr>) -> String {
-    render_to_string(GraphVizFormat::PrettyPrint, &ast)
+    render_to_string(GraphVizFormat::Canon, &ast)
 }
 
 /// Convert an AST into a graphviz svg.

partiql-parser/src/lexer.rs

@@ -632,6 +632,10 @@ pub enum Token<'input> {
     Where,
     #[regex("(?i:With)")]
     With,
+    #[regex("(?i:Without)")]
+    Without,
+    #[regex("(?i:Zone)")]
+    Zone,
 }
 
 impl<'input> Token<'input> {
@@ -804,7 +808,9 @@ impl<'input> fmt::Display for Token<'input> {
             | Token::Values
             | Token::When
             | Token::Where
-            | Token::With => {
+            | Token::With
+            | Token::Without
+            | Token::Zone => {
                 write!(f, "{}", format!("{:?}", self).to_uppercase())
             }
         }