external
/
citus
mirror of https://github.com/citusdata/citus.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

PG18 - Add BUFFERS OFF to EXPLAIN ANALYZE calls (#8101) 

Relevant PG18 commit:
c2a4078eba
- Enable buffer-usage reporting by default in `EXPLAIN ANALYZE` on
PostgreSQL 18 and above.

Solution:
- Introduce the explicit `BUFFERS OFF` option in every existing
regression test to maintain pre-PG18 output consistency.
- This appends, `BUFFERS OFF` to all `EXPLAIN ANALYZE(...)` calls in
src/test/regress/sql and the corresponding .out files.

fixes #8093
pull/8141/head
Mehmet YILMAZ 2025-08-21 13:48:50 +03:00 committed by GitHub
parent 683ead9607
commit f1f0b09f73
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
40 changed files with 202 additions and 202 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/test/regress/expected/binary_protocol.out
View File

@ -49,7 +49,7 @@ SELECT id, id, id, id, id,
10 | 10 | 10 | 10 | 10 | 10 | 10 | 10 | 10 | 10 | 10 | 10 | 10 | 10 | 10 | 10 | 10 | 10 | 10 | 10 | 10 | 10 | 10 | 10 | 10 | 10 | 10 | 10 | 10 | 10
(10 rows)
EXPLAIN (ANALYZE TRUE, TIMING FALSE, COSTS FALSE, SUMMARY FALSE) SELECT id FROM t ORDER BY 1;
EXPLAIN (ANALYZE TRUE, TIMING FALSE, COSTS FALSE, SUMMARY FALSE, BUFFERS OFF) SELECT id FROM t ORDER BY 1;
QUERY PLAN
---------------------------------------------------------------------
Sort (actual rows=10 loops=1)
@ -66,7 +66,7 @@ EXPLAIN (ANALYZE TRUE, TIMING FALSE, COSTS FALSE, SUMMARY FALSE) SELECT id FROM
(11 rows)
SET citus.explain_all_tasks TO ON;
EXPLAIN (ANALYZE TRUE, TIMING FALSE, COSTS FALSE, SUMMARY FALSE) SELECT id FROM t ORDER BY 1;
EXPLAIN (ANALYZE TRUE, TIMING FALSE, COSTS FALSE, SUMMARY FALSE, BUFFERS OFF) SELECT id FROM t ORDER BY 1;
QUERY PLAN
---------------------------------------------------------------------
Sort (actual rows=10 loops=1)

52
src/test/regress/expected/columnar_chunk_filtering.out
View File

@ -125,7 +125,7 @@ SELECT * FROM collation_chunk_filtering_test WHERE A > 'B';
CREATE TABLE simple_chunk_filtering(i int) USING COLUMNAR;
INSERT INTO simple_chunk_filtering SELECT generate_series(0,234567);
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM simple_chunk_filtering WHERE i > 123456;
QUERY PLAN
---------------------------------------------------------------------
@ -138,7 +138,7 @@ EXPLAIN (analyze on, costs off, timing off, summary off)
(6 rows)
SET columnar.enable_qual_pushdown = false;
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM simple_chunk_filtering WHERE i > 123456;
QUERY PLAN
---------------------------------------------------------------------
@ -153,7 +153,7 @@ SET columnar.enable_qual_pushdown TO DEFAULT;
TRUNCATE simple_chunk_filtering;
INSERT INTO simple_chunk_filtering SELECT generate_series(0,200000);
COPY (SELECT * FROM simple_chunk_filtering WHERE i > 180000) TO '/dev/null';
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM simple_chunk_filtering WHERE i > 180000;
QUERY PLAN
---------------------------------------------------------------------
@ -168,7 +168,7 @@ EXPLAIN (analyze on, costs off, timing off, summary off)
DROP TABLE simple_chunk_filtering;
CREATE TABLE multi_column_chunk_filtering(a int, b int) USING columnar;
INSERT INTO multi_column_chunk_filtering SELECT i,i+1 FROM generate_series(0,234567) i;
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT count(*) FROM multi_column_chunk_filtering WHERE a > 50000;
QUERY PLAN
---------------------------------------------------------------------
@ -181,7 +181,7 @@ EXPLAIN (analyze on, costs off, timing off, summary off)
Columnar Chunk Groups Removed by Filter: 5
(7 rows)
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT count(*) FROM multi_column_chunk_filtering WHERE a > 50000 AND b > 50000;
QUERY PLAN
---------------------------------------------------------------------
@ -197,7 +197,7 @@ EXPLAIN (analyze on, costs off, timing off, summary off)
-- make next tests faster
TRUNCATE multi_column_chunk_filtering;
INSERT INTO multi_column_chunk_filtering SELECT generate_series(0,5);
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT b FROM multi_column_chunk_filtering WHERE a > 50000 AND b > 50000;
QUERY PLAN
---------------------------------------------------------------------
@ -208,7 +208,7 @@ EXPLAIN (analyze on, costs off, timing off, summary off)
Columnar Chunk Groups Removed by Filter: 1
(5 rows)
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT b, a FROM multi_column_chunk_filtering WHERE b > 50000;
QUERY PLAN
---------------------------------------------------------------------
@ -220,7 +220,7 @@ EXPLAIN (analyze on, costs off, timing off, summary off)
Columnar Chunk Groups Removed by Filter: 0
(6 rows)
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT FROM multi_column_chunk_filtering WHERE a > 50000;
QUERY PLAN
---------------------------------------------------------------------
@ -231,7 +231,7 @@ EXPLAIN (analyze on, costs off, timing off, summary off)
Columnar Chunk Groups Removed by Filter: 1
(5 rows)
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT FROM multi_column_chunk_filtering;
QUERY PLAN
---------------------------------------------------------------------
@ -242,7 +242,7 @@ EXPLAIN (analyze on, costs off, timing off, summary off)
BEGIN;
ALTER TABLE multi_column_chunk_filtering DROP COLUMN a;
ALTER TABLE multi_column_chunk_filtering DROP COLUMN b;
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM multi_column_chunk_filtering;
QUERY PLAN
---------------------------------------------------------------------
@ -253,7 +253,7 @@ BEGIN;
ROLLBACK;
CREATE TABLE another_columnar_table(x int, y int) USING columnar;
INSERT INTO another_columnar_table SELECT generate_series(0,5);
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT a, y FROM multi_column_chunk_filtering, another_columnar_table WHERE x > 1;
QUERY PLAN
---------------------------------------------------------------------
@ -364,7 +364,7 @@ set enable_mergejoin=false;
set enable_hashjoin=false;
set enable_material=false;
-- test different kinds of expressions
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM r1, coltest WHERE
id1 = id AND x1 > 15000 AND x1::text > '000000' AND n1 % 10 = 0;
QUERY PLAN
@ -391,7 +391,7 @@ SELECT * FROM r1, coltest WHERE
(3 rows)
-- test equivalence classes
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM r1, r2, r3, r4, r5, r6, r7, coltest WHERE
id = id1 AND id1 = id2 AND id2 = id3 AND id3 = id4 AND
id4 = id5 AND id5 = id6 AND id6 = id7;
@ -561,7 +561,7 @@ set columnar.max_custom_scan_paths to default;
set columnar.planner_debug_level to default;
-- test more complex parameterization
set columnar.planner_debug_level = 'notice';
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM r1, r2, r3, coltest WHERE
id1 = id2 AND id2 = id3 AND id3 = id AND
n1 > x1 AND n2 > x2 AND n3 > x3;
@ -613,7 +613,7 @@ SELECT * FROM r1, r2, r3, coltest WHERE
(3 rows)
-- test partitioning parameterization
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM r1, coltest_part WHERE
id1 = id AND n1 > x1;
QUERY PLAN
@ -680,7 +680,7 @@ DETAIL: unparameterized; 0 clauses pushed down
---------------------------------------------------------------------
(0 rows)
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM coltest c1 WHERE ceil(x1) > 4222;
NOTICE: columnar planner: cannot push down clause: must match 'Var <op> Expr' or 'Expr <op> Var'
HINT: Var must only reference this rel, and Expr must not reference this rel
@ -832,7 +832,7 @@ BEGIN;
COMMIT;
SET columnar.max_custom_scan_paths TO 50;
SET columnar.qual_pushdown_correlation_threshold TO 0.0;
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT sum(a) FROM pushdown_test WHERE a = 204356 or a = 104356 or a = 76556;
NOTICE: columnar planner: adding CustomScan path for pushdown_test
DETAIL: unparameterized; 1 clauses pushed down
@ -855,7 +855,7 @@ DETAIL: unparameterized; 1 clauses pushed down
180912
(1 row)
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT sum(a) FROM pushdown_test WHERE a = 194356 or a = 104356 or a = 76556;
NOTICE: columnar planner: adding CustomScan path for pushdown_test
DETAIL: unparameterized; 1 clauses pushed down
@ -878,7 +878,7 @@ DETAIL: unparameterized; 1 clauses pushed down
375268
(1 row)
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT sum(a) FROM pushdown_test WHERE a = 204356 or a > a*-1 + b;
NOTICE: columnar planner: cannot push down clause: must match 'Var <op> Expr' or 'Expr <op> Var'
HINT: Var must only reference this rel, and Expr must not reference this rel
@ -894,7 +894,7 @@ DETAIL: unparameterized; 0 clauses pushed down
Columnar Projected Columns: a, b
(5 rows)
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT sum(a) FROM pushdown_test where (a > 1000 and a < 10000) or (a > 20000 and a < 50000);
NOTICE: columnar planner: adding CustomScan path for pushdown_test
DETAIL: unparameterized; 1 clauses pushed down
@ -917,7 +917,7 @@ DETAIL: unparameterized; 1 clauses pushed down
1099459500
(1 row)
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT sum(a) FROM pushdown_test where (a > random() and a < 2*a) or (a > 100);
NOTICE: columnar planner: cannot push down clause: must match 'Var <op> Expr' or 'Expr <op> Var'
HINT: Var must only reference this rel, and Expr must not reference this rel
@ -949,7 +949,7 @@ DETAIL: unparameterized; 0 clauses pushed down
20000100000
(1 row)
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT sum(a) FROM pushdown_test where (a > random() and a <= 2000) or (a > 200000-1010);
NOTICE: columnar planner: cannot push down clause: must match 'Var <op> Expr' or 'Expr <op> Var'
HINT: Var must only reference this rel, and Expr must not reference this rel
@ -978,7 +978,7 @@ DETAIL: unparameterized; 1 clauses pushed down
SET hash_mem_multiplier = 1.0;
SELECT columnar_test_helpers.explain_with_pg16_subplan_format($Q$
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT sum(a) FROM pushdown_test where
(
a > random()
@ -1043,7 +1043,7 @@ DETAIL: unparameterized; 1 clauses pushed down
create function stable_1(arg int) returns int language plpgsql STRICT IMMUTABLE as
$$ BEGIN RETURN 1+arg; END; $$;
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT sum(a) FROM pushdown_test where (a = random() and a < stable_1(a) and a < stable_1(6000));
NOTICE: columnar planner: cannot push down clause: must match 'Var <op> Expr' or 'Expr <op> Var'
HINT: Var must only reference this rel, and Expr must not reference this rel
@ -1096,7 +1096,7 @@ BEGIN;
INSERT INTO pushdown_test VALUES(7, 'USA');
INSERT INTO pushdown_test VALUES(8, 'ZW');
END;
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT id FROM pushdown_test WHERE country IN ('USA', 'BR', 'ZW');
QUERY PLAN
---------------------------------------------------------------------
@ -1123,7 +1123,7 @@ BEGIN
return 'AL';
END;
$$;
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM pushdown_test WHERE country IN ('USA', 'ZW', volatileFunction());
QUERY PLAN
---------------------------------------------------------------------

52
src/test/regress/expected/columnar_chunk_filtering_0.out
View File

@ -125,7 +125,7 @@ SELECT * FROM collation_chunk_filtering_test WHERE A > 'B';
CREATE TABLE simple_chunk_filtering(i int) USING COLUMNAR;
INSERT INTO simple_chunk_filtering SELECT generate_series(0,234567);
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM simple_chunk_filtering WHERE i > 123456;
QUERY PLAN
---------------------------------------------------------------------
@ -138,7 +138,7 @@ EXPLAIN (analyze on, costs off, timing off, summary off)
(6 rows)
SET columnar.enable_qual_pushdown = false;
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM simple_chunk_filtering WHERE i > 123456;
QUERY PLAN
---------------------------------------------------------------------
@ -153,7 +153,7 @@ SET columnar.enable_qual_pushdown TO DEFAULT;
TRUNCATE simple_chunk_filtering;
INSERT INTO simple_chunk_filtering SELECT generate_series(0,200000);
COPY (SELECT * FROM simple_chunk_filtering WHERE i > 180000) TO '/dev/null';
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM simple_chunk_filtering WHERE i > 180000;
QUERY PLAN
---------------------------------------------------------------------
@ -168,7 +168,7 @@ EXPLAIN (analyze on, costs off, timing off, summary off)
DROP TABLE simple_chunk_filtering;
CREATE TABLE multi_column_chunk_filtering(a int, b int) USING columnar;
INSERT INTO multi_column_chunk_filtering SELECT i,i+1 FROM generate_series(0,234567) i;
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT count(*) FROM multi_column_chunk_filtering WHERE a > 50000;
QUERY PLAN
---------------------------------------------------------------------
@ -181,7 +181,7 @@ EXPLAIN (analyze on, costs off, timing off, summary off)
Columnar Chunk Groups Removed by Filter: 5
(7 rows)
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT count(*) FROM multi_column_chunk_filtering WHERE a > 50000 AND b > 50000;
QUERY PLAN
---------------------------------------------------------------------
@ -197,7 +197,7 @@ EXPLAIN (analyze on, costs off, timing off, summary off)
-- make next tests faster
TRUNCATE multi_column_chunk_filtering;
INSERT INTO multi_column_chunk_filtering SELECT generate_series(0,5);
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT b FROM multi_column_chunk_filtering WHERE a > 50000 AND b > 50000;
QUERY PLAN
---------------------------------------------------------------------
@ -208,7 +208,7 @@ EXPLAIN (analyze on, costs off, timing off, summary off)
Columnar Chunk Groups Removed by Filter: 1
(5 rows)
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT b, a FROM multi_column_chunk_filtering WHERE b > 50000;
QUERY PLAN
---------------------------------------------------------------------
@ -220,7 +220,7 @@ EXPLAIN (analyze on, costs off, timing off, summary off)
Columnar Chunk Groups Removed by Filter: 0
(6 rows)
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT FROM multi_column_chunk_filtering WHERE a > 50000;
QUERY PLAN
---------------------------------------------------------------------
@ -231,7 +231,7 @@ EXPLAIN (analyze on, costs off, timing off, summary off)
Columnar Chunk Groups Removed by Filter: 1
(5 rows)
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT FROM multi_column_chunk_filtering;
QUERY PLAN
---------------------------------------------------------------------
@ -242,7 +242,7 @@ EXPLAIN (analyze on, costs off, timing off, summary off)
BEGIN;
ALTER TABLE multi_column_chunk_filtering DROP COLUMN a;
ALTER TABLE multi_column_chunk_filtering DROP COLUMN b;
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM multi_column_chunk_filtering;
QUERY PLAN
---------------------------------------------------------------------
@ -253,7 +253,7 @@ BEGIN;
ROLLBACK;
CREATE TABLE another_columnar_table(x int, y int) USING columnar;
INSERT INTO another_columnar_table SELECT generate_series(0,5);
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT a, y FROM multi_column_chunk_filtering, another_columnar_table WHERE x > 1;
QUERY PLAN
---------------------------------------------------------------------
@ -364,7 +364,7 @@ set enable_mergejoin=false;
set enable_hashjoin=false;
set enable_material=false;
-- test different kinds of expressions
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM r1, coltest WHERE
id1 = id AND x1 > 15000 AND x1::text > '000000' AND n1 % 10 = 0;
QUERY PLAN
@ -391,7 +391,7 @@ SELECT * FROM r1, coltest WHERE
(3 rows)
-- test equivalence classes
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM r1, r2, r3, r4, r5, r6, r7, coltest WHERE
id = id1 AND id1 = id2 AND id2 = id3 AND id3 = id4 AND
id4 = id5 AND id5 = id6 AND id6 = id7;
@ -561,7 +561,7 @@ set columnar.max_custom_scan_paths to default;
set columnar.planner_debug_level to default;
-- test more complex parameterization
set columnar.planner_debug_level = 'notice';
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM r1, r2, r3, coltest WHERE
id1 = id2 AND id2 = id3 AND id3 = id AND
n1 > x1 AND n2 > x2 AND n3 > x3;
@ -613,7 +613,7 @@ SELECT * FROM r1, r2, r3, coltest WHERE
(3 rows)
-- test partitioning parameterization
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM r1, coltest_part WHERE
id1 = id AND n1 > x1;
QUERY PLAN
@ -680,7 +680,7 @@ DETAIL: unparameterized; 0 clauses pushed down
---------------------------------------------------------------------
(0 rows)
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM coltest c1 WHERE ceil(x1) > 4222;
NOTICE: columnar planner: cannot push down clause: must match 'Var <op> Expr' or 'Expr <op> Var'
HINT: Var must only reference this rel, and Expr must not reference this rel
@ -832,7 +832,7 @@ BEGIN;
COMMIT;
SET columnar.max_custom_scan_paths TO 50;
SET columnar.qual_pushdown_correlation_threshold TO 0.0;
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT sum(a) FROM pushdown_test WHERE a = 204356 or a = 104356 or a = 76556;
NOTICE: columnar planner: adding CustomScan path for pushdown_test
DETAIL: unparameterized; 1 clauses pushed down
@ -855,7 +855,7 @@ DETAIL: unparameterized; 1 clauses pushed down
180912
(1 row)
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT sum(a) FROM pushdown_test WHERE a = 194356 or a = 104356 or a = 76556;
NOTICE: columnar planner: adding CustomScan path for pushdown_test
DETAIL: unparameterized; 1 clauses pushed down
@ -878,7 +878,7 @@ DETAIL: unparameterized; 1 clauses pushed down
375268
(1 row)
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT sum(a) FROM pushdown_test WHERE a = 204356 or a > a*-1 + b;
NOTICE: columnar planner: cannot push down clause: must match 'Var <op> Expr' or 'Expr <op> Var'
HINT: Var must only reference this rel, and Expr must not reference this rel
@ -894,7 +894,7 @@ DETAIL: unparameterized; 0 clauses pushed down
Columnar Projected Columns: a, b
(5 rows)
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT sum(a) FROM pushdown_test where (a > 1000 and a < 10000) or (a > 20000 and a < 50000);
NOTICE: columnar planner: adding CustomScan path for pushdown_test
DETAIL: unparameterized; 1 clauses pushed down
@ -917,7 +917,7 @@ DETAIL: unparameterized; 1 clauses pushed down
1099459500
(1 row)
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT sum(a) FROM pushdown_test where (a > random() and a < 2*a) or (a > 100);
NOTICE: columnar planner: cannot push down clause: must match 'Var <op> Expr' or 'Expr <op> Var'
HINT: Var must only reference this rel, and Expr must not reference this rel
@ -949,7 +949,7 @@ DETAIL: unparameterized; 0 clauses pushed down
20000100000
(1 row)
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT sum(a) FROM pushdown_test where (a > random() and a <= 2000) or (a > 200000-1010);
NOTICE: columnar planner: cannot push down clause: must match 'Var <op> Expr' or 'Expr <op> Var'
HINT: Var must only reference this rel, and Expr must not reference this rel
@ -978,7 +978,7 @@ DETAIL: unparameterized; 1 clauses pushed down
SET hash_mem_multiplier = 1.0;
SELECT columnar_test_helpers.explain_with_pg16_subplan_format($Q$
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT sum(a) FROM pushdown_test where
(
a > random()
@ -1043,7 +1043,7 @@ DETAIL: unparameterized; 1 clauses pushed down
create function stable_1(arg int) returns int language plpgsql STRICT IMMUTABLE as
$$ BEGIN RETURN 1+arg; END; $$;
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT sum(a) FROM pushdown_test where (a = random() and a < stable_1(a) and a < stable_1(6000));
NOTICE: columnar planner: cannot push down clause: must match 'Var <op> Expr' or 'Expr <op> Var'
HINT: Var must only reference this rel, and Expr must not reference this rel
@ -1096,7 +1096,7 @@ BEGIN;
INSERT INTO pushdown_test VALUES(7, 'USA');
INSERT INTO pushdown_test VALUES(8, 'ZW');
END;
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT id FROM pushdown_test WHERE country IN ('USA', 'BR', 'ZW');
QUERY PLAN
---------------------------------------------------------------------
@ -1123,7 +1123,7 @@ BEGIN
return 'AL';
END;
$$;
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM pushdown_test WHERE country IN ('USA', 'ZW', volatileFunction());
QUERY PLAN
---------------------------------------------------------------------

4
src/test/regress/expected/columnar_cursor.out
View File

@ -4,7 +4,7 @@
CREATE TABLE test_cursor (a int, b int) USING columnar;
INSERT INTO test_cursor SELECT i, j FROM generate_series(0, 100)i, generate_series(100, 200)j;
-- A case where the WHERE clause might filter out some chunks
EXPLAIN (analyze on, costs off, timing off, summary off) SELECT * FROM test_cursor WHERE a = 25;
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF) SELECT * FROM test_cursor WHERE a = 25;
QUERY PLAN
---------------------------------------------------------------------
Custom Scan (ColumnarScan) on test_cursor (actual rows=101 loops=1)
@ -107,7 +107,7 @@ UPDATE test_cursor SET a = 8000 WHERE CURRENT OF a_25;
ERROR: UPDATE and CTID scans not supported for ColumnarScan
COMMIT;
-- A case where the WHERE clause doesn't filter out any chunks
EXPLAIN (analyze on, costs off, timing off, summary off) SELECT * FROM test_cursor WHERE a > 25;
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF) SELECT * FROM test_cursor WHERE a > 25;
QUERY PLAN
---------------------------------------------------------------------
Custom Scan (ColumnarScan) on test_cursor (actual rows=7575 loops=1)

4
src/test/regress/expected/columnar_paths.out
View File

@ -579,7 +579,7 @@ CREATE INDEX correlated_idx ON correlated(x);
CREATE INDEX uncorrelated_idx ON uncorrelated(x);
ANALYZE correlated, uncorrelated;
-- should choose chunk group filtering; selective and correlated
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM correlated WHERE x = 78910;
QUERY PLAN
---------------------------------------------------------------------
@ -598,7 +598,7 @@ SELECT * FROM correlated WHERE x = 78910;
(1 row)
-- should choose index scan; selective but uncorrelated
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM uncorrelated WHERE x = 78910;
QUERY PLAN
---------------------------------------------------------------------

4
src/test/regress/expected/columnar_paths_0.out
View File

@ -583,7 +583,7 @@ CREATE INDEX correlated_idx ON correlated(x);
CREATE INDEX uncorrelated_idx ON uncorrelated(x);
ANALYZE correlated, uncorrelated;
-- should choose chunk group filtering; selective and correlated
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM correlated WHERE x = 78910;
QUERY PLAN
---------------------------------------------------------------------
@ -602,7 +602,7 @@ SELECT * FROM correlated WHERE x = 78910;
(1 row)
-- should choose index scan; selective but uncorrelated
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM uncorrelated WHERE x = 78910;
QUERY PLAN
---------------------------------------------------------------------

12
src/test/regress/expected/columnar_transactions.out
View File

@ -219,7 +219,7 @@ EXPLAIN (COSTS OFF) EXECUTE p0;
(2 rows)
EXECUTE p0;
EXPLAIN (ANALYZE true, COSTS off, TIMING off, SUMMARY off) EXECUTE p0;
EXPLAIN (ANALYZE true, COSTS off, TIMING off, SUMMARY off, BUFFERS OFF) EXECUTE p0;
QUERY PLAN
---------------------------------------------------------------------
Insert on t (actual rows=0 loops=1)
@ -252,7 +252,7 @@ EXPLAIN (COSTS OFF) EXECUTE p1(16);
(2 rows)
EXECUTE p1(16);
EXPLAIN (ANALYZE true, COSTS off, TIMING off, SUMMARY off) EXECUTE p1(20);
EXPLAIN (ANALYZE true, COSTS off, TIMING off, SUMMARY off, BUFFERS OFF) EXECUTE p1(20);
QUERY PLAN
---------------------------------------------------------------------
Insert on t (actual rows=0 loops=1)
@ -289,7 +289,7 @@ EXPLAIN (COSTS OFF) EXECUTE p2(30, 40);
(2 rows)
EXECUTE p2(30, 40);
EXPLAIN (ANALYZE true, COSTS off, TIMING off, SUMMARY off) EXECUTE p2(50, 60);
EXPLAIN (ANALYZE true, COSTS off, TIMING off, SUMMARY off, BUFFERS OFF) EXECUTE p2(50, 60);
QUERY PLAN
---------------------------------------------------------------------
Insert on t (actual rows=0 loops=1)
@ -342,7 +342,7 @@ EXECUTE p3;
8 | 8
(2 rows)
EXPLAIN (ANALYZE true, COSTS off, TIMING off, SUMMARY off) EXECUTE p3;
EXPLAIN (ANALYZE true, COSTS off, TIMING off, SUMMARY off, BUFFERS OFF) EXECUTE p3;
QUERY PLAN
---------------------------------------------------------------------
Custom Scan (ColumnarScan) on t (actual rows=2 loops=1)
@ -397,7 +397,7 @@ EXECUTE p5(16);
---------------------------------------------------------------------
(0 rows)
EXPLAIN (ANALYZE true, COSTS off, TIMING off, SUMMARY off) EXECUTE p5(9);
EXPLAIN (ANALYZE true, COSTS off, TIMING off, SUMMARY off, BUFFERS OFF) EXECUTE p5(9);
QUERY PLAN
---------------------------------------------------------------------
Custom Scan (ColumnarScan) on t (actual rows=2 loops=1)
@ -453,7 +453,7 @@ EXECUTE p6(30, 40);
31 | 41
(1 row)
EXPLAIN (ANALYZE true, COSTS off, TIMING off, SUMMARY off) EXECUTE p6(50, 60);
EXPLAIN (ANALYZE true, COSTS off, TIMING off, SUMMARY off, BUFFERS OFF) EXECUTE p6(50, 60);
QUERY PLAN
---------------------------------------------------------------------
Custom Scan (ColumnarScan) on t (actual rows=1 loops=1)

2
src/test/regress/expected/coordinator_shouldhaveshards.out
View File

@ -140,7 +140,7 @@ ROLLBACK;
-- INSERT..SELECT with re-partitioning in EXPLAIN ANALYZE after local execution
BEGIN;
INSERT INTO test VALUES (0,1000);
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE) INSERT INTO test (x, y) SELECT y, x FROM test;
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE, BUFFERS OFF) INSERT INTO test (x, y) SELECT y, x FROM test;
ERROR: EXPLAIN ANALYZE is currently not supported for INSERT ... SELECT commands with repartitioning
ROLLBACK;
-- DDL connects to locahost

2
src/test/regress/expected/local_shard_execution.out
View File

@ -327,7 +327,7 @@ EXPLAIN (ANALYZE, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM distribute
Filter: (age = 20)
(10 rows)
EXPLAIN (ANALYZE ON, COSTS OFF, SUMMARY OFF, TIMING OFF)
EXPLAIN (ANALYZE ON, COSTS OFF, SUMMARY OFF, TIMING OFF, BUFFERS OFF)
WITH r AS ( SELECT GREATEST(random(), 2) z,* FROM distributed_table)
SELECT 1 FROM r WHERE z < 3;
QUERY PLAN

2
src/test/regress/expected/local_shard_execution_replicated.out
View File

@ -265,7 +265,7 @@ EXPLAIN (ANALYZE, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM distribute
Filter: (age = 20)
(10 rows)
EXPLAIN (ANALYZE ON, COSTS OFF, SUMMARY OFF, TIMING OFF)
EXPLAIN (ANALYZE ON, COSTS OFF, SUMMARY OFF, TIMING OFF, BUFFERS OFF)
WITH r AS ( SELECT GREATEST(random(), 2) z,* FROM distributed_table)
SELECT 1 FROM r WHERE z < 3;
QUERY PLAN

8
src/test/regress/expected/merge.out
View File

@ -2019,7 +2019,7 @@ DEBUG: <Deparsed MERGE query: MERGE INTO merge_schema.target_table_xxxxxxx t US
DEBUG: <Deparsed MERGE query: MERGE INTO merge_schema.target_table_xxxxxxx t USING (SELECT intermediate_result.id, intermediate_result.some_number FROM read_intermediate_result('merge_into_XXX_4000079'::text, 'binary'::citus_copy_format) intermediate_result(id integer, some_number integer)) s ON (t.id OPERATOR(pg_catalog.=) s.some_number) WHEN NOT MATCHED THEN INSERT (id, name) VALUES (s.some_number, 'parag'::text)>
DEBUG: Execute MERGE task list
-- let's verify if data inserted to second shard of target.
EXPLAIN (analyze on, costs off, timing off, summary off) SELECT * FROM target_table;
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF) SELECT * FROM target_table;
QUERY PLAN
---------------------------------------------------------------------
Custom Scan (Citus Adaptive) (actual rows=1 loops=1)
@ -2535,7 +2535,7 @@ HINT: To remove the local data, run: SELECT truncate_local_data_after_distribut
-- single shard query given source_json is filtered and Postgres is smart to pushdown
-- filter to the target_json as well
SELECT public.coordinator_plan($Q$
EXPLAIN (ANALYZE ON, TIMING OFF) MERGE INTO target_json sda
EXPLAIN (ANALYZE ON, TIMING OFF, BUFFERS OFF) MERGE INTO target_json sda
USING (SELECT * FROM source_json WHERE id = 1) sdn
ON sda.id = sdn.id
WHEN NOT matched THEN
@ -2564,7 +2564,7 @@ SELECT * FROM target_json ORDER BY 1;
--SELECT * FROM target_json ORDER BY 1;
-- join for source_json is happening at a different place
SELECT public.coordinator_plan($Q$
EXPLAIN (ANALYZE ON, TIMING OFF) MERGE INTO target_json sda
EXPLAIN (ANALYZE ON, TIMING OFF, BUFFERS OFF) MERGE INTO target_json sda
USING source_json s1 LEFT JOIN (SELECT * FROM source_json) s2 USING(z)
ON sda.id = s1.id AND s1.id = s2.id
WHEN NOT matched THEN
@ -2589,7 +2589,7 @@ SELECT * FROM target_json ORDER BY 1;
-- update JSON column
SELECT public.coordinator_plan($Q$
EXPLAIN (ANALYZE ON, TIMING OFF) MERGE INTO target_json sda
EXPLAIN (ANALYZE ON, TIMING OFF, BUFFERS OFF) MERGE INTO target_json sda
USING source_json sdn
ON sda.id = sdn.id
WHEN matched THEN

4
src/test/regress/expected/multi_data_types.out
View File

@ -170,7 +170,7 @@ SELECT * FROM composite_type_partitioned_table WHERE id = 123;
123 | (123,456)
(1 row)
EXPLAIN (ANALYZE TRUE, COSTS FALSE, VERBOSE FALSE, TIMING FALSE, SUMMARY FALSE)
EXPLAIN (ANALYZE TRUE, COSTS FALSE, VERBOSE FALSE, TIMING FALSE, SUMMARY FALSE, BUFFERS OFF)
INSERT INTO composite_type_partitioned_table VALUES (123, '(123, 456)'::other_composite_type);
QUERY PLAN
---------------------------------------------------------------------
@ -212,7 +212,7 @@ $cf$);
(1 row)
INSERT INTO composite_type_partitioned_table VALUES (456, '(456, 678)'::other_composite_type);
EXPLAIN (ANALYZE TRUE, COSTS FALSE, VERBOSE FALSE, TIMING FALSE, SUMMARY FALSE)
EXPLAIN (ANALYZE TRUE, COSTS FALSE, VERBOSE FALSE, TIMING FALSE, SUMMARY FALSE, BUFFERS OFF)
INSERT INTO composite_type_partitioned_table VALUES (123, '(456, 678)'::other_composite_type);
QUERY PLAN
---------------------------------------------------------------------

38
src/test/regress/expected/multi_explain.out
View File

@ -338,7 +338,7 @@ Sort
-> Seq Scan on lineitem_360000 lineitem
-- Test analyze (with TIMING FALSE and SUMMARY FALSE for consistent output)
SELECT public.plan_normalize_memory($Q$
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE)
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE, BUFFERS OFF)
SELECT l_quantity, count(*) count_quantity FROM lineitem
GROUP BY l_quantity ORDER BY count_quantity, l_quantity;
$Q$);
@ -365,7 +365,7 @@ SELECT create_distributed_table('t1', 'a'), create_distributed_table('t2', 'a');
|
BEGIN;
SET LOCAL citus.enable_repartition_joins TO true;
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off) SELECT count(*) FROM t1, t2 WHERE t1.a=t2.b;
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, BUFFERS OFF) SELECT count(*) FROM t1, t2 WHERE t1.a=t2.b;
Aggregate (actual rows=1 loops=1)
-> Custom Scan (Citus Adaptive) (actual rows=6 loops=1)
Task Count: 6
@ -378,7 +378,7 @@ Aggregate (actual rows=1 loops=1)
Map Task Count: 3
Merge Task Count: 6
-- Confirm repartiton join in distributed subplan works
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off)
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, BUFFERS OFF)
WITH repartition AS (SELECT count(*) FROM t1, t2 WHERE t1.a=t2.b)
SELECT count(*) from repartition;
Custom Scan (Citus Adaptive) (actual rows=1 loops=1)
@ -408,7 +408,7 @@ END;
DROP TABLE t1, t2;
-- Test query text output, with ANALYZE ON
SELECT public.plan_normalize_memory($Q$
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE, VERBOSE TRUE)
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE, VERBOSE TRUE, BUFFERS OFF)
SELECT l_quantity, count(*) count_quantity FROM lineitem
GROUP BY l_quantity ORDER BY count_quantity, l_quantity;
$Q$);
@ -519,7 +519,7 @@ Custom Scan (Citus Adaptive)
Filter: (l_partkey = 0)
-- Test analyze (with TIMING FALSE and SUMMARY FALSE for consistent output)
BEGIN;
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE)
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE, BUFFERS OFF)
UPDATE lineitem
SET l_suppkey = 12
WHERE l_orderkey = 1 AND l_partkey = 0;
@ -1074,7 +1074,7 @@ Custom Scan (Citus Adaptive)
-> Seq Scan on lineitem_hash_part_360044 lineitem_hash_part
-- Test analyze (with TIMING FALSE and SUMMARY FALSE for consistent output)
SELECT public.plan_normalize_memory($Q$
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE)
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE, BUFFERS OFF)
SELECT l_quantity, count(*) count_quantity FROM lineitem
GROUP BY l_quantity ORDER BY count_quantity, l_quantity;
$Q$);
@ -1387,7 +1387,7 @@ Custom Scan (Citus Adaptive) (cost=0.00..0.00 rows=0 width=0)
Node: host=localhost port=xxxxx dbname=regression
-> Index Scan using lineitem_pkey_360000 on lineitem_360000 lineitem (cost=0.28..13.60 rows=4 width=5)
Index Cond: (l_orderkey = 5)
EXPLAIN (ANALYZE ON, COSTS OFF, TIMING OFF, SUMMARY OFF) EXECUTE router_executor_query_param(5);
EXPLAIN (ANALYZE ON, COSTS OFF, TIMING OFF, SUMMARY OFF, BUFFERS OFF) EXECUTE router_executor_query_param(5);
Custom Scan (Citus Adaptive) (actual rows=3 loops=1)
Task Count: 1
Tuple data received from nodes: 30 bytes
@ -1410,7 +1410,7 @@ Custom Scan (Citus Adaptive)
-> Seq Scan on lineitem_360000 lineitem
ROLLBACK;
BEGIN;
EXPLAIN (ANALYZE ON, COSTS OFF, TIMING OFF, SUMMARY OFF) EXECUTE multi_shard_query_param(5);
EXPLAIN (ANALYZE ON, COSTS OFF, TIMING OFF, SUMMARY OFF, BUFFERS OFF) EXECUTE multi_shard_query_param(5);
Custom Scan (Citus Adaptive) (actual rows=0 loops=1)
Task Count: 2
Tasks Shown: One of 2
@ -1993,7 +1993,7 @@ SET citus.shard_count TO 4;
SET client_min_messages TO WARNING;
SELECT create_distributed_table('explain_analyze_test', 'a');
\set default_analyze_flags '(ANALYZE on, COSTS off, TIMING off, SUMMARY off)'
\set default_analyze_flags '(ANALYZE on, COSTS off, TIMING off, SUMMARY off, BUFFERS off)'
\set default_explain_flags '(ANALYZE off, COSTS off, TIMING off, SUMMARY off)'
-- router SELECT
EXPLAIN :default_analyze_flags SELECT * FROM explain_analyze_test WHERE a = 1;
@ -2168,7 +2168,7 @@ SELECT * FROM explain_pk ORDER BY 1;
ROLLBACK;
-- test EXPLAIN ANALYZE with non-text output formats
BEGIN;
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, FORMAT JSON) INSERT INTO explain_pk VALUES (1, 2), (2, 3);
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, FORMAT JSON, BUFFERS OFF) INSERT INTO explain_pk VALUES (1, 2), (2, 3);
[
{
"Plan": {
@ -2224,7 +2224,7 @@ EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, FORMAT JSON) INSERT INT
}
]
ROLLBACK;
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, FORMAT JSON) SELECT * FROM explain_pk;
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, FORMAT JSON, BUFFERS OFF) SELECT * FROM explain_pk;
[
{
"Plan": {
@ -2271,7 +2271,7 @@ EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, FORMAT JSON) SELECT * F
}
]
BEGIN;
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, FORMAT XML) INSERT INTO explain_pk VALUES (1, 2), (2, 3);
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, FORMAT XML, BUFFERS OFF) INSERT INTO explain_pk VALUES (1, 2), (2, 3);
<explain xmlns="http://www.postgresql.org/2009/explain">
<Query>
<Plan>
@ -2326,7 +2326,7 @@ EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, FORMAT XML) INSERT INTO
</Query>
</explain>
ROLLBACK;
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, FORMAT XML) SELECT * FROM explain_pk;
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, FORMAT XML, BUFFERS OFF) SELECT * FROM explain_pk;
<explain xmlns="http://www.postgresql.org/2009/explain">
<Query>
<Plan>
@ -2438,7 +2438,7 @@ Aggregate (actual rows=1 loops=1)
Sort Method: quicksort Memory: 25kB
-> Seq Scan on ref_table_570021 ref_table (actual rows=10 loops=1)
SELECT public.explain_with_pg17_initplan_format($Q$
EXPLAIN (ANALYZE on, COSTS off, TIMING off, SUMMARY off)
EXPLAIN (ANALYZE on, COSTS off, TIMING off, SUMMARY off, BUFFERS OFF)
SELECT count(distinct a) FROM dist_table
WHERE EXISTS(SELECT random() < 2 FROM dist_table NATURAL JOIN ref_table);
$Q$);
@ -3076,7 +3076,7 @@ SELECT create_distributed_table('explain_analyze_execution_time', 'a');
-- sleep for the shard that has the single row, so that
-- will definitely be slower
set citus.explain_analyze_sort_method to "taskId";
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE) select a, CASE WHEN pg_sleep(0.4) IS NULL THEN 'x' END from explain_analyze_execution_time;
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE, BUFFERS OFF) select a, CASE WHEN pg_sleep(0.4) IS NULL THEN 'x' END from explain_analyze_execution_time;
Custom Scan (Citus Adaptive) (actual rows=1 loops=1)
Task Count: 2
Tuple data received from nodes: 4 bytes
@ -3086,7 +3086,7 @@ Custom Scan (Citus Adaptive) (actual rows=1 loops=1)
Node: host=localhost port=xxxxx dbname=regression
-> Seq Scan on explain_analyze_execution_time_570029 explain_analyze_execution_time (actual rows=0 loops=1)
set citus.explain_analyze_sort_method to "execution-time";
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE) select a, CASE WHEN pg_sleep(0.4) IS NULL THEN 'x' END from explain_analyze_execution_time;
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE, BUFFERS OFF) select a, CASE WHEN pg_sleep(0.4) IS NULL THEN 'x' END from explain_analyze_execution_time;
Custom Scan (Citus Adaptive) (actual rows=1 loops=1)
Task Count: 2
Tuple data received from nodes: 4 bytes
@ -3233,7 +3233,7 @@ SET search_path TO multi_explain;
CREATE TABLE test_subplans (x int primary key, y int);
SELECT create_distributed_table('test_subplans','x');
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off)
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, BUFFERS OFF)
WITH a AS (INSERT INTO test_subplans VALUES (1,2) RETURNING *)
SELECT * FROM a;
Custom Scan (Citus Adaptive) (actual rows=1 loops=1)
@ -3260,7 +3260,7 @@ Custom Scan (Citus Adaptive) (actual rows=1 loops=1)
SELECT * FROM test_subplans;
1|2
-- Will fail with duplicate pk
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off)
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, BUFFERS OFF)
WITH a AS (INSERT INTO test_subplans VALUES (1,2) RETURNING *)
SELECT * FROM a;
ERROR: duplicate key value violates unique constraint "test_subplans_pkey_570038"
@ -3268,7 +3268,7 @@ DETAIL: Key (x)=(1) already exists.
CONTEXT: while executing command on localhost:xxxxx
-- Test JSON format
TRUNCATE test_subplans;
EXPLAIN (FORMAT JSON, COSTS off, ANALYZE on, TIMING off, SUMMARY off)
EXPLAIN (FORMAT JSON, COSTS off, ANALYZE on, TIMING off, SUMMARY off, BUFFERS OFF)
WITH a AS (INSERT INTO test_subplans VALUES (1,2) RETURNING *)
SELECT * FROM a;
[

38
src/test/regress/expected/multi_explain_0.out
View File

@ -338,7 +338,7 @@ Sort
-> Seq Scan on lineitem_360000 lineitem
-- Test analyze (with TIMING FALSE and SUMMARY FALSE for consistent output)
SELECT public.plan_normalize_memory($Q$
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE)
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE, BUFFERS OFF)
SELECT l_quantity, count(*) count_quantity FROM lineitem
GROUP BY l_quantity ORDER BY count_quantity, l_quantity;
$Q$);
@ -365,7 +365,7 @@ SELECT create_distributed_table('t1', 'a'), create_distributed_table('t2', 'a');
|
BEGIN;
SET LOCAL citus.enable_repartition_joins TO true;
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off) SELECT count(*) FROM t1, t2 WHERE t1.a=t2.b;
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, BUFFERS OFF) SELECT count(*) FROM t1, t2 WHERE t1.a=t2.b;
Aggregate (actual rows=1 loops=1)
-> Custom Scan (Citus Adaptive) (actual rows=6 loops=1)
Task Count: 6
@ -378,7 +378,7 @@ Aggregate (actual rows=1 loops=1)
Map Task Count: 3
Merge Task Count: 6
-- Confirm repartiton join in distributed subplan works
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off)
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, BUFFERS OFF)
WITH repartition AS (SELECT count(*) FROM t1, t2 WHERE t1.a=t2.b)
SELECT count(*) from repartition;
Custom Scan (Citus Adaptive) (actual rows=1 loops=1)
@ -408,7 +408,7 @@ END;
DROP TABLE t1, t2;
-- Test query text output, with ANALYZE ON
SELECT public.plan_normalize_memory($Q$
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE, VERBOSE TRUE)
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE, VERBOSE TRUE, BUFFERS OFF)
SELECT l_quantity, count(*) count_quantity FROM lineitem
GROUP BY l_quantity ORDER BY count_quantity, l_quantity;
$Q$);
@ -519,7 +519,7 @@ Custom Scan (Citus Adaptive)
Filter: (l_partkey = 0)
-- Test analyze (with TIMING FALSE and SUMMARY FALSE for consistent output)
BEGIN;
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE)
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE, BUFFERS OFF)
UPDATE lineitem
SET l_suppkey = 12
WHERE l_orderkey = 1 AND l_partkey = 0;
@ -1074,7 +1074,7 @@ Custom Scan (Citus Adaptive)
-> Seq Scan on lineitem_hash_part_360044 lineitem_hash_part
-- Test analyze (with TIMING FALSE and SUMMARY FALSE for consistent output)
SELECT public.plan_normalize_memory($Q$
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE)
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE, BUFFERS OFF)
SELECT l_quantity, count(*) count_quantity FROM lineitem
GROUP BY l_quantity ORDER BY count_quantity, l_quantity;
$Q$);
@ -1387,7 +1387,7 @@ Custom Scan (Citus Adaptive) (cost=0.00..0.00 rows=0 width=0)
Node: host=localhost port=xxxxx dbname=regression
-> Index Scan using lineitem_pkey_360000 on lineitem_360000 lineitem (cost=0.28..13.60 rows=4 width=5)
Index Cond: (l_orderkey = 5)
EXPLAIN (ANALYZE ON, COSTS OFF, TIMING OFF, SUMMARY OFF) EXECUTE router_executor_query_param(5);
EXPLAIN (ANALYZE ON, COSTS OFF, TIMING OFF, SUMMARY OFF, BUFFERS OFF) EXECUTE router_executor_query_param(5);
Custom Scan (Citus Adaptive) (actual rows=3 loops=1)
Task Count: 1
Tuple data received from nodes: 30 bytes
@ -1410,7 +1410,7 @@ Custom Scan (Citus Adaptive)
-> Seq Scan on lineitem_360000 lineitem
ROLLBACK;
BEGIN;
EXPLAIN (ANALYZE ON, COSTS OFF, TIMING OFF, SUMMARY OFF) EXECUTE multi_shard_query_param(5);
EXPLAIN (ANALYZE ON, COSTS OFF, TIMING OFF, SUMMARY OFF, BUFFERS OFF) EXECUTE multi_shard_query_param(5);
Custom Scan (Citus Adaptive) (actual rows=0 loops=1)
Task Count: 2
Tasks Shown: One of 2
@ -1993,7 +1993,7 @@ SET citus.shard_count TO 4;
SET client_min_messages TO WARNING;
SELECT create_distributed_table('explain_analyze_test', 'a');
\set default_analyze_flags '(ANALYZE on, COSTS off, TIMING off, SUMMARY off)'
\set default_analyze_flags '(ANALYZE on, COSTS off, TIMING off, SUMMARY off, BUFFERS off)'
\set default_explain_flags '(ANALYZE off, COSTS off, TIMING off, SUMMARY off)'
-- router SELECT
EXPLAIN :default_analyze_flags SELECT * FROM explain_analyze_test WHERE a = 1;
@ -2168,7 +2168,7 @@ SELECT * FROM explain_pk ORDER BY 1;
ROLLBACK;
-- test EXPLAIN ANALYZE with non-text output formats
BEGIN;
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, FORMAT JSON) INSERT INTO explain_pk VALUES (1, 2), (2, 3);
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, FORMAT JSON, BUFFERS OFF) INSERT INTO explain_pk VALUES (1, 2), (2, 3);
[
{
"Plan": {
@ -2224,7 +2224,7 @@ EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, FORMAT JSON) INSERT INT
}
]
ROLLBACK;
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, FORMAT JSON) SELECT * FROM explain_pk;
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, FORMAT JSON, BUFFERS OFF) SELECT * FROM explain_pk;
[
{
"Plan": {
@ -2271,7 +2271,7 @@ EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, FORMAT JSON) SELECT * F
}
]
BEGIN;
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, FORMAT XML) INSERT INTO explain_pk VALUES (1, 2), (2, 3);
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, FORMAT XML, BUFFERS OFF) INSERT INTO explain_pk VALUES (1, 2), (2, 3);
<explain xmlns="http://www.postgresql.org/2009/explain">
<Query>
<Plan>
@ -2326,7 +2326,7 @@ EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, FORMAT XML) INSERT INTO
</Query>
</explain>
ROLLBACK;
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, FORMAT XML) SELECT * FROM explain_pk;
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, FORMAT XML, BUFFERS OFF) SELECT * FROM explain_pk;
<explain xmlns="http://www.postgresql.org/2009/explain">
<Query>
<Plan>
@ -2433,7 +2433,7 @@ Aggregate (actual rows=1 loops=1)
Sort Method: quicksort Memory: 25kB
-> Seq Scan on ref_table_570021 ref_table (actual rows=10 loops=1)
SELECT public.explain_with_pg17_initplan_format($Q$
EXPLAIN (ANALYZE on, COSTS off, TIMING off, SUMMARY off)
EXPLAIN (ANALYZE on, COSTS off, TIMING off, SUMMARY off, BUFFERS OFF)
SELECT count(distinct a) FROM dist_table
WHERE EXISTS(SELECT random() < 2 FROM dist_table NATURAL JOIN ref_table);
$Q$);
@ -3065,7 +3065,7 @@ SELECT create_distributed_table('explain_analyze_execution_time', 'a');
-- sleep for the shard that has the single row, so that
-- will definitely be slower
set citus.explain_analyze_sort_method to "taskId";
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE) select a, CASE WHEN pg_sleep(0.4) IS NULL THEN 'x' END from explain_analyze_execution_time;
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE, BUFFERS OFF) select a, CASE WHEN pg_sleep(0.4) IS NULL THEN 'x' END from explain_analyze_execution_time;
Custom Scan (Citus Adaptive) (actual rows=1 loops=1)
Task Count: 2
Tuple data received from nodes: 4 bytes
@ -3075,7 +3075,7 @@ Custom Scan (Citus Adaptive) (actual rows=1 loops=1)
Node: host=localhost port=xxxxx dbname=regression
-> Seq Scan on explain_analyze_execution_time_570029 explain_analyze_execution_time (actual rows=0 loops=1)
set citus.explain_analyze_sort_method to "execution-time";
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE) select a, CASE WHEN pg_sleep(0.4) IS NULL THEN 'x' END from explain_analyze_execution_time;
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE, BUFFERS OFF) select a, CASE WHEN pg_sleep(0.4) IS NULL THEN 'x' END from explain_analyze_execution_time;
Custom Scan (Citus Adaptive) (actual rows=1 loops=1)
Task Count: 2
Tuple data received from nodes: 4 bytes
@ -3222,7 +3222,7 @@ SET search_path TO multi_explain;
CREATE TABLE test_subplans (x int primary key, y int);
SELECT create_distributed_table('test_subplans','x');
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off)
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, BUFFERS OFF)
WITH a AS (INSERT INTO test_subplans VALUES (1,2) RETURNING *)
SELECT * FROM a;
Custom Scan (Citus Adaptive) (actual rows=1 loops=1)
@ -3249,7 +3249,7 @@ Custom Scan (Citus Adaptive) (actual rows=1 loops=1)
SELECT * FROM test_subplans;
1|2
-- Will fail with duplicate pk
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off)
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, BUFFERS OFF)
WITH a AS (INSERT INTO test_subplans VALUES (1,2) RETURNING *)
SELECT * FROM a;
ERROR: duplicate key value violates unique constraint "test_subplans_pkey_570038"
@ -3257,7 +3257,7 @@ DETAIL: Key (x)=(1) already exists.
CONTEXT: while executing command on localhost:xxxxx
-- Test JSON format
TRUNCATE test_subplans;
EXPLAIN (FORMAT JSON, COSTS off, ANALYZE on, TIMING off, SUMMARY off)
EXPLAIN (FORMAT JSON, COSTS off, ANALYZE on, TIMING off, SUMMARY off, BUFFERS OFF)
WITH a AS (INSERT INTO test_subplans VALUES (1,2) RETURNING *)
SELECT * FROM a;
[

2
src/test/regress/expected/multi_insert_select.out
View File

@ -905,7 +905,7 @@ $Q$);
(4 rows)
-- EXPLAIN ANALYZE is not supported for INSERT ... SELECT via coordinator
EXPLAIN (costs off, analyze on)
EXPLAIN (costs off, analyze on, BUFFERS OFF)
INSERT INTO agg_events (user_id)
SELECT
raw_events_first.user_id

8
src/test/regress/expected/pg13.out
View File

@ -173,7 +173,7 @@ CREATE TABLE test_wal(a int, b int);
EXPLAIN (WAL) INSERT INTO test_wal VALUES(1,11);
ERROR: EXPLAIN option WAL requires ANALYZE
-- test WAL working properly for router queries
EXPLAIN (ANALYZE TRUE, WAL TRUE, COSTS FALSE, SUMMARY FALSE, BUFFERS FALSE, TIMING FALSE)
EXPLAIN (ANALYZE TRUE, WAL TRUE, COSTS FALSE, SUMMARY FALSE, BUFFERS FALSE, TIMING FALSE, BUFFERS OFF)
INSERT INTO test_wal VALUES(1,11);
QUERY PLAN
---------------------------------------------------------------------
@ -192,7 +192,7 @@ HINT: To remove the local data, run: SELECT truncate_local_data_after_distribut
(1 row)
EXPLAIN (ANALYZE TRUE, WAL TRUE, COSTS FALSE, SUMMARY FALSE, BUFFERS FALSE, TIMING FALSE)
EXPLAIN (ANALYZE TRUE, WAL TRUE, COSTS FALSE, SUMMARY FALSE, BUFFERS FALSE, TIMING FALSE, BUFFERS OFF)
INSERT INTO test_wal VALUES(2,22);
QUERY PLAN
---------------------------------------------------------------------
@ -208,7 +208,7 @@ INSERT INTO test_wal VALUES(2,22);
-- Test WAL working for multi-shard query
SET citus.explain_all_tasks TO on;
EXPLAIN (ANALYZE TRUE, WAL TRUE, COSTS FALSE, SUMMARY FALSE, BUFFERS FALSE, TIMING FALSE)
EXPLAIN (ANALYZE TRUE, WAL TRUE, COSTS FALSE, SUMMARY FALSE, BUFFERS FALSE, TIMING FALSE, BUFFERS OFF)
INSERT INTO test_wal VALUES(3,33),(4,44),(5,55) RETURNING *;
QUERY PLAN
---------------------------------------------------------------------
@ -229,7 +229,7 @@ INSERT INTO test_wal VALUES(3,33),(4,44),(5,55) RETURNING *;
-- we don't get an error, hence we use explain_has_distributed_subplan.
SELECT public.explain_has_distributed_subplan(
$$
EXPLAIN (ANALYZE TRUE, WAL TRUE, COSTS FALSE, SUMMARY FALSE, BUFFERS FALSE, TIMING FALSE)
EXPLAIN (ANALYZE TRUE, WAL TRUE, COSTS FALSE, SUMMARY FALSE, BUFFERS FALSE, TIMING FALSE, BUFFERS OFF)
WITH cte_1 AS (INSERT INTO test_wal VALUES(6,66),(7,77),(8,88) RETURNING *)
SELECT * FROM cte_1;
$$

2
src/test/regress/expected/pgmerge.out
View File

@ -1372,7 +1372,7 @@ $$
DECLARE ln text;
BEGIN
FOR ln IN
EXECUTE 'explain (analyze, timing off, summary off, costs off) ' ||
EXECUTE 'explain (analyze, timing off, summary off, costs off, buffers off) ' ||
query
LOOP
ln := regexp_replace(ln, '(Memory( Usage)?|Buckets|Batches): \S*', '\1: xxx', 'g');

4
src/test/regress/expected/query_single_shard_table.out
View File

@ -1396,7 +1396,7 @@ DEBUG: Creating router plan
--
-- (*): < SELECT a, b > vs < SELECT table_name.a, table_name.b >
SET client_min_messages TO WARNING;
EXPLAIN (ANALYZE TRUE, TIMING FALSE, COSTS FALSE, SUMMARY FALSE, VERBOSE FALSE)
EXPLAIN (ANALYZE TRUE, TIMING FALSE, COSTS FALSE, SUMMARY FALSE, VERBOSE FALSE, BUFFERS OFF)
INSERT INTO nullkey_c1_t1 SELECT * FROM nullkey_c1_t2;
QUERY PLAN
---------------------------------------------------------------------
@ -1419,7 +1419,7 @@ DEBUG: Creating router plan
DEBUG: Collecting INSERT ... SELECT results on coordinator
-- between a single-shard table and a table of different type
SET client_min_messages TO WARNING;
EXPLAIN (ANALYZE TRUE, TIMING FALSE, COSTS FALSE, SUMMARY FALSE, VERBOSE FALSE)
EXPLAIN (ANALYZE TRUE, TIMING FALSE, COSTS FALSE, SUMMARY FALSE, VERBOSE FALSE, BUFFERS OFF)
INSERT INTO nullkey_c1_t1 SELECT * FROM reference_table;
QUERY PLAN
---------------------------------------------------------------------

2
src/test/regress/expected/single_node.out
View File

@ -983,7 +983,7 @@ BEGIN;
ROLLBACK;
-- explain analyze should work on a single node
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE)
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE, BUFFERS OFF)
SELECT * FROM test;
QUERY PLAN
---------------------------------------------------------------------

2
src/test/regress/expected/single_node_0.out
View File

@ -994,7 +994,7 @@ BEGIN;
ROLLBACK;
-- explain analyze should work on a single node
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE)
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE, BUFFERS OFF)
SELECT * FROM test;
QUERY PLAN
---------------------------------------------------------------------

2
src/test/regress/expected/upgrade_columnar_after.out
View File

@ -184,7 +184,7 @@ SELECT count(*) FROM less_common_data_types_table WHERE dist_key = 1 AND col1 =
set columnar.enable_custom_scan to 'off';
set enable_seqscan to off;
set seq_page_cost TO 10000000;
EXPLAIN (costs off, timing off, summary off, analyze on)
EXPLAIN (costs off, timing off, summary off, analyze on, BUFFERS OFF)
SELECT count(*) FROM less_common_data_types_table WHERE dist_key = 1 AND col1 = ARRAY[1];
QUERY PLAN
---------------------------------------------------------------------

2
src/test/regress/expected/upgrade_columnar_before.out
View File

@ -337,7 +337,7 @@ SELECT count(*) FROM less_common_data_types_table WHERE dist_key = 1 AND col1 =
set columnar.enable_custom_scan to 'off';
set enable_seqscan to off;
set seq_page_cost TO 10000000;
EXPLAIN (costs off, timing off, summary off, analyze on)
EXPLAIN (costs off, timing off, summary off, analyze on, BUFFERS OFF)
SELECT count(*) FROM less_common_data_types_table WHERE dist_key = 1 AND col1 = ARRAY[1];
QUERY PLAN
---------------------------------------------------------------------

4
src/test/regress/sql/binary_protocol.sql
View File

@ -20,9 +20,9 @@ SELECT id, id, id, id, id,
id, id, id, id, id
FROM t ORDER BY id;
EXPLAIN (ANALYZE TRUE, TIMING FALSE, COSTS FALSE, SUMMARY FALSE) SELECT id FROM t ORDER BY 1;
EXPLAIN (ANALYZE TRUE, TIMING FALSE, COSTS FALSE, SUMMARY FALSE, BUFFERS OFF) SELECT id FROM t ORDER BY 1;
SET citus.explain_all_tasks TO ON;
EXPLAIN (ANALYZE TRUE, TIMING FALSE, COSTS FALSE, SUMMARY FALSE) SELECT id FROM t ORDER BY 1;
EXPLAIN (ANALYZE TRUE, TIMING FALSE, COSTS FALSE, SUMMARY FALSE, BUFFERS OFF) SELECT id FROM t ORDER BY 1;
INSERT INTO t SELECT count(*) from t;

52
src/test/regress/sql/columnar_chunk_filtering.sql
View File

@ -79,10 +79,10 @@ SELECT * FROM collation_chunk_filtering_test WHERE A > 'B';
CREATE TABLE simple_chunk_filtering(i int) USING COLUMNAR;
INSERT INTO simple_chunk_filtering SELECT generate_series(0,234567);
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM simple_chunk_filtering WHERE i > 123456;
SET columnar.enable_qual_pushdown = false;
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM simple_chunk_filtering WHERE i > 123456;
SET columnar.enable_qual_pushdown TO DEFAULT;
@ -90,7 +90,7 @@ SET columnar.enable_qual_pushdown TO DEFAULT;
TRUNCATE simple_chunk_filtering;
INSERT INTO simple_chunk_filtering SELECT generate_series(0,200000);
COPY (SELECT * FROM simple_chunk_filtering WHERE i > 180000) TO '/dev/null';
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM simple_chunk_filtering WHERE i > 180000;
DROP TABLE simple_chunk_filtering;
@ -99,39 +99,39 @@ DROP TABLE simple_chunk_filtering;
CREATE TABLE multi_column_chunk_filtering(a int, b int) USING columnar;
INSERT INTO multi_column_chunk_filtering SELECT i,i+1 FROM generate_series(0,234567) i;
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT count(*) FROM multi_column_chunk_filtering WHERE a > 50000;
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT count(*) FROM multi_column_chunk_filtering WHERE a > 50000 AND b > 50000;
-- make next tests faster
TRUNCATE multi_column_chunk_filtering;
INSERT INTO multi_column_chunk_filtering SELECT generate_series(0,5);
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT b FROM multi_column_chunk_filtering WHERE a > 50000 AND b > 50000;
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT b, a FROM multi_column_chunk_filtering WHERE b > 50000;
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT FROM multi_column_chunk_filtering WHERE a > 50000;
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT FROM multi_column_chunk_filtering;
BEGIN;
ALTER TABLE multi_column_chunk_filtering DROP COLUMN a;
ALTER TABLE multi_column_chunk_filtering DROP COLUMN b;
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM multi_column_chunk_filtering;
ROLLBACK;
CREATE TABLE another_columnar_table(x int, y int) USING columnar;
INSERT INTO another_columnar_table SELECT generate_series(0,5);
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT a, y FROM multi_column_chunk_filtering, another_columnar_table WHERE x > 1;
EXPLAIN (costs off, timing off, summary off)
@ -219,7 +219,7 @@ set enable_hashjoin=false;
set enable_material=false;
-- test different kinds of expressions
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM r1, coltest WHERE
id1 = id AND x1 > 15000 AND x1::text > '000000' AND n1 % 10 = 0;
SELECT * FROM r1, coltest WHERE
@ -227,7 +227,7 @@ SELECT * FROM r1, coltest WHERE
-- test equivalence classes
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM r1, r2, r3, r4, r5, r6, r7, coltest WHERE
id = id1 AND id1 = id2 AND id2 = id3 AND id3 = id4 AND
id4 = id5 AND id5 = id6 AND id6 = id7;
@ -258,7 +258,7 @@ set columnar.planner_debug_level to default;
set columnar.planner_debug_level = 'notice';
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM r1, r2, r3, coltest WHERE
id1 = id2 AND id2 = id3 AND id3 = id AND
n1 > x1 AND n2 > x2 AND n3 > x3;
@ -270,7 +270,7 @@ SELECT * FROM r1, r2, r3, coltest WHERE
n1 > x1 AND n2 > x2 AND n3 > x3;
-- test partitioning parameterization
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM r1, coltest_part WHERE
id1 = id AND n1 > x1;
SELECT * FROM r1, coltest_part WHERE
@ -300,7 +300,7 @@ END;
$$;
select * from coltest where x3 = vol();
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM coltest c1 WHERE ceil(x1) > 4222;
set columnar.planner_debug_level to default;
@ -391,32 +391,32 @@ COMMIT;
SET columnar.max_custom_scan_paths TO 50;
SET columnar.qual_pushdown_correlation_threshold TO 0.0;
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT sum(a) FROM pushdown_test WHERE a = 204356 or a = 104356 or a = 76556;
SELECT sum(a) FROM pushdown_test WHERE a = 204356 or a = 104356 or a = 76556;
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT sum(a) FROM pushdown_test WHERE a = 194356 or a = 104356 or a = 76556;
SELECT sum(a) FROM pushdown_test WHERE a = 194356 or a = 104356 or a = 76556;
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT sum(a) FROM pushdown_test WHERE a = 204356 or a > a*-1 + b;
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT sum(a) FROM pushdown_test where (a > 1000 and a < 10000) or (a > 20000 and a < 50000);
SELECT sum(a) FROM pushdown_test where (a > 1000 and a < 10000) or (a > 20000 and a < 50000);
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT sum(a) FROM pushdown_test where (a > random() and a < 2*a) or (a > 100);
SELECT sum(a) FROM pushdown_test where (a > random() and a < 2*a) or (a > 100);
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT sum(a) FROM pushdown_test where (a > random() and a <= 2000) or (a > 200000-1010);
SELECT sum(a) FROM pushdown_test where (a > random() and a <= 2000) or (a > 200000-1010);
SET hash_mem_multiplier = 1.0;
SELECT columnar_test_helpers.explain_with_pg16_subplan_format($Q$
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT sum(a) FROM pushdown_test where
(
a > random()
@ -445,7 +445,7 @@ or
create function stable_1(arg int) returns int language plpgsql STRICT IMMUTABLE as
$$ BEGIN RETURN 1+arg; END; $$;
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT sum(a) FROM pushdown_test where (a = random() and a < stable_1(a) and a < stable_1(6000));
SELECT sum(a) FROM pushdown_test where (a = random() and a < stable_1(a) and a < stable_1(6000));
@ -476,7 +476,7 @@ BEGIN;
INSERT INTO pushdown_test VALUES(7, 'USA');
INSERT INTO pushdown_test VALUES(8, 'ZW');
END;
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT id FROM pushdown_test WHERE country IN ('USA', 'BR', 'ZW');
SELECT id FROM pushdown_test WHERE country IN ('USA', 'BR', 'ZW');
@ -488,7 +488,7 @@ BEGIN
return 'AL';
END;
$$;
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM pushdown_test WHERE country IN ('USA', 'ZW', volatileFunction());
SELECT * FROM pushdown_test WHERE country IN ('USA', 'ZW', volatileFunction());

4
src/test/regress/sql/columnar_cursor.sql
View File

@ -6,7 +6,7 @@ CREATE TABLE test_cursor (a int, b int) USING columnar;
INSERT INTO test_cursor SELECT i, j FROM generate_series(0, 100)i, generate_series(100, 200)j;
-- A case where the WHERE clause might filter out some chunks
EXPLAIN (analyze on, costs off, timing off, summary off) SELECT * FROM test_cursor WHERE a = 25;
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF) SELECT * FROM test_cursor WHERE a = 25;
BEGIN;
DECLARE a_25 SCROLL CURSOR
FOR SELECT * FROM test_cursor WHERE a = 25 ORDER BY 2;
@ -33,7 +33,7 @@ UPDATE test_cursor SET a = 8000 WHERE CURRENT OF a_25;
COMMIT;
-- A case where the WHERE clause doesn't filter out any chunks
EXPLAIN (analyze on, costs off, timing off, summary off) SELECT * FROM test_cursor WHERE a > 25;
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF) SELECT * FROM test_cursor WHERE a > 25;
BEGIN;
DECLARE a_25 SCROLL CURSOR
FOR SELECT * FROM test_cursor WHERE a > 25 ORDER BY 1, 2;

4
src/test/regress/sql/columnar_paths.sql
View File

@ -361,12 +361,12 @@ CREATE INDEX uncorrelated_idx ON uncorrelated(x);
ANALYZE correlated, uncorrelated;
-- should choose chunk group filtering; selective and correlated
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM correlated WHERE x = 78910;
SELECT * FROM correlated WHERE x = 78910;
-- should choose index scan; selective but uncorrelated
EXPLAIN (analyze on, costs off, timing off, summary off)
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF)
SELECT * FROM uncorrelated WHERE x = 78910;
SELECT * FROM uncorrelated WHERE x = 78910;

12
src/test/regress/sql/columnar_transactions.sql
View File

@ -102,42 +102,42 @@ SELECT * FROM t ORDER BY a;
PREPARE p0 AS INSERT INTO t VALUES (8, 8), (9, 9);
EXPLAIN (COSTS OFF) EXECUTE p0;
EXECUTE p0;
EXPLAIN (ANALYZE true, COSTS off, TIMING off, SUMMARY off) EXECUTE p0;
EXPLAIN (ANALYZE true, COSTS off, TIMING off, SUMMARY off, BUFFERS OFF) EXECUTE p0;
SELECT * FROM t ORDER BY a;
-- INSERT INTO with 1 param
PREPARE p1(int) AS INSERT INTO t VALUES (10, $1), (11, $1+2);
EXPLAIN (COSTS OFF) EXECUTE p1(16);
EXECUTE p1(16);
EXPLAIN (ANALYZE true, COSTS off, TIMING off, SUMMARY off) EXECUTE p1(20);
EXPLAIN (ANALYZE true, COSTS off, TIMING off, SUMMARY off, BUFFERS OFF) EXECUTE p1(20);
SELECT * FROM t ORDER BY a;
-- INSERT INTO with >1 params
PREPARE p2(int, int) AS INSERT INTO t VALUES (12, $1), (13, $1+2), (14, $2), ($1+1, $2+1);
EXPLAIN (COSTS OFF) EXECUTE p2(30, 40);
EXECUTE p2(30, 40);
EXPLAIN (ANALYZE true, COSTS off, TIMING off, SUMMARY off) EXECUTE p2(50, 60);
EXPLAIN (ANALYZE true, COSTS off, TIMING off, SUMMARY off, BUFFERS OFF) EXECUTE p2(50, 60);
SELECT * FROM t ORDER BY a;
-- SELECT with 0 params
PREPARE p3 AS SELECT * FROM t WHERE a = 8;
EXPLAIN (COSTS OFF) EXECUTE p3;
EXECUTE p3;
EXPLAIN (ANALYZE true, COSTS off, TIMING off, SUMMARY off) EXECUTE p3;
EXPLAIN (ANALYZE true, COSTS off, TIMING off, SUMMARY off, BUFFERS OFF) EXECUTE p3;
SELECT * FROM t ORDER BY a;
-- SELECT with 1 param
PREPARE p5(int) AS SELECT * FROM t WHERE a = $1;
EXPLAIN (COSTS OFF) EXECUTE p5(16);
EXECUTE p5(16);
EXPLAIN (ANALYZE true, COSTS off, TIMING off, SUMMARY off) EXECUTE p5(9);
EXPLAIN (ANALYZE true, COSTS off, TIMING off, SUMMARY off, BUFFERS OFF) EXECUTE p5(9);
SELECT * FROM t ORDER BY a;
-- SELECT with >1 params
PREPARE p6(int, int) AS SELECT * FROM t WHERE a = $1+1 AND b = $2+1;
EXPLAIN (COSTS OFF) EXECUTE p6(30, 40);
EXECUTE p6(30, 40);
EXPLAIN (ANALYZE true, COSTS off, TIMING off, SUMMARY off) EXECUTE p6(50, 60);
EXPLAIN (ANALYZE true, COSTS off, TIMING off, SUMMARY off, BUFFERS OFF) EXECUTE p6(50, 60);
SELECT * FROM t ORDER BY a;
DROP TABLE t;

2
src/test/regress/sql/coordinator_shouldhaveshards.sql
View File

@ -66,7 +66,7 @@ ROLLBACK;
-- INSERT..SELECT with re-partitioning in EXPLAIN ANALYZE after local execution
BEGIN;
INSERT INTO test VALUES (0,1000);
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE) INSERT INTO test (x, y) SELECT y, x FROM test;
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE, BUFFERS OFF) INSERT INTO test (x, y) SELECT y, x FROM test;
ROLLBACK;
-- DDL connects to locahost

2
src/test/regress/sql/local_shard_execution.sql
View File

@ -220,7 +220,7 @@ EXPLAIN (COSTS OFF) SELECT * FROM distributed_table WHERE key = 1 AND age = 20;
EXPLAIN (ANALYZE, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM distributed_table WHERE key = 1 AND age = 20;
EXPLAIN (ANALYZE ON, COSTS OFF, SUMMARY OFF, TIMING OFF)
EXPLAIN (ANALYZE ON, COSTS OFF, SUMMARY OFF, TIMING OFF, BUFFERS OFF)
WITH r AS ( SELECT GREATEST(random(), 2) z,* FROM distributed_table)
SELECT 1 FROM r WHERE z < 3;

2
src/test/regress/sql/local_shard_execution_replicated.sql
View File

@ -185,7 +185,7 @@ EXPLAIN (COSTS OFF) SELECT * FROM distributed_table WHERE key = 1 AND age = 20;
EXPLAIN (ANALYZE, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM distributed_table WHERE key = 1 AND age = 20;
EXPLAIN (ANALYZE ON, COSTS OFF, SUMMARY OFF, TIMING OFF)
EXPLAIN (ANALYZE ON, COSTS OFF, SUMMARY OFF, TIMING OFF, BUFFERS OFF)
WITH r AS ( SELECT GREATEST(random(), 2) z,* FROM distributed_table)
SELECT 1 FROM r WHERE z < 3;

8
src/test/regress/sql/merge.sql
View File

@ -1282,7 +1282,7 @@ WHEN NOT MATCHED THEN
VALUES (s.some_number, 'parag');
-- let's verify if data inserted to second shard of target.
EXPLAIN (analyze on, costs off, timing off, summary off) SELECT * FROM target_table;
EXPLAIN (analyze on, costs off, timing off, summary off, BUFFERS OFF) SELECT * FROM target_table;
-- let's verify target data too.
SELECT * FROM target_table;
@ -1577,7 +1577,7 @@ SELECT create_distributed_table('target_json','id'), create_distributed_table('s
-- single shard query given source_json is filtered and Postgres is smart to pushdown
-- filter to the target_json as well
SELECT public.coordinator_plan($Q$
EXPLAIN (ANALYZE ON, TIMING OFF) MERGE INTO target_json sda
EXPLAIN (ANALYZE ON, TIMING OFF, BUFFERS OFF) MERGE INTO target_json sda
USING (SELECT * FROM source_json WHERE id = 1) sdn
ON sda.id = sdn.id
WHEN NOT matched THEN
@ -1597,7 +1597,7 @@ SELECT * FROM target_json ORDER BY 1;
-- join for source_json is happening at a different place
SELECT public.coordinator_plan($Q$
EXPLAIN (ANALYZE ON, TIMING OFF) MERGE INTO target_json sda
EXPLAIN (ANALYZE ON, TIMING OFF, BUFFERS OFF) MERGE INTO target_json sda
USING source_json s1 LEFT JOIN (SELECT * FROM source_json) s2 USING(z)
ON sda.id = s1.id AND s1.id = s2.id
WHEN NOT matched THEN
@ -1607,7 +1607,7 @@ SELECT * FROM target_json ORDER BY 1;
-- update JSON column
SELECT public.coordinator_plan($Q$
EXPLAIN (ANALYZE ON, TIMING OFF) MERGE INTO target_json sda
EXPLAIN (ANALYZE ON, TIMING OFF, BUFFERS OFF) MERGE INTO target_json sda
USING source_json sdn
ON sda.id = sdn.id
WHEN matched THEN

4
src/test/regress/sql/multi_data_types.sql
View File

@ -125,7 +125,7 @@ $cf$);
INSERT INTO composite_type_partitioned_table VALUES (123, '(123, 456)'::other_composite_type);
SELECT * FROM composite_type_partitioned_table WHERE id = 123;
EXPLAIN (ANALYZE TRUE, COSTS FALSE, VERBOSE FALSE, TIMING FALSE, SUMMARY FALSE)
EXPLAIN (ANALYZE TRUE, COSTS FALSE, VERBOSE FALSE, TIMING FALSE, SUMMARY FALSE, BUFFERS OFF)
INSERT INTO composite_type_partitioned_table VALUES (123, '(123, 456)'::other_composite_type);
SELECT run_command_on_coordinator_and_workers($cf$
@ -144,7 +144,7 @@ SELECT run_command_on_coordinator_and_workers($cf$
$cf$);
INSERT INTO composite_type_partitioned_table VALUES (456, '(456, 678)'::other_composite_type);
EXPLAIN (ANALYZE TRUE, COSTS FALSE, VERBOSE FALSE, TIMING FALSE, SUMMARY FALSE)
EXPLAIN (ANALYZE TRUE, COSTS FALSE, VERBOSE FALSE, TIMING FALSE, SUMMARY FALSE, BUFFERS OFF)
INSERT INTO composite_type_partitioned_table VALUES (123, '(456, 678)'::other_composite_type);

38
src/test/regress/sql/multi_explain.sql
View File

@ -130,7 +130,7 @@ EXPLAIN (COSTS FALSE, FORMAT TEXT)
-- Test analyze (with TIMING FALSE and SUMMARY FALSE for consistent output)
SELECT public.plan_normalize_memory($Q$
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE)
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE, BUFFERS OFF)
SELECT l_quantity, count(*) count_quantity FROM lineitem
GROUP BY l_quantity ORDER BY count_quantity, l_quantity;
$Q$);
@ -142,9 +142,9 @@ CREATE TABLE t2(a int, b int);
SELECT create_distributed_table('t1', 'a'), create_distributed_table('t2', 'a');
BEGIN;
SET LOCAL citus.enable_repartition_joins TO true;
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off) SELECT count(*) FROM t1, t2 WHERE t1.a=t2.b;
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, BUFFERS OFF) SELECT count(*) FROM t1, t2 WHERE t1.a=t2.b;
-- Confirm repartiton join in distributed subplan works
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off)
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, BUFFERS OFF)
WITH repartition AS (SELECT count(*) FROM t1, t2 WHERE t1.a=t2.b)
SELECT count(*) from repartition;
END;
@ -152,7 +152,7 @@ DROP TABLE t1, t2;
-- Test query text output, with ANALYZE ON
SELECT public.plan_normalize_memory($Q$
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE, VERBOSE TRUE)
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE, VERBOSE TRUE, BUFFERS OFF)
SELECT l_quantity, count(*) count_quantity FROM lineitem
GROUP BY l_quantity ORDER BY count_quantity, l_quantity;
$Q$);
@ -184,7 +184,7 @@ EXPLAIN (COSTS FALSE)
-- Test analyze (with TIMING FALSE and SUMMARY FALSE for consistent output)
BEGIN;
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE)
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE, BUFFERS OFF)
UPDATE lineitem
SET l_suppkey = 12
WHERE l_orderkey = 1 AND l_partkey = 0;
@ -488,7 +488,7 @@ EXPLAIN (COSTS FALSE)
-- Test analyze (with TIMING FALSE and SUMMARY FALSE for consistent output)
SELECT public.plan_normalize_memory($Q$
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE)
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE, BUFFERS OFF)
SELECT l_quantity, count(*) count_quantity FROM lineitem
GROUP BY l_quantity ORDER BY count_quantity, l_quantity;
$Q$);
@ -597,7 +597,7 @@ EXPLAIN (COSTS FALSE) EXECUTE real_time_executor_query;
-- at least make sure to fail without crashing
PREPARE router_executor_query_param(int) AS SELECT l_quantity FROM lineitem WHERE l_orderkey = $1;
EXPLAIN EXECUTE router_executor_query_param(5);
EXPLAIN (ANALYZE ON, COSTS OFF, TIMING OFF, SUMMARY OFF) EXECUTE router_executor_query_param(5);
EXPLAIN (ANALYZE ON, COSTS OFF, TIMING OFF, SUMMARY OFF, BUFFERS OFF) EXECUTE router_executor_query_param(5);
\set VERBOSITY TERSE
PREPARE multi_shard_query_param(int) AS UPDATE lineitem SET l_quantity = $1;
@ -605,7 +605,7 @@ BEGIN;
EXPLAIN (COSTS OFF) EXECUTE multi_shard_query_param(5);
ROLLBACK;
BEGIN;
EXPLAIN (ANALYZE ON, COSTS OFF, TIMING OFF, SUMMARY OFF) EXECUTE multi_shard_query_param(5);
EXPLAIN (ANALYZE ON, COSTS OFF, TIMING OFF, SUMMARY OFF, BUFFERS OFF) EXECUTE multi_shard_query_param(5);
ROLLBACK;
\set VERBOSITY DEFAULT
@ -865,7 +865,7 @@ SET citus.shard_count TO 4;
SET client_min_messages TO WARNING;
SELECT create_distributed_table('explain_analyze_test', 'a');
\set default_analyze_flags '(ANALYZE on, COSTS off, TIMING off, SUMMARY off)'
\set default_analyze_flags '(ANALYZE on, COSTS off, TIMING off, SUMMARY off, BUFFERS off)'
\set default_explain_flags '(ANALYZE off, COSTS off, TIMING off, SUMMARY off)'
-- router SELECT
@ -928,16 +928,16 @@ ROLLBACK;
-- test EXPLAIN ANALYZE with non-text output formats
BEGIN;
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, FORMAT JSON) INSERT INTO explain_pk VALUES (1, 2), (2, 3);
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, FORMAT JSON, BUFFERS OFF) INSERT INTO explain_pk VALUES (1, 2), (2, 3);
ROLLBACK;
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, FORMAT JSON) SELECT * FROM explain_pk;
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, FORMAT JSON, BUFFERS OFF) SELECT * FROM explain_pk;
BEGIN;
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, FORMAT XML) INSERT INTO explain_pk VALUES (1, 2), (2, 3);
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, FORMAT XML, BUFFERS OFF) INSERT INTO explain_pk VALUES (1, 2), (2, 3);
ROLLBACK;
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, FORMAT XML) SELECT * FROM explain_pk;
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, FORMAT XML, BUFFERS OFF) SELECT * FROM explain_pk;
DROP TABLE explain_pk;
@ -960,7 +960,7 @@ EXPLAIN :default_analyze_flags
SELECT count(distinct a) FROM (SELECT GREATEST(random(), 2) r, a FROM dist_table) t NATURAL JOIN ref_table;
SELECT public.explain_with_pg17_initplan_format($Q$
EXPLAIN (ANALYZE on, COSTS off, TIMING off, SUMMARY off)
EXPLAIN (ANALYZE on, COSTS off, TIMING off, SUMMARY off, BUFFERS OFF)
SELECT count(distinct a) FROM dist_table
WHERE EXISTS(SELECT random() < 2 FROM dist_table NATURAL JOIN ref_table);
$Q$);
@ -1114,9 +1114,9 @@ SELECT create_distributed_table('explain_analyze_execution_time', 'a');
-- sleep for the shard that has the single row, so that
-- will definitely be slower
set citus.explain_analyze_sort_method to "taskId";
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE) select a, CASE WHEN pg_sleep(0.4) IS NULL THEN 'x' END from explain_analyze_execution_time;
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE, BUFFERS OFF) select a, CASE WHEN pg_sleep(0.4) IS NULL THEN 'x' END from explain_analyze_execution_time;
set citus.explain_analyze_sort_method to "execution-time";
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE) select a, CASE WHEN pg_sleep(0.4) IS NULL THEN 'x' END from explain_analyze_execution_time;
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE, BUFFERS OFF) select a, CASE WHEN pg_sleep(0.4) IS NULL THEN 'x' END from explain_analyze_execution_time;
-- reset back
reset citus.explain_analyze_sort_method;
DROP TABLE explain_analyze_execution_time;
@ -1171,7 +1171,7 @@ SET search_path TO multi_explain;
CREATE TABLE test_subplans (x int primary key, y int);
SELECT create_distributed_table('test_subplans','x');
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off)
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, BUFFERS OFF)
WITH a AS (INSERT INTO test_subplans VALUES (1,2) RETURNING *)
SELECT * FROM a;
@ -1179,13 +1179,13 @@ SELECT * FROM a;
SELECT * FROM test_subplans;
-- Will fail with duplicate pk
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off)
EXPLAIN (COSTS off, ANALYZE on, TIMING off, SUMMARY off, BUFFERS OFF)
WITH a AS (INSERT INTO test_subplans VALUES (1,2) RETURNING *)
SELECT * FROM a;
-- Test JSON format
TRUNCATE test_subplans;
EXPLAIN (FORMAT JSON, COSTS off, ANALYZE on, TIMING off, SUMMARY off)
EXPLAIN (FORMAT JSON, COSTS off, ANALYZE on, TIMING off, SUMMARY off, BUFFERS OFF)
WITH a AS (INSERT INTO test_subplans VALUES (1,2) RETURNING *)
SELECT * FROM a;

2
src/test/regress/sql/multi_insert_select.sql
View File

@ -682,7 +682,7 @@ SET client_min_messages TO WARNING;
$Q$);
-- EXPLAIN ANALYZE is not supported for INSERT ... SELECT via coordinator
EXPLAIN (costs off, analyze on)
EXPLAIN (costs off, analyze on, BUFFERS OFF)
INSERT INTO agg_events (user_id)
SELECT
raw_events_first.user_id

8
src/test/regress/sql/pg13.sql
View File

@ -93,15 +93,15 @@ CREATE TABLE test_wal(a int, b int);
-- test WAL without ANALYZE, this should raise an error
EXPLAIN (WAL) INSERT INTO test_wal VALUES(1,11);
-- test WAL working properly for router queries
EXPLAIN (ANALYZE TRUE, WAL TRUE, COSTS FALSE, SUMMARY FALSE, BUFFERS FALSE, TIMING FALSE)
EXPLAIN (ANALYZE TRUE, WAL TRUE, COSTS FALSE, SUMMARY FALSE, BUFFERS FALSE, TIMING FALSE, BUFFERS OFF)
INSERT INTO test_wal VALUES(1,11);
SELECT create_distributed_table('test_wal', 'a');
EXPLAIN (ANALYZE TRUE, WAL TRUE, COSTS FALSE, SUMMARY FALSE, BUFFERS FALSE, TIMING FALSE)
EXPLAIN (ANALYZE TRUE, WAL TRUE, COSTS FALSE, SUMMARY FALSE, BUFFERS FALSE, TIMING FALSE, BUFFERS OFF)
INSERT INTO test_wal VALUES(2,22);
-- Test WAL working for multi-shard query
SET citus.explain_all_tasks TO on;
EXPLAIN (ANALYZE TRUE, WAL TRUE, COSTS FALSE, SUMMARY FALSE, BUFFERS FALSE, TIMING FALSE)
EXPLAIN (ANALYZE TRUE, WAL TRUE, COSTS FALSE, SUMMARY FALSE, BUFFERS FALSE, TIMING FALSE, BUFFERS OFF)
INSERT INTO test_wal VALUES(3,33),(4,44),(5,55) RETURNING *;
-- make sure WAL works in distributed subplans
@ -109,7 +109,7 @@ INSERT INTO test_wal VALUES(3,33),(4,44),(5,55) RETURNING *;
-- we don't get an error, hence we use explain_has_distributed_subplan.
SELECT public.explain_has_distributed_subplan(
$$
EXPLAIN (ANALYZE TRUE, WAL TRUE, COSTS FALSE, SUMMARY FALSE, BUFFERS FALSE, TIMING FALSE)
EXPLAIN (ANALYZE TRUE, WAL TRUE, COSTS FALSE, SUMMARY FALSE, BUFFERS FALSE, TIMING FALSE, BUFFERS OFF)
WITH cte_1 AS (INSERT INTO test_wal VALUES(6,66),(7,77),(8,88) RETURNING *)
SELECT * FROM cte_1;
$$

2
src/test/regress/sql/pgmerge.sql
View File

@ -894,7 +894,7 @@ $$
DECLARE ln text;
BEGIN
FOR ln IN
EXECUTE 'explain (analyze, timing off, summary off, costs off) ' ||
EXECUTE 'explain (analyze, timing off, summary off, costs off, buffers off) ' ||
query
LOOP
ln := regexp_replace(ln, '(Memory( Usage)?|Buckets|Batches): \S*', '\1: xxx', 'g');

4
src/test/regress/sql/query_single_shard_table.sql
View File

@ -618,7 +618,7 @@ JOIN LATERAL (
--
-- (*): < SELECT a, b > vs < SELECT table_name.a, table_name.b >
SET client_min_messages TO WARNING;
EXPLAIN (ANALYZE TRUE, TIMING FALSE, COSTS FALSE, SUMMARY FALSE, VERBOSE FALSE)
EXPLAIN (ANALYZE TRUE, TIMING FALSE, COSTS FALSE, SUMMARY FALSE, VERBOSE FALSE, BUFFERS OFF)
INSERT INTO nullkey_c1_t1 SELECT * FROM nullkey_c1_t2;
SET client_min_messages TO DEBUG2;
@ -627,7 +627,7 @@ INSERT INTO nullkey_c1_t1 SELECT * FROM nullkey_c2_t1;
-- between a single-shard table and a table of different type
SET client_min_messages TO WARNING;
EXPLAIN (ANALYZE TRUE, TIMING FALSE, COSTS FALSE, SUMMARY FALSE, VERBOSE FALSE)
EXPLAIN (ANALYZE TRUE, TIMING FALSE, COSTS FALSE, SUMMARY FALSE, VERBOSE FALSE, BUFFERS OFF)
INSERT INTO nullkey_c1_t1 SELECT * FROM reference_table;
SET client_min_messages TO DEBUG2;

2
src/test/regress/sql/single_node.sql
View File

@ -591,7 +591,7 @@ BEGIN;
ROLLBACK;
-- explain analyze should work on a single node
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE)
EXPLAIN (COSTS FALSE, ANALYZE TRUE, TIMING FALSE, SUMMARY FALSE, BUFFERS OFF)
SELECT * FROM test;
-- common utility command

2
src/test/regress/sql/upgrade_columnar_after.sql
View File

@ -65,7 +65,7 @@ set columnar.enable_custom_scan to 'off';
set enable_seqscan to off;
set seq_page_cost TO 10000000;
EXPLAIN (costs off, timing off, summary off, analyze on)
EXPLAIN (costs off, timing off, summary off, analyze on, BUFFERS OFF)
SELECT count(*) FROM less_common_data_types_table WHERE dist_key = 1 AND col1 = ARRAY[1];
-- make sure that we re-enable columnar scan

2
src/test/regress/sql/upgrade_columnar_before.sql
View File

@ -253,7 +253,7 @@ set columnar.enable_custom_scan to 'off';
set enable_seqscan to off;
set seq_page_cost TO 10000000;
EXPLAIN (costs off, timing off, summary off, analyze on)
EXPLAIN (costs off, timing off, summary off, analyze on, BUFFERS OFF)
SELECT count(*) FROM less_common_data_types_table WHERE dist_key = 1 AND col1 = ARRAY[1];
-- make sure that we re-enable columnar scan