CREATE EXTENSION pg_stat_statements;
--
-- simple and compound statements
--
SET pg_stat_statements.track_utility = FALSE;
SET pg_stat_statements.track_planning = TRUE;
SELECT pg_stat_statements_reset();
 pg_stat_statements_reset 
--------------------------
 
(1 row)

SELECT 1 AS "int";
 int 
-----
   1
(1 row)

SELECT 'hello'
  -- multiline
  AS "text";
 text  
-------
 hello
(1 row)

SELECT 'world' AS "text";
 text  
-------
 world
(1 row)

-- transaction
BEGIN;
SELECT 1 AS "int";
 int 
-----
   1
(1 row)

SELECT 'hello' AS "text";
 text  
-------
 hello
(1 row)

COMMIT;
-- compound transaction
BEGIN \;
SELECT 2.0 AS "float" \;
SELECT 'world' AS "text" \;
COMMIT;
 float 
-------
   2.0
(1 row)

 text  
-------
 world
(1 row)

-- compound with empty statements and spurious leading spacing
\;\;   SELECT 3 + 3 \;\;\;   SELECT ' ' || ' !' \;\;   SELECT 1 + 4 \;;
 ?column? 
----------
        6
(1 row)

 ?column? 
----------
   !
(1 row)

 ?column? 
----------
        5
(1 row)

-- non ;-terminated statements
SELECT 1 + 1 + 1 AS "add" \gset
SELECT :add + 1 + 1 AS "add" \;
SELECT :add + 1 + 1 AS "add" \gset
 add 
-----
   5
(1 row)

-- set operator
SELECT 1 AS i UNION SELECT 2 ORDER BY i;
 i 
---
 1
 2
(2 rows)

-- ? operator
select '{"a":1, "b":2}'::jsonb ? 'b';
 ?column? 
----------
 t
(1 row)

-- cte
WITH t(f) AS (
  VALUES (1.0), (2.0)
)
  SELECT f FROM t ORDER BY f;
  f  
-----
 1.0
 2.0
(2 rows)

-- prepared statement with parameter
PREPARE pgss_test (int) AS SELECT $1, 'test' LIMIT 1;
EXECUTE pgss_test(1);
 ?column? | ?column? 
----------+----------
        1 | test
(1 row)

DEALLOCATE pgss_test;
SELECT query, calls, rows FROM pg_stat_statements ORDER BY query COLLATE "C";
                                    query                                     | calls | rows 
------------------------------------------------------------------------------+-------+------
 PREPARE pgss_test (int) AS SELECT $1, $2 LIMIT $3                            |     1 |    1
 SELECT $1                                                                   +|     4 |    4
   -- multiline                                                              +|       | 
   AS "text"                                                                  |       | 
 SELECT $1 + $2                                                               |     2 |    2
 SELECT $1 + $2 + $3 AS "add"                                                 |     3 |    3
 SELECT $1 AS "float"                                                         |     1 |    1
 SELECT $1 AS "int"                                                           |     2 |    2
 SELECT $1 AS i UNION SELECT $2 ORDER BY i                                    |     1 |    2
 SELECT $1 || $2                                                              |     1 |    1
 SELECT pg_stat_statements_reset()                                            |     1 |    1
 SELECT query, calls, rows FROM pg_stat_statements ORDER BY query COLLATE "C" |     0 |    0
 WITH t(f) AS (                                                              +|     1 |    2
   VALUES ($1), ($2)                                                         +|       | 
 )                                                                           +|       | 
   SELECT f FROM t ORDER BY f                                                 |       | 
 select $1::jsonb ? $2                                                        |     1 |    1
(12 rows)

--
-- CRUD: INSERT SELECT UPDATE DELETE on test table
--
SELECT pg_stat_statements_reset();
 pg_stat_statements_reset 
--------------------------
 
(1 row)

-- utility "create table" should not be shown
CREATE TEMP TABLE test (a int, b char(20));
INSERT INTO test VALUES(generate_series(1, 10), 'aaa');
UPDATE test SET b = 'bbb' WHERE a > 7;
DELETE FROM test WHERE a > 9;
-- explicit transaction
BEGIN;
UPDATE test SET b = '111' WHERE a = 1 ;
COMMIT;
BEGIN \;
UPDATE test SET b = '222' WHERE a = 2 \;
COMMIT ;
UPDATE test SET b = '333' WHERE a = 3 \;
UPDATE test SET b = '444' WHERE a = 4 ;
BEGIN \;
UPDATE test SET b = '555' WHERE a = 5 \;
UPDATE test SET b = '666' WHERE a = 6 \;
COMMIT ;
-- many INSERT values
INSERT INTO test (a, b) VALUES (1, 'a'), (2, 'b'), (3, 'c');
-- SELECT with constants
SELECT * FROM test WHERE a > 5 ORDER BY a ;
 a |          b           
---+----------------------
 6 | 666                 
 7 | aaa                 
 8 | bbb                 
 9 | bbb                 
(4 rows)

SELECT *
  FROM test
  WHERE a > 9
  ORDER BY a ;
 a | b 
---+---
(0 rows)

-- SELECT without constants
SELECT * FROM test ORDER BY a;
 a |          b           
---+----------------------
 1 | a                   
 1 | 111                 
 2 | b                   
 2 | 222                 
 3 | c                   
 3 | 333                 
 4 | 444                 
 5 | 555                 
 6 | 666                 
 7 | aaa                 
 8 | bbb                 
 9 | bbb                 
(12 rows)

-- SELECT with IN clause
SELECT * FROM test WHERE a IN (1, 2, 3, 4, 5);
 a |          b           
---+----------------------
 1 | 111                 
 2 | 222                 
 3 | 333                 
 4 | 444                 
 5 | 555                 
 1 | a                   
 2 | b                   
 3 | c                   
(8 rows)

-- MERGE
MERGE INTO test USING test st ON (st.a = test.a AND st.a >= 4)
 WHEN MATCHED THEN UPDATE SET b = st.b || st.a::text;
MERGE INTO test USING test st ON (st.a = test.a AND st.a >= 4)
 WHEN MATCHED THEN UPDATE SET b = test.b || st.a::text;
MERGE INTO test USING test st ON (st.a = test.a AND st.a >= 4)
 WHEN MATCHED AND length(st.b) > 1 THEN UPDATE SET b = test.b || st.a::text;
MERGE INTO test USING test st ON (st.a = test.a)
 WHEN NOT MATCHED THEN INSERT (a, b) VALUES (0, NULL);
MERGE INTO test USING test st ON (st.a = test.a)
 WHEN NOT MATCHED THEN INSERT VALUES (0, NULL);	-- same as above
MERGE INTO test USING test st ON (st.a = test.a)
 WHEN NOT MATCHED THEN INSERT (b, a) VALUES (NULL, 0);
MERGE INTO test USING test st ON (st.a = test.a)
 WHEN NOT MATCHED THEN INSERT (a) VALUES (0);
MERGE INTO test USING test st ON (st.a = test.a AND st.a >= 4)
 WHEN MATCHED THEN DELETE;
MERGE INTO test USING test st ON (st.a = test.a AND st.a >= 4)
 WHEN MATCHED THEN DO NOTHING;
MERGE INTO test USING test st ON (st.a = test.a AND st.a >= 4)
 WHEN NOT MATCHED THEN DO NOTHING;
SELECT query, calls, rows FROM pg_stat_statements ORDER BY query COLLATE "C";
                                    query                                     | calls | rows 
------------------------------------------------------------------------------+-------+------
 DELETE FROM test WHERE a > $1                                                |     1 |    1
 INSERT INTO test (a, b) VALUES ($1, $2), ($3, $4), ($5, $6)                  |     1 |    3
 INSERT INTO test VALUES(generate_series($1, $2), $3)                         |     1 |   10
 MERGE INTO test USING test st ON (st.a = test.a AND st.a >= $1)             +|     1 |    6
  WHEN MATCHED AND length(st.b) > $2 THEN UPDATE SET b = test.b || st.a::text |       | 
 MERGE INTO test USING test st ON (st.a = test.a AND st.a >= $1)             +|     1 |    6
  WHEN MATCHED THEN DELETE                                                    |       | 
 MERGE INTO test USING test st ON (st.a = test.a AND st.a >= $1)             +|     1 |    0
  WHEN MATCHED THEN DO NOTHING                                                |       | 
 MERGE INTO test USING test st ON (st.a = test.a AND st.a >= $1)             +|     1 |    6
  WHEN MATCHED THEN UPDATE SET b = st.b || st.a::text                         |       | 
 MERGE INTO test USING test st ON (st.a = test.a AND st.a >= $1)             +|     1 |    6
  WHEN MATCHED THEN UPDATE SET b = test.b || st.a::text                       |       | 
 MERGE INTO test USING test st ON (st.a = test.a AND st.a >= $1)             +|     1 |    0
  WHEN NOT MATCHED THEN DO NOTHING                                            |       | 
 MERGE INTO test USING test st ON (st.a = test.a)                            +|     1 |    0
  WHEN NOT MATCHED THEN INSERT (a) VALUES ($1)                                |       | 
 MERGE INTO test USING test st ON (st.a = test.a)                            +|     2 |    0
  WHEN NOT MATCHED THEN INSERT (a, b) VALUES ($1, $2)                         |       | 
 MERGE INTO test USING test st ON (st.a = test.a)                            +|     1 |    0
  WHEN NOT MATCHED THEN INSERT (b, a) VALUES ($1, $2)                         |       | 
 SELECT * FROM test ORDER BY a                                                |     1 |   12
 SELECT * FROM test WHERE a > $1 ORDER BY a                                   |     2 |    4
 SELECT * FROM test WHERE a IN ($1, $2, $3, $4, $5)                           |     1 |    8
 SELECT pg_stat_statements_reset()                                            |     1 |    1
 SELECT query, calls, rows FROM pg_stat_statements ORDER BY query COLLATE "C" |     0 |    0
 UPDATE test SET b = $1 WHERE a = $2                                          |     6 |    6
 UPDATE test SET b = $1 WHERE a > $2                                          |     1 |    3
(19 rows)

--
-- INSERT, UPDATE, DELETE on test table to validate WAL generation metrics
--
SELECT pg_stat_statements_reset();
 pg_stat_statements_reset 
--------------------------
 
(1 row)

-- utility "create table" should not be shown
CREATE TABLE pgss_test (a int, b char(20));
INSERT INTO pgss_test VALUES(generate_series(1, 10), 'aaa');
UPDATE pgss_test SET b = 'bbb' WHERE a > 7;
DELETE FROM pgss_test WHERE a > 9;
-- DROP test table
SET pg_stat_statements.track_utility = TRUE;
DROP TABLE pgss_test;
SET pg_stat_statements.track_utility = FALSE;
-- Check WAL is generated for the above statements
SELECT query, calls, rows,
wal_bytes > 0 as wal_bytes_generated,
wal_records > 0 as wal_records_generated,
wal_records = rows as wal_records_as_rows
FROM pg_stat_statements ORDER BY query COLLATE "C";
                           query                           | calls | rows | wal_bytes_generated | wal_records_generated | wal_records_as_rows 
-----------------------------------------------------------+-------+------+---------------------+-----------------------+---------------------
 DELETE FROM pgss_test WHERE a > $1                        |     1 |    1 | t                   | t                     | t
 DROP TABLE pgss_test                                      |     1 |    0 | t                   | t                     | f
 INSERT INTO pgss_test VALUES(generate_series($1, $2), $3) |     1 |   10 | t                   | t                     | t
 SELECT pg_stat_statements_reset()                         |     1 |    1 | f                   | f                     | f
 SELECT query, calls, rows,                               +|     0 |    0 | f                   | f                     | t
 wal_bytes > $1 as wal_bytes_generated,                   +|       |      |                     |                       | 
 wal_records > $2 as wal_records_generated,               +|       |      |                     |                       | 
 wal_records = rows as wal_records_as_rows                +|       |      |                     |                       | 
 FROM pg_stat_statements ORDER BY query COLLATE "C"        |       |      |                     |                       | 
 SET pg_stat_statements.track_utility = FALSE              |     1 |    0 | f                   | f                     | t
 UPDATE pgss_test SET b = $1 WHERE a > $2                  |     1 |    3 | t                   | t                     | t
(7 rows)

--
-- pg_stat_statements.track = none
--
SET pg_stat_statements.track = 'none';
SELECT pg_stat_statements_reset();
 pg_stat_statements_reset 
--------------------------
 
(1 row)

SELECT 1 AS "one";
 one 
-----
   1
(1 row)

SELECT 1 + 1 AS "two";
 two 
-----
   2
(1 row)

SELECT query, calls, rows FROM pg_stat_statements ORDER BY query COLLATE "C";
 query | calls | rows 
-------+-------+------
(0 rows)

--
-- pg_stat_statements.track = top
--
SET pg_stat_statements.track = 'top';
SELECT pg_stat_statements_reset();
 pg_stat_statements_reset 
--------------------------
 
(1 row)

DO LANGUAGE plpgsql $$
BEGIN
  -- this is a SELECT
  PERFORM 'hello world'::TEXT;
END;
$$;
-- PL/pgSQL function
CREATE FUNCTION PLUS_TWO(i INTEGER) RETURNS INTEGER AS $$
DECLARE
  r INTEGER;
BEGIN
  SELECT (i + 1 + 1.0)::INTEGER INTO r;
  RETURN r;
END; $$ LANGUAGE plpgsql;
SELECT PLUS_TWO(3);
 plus_two 
----------
        5
(1 row)

SELECT PLUS_TWO(7);
 plus_two 
----------
        9
(1 row)

-- SQL function --- use LIMIT to keep it from being inlined
CREATE FUNCTION PLUS_ONE(i INTEGER) RETURNS INTEGER AS
$$ SELECT (i + 1.0)::INTEGER LIMIT 1 $$ LANGUAGE SQL;
SELECT PLUS_ONE(8);
 plus_one 
----------
        9
(1 row)

SELECT PLUS_ONE(10);
 plus_one 
----------
       11
(1 row)

SELECT query, calls, rows FROM pg_stat_statements ORDER BY query COLLATE "C";
                                    query                                     | calls | rows 
------------------------------------------------------------------------------+-------+------
 SELECT $1::TEXT                                                              |     1 |    1
 SELECT PLUS_ONE($1)                                                          |     2 |    2
 SELECT PLUS_TWO($1)                                                          |     2 |    2
 SELECT pg_stat_statements_reset()                                            |     1 |    1
 SELECT query, calls, rows FROM pg_stat_statements ORDER BY query COLLATE "C" |     0 |    0
(5 rows)

--
-- pg_stat_statements.track = all
--
SET pg_stat_statements.track = 'all';
SELECT pg_stat_statements_reset();
 pg_stat_statements_reset 
--------------------------
 
(1 row)

-- we drop and recreate the functions to avoid any caching funnies
DROP FUNCTION PLUS_ONE(INTEGER);
DROP FUNCTION PLUS_TWO(INTEGER);
-- PL/pgSQL function
CREATE FUNCTION PLUS_TWO(i INTEGER) RETURNS INTEGER AS $$
DECLARE
  r INTEGER;
BEGIN
  SELECT (i + 1 + 1.0)::INTEGER INTO r;
  RETURN r;
END; $$ LANGUAGE plpgsql;
SELECT PLUS_TWO(-1);
 plus_two 
----------
        1
(1 row)

SELECT PLUS_TWO(2);
 plus_two 
----------
        4
(1 row)

-- SQL function --- use LIMIT to keep it from being inlined
CREATE FUNCTION PLUS_ONE(i INTEGER) RETURNS INTEGER AS
$$ SELECT (i + 1.0)::INTEGER LIMIT 1 $$ LANGUAGE SQL;
SELECT PLUS_ONE(3);
 plus_one 
----------
        4
(1 row)

SELECT PLUS_ONE(1);
 plus_one 
----------
        2
(1 row)

SELECT query, calls, rows FROM pg_stat_statements ORDER BY query COLLATE "C";
                                    query                                     | calls | rows 
------------------------------------------------------------------------------+-------+------
 SELECT (i + $2 + $3)::INTEGER                                                |     2 |    2
 SELECT (i + $2)::INTEGER LIMIT $3                                            |     2 |    2
 SELECT PLUS_ONE($1)                                                          |     2 |    2
 SELECT PLUS_TWO($1)                                                          |     2 |    2
 SELECT pg_stat_statements_reset()                                            |     1 |    1
 SELECT query, calls, rows FROM pg_stat_statements ORDER BY query COLLATE "C" |     0 |    0
(6 rows)

--
-- queries with locking clauses
--
CREATE TABLE pgss_a (id integer PRIMARY KEY);
CREATE TABLE pgss_b (id integer PRIMARY KEY, a_id integer REFERENCES pgss_a);
SELECT pg_stat_statements_reset();
 pg_stat_statements_reset 
--------------------------
 
(1 row)

-- control query
SELECT * FROM pgss_a JOIN pgss_b ON pgss_b.a_id = pgss_a.id;
 id | id | a_id 
----+----+------
(0 rows)

-- test range tables
SELECT * FROM pgss_a JOIN pgss_b ON pgss_b.a_id = pgss_a.id FOR UPDATE;
 id | id | a_id 
----+----+------
(0 rows)

SELECT * FROM pgss_a JOIN pgss_b ON pgss_b.a_id = pgss_a.id FOR UPDATE OF pgss_a;
 id | id | a_id 
----+----+------
(0 rows)

SELECT * FROM pgss_a JOIN pgss_b ON pgss_b.a_id = pgss_a.id FOR UPDATE OF pgss_b;
 id | id | a_id 
----+----+------
(0 rows)

SELECT * FROM pgss_a JOIN pgss_b ON pgss_b.a_id = pgss_a.id FOR UPDATE OF pgss_a, pgss_b; -- matches plain "FOR UPDATE"
 id | id | a_id 
----+----+------
(0 rows)

SELECT * FROM pgss_a JOIN pgss_b ON pgss_b.a_id = pgss_a.id FOR UPDATE OF pgss_b, pgss_a;
 id | id | a_id 
----+----+------
(0 rows)

-- test strengths
SELECT * FROM pgss_a JOIN pgss_b ON pgss_b.a_id = pgss_a.id FOR NO KEY UPDATE;
 id | id | a_id 
----+----+------
(0 rows)

SELECT * FROM pgss_a JOIN pgss_b ON pgss_b.a_id = pgss_a.id FOR SHARE;
 id | id | a_id 
----+----+------
(0 rows)

SELECT * FROM pgss_a JOIN pgss_b ON pgss_b.a_id = pgss_a.id FOR KEY SHARE;
 id | id | a_id 
----+----+------
(0 rows)

-- test wait policies
SELECT * FROM pgss_a JOIN pgss_b ON pgss_b.a_id = pgss_a.id FOR UPDATE NOWAIT;
 id | id | a_id 
----+----+------
(0 rows)

SELECT * FROM pgss_a JOIN pgss_b ON pgss_b.a_id = pgss_a.id FOR UPDATE SKIP LOCKED;
 id | id | a_id 
----+----+------
(0 rows)

SELECT calls, query FROM pg_stat_statements ORDER BY query COLLATE "C";
 calls |                                          query                                           
-------+------------------------------------------------------------------------------------------
     1 | SELECT * FROM pgss_a JOIN pgss_b ON pgss_b.a_id = pgss_a.id
     1 | SELECT * FROM pgss_a JOIN pgss_b ON pgss_b.a_id = pgss_a.id FOR KEY SHARE
     1 | SELECT * FROM pgss_a JOIN pgss_b ON pgss_b.a_id = pgss_a.id FOR NO KEY UPDATE
     1 | SELECT * FROM pgss_a JOIN pgss_b ON pgss_b.a_id = pgss_a.id FOR SHARE
     2 | SELECT * FROM pgss_a JOIN pgss_b ON pgss_b.a_id = pgss_a.id FOR UPDATE
     1 | SELECT * FROM pgss_a JOIN pgss_b ON pgss_b.a_id = pgss_a.id FOR UPDATE NOWAIT
     1 | SELECT * FROM pgss_a JOIN pgss_b ON pgss_b.a_id = pgss_a.id FOR UPDATE OF pgss_a
     1 | SELECT * FROM pgss_a JOIN pgss_b ON pgss_b.a_id = pgss_a.id FOR UPDATE OF pgss_b
     1 | SELECT * FROM pgss_a JOIN pgss_b ON pgss_b.a_id = pgss_a.id FOR UPDATE OF pgss_b, pgss_a
     1 | SELECT * FROM pgss_a JOIN pgss_b ON pgss_b.a_id = pgss_a.id FOR UPDATE SKIP LOCKED
     0 | SELECT calls, query FROM pg_stat_statements ORDER BY query COLLATE "C"
     1 | SELECT pg_stat_statements_reset()
(12 rows)

DROP TABLE pgss_a, pgss_b CASCADE;
--
-- utility commands
--
SET pg_stat_statements.track_utility = TRUE;
SELECT pg_stat_statements_reset();
 pg_stat_statements_reset 
--------------------------
 
(1 row)

SELECT 1;
 ?column? 
----------
        1
(1 row)

CREATE INDEX test_b ON test(b);
DROP TABLE test \;
DROP TABLE IF EXISTS test \;
DROP FUNCTION PLUS_ONE(INTEGER);
NOTICE:  table "test" does not exist, skipping
DROP TABLE IF EXISTS test \;
DROP TABLE IF EXISTS test \;
DROP FUNCTION IF EXISTS PLUS_ONE(INTEGER);
NOTICE:  table "test" does not exist, skipping
NOTICE:  table "test" does not exist, skipping
NOTICE:  function plus_one(pg_catalog.int4) does not exist, skipping
DROP FUNCTION PLUS_TWO(INTEGER);
SELECT query, calls, rows FROM pg_stat_statements ORDER BY query COLLATE "C";
                                    query                                     | calls | rows 
------------------------------------------------------------------------------+-------+------
 CREATE INDEX test_b ON test(b)                                               |     1 |    0
 DROP FUNCTION IF EXISTS PLUS_ONE(INTEGER)                                    |     1 |    0
 DROP FUNCTION PLUS_ONE(INTEGER)                                              |     1 |    0
 DROP FUNCTION PLUS_TWO(INTEGER)                                              |     1 |    0
 DROP TABLE IF EXISTS test                                                    |     3 |    0
 DROP TABLE test                                                              |     1 |    0
 SELECT $1                                                                    |     1 |    1
 SELECT pg_stat_statements_reset()                                            |     1 |    1
 SELECT query, calls, rows FROM pg_stat_statements ORDER BY query COLLATE "C" |     0 |    0
(9 rows)

--
-- 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
--
SELECT pg_stat_statements_reset();
 pg_stat_statements_reset 
--------------------------
 
(1 row)

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 query, plans, calls, rows FROM pg_stat_statements ORDER BY query COLLATE "C";
                                        query                                        | plans | calls | rows 
-------------------------------------------------------------------------------------+-------+-------+------
 BEGIN                                                                               |     0 |     1 |    0
 COMMIT                                                                              |     0 |     1 |    0
 COPY pgss_ctas (a, b) FROM STDIN                                                    |     0 |     1 |    3
 CREATE MATERIALIZED VIEW pgss_matv AS SELECT * FROM pgss_ctas                       |     0 |     1 |   13
 CREATE TABLE pgss_ctas AS SELECT a, 'ctas' b FROM generate_series(1, 10) a          |     0 |     1 |   10
 DECLARE pgss_cursor CURSOR FOR SELECT * FROM pgss_matv                              |     0 |     1 |    0
 FETCH FORWARD 5 pgss_cursor                                                         |     0 |     1 |    5
 FETCH FORWARD ALL pgss_cursor                                                       |     0 |     1 |    7
 FETCH NEXT pgss_cursor                                                              |     0 |     1 |    1
 REFRESH MATERIALIZED VIEW pgss_matv                                                 |     0 |     1 |   13
 SELECT generate_series(1, 10) c INTO pgss_select_into                               |     0 |     1 |   10
 SELECT pg_stat_statements_reset()                                                   |     0 |     1 |    1
 SELECT query, plans, calls, rows FROM pg_stat_statements ORDER BY query COLLATE "C" |     1 |     0 |    0
(13 rows)

--
-- Track user activity and reset them
--
SELECT pg_stat_statements_reset();
 pg_stat_statements_reset 
--------------------------
 
(1 row)

CREATE ROLE regress_stats_user1;
CREATE ROLE regress_stats_user2;
SET ROLE regress_stats_user1;
SELECT 1 AS "ONE";
 ONE 
-----
   1
(1 row)

SELECT 1+1 AS "TWO";
 TWO 
-----
   2
(1 row)

RESET ROLE;
SET ROLE regress_stats_user2;
SELECT 1 AS "ONE";
 ONE 
-----
   1
(1 row)

SELECT 1+1 AS "TWO";
 TWO 
-----
   2
(1 row)

RESET ROLE;
SELECT query, calls, rows FROM pg_stat_statements ORDER BY query COLLATE "C";
                                    query                                     | calls | rows 
------------------------------------------------------------------------------+-------+------
 CREATE ROLE regress_stats_user1                                              |     1 |    0
 CREATE ROLE regress_stats_user2                                              |     1 |    0
 RESET ROLE                                                                   |     2 |    0
 SELECT $1 AS "ONE"                                                           |     1 |    1
 SELECT $1 AS "ONE"                                                           |     1 |    1
 SELECT $1+$2 AS "TWO"                                                        |     1 |    1
 SELECT $1+$2 AS "TWO"                                                        |     1 |    1
 SELECT pg_stat_statements_reset()                                            |     1 |    1
 SELECT query, calls, rows FROM pg_stat_statements ORDER BY query COLLATE "C" |     0 |    0
 SET ROLE regress_stats_user1                                                 |     1 |    0
 SET ROLE regress_stats_user2                                                 |     1 |    0
(11 rows)

--
-- Don't reset anything if any of the parameter is NULL
--
SELECT pg_stat_statements_reset(NULL);
 pg_stat_statements_reset 
--------------------------
 
(1 row)

SELECT query, calls, rows FROM pg_stat_statements ORDER BY query COLLATE "C";
                                    query                                     | calls | rows 
------------------------------------------------------------------------------+-------+------
 CREATE ROLE regress_stats_user1                                              |     1 |    0
 CREATE ROLE regress_stats_user2                                              |     1 |    0
 RESET ROLE                                                                   |     2 |    0
 SELECT $1 AS "ONE"                                                           |     1 |    1
 SELECT $1 AS "ONE"                                                           |     1 |    1
 SELECT $1+$2 AS "TWO"                                                        |     1 |    1
 SELECT $1+$2 AS "TWO"                                                        |     1 |    1
 SELECT pg_stat_statements_reset($1)                                          |     1 |    1
 SELECT pg_stat_statements_reset()                                            |     1 |    1
 SELECT query, calls, rows FROM pg_stat_statements ORDER BY query COLLATE "C" |     1 |   11
 SET ROLE regress_stats_user1                                                 |     1 |    0
 SET ROLE regress_stats_user2                                                 |     1 |    0
(12 rows)

--
-- remove query ('SELECT $1+$2 AS "TWO"') executed by regress_stats_user2
-- in the current_database
--
SELECT pg_stat_statements_reset(
	(SELECT r.oid FROM pg_roles AS r WHERE r.rolname = 'regress_stats_user2'),
	(SELECT d.oid FROM pg_database As d where datname = current_database()),
	(SELECT s.queryid FROM pg_stat_statements AS s
				WHERE s.query = 'SELECT $1+$2 AS "TWO"' LIMIT 1));
 pg_stat_statements_reset 
--------------------------
 
(1 row)

SELECT query, calls, rows FROM pg_stat_statements ORDER BY query COLLATE "C";
                                      query                                       | calls | rows 
----------------------------------------------------------------------------------+-------+------
 CREATE ROLE regress_stats_user1                                                  |     1 |    0
 CREATE ROLE regress_stats_user2                                                  |     1 |    0
 RESET ROLE                                                                       |     2 |    0
 SELECT $1 AS "ONE"                                                               |     1 |    1
 SELECT $1 AS "ONE"                                                               |     1 |    1
 SELECT $1+$2 AS "TWO"                                                            |     1 |    1
 SELECT pg_stat_statements_reset(                                                +|     1 |    1
         (SELECT r.oid FROM pg_roles AS r WHERE r.rolname = $1),                 +|       | 
         (SELECT d.oid FROM pg_database As d where datname = current_database()),+|       | 
         (SELECT s.queryid FROM pg_stat_statements AS s                          +|       | 
                                 WHERE s.query = $2 LIMIT $3))                    |       | 
 SELECT pg_stat_statements_reset($1)                                              |     1 |    1
 SELECT pg_stat_statements_reset()                                                |     1 |    1
 SELECT query, calls, rows FROM pg_stat_statements ORDER BY query COLLATE "C"     |     2 |   23
 SET ROLE regress_stats_user1                                                     |     1 |    0
 SET ROLE regress_stats_user2                                                     |     1 |    0
(12 rows)

--
-- remove query ('SELECT $1 AS "ONE"') executed by two users
--
SELECT pg_stat_statements_reset(0,0,s.queryid)
	FROM pg_stat_statements AS s WHERE s.query = 'SELECT $1 AS "ONE"';
 pg_stat_statements_reset 
--------------------------
 
 
(2 rows)

SELECT query, calls, rows FROM pg_stat_statements ORDER BY query COLLATE "C";
                                      query                                       | calls | rows 
----------------------------------------------------------------------------------+-------+------
 CREATE ROLE regress_stats_user1                                                  |     1 |    0
 CREATE ROLE regress_stats_user2                                                  |     1 |    0
 RESET ROLE                                                                       |     2 |    0
 SELECT $1+$2 AS "TWO"                                                            |     1 |    1
 SELECT pg_stat_statements_reset(                                                +|     1 |    1
         (SELECT r.oid FROM pg_roles AS r WHERE r.rolname = $1),                 +|       | 
         (SELECT d.oid FROM pg_database As d where datname = current_database()),+|       | 
         (SELECT s.queryid FROM pg_stat_statements AS s                          +|       | 
                                 WHERE s.query = $2 LIMIT $3))                    |       | 
 SELECT pg_stat_statements_reset($1)                                              |     1 |    1
 SELECT pg_stat_statements_reset($1,$2,s.queryid)                                +|     1 |    2
         FROM pg_stat_statements AS s WHERE s.query = $3                          |       | 
 SELECT pg_stat_statements_reset()                                                |     1 |    1
 SELECT query, calls, rows FROM pg_stat_statements ORDER BY query COLLATE "C"     |     3 |   35
 SET ROLE regress_stats_user1                                                     |     1 |    0
 SET ROLE regress_stats_user2                                                     |     1 |    0
(11 rows)

--
-- remove query of a user (regress_stats_user1)
--
SELECT pg_stat_statements_reset(r.oid)
		FROM pg_roles AS r WHERE r.rolname = 'regress_stats_user1';
 pg_stat_statements_reset 
--------------------------
 
(1 row)

SELECT query, calls, rows FROM pg_stat_statements ORDER BY query COLLATE "C";
                                      query                                       | calls | rows 
----------------------------------------------------------------------------------+-------+------
 CREATE ROLE regress_stats_user1                                                  |     1 |    0
 CREATE ROLE regress_stats_user2                                                  |     1 |    0
 RESET ROLE                                                                       |     2 |    0
 SELECT pg_stat_statements_reset(                                                +|     1 |    1
         (SELECT r.oid FROM pg_roles AS r WHERE r.rolname = $1),                 +|       | 
         (SELECT d.oid FROM pg_database As d where datname = current_database()),+|       | 
         (SELECT s.queryid FROM pg_stat_statements AS s                          +|       | 
                                 WHERE s.query = $2 LIMIT $3))                    |       | 
 SELECT pg_stat_statements_reset($1)                                              |     1 |    1
 SELECT pg_stat_statements_reset($1,$2,s.queryid)                                +|     1 |    2
         FROM pg_stat_statements AS s WHERE s.query = $3                          |       | 
 SELECT pg_stat_statements_reset()                                                |     1 |    1
 SELECT pg_stat_statements_reset(r.oid)                                          +|     1 |    1
                 FROM pg_roles AS r WHERE r.rolname = $1                          |       | 
 SELECT query, calls, rows FROM pg_stat_statements ORDER BY query COLLATE "C"     |     4 |   46
 SET ROLE regress_stats_user2                                                     |     1 |    0
(10 rows)

--
-- reset all
--
SELECT pg_stat_statements_reset(0,0,0);
 pg_stat_statements_reset 
--------------------------
 
(1 row)

SELECT query, calls, rows FROM pg_stat_statements ORDER BY query COLLATE "C";
                                    query                                     | calls | rows 
------------------------------------------------------------------------------+-------+------
 SELECT pg_stat_statements_reset(0,0,0)                                       |     1 |    1
 SELECT query, calls, rows FROM pg_stat_statements ORDER BY query COLLATE "C" |     0 |    0
(2 rows)

--
-- cleanup
--
DROP ROLE regress_stats_user1;
DROP ROLE regress_stats_user2;
DROP MATERIALIZED VIEW pgss_matv;
DROP TABLE pgss_ctas;
DROP TABLE pgss_select_into;
--
-- [re]plan counting
--
SELECT pg_stat_statements_reset();
 pg_stat_statements_reset 
--------------------------
 
(1 row)

CREATE TABLE test ();
PREPARE prep1 AS SELECT COUNT(*) FROM test;
EXECUTE prep1;
 count 
-------
     0
(1 row)

EXECUTE prep1;
 count 
-------
     0
(1 row)

EXECUTE prep1;
 count 
-------
     0
(1 row)

ALTER TABLE test ADD COLUMN x int;
EXECUTE prep1;
 count 
-------
     0
(1 row)

SELECT 42;
 ?column? 
----------
       42
(1 row)

SELECT 42;
 ?column? 
----------
       42
(1 row)

SELECT 42;
 ?column? 
----------
       42
(1 row)

SELECT query, plans, calls, rows FROM pg_stat_statements
  WHERE query NOT LIKE 'PREPARE%' ORDER BY query COLLATE "C";
                          query                           | plans | calls | rows 
----------------------------------------------------------+-------+-------+------
 ALTER TABLE test ADD COLUMN x int                        |     0 |     1 |    0
 CREATE TABLE test ()                                     |     0 |     1 |    0
 SELECT $1                                                |     3 |     3 |    3
 SELECT pg_stat_statements_reset()                        |     0 |     1 |    1
 SELECT query, plans, calls, rows FROM pg_stat_statements+|     1 |     0 |    0
   WHERE query NOT LIKE $1 ORDER BY query COLLATE "C"     |       |       | 
(5 rows)

-- for the prepared statement we expect at least one replan, but cache
-- invalidations could force more
SELECT query, plans >= 2 AND plans <= calls AS plans_ok, calls, rows FROM pg_stat_statements
  WHERE query LIKE 'PREPARE%' ORDER BY query COLLATE "C";
                   query                    | plans_ok | calls | rows 
--------------------------------------------+----------+-------+------
 PREPARE prep1 AS SELECT COUNT(*) FROM test | t        |     4 |    4
(1 row)

--
-- access to pg_stat_statements_info view
--
SELECT pg_stat_statements_reset();
 pg_stat_statements_reset 
--------------------------
 
(1 row)

SELECT dealloc FROM pg_stat_statements_info;
 dealloc 
---------
       0
(1 row)

--
-- top level handling
--
SET pg_stat_statements.track = 'top';
DELETE FROM test;
DO $$
BEGIN
    DELETE FROM test;
END;
$$ LANGUAGE plpgsql;
SELECT query, toplevel, plans, calls FROM pg_stat_statements WHERE query LIKE '%DELETE%' ORDER BY query COLLATE "C", toplevel;
         query         | toplevel | plans | calls 
-----------------------+----------+-------+-------
 DELETE FROM test      | t        |     1 |     1
 DO $$                +| t        |     0 |     1
 BEGIN                +|          |       | 
     DELETE FROM test;+|          |       | 
 END;                 +|          |       | 
 $$ LANGUAGE plpgsql   |          |       | 
(2 rows)

SET pg_stat_statements.track = 'all';
DELETE FROM test;
DO $$
BEGIN
    DELETE FROM test;
END;
$$ LANGUAGE plpgsql;
SELECT query, toplevel, plans, calls FROM pg_stat_statements WHERE query LIKE '%DELETE%' ORDER BY query COLLATE "C", toplevel;
         query         | toplevel | plans | calls 
-----------------------+----------+-------+-------
 DELETE FROM test      | f        |     1 |     1
 DELETE FROM test      | t        |     2 |     2
 DO $$                +| t        |     0 |     2
 BEGIN                +|          |       | 
     DELETE FROM test;+|          |       | 
 END;                 +|          |       | 
 $$ LANGUAGE plpgsql   |          |       | 
(3 rows)

-- FROM [ONLY]
CREATE TABLE tbl_inh(id integer);
CREATE TABLE tbl_inh_1() INHERITS (tbl_inh);
INSERT INTO tbl_inh_1 SELECT 1;
SELECT * FROM tbl_inh;
 id 
----
  1
(1 row)

SELECT * FROM ONLY tbl_inh;
 id 
----
(0 rows)

SELECT COUNT(*) FROM pg_stat_statements WHERE query LIKE '%FROM%tbl_inh%';
 count 
-------
     2
(1 row)

-- WITH TIES
CREATE TABLE limitoption AS SELECT 0 AS val FROM generate_series(1, 10);
SELECT *
FROM limitoption
WHERE val < 2
ORDER BY val
FETCH FIRST 2 ROWS WITH TIES;
 val 
-----
   0
   0
   0
   0
   0
   0
   0
   0
   0
   0
(10 rows)

SELECT *
FROM limitoption
WHERE val < 2
ORDER BY val
FETCH FIRST 2 ROW ONLY;
 val 
-----
   0
   0
(2 rows)

SELECT COUNT(*) FROM pg_stat_statements WHERE query LIKE '%FETCH FIRST%';
 count 
-------
     2
(1 row)

-- GROUP BY [DISTINCT]
SELECT a, b, c
FROM (VALUES (1, 2, 3), (4, NULL, 6), (7, 8, 9)) AS t (a, b, c)
GROUP BY ROLLUP(a, b), rollup(a, c)
ORDER BY a, b, c;
 a | b | c 
---+---+---
 1 | 2 | 3
 1 | 2 |  
 1 | 2 |  
 1 |   | 3
 1 |   | 3
 1 |   |  
 1 |   |  
 1 |   |  
 4 |   | 6
 4 |   | 6
 4 |   | 6
 4 |   |  
 4 |   |  
 4 |   |  
 4 |   |  
 4 |   |  
 7 | 8 | 9
 7 | 8 |  
 7 | 8 |  
 7 |   | 9
 7 |   | 9
 7 |   |  
 7 |   |  
 7 |   |  
   |   |  
(25 rows)

SELECT a, b, c
FROM (VALUES (1, 2, 3), (4, NULL, 6), (7, 8, 9)) AS t (a, b, c)
GROUP BY DISTINCT ROLLUP(a, b), rollup(a, c)
ORDER BY a, b, c;
 a | b | c 
---+---+---
 1 | 2 | 3
 1 | 2 |  
 1 |   | 3
 1 |   |  
 4 |   | 6
 4 |   | 6
 4 |   |  
 4 |   |  
 7 | 8 | 9
 7 | 8 |  
 7 |   | 9
 7 |   |  
   |   |  
(13 rows)

SELECT COUNT(*) FROM pg_stat_statements WHERE query LIKE '%GROUP BY%ROLLUP%';
 count 
-------
     2
(1 row)

-- GROUPING SET agglevelsup
SELECT (
  SELECT (
    SELECT GROUPING(a,b) FROM (VALUES (1)) v2(c)
  ) FROM (VALUES (1,2)) v1(a,b) GROUP BY (a,b)
) FROM (VALUES(6,7)) v3(e,f) GROUP BY ROLLUP(e,f);
 grouping 
----------
        0
        0
        0
(3 rows)

SELECT (
  SELECT (
    SELECT GROUPING(e,f) FROM (VALUES (1)) v2(c)
  ) FROM (VALUES (1,2)) v1(a,b) GROUP BY (a,b)
) FROM (VALUES(6,7)) v3(e,f) GROUP BY ROLLUP(e,f);
 grouping 
----------
        3
        0
        1
(3 rows)

SELECT COUNT(*) FROM pg_stat_statements WHERE query LIKE '%SELECT GROUPING%';
 count 
-------
     2
(1 row)

DROP EXTENSION pg_stat_statements;