Add experimental, initial, draft support for GPML-style graph query (#…

…652)

This adds draft parser/AST support for a subset of GPML as outlined by "Graph Pattern Matching in GQL and SQL/PGQ"[1]. The use within the grammar is based on the assumption of a new graph data type being added to the specification of data types within PartiQL, and should be considered experimental until the semantics of the graph data type are specified.

This adds support for parsing:

    basic and abbreviated node and edge patterns (section 4.1 of the GPML paper)
    concatenated path patterns (section 4.2 of the GPML paper)
    graph patterns (i.e., comma separated path patterns) (section 4.3 of the GPML paper)
    AST support for path quantifiers (section 4.4 of the GPML paper)
    AST support for pre-filters (section 5.2 of the GPML paper)

[1]: https://arxiv.org/abs/2112.06217

lang/resources/org/partiql/type-domains/partiql.ion

@@ -210,12 +210,68 @@ may then be further optimized by selecting better implementations of each operat
             // UNPIVOT <expr> [AS <id>] [AT <id>] [BY <id>]
             (unpivot expr::expr as_alias::(? symbol) at_alias::(? symbol) by_alias::(? symbol))
 
-            // <from_source> JOIN [INNER | LEFT | RIGHT | FULL] <from_source> ON <expr>
-            (join type::join_type left::from_source right::from_source predicate::(? expr)))
+             // <from_source> JOIN [INNER | LEFT | RIGHT | FULL] <from_source> ON <expr>
+             (join type::join_type left::from_source right::from_source predicate::(? expr))
+
+             // <expr> MATCH <graph_pattern>
+             (graph_match expr::expr graph_expr::graph_match_expr))
 
         // Indicates the logical type of join.
         (sum join_type (inner) (left) (right) (full))
 
+        // The direction of an edge
+        // | Orientation               | Edge pattern | Abbreviation |
+        // |---------------------------+--------------+--------------|
+        // | Pointing left             | <−[ spec ]−  | <−           |
+        // | Undirected                | ~[ spec ]~   | ~            |
+        // | Pointing right            | −[ spec ]−>  | −>           |
+        // | Left or undirected        | <~[ spec ]~  | <~           |
+        // | Undirected or right       | ~[ spec ]~>  | ~>           |
+        // | Left or right             | <−[ spec ]−> | <−>          |
+        // | Left, undirected or right | −[ spec ]−   | −            |
+        //
+        // Fig. 5. Table of edge patterns:
+        // https://arxiv.org/abs/2112.06217
+        (sum graph_match_direction
+             (edge_left)
+             (edge_undirected)
+             (edge_right)
+             (edge_left_or_undirected)
+             (edge_undirected_or_right)
+             (edge_left_or_right)
+             (edge_left_or_undirected_or_right))
+
+        // A part of a graph pattern
+        (sum graph_match_pattern_part
+             // A single node in a graph pattern.
+             (node
+                 predicate::(? expr)   // an optional node pre-filter, e.g.: `WHERE c.name='Alarm'` in `MATCH (c WHERE c.name='Alarm')`
+                 variable::(? symbol)  // the optional element variable of the node match, e.g.: `x` in `MATCH (x)`
+                 label::(* symbol 0))  // the optional label(s) to match for the node, e.g.: `Entity` in `MATCH (x:Entity)`
+
+             // A single edge in a graph pattern.
+             (edge
+                 direction::graph_match_direction       // edge direction
+                 quantifier::(? graph_match_quantifier) // an optional quantifier for the edge match
+                 predicate::(? expr)   // an optional edge pre-filter, e.g.: `WHERE t.capacity>100` in `MATCH −[t:hasSupply WHERE t.capacity>100]−>`
+                 variable::(? symbol)  // the optional element variable of the edge match, e.g.: `t` in `MATCH −[t]−>`
+                 label::(* symbol 0))  // the optional label(s) to match for the edge. e.g.: `Target` in `MATCH −[t:Target]−>`
+             // A sub-pattern.
+             (pattern pattern::graph_match_pattern))
+
+        // A quantifier for graph edges or patterns. (e.g., the `{2,5}` in `MATCH (x)->{2,5}(y)`)
+        (product graph_match_quantifier lower::int upper::(? int))
+
+        // A single graph match pattern.
+        (product graph_match_pattern
+                 quantifier::(? graph_match_quantifier) // an optional quantifier for the entire pattern match
+                 parts::(* graph_match_pattern_part 1)) // the ordered pattern parts
+
+        // A graph match clause as defined in GPML
+        // See https://arxiv.org/abs/2112.06217
+        (product graph_match_expr patterns::(*graph_match_pattern 1))
+
+
         // A generic pair of expressions.  Used in the `struct`, `searched_case` and `simple_case` expr variants above.
         (product expr_pair first::expr second::expr)
 

lang/src/org/partiql/lang/ast/StatementToExprNode.kt

@@ -266,6 +266,7 @@ private class StatementTransformer(val ion: IonSystem) {
                     condition = predicate?.toExprNode() ?: Literal(ion.newBool(true), metaContainerOf(StaticTypeMeta(StaticType.BOOL))),
                     metas = metas
                 )
+            is PartiqlAst.FromSource.GraphMatch -> error("$this node has no representation in prior ASTs.")
         }
     }
 

lang/src/org/partiql/lang/errors/ErrorCode.kt

@@ -393,6 +393,42 @@ enum class ErrorCode(
         "expected identifier for alias"
     ),
 
+    PARSE_EXPECTED_IDENT_FOR_MATCH(
+        ErrorCategory.PARSER,
+        LOC_TOKEN,
+        "expected identifier for match"
+    ),
+
+    PARSE_EXPECTED_LEFT_PAREN_FOR_MATCH_NODE(
+        ErrorCategory.PARSER,
+        LOC_TOKEN,
+        "expected left parenthesis for match node"
+    ),
+
+    PARSE_EXPECTED_RIGHT_PAREN_FOR_MATCH_NODE(
+        ErrorCategory.PARSER,
+        LOC_TOKEN,
+        "expected right parenthesis for match node"
+    ),
+
+    PARSE_EXPECTED_LEFT_BRACKET_FOR_MATCH_EDGE(
+        ErrorCategory.PARSER,
+        LOC_TOKEN,
+        "expected left bracket for match edge"
+    ),
+
+    PARSE_EXPECTED_RIGHT_BRACKET_FOR_MATCH_EDGE(
+        ErrorCategory.PARSER,
+        LOC_TOKEN,
+        "expected right bracket for match edge"
+    ),
+
+    PARSE_EXPECTED_EDGE_PATTERN_MATCH_EDGE(
+        ErrorCategory.PARSER,
+        LOC_TOKEN,
+        "expected edge pattern for match edge"
+    ),
+
     PARSE_EXPECTED_AS_FOR_LET(
         ErrorCategory.PARSER,
         LOC_TOKEN,

lang/src/org/partiql/lang/eval/visitors/GroupByPathExpressionVisitorTransform.kt

@@ -76,6 +76,9 @@ class GroupByPathExpressionVisitorTransform(
 
                 is PartiqlAst.FromSource.Unpivot ->
                     listOfNotNull(fromSource.asAlias?.text, fromSource.atAlias?.text)
+
+                is PartiqlAst.FromSource.GraphMatch ->
+                    TODO("Handle MATCH for GROUP BY")
             }
     }
 

lang/src/org/partiql/lang/planner/transforms/AstToLogicalVisitorTransform.kt

@@ -165,4 +165,8 @@ private object FromSourceToBexpr : PartiqlAst.FromSource.Converter<PartiqlLogica
                 node.metas
             )
         }
+
+    override fun convertGraphMatch(node: PartiqlAst.FromSource.GraphMatch): PartiqlLogical.Bexpr {
+        TODO("Support for MATCH")
+    }
 }

lang/src/org/partiql/lang/syntax/LexerConstants.kt

@@ -499,15 +499,20 @@ internal val DATE_TIME_PART_KEYWORDS: Set<String> = DateTimePart.values()
     "+", "-", "not"
 )
 
+/** Operators specific to the `MATCH` clause. */
+@JvmField internal val MATCH_OPERATORS = setOf(
+    "~"
+)
+
 /** All operators with special parsing rules. */
 @JvmField internal val SPECIAL_OPERATORS = SPECIAL_INFIX_OPERATORS + setOf(
     "@"
 )
 
 @JvmField internal val ALL_SINGLE_LEXEME_OPERATORS =
-    SINGLE_LEXEME_BINARY_OPERATORS + UNARY_OPERATORS + SPECIAL_OPERATORS
+    SINGLE_LEXEME_BINARY_OPERATORS + UNARY_OPERATORS + SPECIAL_OPERATORS + MATCH_OPERATORS
 @JvmField internal val ALL_OPERATORS =
-    BINARY_OPERATORS + UNARY_OPERATORS + SPECIAL_OPERATORS
+    BINARY_OPERATORS + UNARY_OPERATORS + SPECIAL_OPERATORS + MATCH_OPERATORS
 
 /**
  * Operator precedence groups
@@ -585,7 +590,7 @@ internal const val DIGIT_CHARS = "0" + NON_ZERO_DIGIT_CHARS
 
 @JvmField internal val E_NOTATION_CHARS = allCase("E")
 
-internal const val NON_OVERLOADED_OPERATOR_CHARS = "^%=@+"
+internal const val NON_OVERLOADED_OPERATOR_CHARS = "^%=@+~"
 internal const val OPERATOR_CHARS = NON_OVERLOADED_OPERATOR_CHARS + "-*/<>|!"
 
 @JvmField internal val ALPHA_CHARS = allCase("ABCDEFGHIJKLMNOPQRSTUVWXYZ")