From 2750e71ceeebf9abdca83007a03b6ff7aef8a3ff Mon Sep 17 00:00:00 2001 From: Jason Kim Date: Wed, 3 Jul 2024 14:34:14 -0700 Subject: [PATCH] [pg15] test: fully port regress yb_pg_select Summary: Fully port regress test select to yb_pg_select. Make use of yb_use_hash_splitting_by_default=false and compute_query_id=regress, now set by default for ported tests. Of particular note is that some YB bitmap table scans output rows in a different order from upstream PG. I am not aware of the cause, but I assume it has to do with how YB's bitmap scan internals are different. Add new yb_dep_int8_tbl for support. Test Plan: On Almalinux 8: #!/usr/bin/env bash set -eu ./yb_build.sh fastdebug --gcc11 yes "$(grep 'PgSelect$' pg15_tests/passing_tests.tsv)" | head -50 | pg15_tests/run_tests.sh Depends on D36352 Jenkins: rebase: pg15, test regex: TestPgRegressPgSelect Reviewers: aagrawal, fizaa, tfoucher Reviewed By: aagrawal Subscribers: yql Differential Revision: https://phorge.dev.yugabyte.com/D36354 --- .../org/yb/pgsql/TestPgRegressPgSelect.java | 2 +- .../test/regress/expected/yb_dep_int8_tbl.out | 19 + .../test/regress/expected/yb_pg_select.out | 349 +++++++++++++++--- .../src/test/regress/sql/yb_dep_int8_tbl.sql | 21 ++ .../src/test/regress/sql/yb_pg_select.sql | 113 +++++- .../src/test/regress/yb_pg_select_schedule | 1 + 6 files changed, 438 insertions(+), 67 deletions(-) create mode 100644 src/postgres/src/test/regress/expected/yb_dep_int8_tbl.out create mode 100644 src/postgres/src/test/regress/sql/yb_dep_int8_tbl.sql diff --git a/java/yb-pgsql/src/test/java/org/yb/pgsql/TestPgRegressPgSelect.java b/java/yb-pgsql/src/test/java/org/yb/pgsql/TestPgRegressPgSelect.java index 4489e880bbe0..a7b2bb6174b6 100644 --- a/java/yb-pgsql/src/test/java/org/yb/pgsql/TestPgRegressPgSelect.java +++ b/java/yb-pgsql/src/test/java/org/yb/pgsql/TestPgRegressPgSelect.java @@ -20,7 +20,7 @@ * Runs the pg_regress test suite on YB code. */ @RunWith(value=YBTestRunner.class) -public class TestPgRegressPgSelect extends BasePgRegressTest { +public class TestPgRegressPgSelect extends BasePgRegressTestPorted { @Override public int getTestMethodTimeoutSec() { return 600; diff --git a/src/postgres/src/test/regress/expected/yb_dep_int8_tbl.out b/src/postgres/src/test/regress/expected/yb_dep_int8_tbl.out new file mode 100644 index 000000000000..064827db679c --- /dev/null +++ b/src/postgres/src/test/regress/expected/yb_dep_int8_tbl.out @@ -0,0 +1,19 @@ +-- +-- A collection of queries to build the int8_tbl table. +-- +-- The queries are taken from the relevant dependency files. Since it is +-- faster to run this rather than each file itself (e.g. dependency chain +-- test_setup, create_index), prefer using this. +-- +-- +-- test_setup +-- +CREATE TABLE INT8_TBL(q1 int8, q2 int8); +INSERT INTO INT8_TBL VALUES + (' 123 ',' 456'), + ('123 ','4567890123456789'), + ('4567890123456789','123'), + (+4567890123456789,'4567890123456789'), + ('+4567890123456789','-4567890123456789'); +VACUUM INT8_TBL; +NOTICE: VACUUM is a no-op statement since YugabyteDB performs garbage collection of dead tuples automatically diff --git a/src/postgres/src/test/regress/expected/yb_pg_select.out b/src/postgres/src/test/regress/expected/yb_pg_select.out index b94922f2b208..6591d8e1870e 100644 --- a/src/postgres/src/test/regress/expected/yb_pg_select.out +++ b/src/postgres/src/test/regress/expected/yb_pg_select.out @@ -2,7 +2,7 @@ -- SELECT -- SET yb_enable_bitmapscan TO on; --- lsm index +-- btree index -- awk '{if($1<10){print;}else{next;}}' onek.data | sort +0n -1 -- SELECT * FROM onek @@ -216,9 +216,8 @@ SET enable_bitmapscan TO off; SET enable_sort TO off; -- -- awk '{if($1<10){print $0;}else{next;}}' onek.data | sort +0n -1 --- YB edit: add ORDER BY 1 for consistent ordering. -- -SELECT onek2.* FROM onek2 WHERE onek2.unique1 < 10 ORDER BY 1; +SELECT onek2.* FROM onek2 WHERE onek2.unique1 < 10; unique1 | unique2 | two | four | ten | twenty | hundred | thousand | twothousand | fivethous | tenthous | odd | even | stringu1 | stringu2 | string4 ---------+---------+-----+------+-----+--------+---------+----------+-------------+-----------+----------+-----+------+----------+----------+--------- 0 | 998 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | AAAAAA | KMBAAA | OOOOxx @@ -265,10 +264,9 @@ SELECT onek2.unique1, onek2.stringu1 FROM onek2 -- -- awk '{if($1>980){print $1,$14;}else{next;}}' onek.data | sort +1d -2 --- YB edit: add ORDER BY 1 for consistent ordering. -- SELECT onek2.unique1, onek2.stringu1 FROM onek2 - WHERE onek2.unique1 > 980 ORDER BY 1; + WHERE onek2.unique1 > 980; unique1 | stringu1 ---------+---------- 981 | TLAAAA @@ -295,6 +293,219 @@ SELECT onek2.unique1, onek2.stringu1 FROM onek2 RESET enable_seqscan; RESET enable_bitmapscan; RESET enable_sort; +-- +-- awk '{print $1,$2;}' person.data | +-- awk '{if(NF!=2){print $3,$2;}else{print;}}' - emp.data | +-- awk '{if(NF!=2){print $3,$2;}else{print;}}' - student.data | +-- awk 'BEGIN{FS=" ";}{if(NF!=2){print $4,$5;}else{print;}}' - stud_emp.data +-- +-- SELECT name, age FROM person*; ??? check if different +SELECT p.name, p.age FROM person* p; -- YB: output missing rows due to lack of INHERITS support + name | age +---------+----- + mike | 40 + joe | 20 + sally | 34 + sandra | 19 + alex | 30 + sue | 50 + denise | 24 + sarah | 88 + teresa | 38 + nan | 28 + leah | 68 + wendy | 78 + melissa | 28 + joan | 18 + mary | 8 + jane | 58 + liza | 38 + jean | 28 + jenifer | 38 + juanita | 58 + susan | 78 + zena | 98 + martie | 88 + chris | 78 + pat | 18 + zola | 58 + louise | 98 + edna | 18 + bertha | 88 + sumi | 38 + koko | 88 + gina | 18 + rean | 48 + sharon | 78 + paula | 68 + julie | 68 + belinda | 38 + karen | 48 + carina | 58 + diane | 18 + esther | 98 + trudy | 88 + fanny | 8 + carmen | 78 + lita | 25 + pamela | 48 + sandy | 38 + trisha | 88 + uma | 78 + velma | 68 +(50 rows) + +-- +-- awk '{print $1,$2;}' person.data | +-- awk '{if(NF!=2){print $3,$2;}else{print;}}' - emp.data | +-- awk '{if(NF!=2){print $3,$2;}else{print;}}' - student.data | +-- awk 'BEGIN{FS=" ";}{if(NF!=1){print $4,$5;}else{print;}}' - stud_emp.data | +-- sort +1nr -2 +-- +SELECT p.name, p.age FROM person* p ORDER BY age using >, name; -- YB: output missing rows due to lack of INHERITS support + name | age +---------+----- + esther | 98 + louise | 98 + zena | 98 + bertha | 88 + koko | 88 + martie | 88 + sarah | 88 + trisha | 88 + trudy | 88 + carmen | 78 + chris | 78 + sharon | 78 + susan | 78 + uma | 78 + wendy | 78 + julie | 68 + leah | 68 + paula | 68 + velma | 68 + carina | 58 + jane | 58 + juanita | 58 + zola | 58 + sue | 50 + karen | 48 + pamela | 48 + rean | 48 + mike | 40 + belinda | 38 + jenifer | 38 + liza | 38 + sandy | 38 + sumi | 38 + teresa | 38 + sally | 34 + alex | 30 + jean | 28 + melissa | 28 + nan | 28 + lita | 25 + denise | 24 + joe | 20 + sandra | 19 + diane | 18 + edna | 18 + gina | 18 + joan | 18 + pat | 18 + fanny | 8 + mary | 8 +(50 rows) + +-- +-- Test some cases involving whole-row Var referencing a subquery +-- +select foo from (select 1 offset 0) as foo; + foo +----- + (1) +(1 row) + +select foo from (select null offset 0) as foo; + foo +----- + () +(1 row) + +select foo from (select 'xyzzy',1,null offset 0) as foo; + foo +------------ + (xyzzy,1,) +(1 row) + +-- +-- Test VALUES lists +-- +select * from onek, (values(147, 'RFAAAA'), (931, 'VJAAAA')) as v (i, j) + WHERE onek.unique1 = v.i and onek.stringu1 = v.j; + unique1 | unique2 | two | four | ten | twenty | hundred | thousand | twothousand | fivethous | tenthous | odd | even | stringu1 | stringu2 | string4 | i | j +---------+---------+-----+------+-----+--------+---------+----------+-------------+-----------+----------+-----+------+----------+----------+---------+-----+-------- + 147 | 0 | 1 | 3 | 7 | 7 | 7 | 47 | 147 | 147 | 147 | 14 | 15 | RFAAAA | AAAAAA | AAAAxx | 147 | RFAAAA + 931 | 1 | 1 | 3 | 1 | 11 | 1 | 31 | 131 | 431 | 931 | 2 | 3 | VJAAAA | BAAAAA | HHHHxx | 931 | VJAAAA +(2 rows) + +-- a more complex case +-- looks like we're coding lisp :-) +select * from onek, + (values ((select i from + (values(10000), (2), (389), (1000), (2000), ((select 10029))) as foo(i) + order by i asc limit 1))) bar (i) + where onek.unique1 = bar.i; + unique1 | unique2 | two | four | ten | twenty | hundred | thousand | twothousand | fivethous | tenthous | odd | even | stringu1 | stringu2 | string4 | i +---------+---------+-----+------+-----+--------+---------+----------+-------------+-----------+----------+-----+------+----------+----------+---------+--- + 2 | 326 | 0 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 4 | 5 | CAAAAA | OMAAAA | OOOOxx | 2 +(1 row) + +-- try VALUES in a subquery +select * from onek + where (unique1,ten) in (values (1,1), (20,0), (99,9), (17,99)) + order by unique1; + unique1 | unique2 | two | four | ten | twenty | hundred | thousand | twothousand | fivethous | tenthous | odd | even | stringu1 | stringu2 | string4 +---------+---------+-----+------+-----+--------+---------+----------+-------------+-----------+----------+-----+------+----------+----------+--------- + 1 | 214 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 2 | 3 | BAAAAA | GIAAAA | OOOOxx + 20 | 306 | 0 | 0 | 0 | 0 | 0 | 20 | 20 | 20 | 20 | 0 | 1 | UAAAAA | ULAAAA | OOOOxx + 99 | 101 | 1 | 3 | 9 | 19 | 9 | 99 | 99 | 99 | 99 | 18 | 19 | VDAAAA | XDAAAA | HHHHxx +(3 rows) + +-- VALUES is also legal as a standalone query or a set-operation member +VALUES (1,2), (3,4+4), (7,77.7); + column1 | column2 +---------+--------- + 1 | 2 + 3 | 8 + 7 | 77.7 +(3 rows) + +VALUES (1,2), (3,4+4), (7,77.7) +UNION ALL +SELECT 2+2, 57 +UNION ALL +TABLE int8_tbl; + column1 | column2 +------------------+------------------- + 1 | 2 + 3 | 8 + 7 | 77.7 + 4 | 57 + 123 | 456 + 123 | 4567890123456789 + 4567890123456789 | 123 + 4567890123456789 | 4567890123456789 + 4567890123456789 | -4567890123456789 +(9 rows) + +-- corner case: VALUES with no columns +CREATE TEMP TABLE nocols(); +INSERT INTO nocols DEFAULT VALUES; +SELECT * FROM nocols n, LATERAL (VALUES(n.*)) v; +-- +(1 row) + -- -- Test ORDER BY options -- @@ -635,61 +846,107 @@ select unique2 from onek2 where unique2 = 11 and stringu1 < 'B'; RESET enable_indexscan; -- check multi-index cases too --- YB edit: add "ORDER BY unique2" for consistent ordering. explain (costs off) -SELECT * FROM ( select unique1, unique2 from onek2 - where (unique2 = 11 or unique1 = 0) and stringu1 < 'B' -LIMIT ALL) ybview ORDER BY unique2; - QUERY PLAN ------------------------------------------------------- - Sort - Sort Key: onek2.unique2 - -> YB Bitmap Table Scan on onek2 - Storage Filter: (stringu1 < 'B'::name) - -> BitmapOr - -> Bitmap Index Scan on onek2_u2_prtl - Index Cond: (unique2 = 11) - -> Bitmap Index Scan on onek2_u1_prtl - Index Cond: (unique1 = 0) -(9 rows) + where (unique2 = 11 or unique1 = 0) and stringu1 < 'B'; + QUERY PLAN +------------------------------------------------ + YB Bitmap Table Scan on onek2 + Storage Filter: (stringu1 < 'B'::name) + -> BitmapOr + -> Bitmap Index Scan on onek2_u2_prtl + Index Cond: (unique2 = 11) + -> Bitmap Index Scan on onek2_u1_prtl + Index Cond: (unique1 = 0) +(7 rows) -SELECT * FROM ( select unique1, unique2 from onek2 - where (unique2 = 11 or unique1 = 0) and stringu1 < 'B' -LIMIT ALL) ybview ORDER BY unique2; + where (unique2 = 11 or unique1 = 0) and stringu1 < 'B'; unique1 | unique2 ---------+--------- - 494 | 11 0 | 998 + 494 | 11 (2 rows) --- YB edit: add "ORDER BY unique2" for consistent ordering. explain (costs off) -SELECT * FROM ( select unique1, unique2 from onek2 - where (unique2 = 11 and stringu1 < 'B') or unique1 = 0 -LIMIT ALL) ybview ORDER BY unique2; - QUERY PLAN ------------------------------------------------------- - Sort - Sort Key: onek2.unique2 - -> YB Bitmap Table Scan on onek2 - -> BitmapOr - -> Bitmap Index Scan on onek2_u2_prtl - Index Cond: (unique2 = 11) - -> Bitmap Index Scan on onek2_u1_prtl - Index Cond: (unique1 = 0) -(8 rows) - -SELECT * FROM ( + where (unique2 = 11 and stringu1 < 'B') or unique1 = 0; + QUERY PLAN +------------------------------------------------ + YB Bitmap Table Scan on onek2 + -> BitmapOr + -> Bitmap Index Scan on onek2_u2_prtl + Index Cond: (unique2 = 11) + -> Bitmap Index Scan on onek2_u1_prtl + Index Cond: (unique1 = 0) +(6 rows) + select unique1, unique2 from onek2 - where (unique2 = 11 and stringu1 < 'B') or unique1 = 0 -LIMIT ALL) ybview ORDER BY unique2; + where (unique2 = 11 and stringu1 < 'B') or unique1 = 0; unique1 | unique2 ---------+--------- - 494 | 11 0 | 998 + 494 | 11 +(2 rows) + +-- +-- Test some corner cases that have been known to confuse the planner +-- +-- ORDER BY on a constant doesn't really need any sorting +SELECT 1 AS x ORDER BY x; + x +--- + 1 +(1 row) + +-- But ORDER BY on a set-valued expression does +create function sillysrf(int) returns setof int as + 'values (1),(10),(2),($1)' language sql immutable; +select sillysrf(42); + sillysrf +---------- + 1 + 10 + 2 + 42 +(4 rows) + +select sillysrf(-1) order by 1; + sillysrf +---------- + -1 + 1 + 2 + 10 +(4 rows) + +drop function sillysrf(int); +-- X = X isn't a no-op, it's effectively X IS NOT NULL assuming = is strict +-- (see bug #5084) +select * from (values (2),(null),(1)) v(k) where k = k order by k; + k +--- + 1 + 2 +(2 rows) + +select * from (values (2),(null),(1)) v(k) where k = k; + k +--- + 2 + 1 +(2 rows) + +-- Test partitioned tables with no partitions, which should be handled the +-- same as the non-inheritance case when expanding its RTE. +create table list_parted_tbl (a int,b int) partition by list (a); +create table list_parted_tbl1 partition of list_parted_tbl + for values in (1) partition by list(b); +explain (costs off) select * from list_parted_tbl; + QUERY PLAN +-------------------------- + Result + One-Time Filter: false (2 rows) -RESET yb_enable_bitmapscan; +drop table list_parted_tbl; diff --git a/src/postgres/src/test/regress/sql/yb_dep_int8_tbl.sql b/src/postgres/src/test/regress/sql/yb_dep_int8_tbl.sql new file mode 100644 index 000000000000..2f88dc54d9c1 --- /dev/null +++ b/src/postgres/src/test/regress/sql/yb_dep_int8_tbl.sql @@ -0,0 +1,21 @@ +-- +-- A collection of queries to build the int8_tbl table. +-- +-- The queries are taken from the relevant dependency files. Since it is +-- faster to run this rather than each file itself (e.g. dependency chain +-- test_setup, create_index), prefer using this. +-- + +-- +-- test_setup +-- + +CREATE TABLE INT8_TBL(q1 int8, q2 int8); + +INSERT INTO INT8_TBL VALUES + (' 123 ',' 456'), + ('123 ','4567890123456789'), + ('4567890123456789','123'), + (+4567890123456789,'4567890123456789'), + ('+4567890123456789','-4567890123456789'); +VACUUM INT8_TBL; diff --git a/src/postgres/src/test/regress/sql/yb_pg_select.sql b/src/postgres/src/test/regress/sql/yb_pg_select.sql index c2e887a33dbf..ed795dc2a009 100644 --- a/src/postgres/src/test/regress/sql/yb_pg_select.sql +++ b/src/postgres/src/test/regress/sql/yb_pg_select.sql @@ -3,7 +3,7 @@ -- SET yb_enable_bitmapscan TO on; --- lsm index +-- btree index -- awk '{if($1<10){print;}else{next;}}' onek.data | sort +0n -1 -- SELECT * FROM onek @@ -71,9 +71,8 @@ SET enable_sort TO off; -- -- awk '{if($1<10){print $0;}else{next;}}' onek.data | sort +0n -1 --- YB edit: add ORDER BY 1 for consistent ordering. -- -SELECT onek2.* FROM onek2 WHERE onek2.unique1 < 10 ORDER BY 1; +SELECT onek2.* FROM onek2 WHERE onek2.unique1 < 10; -- -- awk '{if($1<20){print $1,$14;}else{next;}}' onek.data | sort +0nr -1 @@ -84,15 +83,72 @@ SELECT onek2.unique1, onek2.stringu1 FROM onek2 -- -- awk '{if($1>980){print $1,$14;}else{next;}}' onek.data | sort +1d -2 --- YB edit: add ORDER BY 1 for consistent ordering. -- SELECT onek2.unique1, onek2.stringu1 FROM onek2 - WHERE onek2.unique1 > 980 ORDER BY 1; + WHERE onek2.unique1 > 980; RESET enable_seqscan; RESET enable_bitmapscan; RESET enable_sort; +-- +-- awk '{print $1,$2;}' person.data | +-- awk '{if(NF!=2){print $3,$2;}else{print;}}' - emp.data | +-- awk '{if(NF!=2){print $3,$2;}else{print;}}' - student.data | +-- awk 'BEGIN{FS=" ";}{if(NF!=2){print $4,$5;}else{print;}}' - stud_emp.data +-- +-- SELECT name, age FROM person*; ??? check if different +SELECT p.name, p.age FROM person* p; -- YB: output missing rows due to lack of INHERITS support + +-- +-- awk '{print $1,$2;}' person.data | +-- awk '{if(NF!=2){print $3,$2;}else{print;}}' - emp.data | +-- awk '{if(NF!=2){print $3,$2;}else{print;}}' - student.data | +-- awk 'BEGIN{FS=" ";}{if(NF!=1){print $4,$5;}else{print;}}' - stud_emp.data | +-- sort +1nr -2 +-- +SELECT p.name, p.age FROM person* p ORDER BY age using >, name; -- YB: output missing rows due to lack of INHERITS support + +-- +-- Test some cases involving whole-row Var referencing a subquery +-- +select foo from (select 1 offset 0) as foo; +select foo from (select null offset 0) as foo; +select foo from (select 'xyzzy',1,null offset 0) as foo; + +-- +-- Test VALUES lists +-- +select * from onek, (values(147, 'RFAAAA'), (931, 'VJAAAA')) as v (i, j) + WHERE onek.unique1 = v.i and onek.stringu1 = v.j; + +-- a more complex case +-- looks like we're coding lisp :-) +select * from onek, + (values ((select i from + (values(10000), (2), (389), (1000), (2000), ((select 10029))) as foo(i) + order by i asc limit 1))) bar (i) + where onek.unique1 = bar.i; + +-- try VALUES in a subquery +select * from onek + where (unique1,ten) in (values (1,1), (20,0), (99,9), (17,99)) + order by unique1; + +-- VALUES is also legal as a standalone query or a set-operation member +VALUES (1,2), (3,4+4), (7,77.7); + +VALUES (1,2), (3,4+4), (7,77.7) +UNION ALL +SELECT 2+2, 57 +UNION ALL +TABLE int8_tbl; + +-- corner case: VALUES with no columns +CREATE TEMP TABLE nocols(); +INSERT INTO nocols DEFAULT VALUES; +SELECT * FROM nocols n, LATERAL (VALUES(n.*)) v; + -- -- Test ORDER BY options -- @@ -168,25 +224,42 @@ select unique2 from onek2 where unique2 = 11 and stringu1 < 'B'; select unique2 from onek2 where unique2 = 11 and stringu1 < 'B'; RESET enable_indexscan; -- check multi-index cases too --- YB edit: add "ORDER BY unique2" for consistent ordering. explain (costs off) -SELECT * FROM ( select unique1, unique2 from onek2 - where (unique2 = 11 or unique1 = 0) and stringu1 < 'B' -LIMIT ALL) ybview ORDER BY unique2; -SELECT * FROM ( + where (unique2 = 11 or unique1 = 0) and stringu1 < 'B'; select unique1, unique2 from onek2 - where (unique2 = 11 or unique1 = 0) and stringu1 < 'B' -LIMIT ALL) ybview ORDER BY unique2; --- YB edit: add "ORDER BY unique2" for consistent ordering. + where (unique2 = 11 or unique1 = 0) and stringu1 < 'B'; explain (costs off) -SELECT * FROM ( select unique1, unique2 from onek2 - where (unique2 = 11 and stringu1 < 'B') or unique1 = 0 -LIMIT ALL) ybview ORDER BY unique2; -SELECT * FROM ( + where (unique2 = 11 and stringu1 < 'B') or unique1 = 0; select unique1, unique2 from onek2 - where (unique2 = 11 and stringu1 < 'B') or unique1 = 0 -LIMIT ALL) ybview ORDER BY unique2; + where (unique2 = 11 and stringu1 < 'B') or unique1 = 0; + +-- +-- Test some corner cases that have been known to confuse the planner +-- + +-- ORDER BY on a constant doesn't really need any sorting +SELECT 1 AS x ORDER BY x; + +-- But ORDER BY on a set-valued expression does +create function sillysrf(int) returns setof int as + 'values (1),(10),(2),($1)' language sql immutable; + +select sillysrf(42); +select sillysrf(-1) order by 1; + +drop function sillysrf(int); + +-- X = X isn't a no-op, it's effectively X IS NOT NULL assuming = is strict +-- (see bug #5084) +select * from (values (2),(null),(1)) v(k) where k = k order by k; +select * from (values (2),(null),(1)) v(k) where k = k; -RESET yb_enable_bitmapscan; +-- Test partitioned tables with no partitions, which should be handled the +-- same as the non-inheritance case when expanding its RTE. +create table list_parted_tbl (a int,b int) partition by list (a); +create table list_parted_tbl1 partition of list_parted_tbl + for values in (1) partition by list(b); +explain (costs off) select * from list_parted_tbl; +drop table list_parted_tbl; diff --git a/src/postgres/src/test/regress/yb_pg_select_schedule b/src/postgres/src/test/regress/yb_pg_select_schedule index 328c2217d54a..d0e7155b25bf 100644 --- a/src/postgres/src/test/regress/yb_pg_select_schedule +++ b/src/postgres/src/test/regress/yb_pg_select_schedule @@ -6,6 +6,7 @@ ############################################################################### # Dependencies. test: yb_dep_int4_tbl +test: yb_dep_int8_tbl test: yb_dep_onek test: yb_dep_tenk1 test: yb_dep_person