From: Pavan Deolasee Date: Fri, 7 Sep 2018 06:12:38 +0000 (+0530) Subject: Adjust 'limit' test case to avoid regression failures. X-Git-Tag: XL_10_R1BETA1~17 X-Git-Url: http://git.postgresql.org/gitweb/static/gitweb.js?a=commitdiff_plain;h=e3e863deb2d82a95f9c623021468d7cca4b91547;p=postgres-xl.git Adjust 'limit' test case to avoid regression failures. There are two known problems in the test case. 1. When nextval() is pushed down to the remote nodes, the coordinator session won't have seen a nextval() invokation and hence a subsequent currval() will throw an ERROR or return a stale value. 2. When nextval() is pushed down to the remote nodes and a set of rows are fetched (either ordered or otherwise), the results may be somewhat inconsistent because each node will run nextval() concurrently and hence the ordering will change depending on who runs when. For now, change the queries to force nextval() evaluation on the coordinator. Also move the original test cases to xl_known_bugs test case and we also have an internal issue open to track this problem. --- diff --git a/src/test/regress/expected/limit.out b/src/test/regress/expected/limit.out index 503bdda0e1..8c64d8192e 100644 --- a/src/test/regress/expected/limit.out +++ b/src/test/regress/expected/limit.out @@ -313,24 +313,31 @@ SELECT -- with ORDER BY and LIMIT. -- create temp sequence testseq; +-- XL: The query has been slightly modified to suit XL's execution mechanism +-- when nextval is pushed down to the remote node. Using a subquery gives +-- consistent results and also ensures currval() returns correct value (since +-- nextval gets executed on the coordinator). The original two tests are +-- copied to xl_known_bugs test case explain (verbose, costs off) -select unique1, unique2, nextval('testseq') - from tenk1 order by unique2 limit 10; - QUERY PLAN ----------------------------------------------------------------------------- - Limit - Output: unique1, unique2, (nextval('testseq'::regclass)) - -> Remote Subquery Scan on all (datanode_1,datanode_2) - Output: unique1, unique2, nextval('testseq'::regclass) - Sort Key: tenk1.unique2 - -> Limit - Output: unique1, unique2, (nextval('testseq'::regclass)) - -> Index Scan using tenk1_unique2 on public.tenk1 - Output: unique1, unique2, nextval('testseq'::regclass) -(9 rows) +select *, nextval('testseq') from + (select unique1, unique2 from tenk1 order by unique2 limit 10) x; + QUERY PLAN +------------------------------------------------------------------------ + Subquery Scan on x + Output: x.unique1, x.unique2, nextval('testseq'::regclass) + -> Limit + Output: tenk1.unique1, tenk1.unique2 + -> Remote Subquery Scan on all (datanode_1,datanode_2) + Output: tenk1.unique1, tenk1.unique2 + Sort Key: tenk1.unique2 + -> Limit + Output: tenk1.unique1, tenk1.unique2 + -> Index Scan using tenk1_unique2 on public.tenk1 + Output: tenk1.unique1, tenk1.unique2 +(11 rows) -select unique1, unique2, nextval('testseq') - from tenk1 order by unique2 limit 10; +select *, nextval('testseq') from + (select unique1, unique2 from tenk1 order by unique2 limit 10) x; unique1 | unique2 | nextval ---------+---------+--------- 8800 | 0 | 1 @@ -352,28 +359,28 @@ select currval('testseq'); (1 row) explain (verbose, costs off) -select unique1, unique2, nextval('testseq') - from tenk1 order by tenthous limit 10; +select *, nextval('testseq') from + (select unique1, unique2 from tenk1 order by tenthous limit 10) x; QUERY PLAN -------------------------------------------------------------------------------------- - Limit - Output: unique1, unique2, (nextval('testseq'::regclass)), tenthous - -> Remote Subquery Scan on all (datanode_1,datanode_2) - Output: unique1, unique2, nextval('testseq'::regclass), tenthous - Sort Key: tenk1.tenthous - -> Limit - Output: unique1, unique2, (nextval('testseq'::regclass)), tenthous - -> Result - Output: unique1, unique2, nextval('testseq'::regclass), tenthous + Subquery Scan on x + Output: x.unique1, x.unique2, nextval('testseq'::regclass) + -> Limit + Output: tenk1.unique1, tenk1.unique2, tenk1.tenthous + -> Remote Subquery Scan on all (datanode_1,datanode_2) + Output: tenk1.unique1, tenk1.unique2, tenk1.tenthous + Sort Key: tenk1.tenthous + -> Limit + Output: tenk1.unique1, tenk1.unique2, tenk1.tenthous -> Sort - Output: unique1, unique2, tenthous + Output: tenk1.unique1, tenk1.unique2, tenk1.tenthous Sort Key: tenk1.tenthous -> Seq Scan on public.tenk1 - Output: unique1, unique2, tenthous + Output: tenk1.unique1, tenk1.unique2, tenk1.tenthous (14 rows) -select unique1, unique2, nextval('testseq') - from tenk1 order by tenthous limit 10; +select *, nextval('testseq') from + (select unique1, unique2 from tenk1 order by tenthous limit 10) x; unique1 | unique2 | nextval ---------+---------+--------- 0 | 9998 | 11 diff --git a/src/test/regress/expected/xl_known_bugs.out b/src/test/regress/expected/xl_known_bugs.out index 9575409d3b..e4a1b986f8 100644 --- a/src/test/regress/expected/xl_known_bugs.out +++ b/src/test/regress/expected/xl_known_bugs.out @@ -772,3 +772,87 @@ UPDATE xl_tmp drop table xl_tmp; drop table xl_onek; ------------------------------------------ +-- When nextval is pushed down the datanode, currval may not be set on the +-- coordinator (or can be stale). This case is picked up from 'limit' test case, +-- which is modified to suit XL's current behaviour +create temp sequence testseq; +explain (verbose, costs off) +select unique1, unique2, nextval('testseq') + from tenk1 order by unique2 limit 10; + QUERY PLAN +---------------------------------------------------------------------------- + Limit + Output: unique1, unique2, (nextval('testseq'::regclass)) + -> Remote Subquery Scan on all (datanode_1,datanode_2) + Output: unique1, unique2, nextval('testseq'::regclass) + Sort Key: tenk1.unique2 + -> Limit + Output: unique1, unique2, (nextval('testseq'::regclass)) + -> Index Scan using tenk1_unique2 on public.tenk1 + Output: unique1, unique2, nextval('testseq'::regclass) +(9 rows) + +select unique1, unique2, nextval('testseq') + from tenk1 order by unique2 limit 10; + unique1 | unique2 | nextval +---------+---------+--------- + 8800 | 0 | 1 + 1891 | 1 | 2 + 3420 | 2 | 3 + 9850 | 3 | 4 + 7164 | 4 | 5 + 8009 | 5 | 6 + 5057 | 6 | 7 + 6701 | 7 | 8 + 4321 | 8 | 9 + 3043 | 9 | 10 +(10 rows) + +select currval('testseq'); + currval +--------- + 10 +(1 row) + +explain (verbose, costs off) +select unique1, unique2, nextval('testseq') + from tenk1 order by tenthous limit 10; + QUERY PLAN +-------------------------------------------------------------------------------------- + Limit + Output: unique1, unique2, (nextval('testseq'::regclass)), tenthous + -> Remote Subquery Scan on all (datanode_1,datanode_2) + Output: unique1, unique2, nextval('testseq'::regclass), tenthous + Sort Key: tenk1.tenthous + -> Limit + Output: unique1, unique2, (nextval('testseq'::regclass)), tenthous + -> Result + Output: unique1, unique2, nextval('testseq'::regclass), tenthous + -> Sort + Output: unique1, unique2, tenthous + Sort Key: tenk1.tenthous + -> Seq Scan on public.tenk1 + Output: unique1, unique2, tenthous +(14 rows) + +select unique1, unique2, nextval('testseq') + from tenk1 order by tenthous limit 10; + unique1 | unique2 | nextval +---------+---------+--------- + 0 | 9998 | 11 + 1 | 2838 | 12 + 2 | 2716 | 13 + 3 | 5679 | 14 + 4 | 1621 | 15 + 5 | 5557 | 16 + 6 | 2855 | 17 + 7 | 8518 | 18 + 8 | 5435 | 19 + 9 | 4463 | 20 +(10 rows) + +select currval('testseq'); + currval +--------- + 20 +(1 row) diff --git a/src/test/regress/sql/limit.sql b/src/test/regress/sql/limit.sql index f9b2fe5c00..a87dfc8ef1 100644 --- a/src/test/regress/sql/limit.sql +++ b/src/test/regress/sql/limit.sql @@ -88,22 +88,26 @@ SELECT -- create temp sequence testseq; - +-- XL: The query has been slightly modified to suit XL's execution mechanism +-- when nextval is pushed down to the remote node. Using a subquery gives +-- consistent results and also ensures currval() returns correct value (since +-- nextval gets executed on the coordinator). The original two tests are +-- copied to xl_known_bugs test case explain (verbose, costs off) -select unique1, unique2, nextval('testseq') - from tenk1 order by unique2 limit 10; +select *, nextval('testseq') from + (select unique1, unique2 from tenk1 order by unique2 limit 10) x; -select unique1, unique2, nextval('testseq') - from tenk1 order by unique2 limit 10; +select *, nextval('testseq') from + (select unique1, unique2 from tenk1 order by unique2 limit 10) x; select currval('testseq'); explain (verbose, costs off) -select unique1, unique2, nextval('testseq') - from tenk1 order by tenthous limit 10; +select *, nextval('testseq') from + (select unique1, unique2 from tenk1 order by tenthous limit 10) x; -select unique1, unique2, nextval('testseq') - from tenk1 order by tenthous limit 10; +select *, nextval('testseq') from + (select unique1, unique2 from tenk1 order by tenthous limit 10) x; select currval('testseq'); diff --git a/src/test/regress/sql/xl_known_bugs.sql b/src/test/regress/sql/xl_known_bugs.sql index d2a74a0c79..4dc6ca94d0 100644 --- a/src/test/regress/sql/xl_known_bugs.sql +++ b/src/test/regress/sql/xl_known_bugs.sql @@ -336,3 +336,24 @@ drop table xl_tmp; drop table xl_onek; ------------------------------------------ + +-- When nextval is pushed down the datanode, currval may not be set on the +-- coordinator (or can be stale). This case is picked up from 'limit' test case, +-- which is modified to suit XL's current behaviour +create temp sequence testseq; + +explain (verbose, costs off) +select unique1, unique2, nextval('testseq') + from tenk1 order by unique2 limit 10; + +select unique1, unique2, nextval('testseq') + from tenk1 order by unique2 limit 10; + +select currval('testseq'); + +explain (verbose, costs off) +select unique1, unique2, nextval('testseq') + from tenk1 order by tenthous limit 10; + +select unique1, unique2, nextval('testseq') + from tenk1 order by tenthous limit 10;