add with_where[1-7].test (#2431)

Co-authored-by: Russell Liu <russell.liu@uwaterloo.ca>

test/test_files/tck/with-where/with_where1.test

@@ -0,0 +1,73 @@
+-GROUP TCKWithWhere1
+-DATASET CSV tck
+
+--
+
+# Filter node with property predicate on a single variable with multiple bindings
+-CASE Scenario1
+-STATEMENT CREATE NODE TABLE A(ID SERIAL, name STRING, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE (:A {name: 'A'}),
+                  (:A {name: 'B'}),
+                  (:A {name: 'C'});
+---- ok
+-STATEMENT MATCH (a)
+           WITH a
+           WHERE a.name = 'B'
+           RETURN a;
+---- 1
+{_ID: 0:1, _LABEL: A, ID: 1, name: B}
+
+# Filter node with property predicate on a single variable with multiple distinct bindings
+-CASE Scenario2
+-SKIP
+-STATEMENT CREATE NODE TABLE A(ID SERIAL, name2 STRING, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE (:A {name2: 'A'}),
+                  (:A {name2: 'A'}),
+                  (:A {name2: 'B'});
+---- ok
+-STATEMENT MATCH (a)
+           WITH DISTINCT a.name2 AS name
+           WHERE a.name2 = 'B'
+           RETURN *;
+---- 1
+B
+
+# Filter for an unbound relationship variable
+-CASE Scenario3
+-SKIP
+-STATEMENT CREATE NODE TABLE A(ID SERIAL, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE NODE TABLE B(id INT64, PRIMARY KEY(id));
+---- ok
+-STATEMENT CREATE REL TABLE T(FROM A TO B);
+---- ok
+-STATEMENT CREATE (a:A), (b:B {id: 1}), (:B {id: 2})
+           CREATE (a)-[:T]->(b);
+---- ok
+-STATEMENT MATCH (a:A), (other:B)
+           OPTIONAL MATCH (a)-[r]->(other)
+           WITH other WHERE r IS NULL
+           RETURN other;
+---- 1
+{_ID: 1:1, _LABEL: B, id: 2}
+
+# Filter for an unbound node variable
+-CASE Scenario4
+-SKIP
+-STATEMENT CREATE NODE TABLE A(ID SERIAL, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE NODE TABLE B(id INT64, PRIMARY KEY(id));
+---- ok
+-STATEMENT CREATE REL TABLE T(FROM A TO B);
+---- ok
+-STATEMENT CREATE (a:A), (b:B {id: 1}), (:B {id: 2})
+           CREATE (a)-[:T]->(b);
+---- ok
+-STATEMENT MATCH (other:B)
+           OPTIONAL MATCH (a)-[r]->(other)
+           WITH other WHERE a IS NULL
+           RETURN other;
+---- 1
+{_ID: 1:1, _LABEL: B, id: 2}

test/test_files/tck/with-where/with_where2.test

@@ -0,0 +1,68 @@
+-GROUP TCKWithWhere2
+-DATASET CSV tck
+
+--
+
+# Filter nodes with conjunctive two-part property predicate on multi variables with multiple bindings
+-CASE Scenario1
+-SKIP
+-STATEMENT CREATE NODE TABLE A(ID SERIAL, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE NODE TABLE D(ID SERIAL, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE NODE TABLE B(id INT64, PRIMARY KEY(id));
+---- ok
+-STATEMENT CREATE NODE TABLE C(id INT64, PRIMARY KEY(id));
+---- ok
+-STATEMENT CREATE REL TABLE GROUP T(FROM A TO B, FROM A TO C, FROM A TO D, FROM B TO C, FROM B TO D, FROM C TO D);
+---- ok
+-STATEMENT CREATE (a:A), (b:B {id: 1}), (c:C {id: 2}), (d:D)
+           CREATE (a)-[:T_A_B]->(b),
+                  (a)-[:T_A_C]->(c),
+                  (a)-[:T_A_D]->(d),
+                  (b)-[:T_B_C]->(c),
+                  (b)-[:T_B_D]->(d),
+                  (c)-[:T_C_D]->(d);
+---- ok
+-STATEMENT MATCH (a)--(b)--(c)--(d)--(a), (b)--(d)
+           WITH a, c, d
+           WHERE a.id = 1
+             AND c.id = 2
+           RETURN d;
+---- 2
+{_ID: 0:0, _LABEL: A, ID: 0}
+{_ID: 1:0, _LABEL: D, ID: 0}
+
+# Filter node with conjunctive multi-part property predicates on multi variables with multiple bindings
+-CASE Scenario2
+-SKIP
+-STATEMENT CREATE NODE TABLE A(name STRING, id INT64, PRIMARY KEY(id));
+---- ok
+-STATEMENT CREATE NODE TABLE B(ID SERIAL, name STRING, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE REL TABLE ADV_HAS_PRODUCT(FROM A TO B);
+---- ok
+-STATEMENT CREATE REL TABLE AA_HAS_VALUE(FROM A TO B);
+---- ok
+-STATEMENT CREATE REL TABLE AP_HAS_VALUE(FROM B TO B);
+---- ok
+-STATEMENT CREATE (advertiser:A {name: 'advertiser1', id: 0}),
+                  (thing:A {name: 'Color', id: 1}),
+                  (red:B {name: 'red'}),
+                  (p1:B {name: 'product1'}),
+                  (p2:B {name: 'product4'})
+           CREATE (advertiser)-[:ADV_HAS_PRODUCT]->(p1),
+                  (advertiser)-[:ADV_HAS_PRODUCT]->(p2),
+                  (thing)-[:AA_HAS_VALUE]->(red),
+                  (p1)-[:AP_HAS_VALUE]->(red),
+                  (p2)-[:AP_HAS_VALUE]->(red);
+---- ok
+-STATEMENT MATCH (advertiser)-[:ADV_HAS_PRODUCT]->(out)-[:AP_HAS_VALUE]->(red)<-[:AA_HAS_VALUE]-(a)
+           WITH a, advertiser, red, out
+           WHERE advertiser.id = $1
+             AND a.id = $2
+             AND red.name = 'red'
+             AND out.name = 'product1'
+           RETURN out.name;
+---- 1
+product1

test/test_files/tck/with-where/with_where3.test

@@ -0,0 +1,69 @@
+-GROUP TCKWithWhere3
+-DATASET CSV tck
+
+--
+
+# Join between node identities
+-CASE Scenario1
+-SKIP
+-STATEMENT CREATE NODE TABLE A(ID SERIAL, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE NODE TABLE B(ID SERIAL, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE (:A), (:B);
+---- ok
+-STATEMENT MATCH (a), (b)
+           WITH a, b
+           WHERE a = b
+           RETURN a, b;
+---- 2
+{_ID: 0:0, _LABEL: A, ID: 0}|{_ID: 0:0, _LABEL: A, ID: 0}
+{_ID: 1:0, _LABEL: B, ID: 0}|{_ID: 1:0, _LABEL: B, ID: 0}
+
+# Join between node properties of disconnected nodes
+-CASE Scenario2
+-STATEMENT CREATE NODE TABLE A(id INT64, PRIMARY KEY(id));
+---- ok
+-STATEMENT CREATE NODE TABLE B(id INT64, PRIMARY KEY(id));
+---- ok
+-STATEMENT CREATE (:A {id: 1}),
+                  (:A {id: 2}),
+                  (:B {id: 2}),
+                  (:B {id: 3});
+---- ok
+-STATEMENT MATCH (a:A), (b:B)
+           WITH a, b
+           WHERE a.id = b.id
+           RETURN a, b;
+---- 1
+{_ID: 0:1, _LABEL: A, id: 2}|{_ID: 1:0, _LABEL: B, id: 2}
+
+# Join between node properties of adjacent nodes
+-CASE Scenario3
+-SKIP
+-STATEMENT CREATE NODE TABLE A(ID SERIAL, animal STRING, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE NODE TABLE B(ID SERIAL, animal STRING, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE NODE TABLE C(ID SERIAL, animal STRING, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE NODE TABLE D(ID SERIAL, animal STRING, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE REL TABLE GROUP KNOWS(FROM A TO B, FROM A TO C, FROM D TO B, FROM D TO C);
+---- ok
+-STATEMENT CREATE (a:A {animal: 'monkey'}),
+                  (b:B {animal: 'cow'}),
+                  (c:C {animal: 'monkey'}),
+                  (d:D {animal: 'cow'}),
+                  (a)-[:KNOWS_A_B]->(b),
+                  (a)-[:KNOWS_A_C]->(c),
+                  (d)-[:KNOWS_D_B]->(b),
+                  (d)-[:KNOWS_D_C]->(c);
+---- ok
+-STATEMENT MATCH (n)-[rel]->(x)
+           WITH n, x
+           WHERE n.animal = x.animal
+           RETURN n, x;
+---- 2
+{_ID: 0:0, _LABEL: A, ID: 0, animal: monkey}|{_ID: 2:0, _LABEL: C, ID: 0, animal: monkey}
+{_ID: 3:0, _LABEL: D, ID: 0, animal: cow}|{_ID: 1:0, _LABEL: B, ID: 0, animal: cow}

test/test_files/tck/with-where/with_where4.test

@@ -0,0 +1,41 @@
+-GROUP TCKWithWhere4
+-DATASET CSV tck
+
+--
+
+# Join nodes on inequality
+-CASE Scenario1
+-SKIP
+-STATEMENT CREATE NODE TABLE A(ID SERIAL, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE NODE TABLE B(ID SERIAL, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE (:A), (:B);
+---- ok
+-STATEMENT MATCH (a), (b)
+           WITH a, b
+           WHERE a <> b
+           RETURN a, b;
+---- 2
+{_ID: 0:0, _LABEL: A, ID: 0}|{_ID: 1:0, _LABEL: B, ID: 0}
+{_ID: 0:0, _LABEL: A, ID: 0}|{_ID: 1:0, _LABEL: B, ID: 0}
+
+# Join with disjunctive multi-part predicates including patterns
+-CASE Scenario2
+-SKIP
+-STATEMENT CREATE NODE TABLE TheLabel(id INT64, PRIMARY KEY(id));
+---- ok
+-STATEMENT CREATE REL TABLE T(FROM TheLabel TO TheLabel);
+---- ok
+-STATEMENT CREATE (a:TheLabel {id: 0}), (b:TheLabel {id: 1}), (c:TheLabel {id: 2})
+           CREATE (a)-[:T]->(b),
+                  (b)-[:T]->(c);
+---- ok
+-STATEMENT MATCH (a), (b)
+           WITH a, b
+           WHERE a.id = 0
+             AND (a)-[:T]->(b:TheLabel)
+             OR (a)-[:T*]->(b:MissingLabel)
+           RETURN DISTINCT b;
+---- 1
+{_ID: 0:1, _LABEL: TheLabel, id: 1}

test/test_files/tck/with-where/with_where5.test

@@ -0,0 +1,98 @@
+-GROUP TCKWithWhere5
+-DATASET CSV tck
+
+--
+
+# Filter out on null
+-CASE Scenario1
+-STATEMENT CREATE NODE TABLE Root(ID SERIAL, name STRING, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE NODE TABLE TextNode(ID SERIAL, var STRING, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE NODE TABLE IntNode(ID SERIAL, var INT64, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE REL TABLE GROUP T(FROM Root TO TextNode, FROM Root TO IntNode);
+---- ok
+-STATEMENT CREATE (root:Root {name: 'x'}),
+                  (child1:TextNode {var: 'text'}),
+                  (child2:IntNode {var: 0})
+           CREATE (root)-[:T_Root_TextNode]->(child1),
+                  (root)-[:T_Root_IntNode]->(child2);
+---- ok
+-STATEMENT MATCH (:Root {name: 'x'})-->(i:TextNode)
+           WITH i
+           WHERE i.var > 'te'
+           RETURN i;
+---- 1
+{_ID: 1:0, _LABEL: TextNode, ID: 0, var: text}
+
+# Filter out on null if the AND'd predicate evaluates to false
+-CASE Scenario2
+-STATEMENT CREATE NODE TABLE Root(ID SERIAL, name STRING, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE NODE TABLE TextNode(ID SERIAL, var STRING, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE NODE TABLE IntNode(ID SERIAL, var INT64, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE REL TABLE GROUP T(FROM Root TO TextNode, FROM Root TO IntNode);
+---- ok
+-STATEMENT CREATE (root:Root {name: 'x'}),
+                  (child1:TextNode {var: 'text'}),
+                  (child2:IntNode {var: 0})
+           CREATE (root)-[:T_Root_TextNode]->(child1),
+                  (root)-[:T_Root_IntNode]->(child2);
+---- ok
+-STATEMENT MATCH (:Root {name: 'x'})-->(i:TextNode)
+           WITH i
+           WHERE i.var > 'te' AND LABEL(i) = 'TextNode'
+           RETURN i;
+---- 1
+{_ID: 1:0, _LABEL: TextNode, ID: 0, var: text}
+
+# Filter out on null if the AND'd predicate evaluates to true
+-CASE Scenario3
+-STATEMENT CREATE NODE TABLE Root(ID SERIAL, name STRING, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE NODE TABLE TextNode(ID SERIAL, var STRING, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE NODE TABLE IntNode(ID SERIAL, var INT64, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE REL TABLE GROUP T(FROM Root TO TextNode, FROM Root TO IntNode);
+---- ok
+-STATEMENT CREATE (root:Root {name: 'x'}),
+                  (child1:TextNode {var: 'text'}),
+                  (child2:IntNode {var: 0})
+           CREATE (root)-[:T_Root_TextNode]->(child1),
+                  (root)-[:T_Root_IntNode]->(child2);
+---- ok
+-STATEMENT MATCH (:Root {name: 'x'})-->(i:TextNode)
+           WITH i
+           WHERE i.var > 'te' AND i.var IS NOT NULL
+           RETURN i;
+---- 1
+{_ID: 1:0, _LABEL: TextNode, ID: 0, var: text}
+
+# Do not filter out on null if the OR'd predicate evaluates to true
+-CASE Scenario4
+-SKIP
+-STATEMENT CREATE NODE TABLE Root(ID SERIAL, name STRING, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE NODE TABLE TextNode(ID SERIAL, var STRING, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE NODE TABLE IntNode(ID SERIAL, var INT64, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE REL TABLE GROUP T(FROM Root TO TextNode, FROM Root TO IntNode);
+---- ok
+-STATEMENT CREATE (root:Root {name: 'x'}),
+                  (child1:TextNode {var: 'text'}),
+                  (child2:IntNode {var: 0})
+           CREATE (root)-[:T_Root_TextNode]->(child1),
+                  (root)-[:T_Root_IntNode]->(child2);
+---- ok
+-STATEMENT MATCH (:Root {name: 'x'})-->(i)
+           WITH i
+           WHERE i.var > 'te' OR i.var IS NOT NULL
+           RETURN i;
+---- 2
+{_ID: 1:0, _LABEL: TextNode, ID: 0, var: text}
+{_ID: 2:0, _LABEL: IntNode, ID: 0, var: 0}

test/test_files/tck/with-where/with_where6.test

@@ -0,0 +1,27 @@
+-GROUP TCKWithWhere6
+-DATASET CSV tck
+
+--
+
+# Filter a single aggregate
+-CASE Scenario1
+-SKIP
+-STATEMENT CREATE NODE TABLE A(ID SERIAL, name STRING, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE NODE TABLE B(ID SERIAL, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE REL TABLE REL(FROM A TO B);
+---- ok
+-STATEMENT CREATE (a:A {name: 'A'}),
+                  (b:A {name: 'B'})
+           CREATE (a)-[:REL]->(:B),
+                  (a)-[:REL]->(:B),
+                  (a)-[:REL]->(:B),
+                  (b)-[:REL]->(:B);
+---- ok
+-STATEMENT MATCH (a)-->()
+           WITH a, count(*) AS relCount
+           WHERE relCount > 1
+           RETURN a;
+---- 1
+{_ID: 0:0, _LABEL: A, ID: 0, name: A}