mirror of
https://github.com/postgres/postgres.git
synced 2025-10-31 10:30:33 +03:00
daa8365a90
Applying normalization changes how the following query strings are
reflected in pg_stat_statements, by showing Const nodes with a
dollar-signed parameter as this is how such queries are structured
internally once parsed:
- DECLARE
- EXPLAIN
- CREATE MATERIALIZED VIEW
- CREATE TABLE AS
More normalization could be done in the future depending on the parts
where query jumbling is applied (like A_Const nodes?), the changes being
reflected in the regression tests in majority created in de2aca2. This
just allows the basics to work for utility queries using Const nodes.
Reviewed-by: Bertrand Drouvot
Discussion: https://postgr.es/m/Y+MRdEq9W9XVa2AB@paquier.xyz
563 lines
21 KiB
Plaintext
563 lines
21 KiB
Plaintext
--
|
|
-- Utility commands
|
|
--
|
|
-- These tests require track_utility to be enabled.
|
|
SET pg_stat_statements.track_utility = TRUE;
|
|
SELECT pg_stat_statements_reset();
|
|
pg_stat_statements_reset
|
|
--------------------------
|
|
|
|
(1 row)
|
|
|
|
-- Tables, indexes, triggers
|
|
CREATE TEMP TABLE tab_stats (a int, b char(20));
|
|
CREATE INDEX index_stats ON tab_stats(b, (b || 'data1'), (b || 'data2')) WHERE a > 0;
|
|
ALTER TABLE tab_stats ALTER COLUMN b set default 'a';
|
|
ALTER TABLE tab_stats ALTER COLUMN b TYPE text USING 'data' || b;
|
|
ALTER TABLE tab_stats ADD CONSTRAINT a_nonzero CHECK (a <> 0);
|
|
DROP TABLE tab_stats \;
|
|
DROP TABLE IF EXISTS tab_stats \;
|
|
-- This DROP query uses two different strings, still they count as one entry.
|
|
DROP TABLE IF EXISTS tab_stats \;
|
|
Drop Table If Exists tab_stats \;
|
|
SELECT calls, rows, query FROM pg_stat_statements ORDER BY query COLLATE "C";
|
|
NOTICE: table "tab_stats" does not exist, skipping
|
|
NOTICE: table "tab_stats" does not exist, skipping
|
|
NOTICE: table "tab_stats" does not exist, skipping
|
|
calls | rows | query
|
|
-------+------+--------------------------------------------------------------------------------------
|
|
1 | 0 | ALTER TABLE tab_stats ADD CONSTRAINT a_nonzero CHECK (a <> 0)
|
|
1 | 0 | ALTER TABLE tab_stats ALTER COLUMN b TYPE text USING 'data' || b
|
|
1 | 0 | ALTER TABLE tab_stats ALTER COLUMN b set default 'a'
|
|
1 | 0 | CREATE INDEX index_stats ON tab_stats(b, (b || 'data1'), (b || 'data2')) WHERE a > 0
|
|
1 | 0 | CREATE TEMP TABLE tab_stats (a int, b char(20))
|
|
3 | 0 | DROP TABLE IF EXISTS tab_stats
|
|
1 | 0 | DROP TABLE tab_stats
|
|
1 | 1 | SELECT pg_stat_statements_reset()
|
|
(8 rows)
|
|
|
|
SELECT pg_stat_statements_reset();
|
|
pg_stat_statements_reset
|
|
--------------------------
|
|
|
|
(1 row)
|
|
|
|
-- Partitions
|
|
CREATE TABLE pt_stats (a int, b int) PARTITION BY range (a);
|
|
CREATE TABLE pt_stats1 (a int, b int);
|
|
ALTER TABLE pt_stats ATTACH PARTITION pt_stats1 FOR VALUES FROM (0) TO (100);
|
|
CREATE TABLE pt_stats2 PARTITION OF pt_stats FOR VALUES FROM (100) TO (200);
|
|
CREATE INDEX pt_stats_index ON ONLY pt_stats (a);
|
|
CREATE INDEX pt_stats2_index ON ONLY pt_stats2 (a);
|
|
ALTER INDEX pt_stats_index ATTACH PARTITION pt_stats2_index;
|
|
DROP TABLE pt_stats;
|
|
-- Views
|
|
CREATE VIEW view_stats AS SELECT 1::int AS a, 2::int AS b;
|
|
ALTER VIEW view_stats ALTER COLUMN a SET DEFAULT 2;
|
|
DROP VIEW view_stats;
|
|
-- Foreign tables
|
|
CREATE FOREIGN DATA WRAPPER wrapper_stats;
|
|
CREATE SERVER server_stats FOREIGN DATA WRAPPER wrapper_stats;
|
|
CREATE FOREIGN TABLE foreign_stats (a int) SERVER server_stats;
|
|
ALTER FOREIGN TABLE foreign_stats ADD COLUMN b integer DEFAULT 1;
|
|
ALTER FOREIGN TABLE foreign_stats ADD CONSTRAINT b_nonzero CHECK (b <> 0);
|
|
DROP FOREIGN TABLE foreign_stats;
|
|
DROP SERVER server_stats;
|
|
DROP FOREIGN DATA WRAPPER wrapper_stats;
|
|
-- Functions
|
|
CREATE FUNCTION func_stats(a text DEFAULT 'a_data', b text DEFAULT lower('b_data'))
|
|
RETURNS text AS $$ SELECT $1::text || '_' || $2::text; $$ LANGUAGE SQL;
|
|
DROP FUNCTION func_stats;
|
|
-- Rules
|
|
CREATE TABLE tab_rule_stats (a int, b int);
|
|
CREATE TABLE tab_rule_stats_2 (a int, b int, c int, d int);
|
|
CREATE RULE rules_stats AS ON INSERT TO tab_rule_stats DO INSTEAD
|
|
INSERT INTO tab_rule_stats_2 VALUES(new.*, 1, 2);
|
|
DROP RULE rules_stats ON tab_rule_stats;
|
|
DROP TABLE tab_rule_stats, tab_rule_stats_2;
|
|
-- Types
|
|
CREATE TYPE stats_type as (f1 numeric(35, 6), f2 numeric(35, 2));
|
|
DROP TYPE stats_type;
|
|
-- Triggers
|
|
CREATE TABLE trigger_tab_stats (a int, b int);
|
|
CREATE FUNCTION trigger_func_stats () RETURNS trigger LANGUAGE plpgsql
|
|
AS $$ BEGIN return OLD; end; $$;
|
|
CREATE TRIGGER trigger_tab_stats
|
|
AFTER UPDATE ON trigger_tab_stats
|
|
FOR EACH ROW WHEN (OLD.a < 0 AND OLD.b < 1 AND true)
|
|
EXECUTE FUNCTION trigger_func_stats();
|
|
DROP TABLE trigger_tab_stats;
|
|
-- Policies
|
|
CREATE TABLE tab_policy_stats (a int, b int);
|
|
CREATE POLICY policy_stats ON tab_policy_stats USING (a = 5) WITH CHECK (b < 5);
|
|
DROP TABLE tab_policy_stats;
|
|
-- Statistics
|
|
CREATE TABLE tab_expr_stats (a int, b int);
|
|
CREATE STATISTICS tab_expr_stats_1 (mcv) ON a, (2*a), (3*b) FROM tab_expr_stats;
|
|
DROP TABLE tab_expr_stats;
|
|
SELECT calls, rows, query FROM pg_stat_statements ORDER BY query COLLATE "C";
|
|
calls | rows | query
|
|
-------+------+-------------------------------------------------------------------------------------
|
|
1 | 0 | ALTER FOREIGN TABLE foreign_stats ADD COLUMN b integer DEFAULT 1
|
|
1 | 0 | ALTER FOREIGN TABLE foreign_stats ADD CONSTRAINT b_nonzero CHECK (b <> 0)
|
|
1 | 0 | ALTER INDEX pt_stats_index ATTACH PARTITION pt_stats2_index
|
|
1 | 0 | ALTER TABLE pt_stats ATTACH PARTITION pt_stats1 FOR VALUES FROM (0) TO (100)
|
|
1 | 0 | ALTER VIEW view_stats ALTER COLUMN a SET DEFAULT 2
|
|
1 | 0 | CREATE FOREIGN DATA WRAPPER wrapper_stats
|
|
1 | 0 | CREATE FOREIGN TABLE foreign_stats (a int) SERVER server_stats
|
|
1 | 0 | CREATE FUNCTION func_stats(a text DEFAULT 'a_data', b text DEFAULT lower('b_data'))+
|
|
| | RETURNS text AS $$ SELECT $1::text || '_' || $2::text; $$ LANGUAGE SQL
|
|
1 | 0 | CREATE FUNCTION trigger_func_stats () RETURNS trigger LANGUAGE plpgsql +
|
|
| | AS $$ BEGIN return OLD; end; $$
|
|
1 | 0 | CREATE INDEX pt_stats2_index ON ONLY pt_stats2 (a)
|
|
1 | 0 | CREATE INDEX pt_stats_index ON ONLY pt_stats (a)
|
|
1 | 0 | CREATE POLICY policy_stats ON tab_policy_stats USING (a = 5) WITH CHECK (b < 5)
|
|
1 | 0 | CREATE RULE rules_stats AS ON INSERT TO tab_rule_stats DO INSTEAD +
|
|
| | INSERT INTO tab_rule_stats_2 VALUES(new.*, 1, 2)
|
|
1 | 0 | CREATE SERVER server_stats FOREIGN DATA WRAPPER wrapper_stats
|
|
1 | 0 | CREATE STATISTICS tab_expr_stats_1 (mcv) ON a, (2*a), (3*b) FROM tab_expr_stats
|
|
1 | 0 | CREATE TABLE pt_stats (a int, b int) PARTITION BY range (a)
|
|
1 | 0 | CREATE TABLE pt_stats1 (a int, b int)
|
|
1 | 0 | CREATE TABLE pt_stats2 PARTITION OF pt_stats FOR VALUES FROM (100) TO (200)
|
|
1 | 0 | CREATE TABLE tab_expr_stats (a int, b int)
|
|
1 | 0 | CREATE TABLE tab_policy_stats (a int, b int)
|
|
1 | 0 | CREATE TABLE tab_rule_stats (a int, b int)
|
|
1 | 0 | CREATE TABLE tab_rule_stats_2 (a int, b int, c int, d int)
|
|
1 | 0 | CREATE TABLE trigger_tab_stats (a int, b int)
|
|
1 | 0 | CREATE TRIGGER trigger_tab_stats +
|
|
| | AFTER UPDATE ON trigger_tab_stats +
|
|
| | FOR EACH ROW WHEN (OLD.a < 0 AND OLD.b < 1 AND true) +
|
|
| | EXECUTE FUNCTION trigger_func_stats()
|
|
1 | 0 | CREATE TYPE stats_type as (f1 numeric(35, 6), f2 numeric(35, 2))
|
|
1 | 0 | CREATE VIEW view_stats AS SELECT 1::int AS a, 2::int AS b
|
|
1 | 0 | DROP FOREIGN DATA WRAPPER wrapper_stats
|
|
1 | 0 | DROP FOREIGN TABLE foreign_stats
|
|
1 | 0 | DROP FUNCTION func_stats
|
|
1 | 0 | DROP RULE rules_stats ON tab_rule_stats
|
|
1 | 0 | DROP SERVER server_stats
|
|
1 | 0 | DROP TABLE pt_stats
|
|
1 | 0 | DROP TABLE tab_expr_stats
|
|
1 | 0 | DROP TABLE tab_policy_stats
|
|
1 | 0 | DROP TABLE tab_rule_stats, tab_rule_stats_2
|
|
1 | 0 | DROP TABLE trigger_tab_stats
|
|
1 | 0 | DROP TYPE stats_type
|
|
1 | 0 | DROP VIEW view_stats
|
|
1 | 1 | SELECT pg_stat_statements_reset()
|
|
(39 rows)
|
|
|
|
SELECT pg_stat_statements_reset();
|
|
pg_stat_statements_reset
|
|
--------------------------
|
|
|
|
(1 row)
|
|
|
|
-- Transaction statements
|
|
BEGIN;
|
|
ABORT;
|
|
BEGIN;
|
|
ROLLBACK;
|
|
-- WORK
|
|
BEGIN WORK;
|
|
COMMIT WORK;
|
|
BEGIN WORK;
|
|
ABORT WORK;
|
|
-- TRANSACTION
|
|
BEGIN TRANSACTION;
|
|
COMMIT TRANSACTION;
|
|
BEGIN TRANSACTION;
|
|
ABORT TRANSACTION;
|
|
-- More isolation levels
|
|
BEGIN TRANSACTION DEFERRABLE;
|
|
COMMIT TRANSACTION AND NO CHAIN;
|
|
BEGIN ISOLATION LEVEL SERIALIZABLE;
|
|
COMMIT;
|
|
BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE;
|
|
COMMIT;
|
|
-- List of A_Const nodes, same lists.
|
|
BEGIN TRANSACTION READ ONLY, READ WRITE, DEFERRABLE, NOT DEFERRABLE;
|
|
COMMIT;
|
|
BEGIN TRANSACTION NOT DEFERRABLE, READ ONLY, READ WRITE, DEFERRABLE;
|
|
COMMIT;
|
|
SELECT calls, rows, query FROM pg_stat_statements ORDER BY query COLLATE "C";
|
|
calls | rows | query
|
|
-------+------+---------------------------------------------------------------------
|
|
4 | 0 | ABORT
|
|
6 | 0 | BEGIN
|
|
2 | 0 | BEGIN ISOLATION LEVEL SERIALIZABLE
|
|
1 | 0 | BEGIN TRANSACTION DEFERRABLE
|
|
1 | 0 | BEGIN TRANSACTION NOT DEFERRABLE, READ ONLY, READ WRITE, DEFERRABLE
|
|
1 | 0 | BEGIN TRANSACTION READ ONLY, READ WRITE, DEFERRABLE, NOT DEFERRABLE
|
|
7 | 0 | COMMIT WORK
|
|
1 | 1 | SELECT pg_stat_statements_reset()
|
|
(8 rows)
|
|
|
|
SELECT pg_stat_statements_reset();
|
|
pg_stat_statements_reset
|
|
--------------------------
|
|
|
|
(1 row)
|
|
|
|
-- EXPLAIN statements
|
|
-- A Query is used, normalized by the query jumbling.
|
|
EXPLAIN (costs off) SELECT 1;
|
|
QUERY PLAN
|
|
------------
|
|
Result
|
|
(1 row)
|
|
|
|
EXPLAIN (costs off) SELECT 2;
|
|
QUERY PLAN
|
|
------------
|
|
Result
|
|
(1 row)
|
|
|
|
EXPLAIN (costs off) SELECT a FROM generate_series(1,10) AS tab(a) WHERE a = 3;
|
|
QUERY PLAN
|
|
--------------------------------------
|
|
Function Scan on generate_series tab
|
|
Filter: (a = 3)
|
|
(2 rows)
|
|
|
|
EXPLAIN (costs off) SELECT a FROM generate_series(1,10) AS tab(a) WHERE a = 7;
|
|
QUERY PLAN
|
|
--------------------------------------
|
|
Function Scan on generate_series tab
|
|
Filter: (a = 7)
|
|
(2 rows)
|
|
|
|
SELECT calls, rows, query FROM pg_stat_statements ORDER BY query COLLATE "C";
|
|
calls | rows | query
|
|
-------+------+---------------------------------------------------------------------------------
|
|
2 | 0 | EXPLAIN (costs off) SELECT $1
|
|
2 | 0 | EXPLAIN (costs off) SELECT a FROM generate_series($1,$2) AS tab(a) WHERE a = $3
|
|
1 | 1 | SELECT pg_stat_statements_reset()
|
|
(3 rows)
|
|
|
|
-- CALL
|
|
CREATE OR REPLACE PROCEDURE sum_one(i int) AS $$
|
|
DECLARE
|
|
r int;
|
|
BEGIN
|
|
SELECT (i + i)::int INTO r;
|
|
END; $$ LANGUAGE plpgsql;
|
|
CREATE OR REPLACE PROCEDURE sum_two(i int, j int) AS $$
|
|
DECLARE
|
|
r int;
|
|
BEGIN
|
|
SELECT (i + j)::int INTO r;
|
|
END; $$ LANGUAGE plpgsql;
|
|
SELECT pg_stat_statements_reset();
|
|
pg_stat_statements_reset
|
|
--------------------------
|
|
|
|
(1 row)
|
|
|
|
CALL sum_one(3);
|
|
CALL sum_one(199);
|
|
CALL sum_two(1,1);
|
|
CALL sum_two(1,2);
|
|
SELECT calls, rows, query FROM pg_stat_statements ORDER BY query COLLATE "C";
|
|
calls | rows | query
|
|
-------+------+-----------------------------------
|
|
1 | 0 | CALL sum_one(199)
|
|
1 | 0 | CALL sum_one(3)
|
|
1 | 0 | CALL sum_two(1,1)
|
|
1 | 0 | CALL sum_two(1,2)
|
|
1 | 1 | SELECT pg_stat_statements_reset()
|
|
(5 rows)
|
|
|
|
-- COPY
|
|
CREATE TABLE copy_stats (a int, b int);
|
|
SELECT pg_stat_statements_reset();
|
|
pg_stat_statements_reset
|
|
--------------------------
|
|
|
|
(1 row)
|
|
|
|
-- Some queries with A_Const nodes.
|
|
COPY (SELECT 1) TO STDOUT;
|
|
1
|
|
COPY (SELECT 2) TO STDOUT;
|
|
2
|
|
COPY (INSERT INTO copy_stats VALUES (1, 1) RETURNING *) TO STDOUT;
|
|
1 1
|
|
COPY (INSERT INTO copy_stats VALUES (2, 2) RETURNING *) TO STDOUT;
|
|
2 2
|
|
COPY (UPDATE copy_stats SET b = b + 1 RETURNING *) TO STDOUT;
|
|
1 2
|
|
2 3
|
|
COPY (UPDATE copy_stats SET b = b + 2 RETURNING *) TO STDOUT;
|
|
1 4
|
|
2 5
|
|
COPY (DELETE FROM copy_stats WHERE a = 1 RETURNING *) TO STDOUT;
|
|
1 4
|
|
SELECT calls, rows, query FROM pg_stat_statements ORDER BY query COLLATE "C";
|
|
calls | rows | query
|
|
-------+------+-------------------------------------------------------------------
|
|
1 | 1 | COPY (DELETE FROM copy_stats WHERE a = 1 RETURNING *) TO STDOUT
|
|
1 | 1 | COPY (INSERT INTO copy_stats VALUES (1, 1) RETURNING *) TO STDOUT
|
|
1 | 1 | COPY (INSERT INTO copy_stats VALUES (2, 2) RETURNING *) TO STDOUT
|
|
1 | 1 | COPY (SELECT 1) TO STDOUT
|
|
1 | 1 | COPY (SELECT 2) TO STDOUT
|
|
1 | 2 | COPY (UPDATE copy_stats SET b = b + 1 RETURNING *) TO STDOUT
|
|
1 | 2 | COPY (UPDATE copy_stats SET b = b + 2 RETURNING *) TO STDOUT
|
|
1 | 1 | SELECT pg_stat_statements_reset()
|
|
(8 rows)
|
|
|
|
DROP TABLE copy_stats;
|
|
SELECT pg_stat_statements_reset();
|
|
pg_stat_statements_reset
|
|
--------------------------
|
|
|
|
(1 row)
|
|
|
|
-- CREATE TABLE AS
|
|
-- SELECT queries are normalized, creating matching query IDs.
|
|
CREATE TABLE ctas_stats_1 AS SELECT 1 AS a;
|
|
DROP TABLE ctas_stats_1;
|
|
CREATE TABLE ctas_stats_1 AS SELECT 2 AS a;
|
|
DROP TABLE ctas_stats_1;
|
|
CREATE TABLE ctas_stats_2 AS
|
|
SELECT a AS col1, 2::int AS col2
|
|
FROM generate_series(1, 10) AS tab(a) WHERE a < 5 AND a > 2;
|
|
DROP TABLE ctas_stats_2;
|
|
CREATE TABLE ctas_stats_2 AS
|
|
SELECT a AS col1, 4::int AS col2
|
|
FROM generate_series(1, 5) AS tab(a) WHERE a < 4 AND a > 1;
|
|
DROP TABLE ctas_stats_2;
|
|
SELECT calls, rows, query FROM pg_stat_statements ORDER BY query COLLATE "C";
|
|
calls | rows | query
|
|
-------+------+--------------------------------------------------------------------
|
|
2 | 2 | CREATE TABLE ctas_stats_1 AS SELECT $1 AS a
|
|
2 | 4 | CREATE TABLE ctas_stats_2 AS +
|
|
| | SELECT a AS col1, $1::int AS col2 +
|
|
| | FROM generate_series($2, $3) AS tab(a) WHERE a < $4 AND a > $5
|
|
2 | 0 | DROP TABLE ctas_stats_1
|
|
2 | 0 | DROP TABLE ctas_stats_2
|
|
1 | 1 | SELECT pg_stat_statements_reset()
|
|
(5 rows)
|
|
|
|
SELECT pg_stat_statements_reset();
|
|
pg_stat_statements_reset
|
|
--------------------------
|
|
|
|
(1 row)
|
|
|
|
-- CREATE MATERIALIZED VIEW
|
|
-- SELECT queries are normalized, creating matching query IDs.
|
|
CREATE MATERIALIZED VIEW matview_stats_1 AS
|
|
SELECT a AS col1, 2::int AS col2
|
|
FROM generate_series(1, 10) AS tab(a) WHERE a < 5 AND a > 2;
|
|
DROP MATERIALIZED VIEW matview_stats_1;
|
|
CREATE MATERIALIZED VIEW matview_stats_1 AS
|
|
SELECT a AS col1, 4::int AS col2
|
|
FROM generate_series(1, 5) AS tab(a) WHERE a < 4 AND a > 3;
|
|
DROP MATERIALIZED VIEW matview_stats_1;
|
|
SELECT calls, rows, query FROM pg_stat_statements ORDER BY query COLLATE "C";
|
|
calls | rows | query
|
|
-------+------+--------------------------------------------------------------------
|
|
2 | 2 | CREATE MATERIALIZED VIEW matview_stats_1 AS +
|
|
| | SELECT a AS col1, $1::int AS col2 +
|
|
| | FROM generate_series($2, $3) AS tab(a) WHERE a < $4 AND a > $5
|
|
2 | 0 | DROP MATERIALIZED VIEW matview_stats_1
|
|
1 | 1 | SELECT pg_stat_statements_reset()
|
|
(3 rows)
|
|
|
|
SELECT pg_stat_statements_reset();
|
|
pg_stat_statements_reset
|
|
--------------------------
|
|
|
|
(1 row)
|
|
|
|
-- CREATE VIEW
|
|
CREATE VIEW view_stats_1 AS
|
|
SELECT a AS col1, 2::int AS col2
|
|
FROM generate_series(1, 10) AS tab(a) WHERE a < 5 AND a > 2;
|
|
DROP VIEW view_stats_1;
|
|
CREATE VIEW view_stats_1 AS
|
|
SELECT a AS col1, 4::int AS col2
|
|
FROM generate_series(1, 5) AS tab(a) WHERE a < 4 AND a > 3;
|
|
DROP VIEW view_stats_1;
|
|
SELECT calls, rows, query FROM pg_stat_statements ORDER BY query COLLATE "C";
|
|
calls | rows | query
|
|
-------+------+-----------------------------------------------------------------
|
|
1 | 0 | CREATE VIEW view_stats_1 AS +
|
|
| | SELECT a AS col1, 2::int AS col2 +
|
|
| | FROM generate_series(1, 10) AS tab(a) WHERE a < 5 AND a > 2
|
|
1 | 0 | CREATE VIEW view_stats_1 AS +
|
|
| | SELECT a AS col1, 4::int AS col2 +
|
|
| | FROM generate_series(1, 5) AS tab(a) WHERE a < 4 AND a > 3
|
|
2 | 0 | DROP VIEW view_stats_1
|
|
1 | 1 | SELECT pg_stat_statements_reset()
|
|
(4 rows)
|
|
|
|
SELECT pg_stat_statements_reset();
|
|
pg_stat_statements_reset
|
|
--------------------------
|
|
|
|
(1 row)
|
|
|
|
-- Domains
|
|
CREATE DOMAIN domain_stats AS int CHECK (VALUE > 0);
|
|
ALTER DOMAIN domain_stats SET DEFAULT '3';
|
|
ALTER DOMAIN domain_stats ADD CONSTRAINT higher_than_one CHECK (VALUE > 1);
|
|
DROP DOMAIN domain_stats;
|
|
SELECT calls, rows, query FROM pg_stat_statements ORDER BY query COLLATE "C";
|
|
calls | rows | query
|
|
-------+------+----------------------------------------------------------------------------
|
|
1 | 0 | ALTER DOMAIN domain_stats ADD CONSTRAINT higher_than_one CHECK (VALUE > 1)
|
|
1 | 0 | ALTER DOMAIN domain_stats SET DEFAULT '3'
|
|
1 | 0 | CREATE DOMAIN domain_stats AS int CHECK (VALUE > 0)
|
|
1 | 0 | DROP DOMAIN domain_stats
|
|
1 | 1 | SELECT pg_stat_statements_reset()
|
|
(5 rows)
|
|
|
|
SELECT pg_stat_statements_reset();
|
|
pg_stat_statements_reset
|
|
--------------------------
|
|
|
|
(1 row)
|
|
|
|
-- SET statements.
|
|
-- These use two different strings, still they count as one entry.
|
|
SET work_mem = '1MB';
|
|
Set work_mem = '1MB';
|
|
SET work_mem = '2MB';
|
|
RESET work_mem;
|
|
SET enable_seqscan = off;
|
|
SET enable_seqscan = on;
|
|
RESET enable_seqscan;
|
|
-- SET TRANSACTION ISOLATION
|
|
BEGIN;
|
|
SET TRANSACTION ISOLATION LEVEL READ COMMITTED;
|
|
SET TRANSACTION ISOLATION LEVEL REPEATABLE READ;
|
|
SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;
|
|
COMMIT;
|
|
-- SET SESSION CHARACTERISTICS
|
|
SET SESSION SESSION AUTHORIZATION DEFAULT;
|
|
RESET SESSION AUTHORIZATION;
|
|
BEGIN;
|
|
SET LOCAL SESSION AUTHORIZATION DEFAULT;
|
|
RESET SESSION AUTHORIZATION;
|
|
COMMIT;
|
|
SELECT calls, rows, query FROM pg_stat_statements ORDER BY query COLLATE "C";
|
|
calls | rows | query
|
|
-------+------+-------------------------------------------------
|
|
2 | 0 | BEGIN
|
|
2 | 0 | COMMIT
|
|
2 | 0 | RESET SESSION AUTHORIZATION
|
|
1 | 0 | RESET enable_seqscan
|
|
1 | 0 | RESET work_mem
|
|
1 | 1 | SELECT pg_stat_statements_reset()
|
|
1 | 0 | SET LOCAL SESSION AUTHORIZATION DEFAULT
|
|
1 | 0 | SET SESSION SESSION AUTHORIZATION DEFAULT
|
|
1 | 0 | SET TRANSACTION ISOLATION LEVEL READ COMMITTED
|
|
1 | 0 | SET TRANSACTION ISOLATION LEVEL REPEATABLE READ
|
|
1 | 0 | SET TRANSACTION ISOLATION LEVEL SERIALIZABLE
|
|
1 | 0 | SET enable_seqscan = off
|
|
1 | 0 | SET enable_seqscan = on
|
|
2 | 0 | SET work_mem = '1MB'
|
|
1 | 0 | SET work_mem = '2MB'
|
|
(15 rows)
|
|
|
|
SELECT pg_stat_statements_reset();
|
|
pg_stat_statements_reset
|
|
--------------------------
|
|
|
|
(1 row)
|
|
|
|
--
|
|
-- Track the total number of rows retrieved or affected by the utility
|
|
-- commands of COPY, FETCH, CREATE TABLE AS, CREATE MATERIALIZED VIEW,
|
|
-- REFRESH MATERIALIZED VIEW and SELECT INTO
|
|
--
|
|
CREATE TABLE pgss_ctas AS SELECT a, 'ctas' b FROM generate_series(1, 10) a;
|
|
SELECT generate_series(1, 10) c INTO pgss_select_into;
|
|
COPY pgss_ctas (a, b) FROM STDIN;
|
|
CREATE MATERIALIZED VIEW pgss_matv AS SELECT * FROM pgss_ctas;
|
|
REFRESH MATERIALIZED VIEW pgss_matv;
|
|
BEGIN;
|
|
DECLARE pgss_cursor CURSOR FOR SELECT * FROM pgss_matv;
|
|
FETCH NEXT pgss_cursor;
|
|
a | b
|
|
---+------
|
|
1 | ctas
|
|
(1 row)
|
|
|
|
FETCH FORWARD 5 pgss_cursor;
|
|
a | b
|
|
---+------
|
|
2 | ctas
|
|
3 | ctas
|
|
4 | ctas
|
|
5 | ctas
|
|
6 | ctas
|
|
(5 rows)
|
|
|
|
FETCH FORWARD ALL pgss_cursor;
|
|
a | b
|
|
----+------
|
|
7 | ctas
|
|
8 | ctas
|
|
9 | ctas
|
|
10 | ctas
|
|
11 | copy
|
|
12 | copy
|
|
13 | copy
|
|
(7 rows)
|
|
|
|
COMMIT;
|
|
SELECT calls, rows, query FROM pg_stat_statements ORDER BY query COLLATE "C";
|
|
calls | rows | query
|
|
-------+------+-------------------------------------------------------------------------
|
|
1 | 0 | BEGIN
|
|
1 | 0 | COMMIT
|
|
1 | 3 | COPY pgss_ctas (a, b) FROM STDIN
|
|
1 | 13 | CREATE MATERIALIZED VIEW pgss_matv AS SELECT * FROM pgss_ctas
|
|
1 | 10 | CREATE TABLE pgss_ctas AS SELECT a, $1 b FROM generate_series($2, $3) a
|
|
1 | 0 | DECLARE pgss_cursor CURSOR FOR SELECT * FROM pgss_matv
|
|
1 | 5 | FETCH FORWARD 5 pgss_cursor
|
|
1 | 7 | FETCH FORWARD ALL pgss_cursor
|
|
1 | 1 | FETCH NEXT pgss_cursor
|
|
1 | 13 | REFRESH MATERIALIZED VIEW pgss_matv
|
|
1 | 10 | SELECT generate_series($1, $2) c INTO pgss_select_into
|
|
1 | 1 | SELECT pg_stat_statements_reset()
|
|
(12 rows)
|
|
|
|
DROP MATERIALIZED VIEW pgss_matv;
|
|
DROP TABLE pgss_ctas;
|
|
DROP TABLE pgss_select_into;
|
|
SELECT pg_stat_statements_reset();
|
|
pg_stat_statements_reset
|
|
--------------------------
|
|
|
|
(1 row)
|
|
|
|
-- SET statements.
|
|
-- These use two different strings, still they count as one entry.
|
|
SET work_mem = '1MB';
|
|
Set work_mem = '1MB';
|
|
SET work_mem = '2MB';
|
|
RESET work_mem;
|
|
SET enable_seqscan = off;
|
|
SET enable_seqscan = on;
|
|
RESET enable_seqscan;
|
|
SELECT calls, rows, query FROM pg_stat_statements ORDER BY query COLLATE "C";
|
|
calls | rows | query
|
|
-------+------+-----------------------------------
|
|
1 | 0 | RESET enable_seqscan
|
|
1 | 0 | RESET work_mem
|
|
1 | 1 | SELECT pg_stat_statements_reset()
|
|
1 | 0 | SET enable_seqscan = off
|
|
1 | 0 | SET enable_seqscan = on
|
|
2 | 0 | SET work_mem = '1MB'
|
|
1 | 0 | SET work_mem = '2MB'
|
|
(7 rows)
|
|
|
|
SELECT pg_stat_statements_reset();
|
|
pg_stat_statements_reset
|
|
--------------------------
|
|
|
|
(1 row)
|
|
|