Additional parse/lex tests

Author: jpschorr

partiql-ast/src/pretty.rs

@@ -1,6 +1,6 @@
 use crate::ast::*;
 use partiql_common::pretty::{
-    pretty_list, pretty_parenthesized_doc, pretty_prefixed_doc, pretty_seperated,
+    pretty_doc_list, pretty_list, pretty_parenthesized_doc, pretty_prefixed_doc, pretty_seperated,
     pretty_seperated_doc, pretty_seq, pretty_seq_doc, pretty_surrounded, pretty_surrounded_doc,
     PrettyDoc, PRETTY_INDENT_MINOR_NEST, PRETTY_INDENT_SUBORDINATE_CLAUSE_NEST,
 };
@@ -1032,35 +1032,139 @@ impl PrettyDoc for GraphMatch {
 }
 
 impl PrettyDoc for GraphTableRows {
-    fn pretty_doc<'b, D, A>(&'b self, _arena: &'b D) -> DocBuilder<'b, D, A>
+    fn pretty_doc<'b, D, A>(&'b self, arena: &'b D) -> DocBuilder<'b, D, A>
     where
         D: DocAllocator<'b, A>,
         D::Doc: Clone,
         A: Clone,
     {
-        todo!()
+        match self {
+            GraphTableRows::OneRowPerMatch => arena.text("ONE ROW PER MATCH"),
+            GraphTableRows::OneRowPerVertex { v, in_paths } => {
+                let prefix = arena.text("ONE ROW PER NODE");
+                let spec = pretty_parenthesized_doc(arena.text(&v.value), arena);
+                let in_paths = in_paths.as_ref().map(|paths| {
+                    let paths = pretty_parenthesized_doc(
+                        pretty_doc_list(paths.into_iter().map(|p| arena.text(&p.value)), 0, arena),
+                        arena,
+                    );
+                    [arena.text("IN"), paths]
+                });
+                arena.intersperse(
+                    [Some([prefix, spec]), in_paths]
+                        .into_iter()
+                        .flatten()
+                        .flatten(),
+                    arena.softline(),
+                )
+            }
+            GraphTableRows::OneRowPerStep {
+                v1,
+                e,
+                v2,
+                in_paths,
+            } => {
+                let prefix = arena.text("ONE ROW PER STEP");
+                let step = pretty_doc_list(
+                    [v1, e, v2].into_iter().map(|n| arena.text(&n.value)),
+                    0,
+                    arena,
+                );
+                let spec = pretty_parenthesized_doc(step, arena);
+                let in_paths = in_paths.as_ref().map(|paths| {
+                    let paths =
+                        pretty_doc_list(paths.into_iter().map(|p| arena.text(&p.value)), 0, arena);
+                    [arena.text("IN"), pretty_parenthesized_doc(paths, arena)]
+                });
+                arena.intersperse(
+                    [Some([prefix, spec]), in_paths]
+                        .into_iter()
+                        .flatten()
+                        .flatten(),
+                    arena.softline(),
+                )
+            }
+        }
     }
 }
 
 impl PrettyDoc for GraphTableColumns {
-    fn pretty_doc<'b, D, A>(&'b self, _arena: &'b D) -> DocBuilder<'b, D, A>
+    fn pretty_doc<'b, D, A>(&'b self, arena: &'b D) -> DocBuilder<'b, D, A>
     where
         D: DocAllocator<'b, A>,
         D::Doc: Clone,
         A: Clone,
     {
-        todo!()
+        let col_defs = pretty_list(&self.columns, 0, arena);
+        arena.intersperse(
+            [
+                arena.text("COLUMNS"),
+                pretty_parenthesized_doc(col_defs, arena),
+            ],
+            arena.space(),
+        )
+    }
+}
+
+impl PrettyDoc for GraphTableColumnDef {
+    fn pretty_doc<'b, D, A>(&'b self, arena: &'b D) -> DocBuilder<'b, D, A>
+    where
+        D: DocAllocator<'b, A>,
+        D::Doc: Clone,
+        A: Clone,
+    {
+        match self {
+            GraphTableColumnDef::Expr(expr, as_ident) => {
+                let parts = if let Some(as_ident) = as_ident {
+                    vec![
+                        expr.pretty_doc(arena),
+                        arena.text("AS"),
+                        arena.text(&as_ident.value),
+                    ]
+                } else {
+                    vec![expr.pretty_doc(arena)]
+                };
+                arena.intersperse(parts, arena.space())
+            }
+            GraphTableColumnDef::AllProperties(_) => {
+                unreachable!()
+            }
+        }
     }
 }
 
 impl PrettyDoc for GraphTableExport {
-    fn pretty_doc<'b, D, A>(&'b self, _arena: &'b D) -> DocBuilder<'b, D, A>
+    fn pretty_doc<'b, D, A>(&'b self, arena: &'b D) -> DocBuilder<'b, D, A>
     where
         D: DocAllocator<'b, A>,
         D::Doc: Clone,
         A: Clone,
     {
-        todo!()
+        match self {
+            GraphTableExport::AllSingletons { except } => {
+                let prefix = arena.text("EXPORT ALL SINGLETONS");
+                if let Some(except) = except {
+                    let except =
+                        pretty_doc_list(except.iter().map(|s| arena.text(&s.value)), 0, arena);
+                    let parts = [
+                        prefix,
+                        arena.text("EXCEPT"),
+                        pretty_parenthesized_doc(except, arena),
+                    ];
+                    arena.intersperse(parts, arena.space())
+                } else {
+                    prefix
+                }
+            }
+            GraphTableExport::Singletons { exports } => {
+                let prefix = arena.text("EXPORT SINGLETONS");
+                let exports =
+                    pretty_doc_list(exports.iter().map(|e| arena.text(&e.value)), 0, arena);
+                let parts = [prefix, pretty_parenthesized_doc(exports, arena)];
+                arena.intersperse(parts, arena.space())
+            }
+            GraphTableExport::NoSingletons => arena.text("EXPORT NO SINGLETONS"),
+        }
     }
 }
 

partiql-common/src/pretty.rs

@@ -262,6 +262,18 @@ where
     pretty_seperated(sep, list, nest, arena)
 }
 
+#[inline]
+pub fn pretty_doc_list<'b, I, D, A>(list: I, nest: isize, arena: &'b D) -> DocBuilder<'b, D, A>
+where
+    I: IntoIterator<Item = DocBuilder<'b, D, A>>,
+    D: DocAllocator<'b, A>,
+    D::Doc: Clone,
+    A: Clone,
+{
+    let sep = arena.text(",").append(arena.softline());
+    pretty_seperated_doc(sep, list, nest, arena)
+}
+
 #[inline]
 pub fn pretty_seperated<'b, I, E, P, D, A>(
     sep: E,

partiql-parser/src/lexer/mod.rs

@@ -84,25 +84,39 @@ mod tests {
     fn display() -> Result<(), ParseError<'static, BytePosition>> {
         let symbols =
             "( [ { } ] ) << >> ; , < > <= >= != <> = == - + * ? % / ^ . || : --foo /*block*/";
+        let graph_symbols =
+            "|+| <- ~ -> <~ ~> <-[ ]- ~[ ]~ -[ ]-> <~[ ]~> <-> <-/ /- ~/ /~ -/ /-> <~/ /~>";
         let primitives = r#"unquoted_ident "quoted_ident" @unquoted_atident @"quoted_atident""#;
         let keywords =
             "WiTH Where Value uSiNg Unpivot UNION True Select right Preserve pivoT Outer Order Or \
              On Offset Nulls Null Not Natural Missing Limit Like Left Lateral Last Join \
              Intersect Is Inner In Having Group From For Full First False Except Escape Desc \
              Cross Table Time Timestamp Date By Between At As And Asc All Values Case When Then Else End \
-             Match Any Shortest Trail Acyclic Simple";
-        let symbols = symbols.split(' ').chain(primitives.split(' '));
+             Match";
+        let nonreserved_kw = "Any Simple Acyclic Bindings Bound Destination \
+            Different Directed Edge Edges Elements label Labeled Node Paths Properties Property \
+            PROPERTY_GRAPH_CaTalOg PROPERTY_GRAPH_NaMe PROPERTY_GRAPH_SchEma Relationship Relationships \
+            Shortest Singletons Step Tables Trail Vertex Walk";
+        let symbols = symbols.split(' ');
+        let graph_symbols = graph_symbols.split(' ');
+        let primitives = primitives.split(' ');
+        let nonreserved_kws = nonreserved_kw.split(' ');
         let keywords = keywords.split(' ');
 
-        let text = symbols.interleave(keywords).join("\n");
+        let text = symbols
+            .chain(graph_symbols)
+            .chain(primitives)
+            .chain(keywords)
+            .chain(nonreserved_kws)
+            .join("\n");
         let s = text.as_str();
 
         let mut offset_tracker = LineOffsetTracker::default();
         let lexer = PartiqlLexer::new(s, &mut offset_tracker);
         let toks: Vec<_> = lexer.collect::<Result<_, _>>().unwrap();
 
-        let toks = toks.into_iter().map(|(_s, t, _e)| t).collect::<Vec<_>>();
-        insta::assert_debug_snapshot!(toks);
+        let toks = toks.into_iter().map(|(_s, t, _e)| t.to_string()).join("\n");
+        insta::assert_snapshot!(toks);
 
         Ok(())
     }