Merge pull request #2610 from kuzudb/tck-with-skip-limit

OpenCypher regression test - WITH SKIP LIMIT clause

test/test_files/tck/with-skip-limit/with_skip_limit1.test

@@ -0,0 +1,48 @@
+-GROUP TCKWithSkipLimit1
+-DATASET CSV tck
+
+--
+
+# Handle dependencies across WITH with SKIP
+-CASE Scenario1
+-SKIP
+-STATEMENT CREATE NODE TABLE A(name STRING, num INT64, id INT64, PRIMARY KEY(id));
+---- ok
+-STATEMENT CREATE (a:A {name: 'A', num: 0, id: 0}),
+                  (:A {name: 'B', num: a.id, id: 1}),
+                  (:A {name: 'C', num: 0, id: 2});
+---- ok
+-STATEMENT MATCH (a)
+           WITH a.name AS property, a.num AS idToUse
+             ORDER BY property
+             SKIP 1
+           MATCH (b)
+           WHERE b.id = idToUse
+           RETURN DISTINCT b;
+---- 1
+{_ID: 0:0, _LABEL: A, name: A, num: 0, id: 0}
+
+# Ordering and skipping on aggregate
+-CASE Scenario2
+-STATEMENT CREATE NODE TABLE A(ID SERIAL, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE NODE TABLE X(ID SERIAL, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE NODE TABLE Y(ID SERIAL, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE REL TABLE T1(FROM A TO X, num INT64);
+---- ok
+-STATEMENT CREATE REL TABLE T2(FROM A TO X, num INT64);
+---- ok
+-STATEMENT CREATE REL TABLE T3(FROM A TO Y, num INT64);
+---- ok
+-STATEMENT CREATE (:A)-[:T1 {num: 3}]->(x:X),
+                  (:A)-[:T2 {num: 2}]->(x),
+                  (:A)-[:T3 {num: 1}]->(:Y);
+---- ok
+-STATEMENT MATCH ()-[r1]->(x)
+           WITH x, sum(r1.num) AS c
+             ORDER BY c SKIP 1
+           RETURN x, c;
+---- 1
+{_ID: 1:0, _LABEL: X, ID: 0}|5

test/test_files/tck/with-skip-limit/with_skip_limit2.test

@@ -0,0 +1,91 @@
+-GROUP TCKWithSkipLimit2
+-DATASET CSV tck
+
+--
+
+# ORDER BY and LIMIT can be used
+-CASE Scenario1
+-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), (:B), (:B), (:B),
+                  (a)-[:REL]->(:B);
+---- ok
+-STATEMENT MATCH (a:A)
+           WITH a
+           ORDER BY a.name
+           LIMIT 1
+           MATCH (a)-->(b)
+           RETURN a;
+---- 1
+{_ID: 0:0, _LABEL: A, ID: 0}
+
+# Handle dependencies across WITH with LIMIT
+-CASE Scenario2
+-SKIP
+-STATEMENT CREATE NODE TABLE End(ID SERIAL, num INT64, id INT64, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE NODE TABLE Begin(ID SERIAL, num INT64, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE (a:End {num: 42, id: 0}),
+                        (:End {num: 3}),
+                        (:Begin {num: a.id});
+---- ok
+-STATEMENT MATCH (a:Begin)
+           WITH a.num AS property
+             LIMIT 1
+           MATCH (b)
+           WHERE b.id = property
+           RETURN b;
+---- 1
+{_ID: 0:0, _LABEL: End, ID: 0, num: 42, id: 0}
+
+# Connected components succeeding WITH with LIMIT
+-CASE Scenario3
+-STATEMENT CREATE NODE TABLE A(ID SERIAL, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE NODE TABLE X(ID SERIAL, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE NODE TABLE B(ID SERIAL, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE REL TABLE REL(FROM A TO X);
+---- ok
+-STATEMENT CREATE (:A)-[:REL]->(:X);
+---- ok
+-STATEMENT CREATE (:B);
+---- ok
+-STATEMENT MATCH (n:A)
+           WITH n
+           LIMIT 1
+           MATCH (m:B), (n)-->(x:X)
+           RETURN *;
+---- 1
+{_ID: 0:0, _LABEL: A, ID: 0}|{_ID: 2:0, _LABEL: B, ID: 0}|{_ID: 1:0, _LABEL: X, ID: 0}
+
+# Ordering and limiting on aggregate
+-CASE Scenario4
+-STATEMENT CREATE NODE TABLE A(ID SERIAL, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE NODE TABLE X(ID SERIAL, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE NODE TABLE Y(ID SERIAL, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE REL TABLE T1(FROM A TO X, num INT64);
+---- ok
+-STATEMENT CREATE REL TABLE T2(FROM A TO X, num INT64);
+---- ok
+-STATEMENT CREATE REL TABLE T3(FROM A TO Y, num INT64);
+---- ok
+-STATEMENT CREATE (:A)-[:T1 {num: 3}]->(x:X),
+                  (:A)-[:T2 {num: 2}]->(x),
+                  (:A)-[:T3 {num: 1}]->(:Y);
+---- ok
+-STATEMENT MATCH ()-[r1]->(x)
+           WITH x, sum(r1.num) AS c
+             ORDER BY c LIMIT 1
+           RETURN x, c;
+---- 1
+{_ID: 2:0, _LABEL: Y, ID: 0}|1

test/test_files/tck/with-skip-limit/with_skip_limit3.test

@@ -0,0 +1,69 @@
+-GROUP TCKWithSkipLimit3
+-DATASET CSV tck
+
+--
+
+# Get rows in the middle
+-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'}),
+                  (:A {name: 'D'}),
+                  (:A {name: 'E'});
+---- ok
+-STATEMENT MATCH (n)
+           WITH n
+           ORDER BY n.name ASC
+           SKIP 2
+           LIMIT 2
+           RETURN n;
+-CHECK_ORDER
+---- 2
+{_ID: 0:2, _LABEL: A, ID: 2, name: C}
+{_ID: 0:3, _LABEL: A, ID: 3, name: D}
+
+# Get rows in the middle by param
+-CASE Scenario2
+-SKIP
+-STATEMENT CREATE NODE TABLE A(ID SERIAL, name STRING, PRIMARY KEY(ID));
+---- ok
+-STATEMENT CREATE (:A {name: 'A'}),
+                  (:A {name: 'B'}),
+                  (:A {name: 'C'}),
+                  (:A {name: 'D'}),
+                  (:A {name: 'E'});
+---- ok
+-STATEMENT MATCH (n)
+           WITH n
+           ORDER BY n.name ASC
+           SKIP $s
+           LIMIT $l
+           RETURN n;
+-CHECK_ORDER
+---- 2
+{_ID: 0:2, _LABEL: A, ID: 2, name: C}
+{_ID: 0:3, _LABEL: A, ID: 3, name: D}
+
+# Limiting amount of rows when there are fewer left than the LIMIT argument
+-CASE Scenario3
+-STATEMENT CREATE NODE TABLE A(ID SERIAL, count INT64, PRIMARY KEY(ID));
+---- ok
+-STATEMENT UNWIND range(0, 15) AS i
+           CREATE (:A {count: i});
+---- ok
+-STATEMENT  MATCH (a)
+            WITH a.count AS count
+              ORDER BY a.count
+              SKIP 10
+              LIMIT 10
+            RETURN count;
+-CHECK_ORDER
+---- 6
+10
+11
+12
+13
+14
+15