src/test/isolation/expected/stats.out - master - githubmirror/postgres

src/test/isolation/expected/stats.out
3 753 строки118 KB
Michael Paquier
Add stats_reset to pg_stat_user_functions
08 окт 2025, 06:43
08 окт 2025, 06:43b71bae4
Parsed test spec with 2 sessions

starting permutation: s1_track_funcs_none s1_func_stats s1_func_call s1_func_call s1_ff s1_func_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_track_funcs_none: SET track_functions = 'none';
step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)

step s1_func_call: SELECT test_stat_func();
test_stat_func
--------------
              
(1 row)

step s1_func_call: SELECT test_stat_func();
test_stat_func
--------------
              
(1 row)

step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)


starting permutation: s1_track_funcs_all s1_func_stats s1_func_call s1_func_call s1_ff s1_func_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_track_funcs_all: SET track_functions = 'all';
step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)

step s1_func_call: SELECT test_stat_func();
test_stat_func
--------------
              
(1 row)

step s1_func_call: SELECT test_stat_func();
test_stat_func
--------------
              
(1 row)

step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         2|t               |t              
(1 row)


starting permutation: s1_track_funcs_all s2_track_funcs_all s1_func_stats s2_func_stats s1_func_call s2_func_call s1_func_call s2_func_call s2_func_call s1_ff s2_ff s1_func_stats s2_func_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_track_funcs_all: SET track_functions = 'all';
step s2_track_funcs_all: SET track_functions = 'all';
step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)

step s2_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)

step s1_func_call: SELECT test_stat_func();
test_stat_func
--------------
              
(1 row)

step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s1_func_call: SELECT test_stat_func();
test_stat_func
--------------
              
(1 row)

step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         5|t               |t              
(1 row)

step s2_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         5|t               |t              
(1 row)


starting permutation: s1_track_funcs_all s2_track_funcs_all s1_func_stats s2_func_stats s1_func_call s1_ff s2_func_call s2_func_call s2_ff s1_func_stats s2_func_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_track_funcs_all: SET track_functions = 'all';
step s2_track_funcs_all: SET track_functions = 'all';
step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)

step s2_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)

step s1_func_call: SELECT test_stat_func();
test_stat_func
--------------
              
(1 row)

step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         3|t               |t              
(1 row)

step s2_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         3|t               |t              
(1 row)


starting permutation: s1_track_funcs_all s2_track_funcs_all s1_func_stats s2_func_stats s1_begin s1_func_call s1_func_call s1_commit s1_ff s1_func_stats s2_func_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_track_funcs_all: SET track_functions = 'all';
step s2_track_funcs_all: SET track_functions = 'all';
step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)

step s2_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)

step s1_begin: BEGIN;
step s1_func_call: SELECT test_stat_func();
test_stat_func
--------------
              
(1 row)

step s1_func_call: SELECT test_stat_func();
test_stat_func
--------------
              
(1 row)

step s1_commit: COMMIT;
step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         2|t               |t              
(1 row)

step s2_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         2|t               |t              
(1 row)


starting permutation: s1_track_funcs_all s2_track_funcs_all s1_func_stats s2_func_stats s1_begin s1_func_call s2_func_call s1_func_drop s2_func_call s2_ff s2_func_stats s1_commit s1_ff s1_func_stats s2_func_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_track_funcs_all: SET track_functions = 'all';
step s2_track_funcs_all: SET track_functions = 'all';
step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)

step s2_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)

step s1_begin: BEGIN;
step s1_func_call: SELECT test_stat_func();
test_stat_func
--------------
              
(1 row)

step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s1_func_drop: DROP FUNCTION test_stat_func();
step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s2_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         2|t               |t              
(1 row)

step s1_commit: COMMIT;
step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)

step s2_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)


starting permutation: s1_track_funcs_all s2_track_funcs_all s1_func_stats s2_func_stats s1_begin s1_func_call s2_func_call s1_func_drop s2_func_call s2_ff s2_func_stats s1_rollback s1_ff s1_func_stats s2_func_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_track_funcs_all: SET track_functions = 'all';
step s2_track_funcs_all: SET track_functions = 'all';
step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)

step s2_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)

step s1_begin: BEGIN;
step s1_func_call: SELECT test_stat_func();
test_stat_func
--------------
              
(1 row)

step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s1_func_drop: DROP FUNCTION test_stat_func();
step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s2_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         2|t               |t              
(1 row)

step s1_rollback: ROLLBACK;
step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         3|t               |t              
(1 row)

step s2_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         3|t               |t              
(1 row)


starting permutation: s1_track_funcs_all s2_track_funcs_all s2_func_call s2_ff s2_begin s2_func_call_ifexists s1_func_drop s1_func_stats s2_commit s2_ff s1_func_stats s2_func_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_track_funcs_all: SET track_functions = 'all';
step s2_track_funcs_all: SET track_functions = 'all';
step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s2_begin: BEGIN;
step s2_func_call_ifexists: SELECT test_stat_func_ifexists();
test_stat_func_ifexists
-----------------------
                       
(1 row)

step s1_func_drop: DROP FUNCTION test_stat_func();
step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)

step s2_commit: COMMIT;
step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)

step s2_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)


starting permutation: s1_track_funcs_all s2_track_funcs_all s2_begin s2_func_call_ifexists s1_func_drop s1_func_stats s2_commit s2_ff s1_func_stats s2_func_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_track_funcs_all: SET track_functions = 'all';
step s2_track_funcs_all: SET track_functions = 'all';
step s2_begin: BEGIN;
step s2_func_call_ifexists: SELECT test_stat_func_ifexists();
test_stat_func_ifexists
-----------------------
                       
(1 row)

step s1_func_drop: DROP FUNCTION test_stat_func();
step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)

step s2_commit: COMMIT;
step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)

step s2_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)


starting permutation: s1_track_funcs_all s2_track_funcs_all s1_func_call s2_begin s2_func_call_ifexists s1_func_drop s2_func_call_ifexists s2_commit s2_ff s1_func_stats s2_func_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_track_funcs_all: SET track_functions = 'all';
step s2_track_funcs_all: SET track_functions = 'all';
step s1_func_call: SELECT test_stat_func();
test_stat_func
--------------
              
(1 row)

step s2_begin: BEGIN;
step s2_func_call_ifexists: SELECT test_stat_func_ifexists();
test_stat_func_ifexists
-----------------------
                       
(1 row)

step s1_func_drop: DROP FUNCTION test_stat_func();
step s2_func_call_ifexists: SELECT test_stat_func_ifexists();
test_stat_func_ifexists
-----------------------
                       
(1 row)

step s2_commit: COMMIT;
step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)

step s2_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)


starting permutation: s1_track_funcs_all s2_track_funcs_none s1_func_call s2_begin s2_func_call_ifexists s1_ff s1_func_stats s1_func_drop s2_track_funcs_none s1_func_stats s2_func_call_ifexists s2_commit s2_ff s1_func_stats s2_func_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_track_funcs_all: SET track_functions = 'all';
step s2_track_funcs_none: SET track_functions = 'none';
step s1_func_call: SELECT test_stat_func();
test_stat_func
--------------
              
(1 row)

step s2_begin: BEGIN;
step s2_func_call_ifexists: SELECT test_stat_func_ifexists();
test_stat_func_ifexists
-----------------------
                       
(1 row)

step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         1|t               |t              
(1 row)

step s1_func_drop: DROP FUNCTION test_stat_func();
step s2_track_funcs_none: SET track_functions = 'none';
step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)

step s2_func_call_ifexists: SELECT test_stat_func_ifexists();
test_stat_func_ifexists
-----------------------
                       
(1 row)

step s2_commit: COMMIT;
step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)

step s2_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)


starting permutation: s1_track_funcs_all s2_track_funcs_none s1_func_call s2_begin s2_func_call_ifexists s1_ff s1_func_stats s1_func_drop s2_track_funcs_all s1_func_stats s2_func_call_ifexists s2_commit s2_ff s1_func_stats s2_func_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_track_funcs_all: SET track_functions = 'all';
step s2_track_funcs_none: SET track_functions = 'none';
step s1_func_call: SELECT test_stat_func();
test_stat_func
--------------
              
(1 row)

step s2_begin: BEGIN;
step s2_func_call_ifexists: SELECT test_stat_func_ifexists();
test_stat_func_ifexists
-----------------------
                       
(1 row)

step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         1|t               |t              
(1 row)

step s1_func_drop: DROP FUNCTION test_stat_func();
step s2_track_funcs_all: SET track_functions = 'all';
step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)

step s2_func_call_ifexists: SELECT test_stat_func_ifexists();
test_stat_func_ifexists
-----------------------
                       
(1 row)

step s2_commit: COMMIT;
step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)

step s2_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)


starting permutation: s1_track_funcs_all s2_track_funcs_all s1_func_call s2_func_call s2_func_call2 s1_ff s2_ff s1_func_stats s2_func_call s2_func_call2 s2_ff s1_func_stats s1_func_stats2 s1_func_stats s1_func_stats_reset_check s1_func_stats_reset s1_func_stats s1_func_stats2 s1_func_stats s1_func_stats_reset_check
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_track_funcs_all: SET track_functions = 'all';
step s2_track_funcs_all: SET track_functions = 'all';
step s1_func_call: SELECT test_stat_func();
test_stat_func
--------------
              
(1 row)

step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s2_func_call2: SELECT test_stat_func2()
test_stat_func2
---------------
               
(1 row)

step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         2|t               |t              
(1 row)

step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s2_func_call2: SELECT test_stat_func2()
test_stat_func2
---------------
               
(1 row)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         3|t               |t              
(1 row)

step s1_func_stats2: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func2'

name           |pg_stat_get_function_calls|total_above_zero|self_above_zero
---------------+--------------------------+----------------+---------------
test_stat_func2|                         2|t               |t              
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         3|t               |t              
(1 row)

step s1_func_stats_reset_check: 
    SELECT pg_stat_get_function_stat_reset_time('test_stat_func'::regproc)
        IS NOT NULL AS has_stats_reset;

has_stats_reset
---------------
f              
(1 row)

step s1_func_stats_reset: SELECT pg_stat_reset_single_function_counters('test_stat_func'::regproc);
pg_stat_reset_single_function_counters
--------------------------------------
                                      
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         0|f               |f              
(1 row)

step s1_func_stats2: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func2'

name           |pg_stat_get_function_calls|total_above_zero|self_above_zero
---------------+--------------------------+----------------+---------------
test_stat_func2|                         2|t               |t              
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         0|f               |f              
(1 row)

step s1_func_stats_reset_check: 
    SELECT pg_stat_get_function_stat_reset_time('test_stat_func'::regproc)
        IS NOT NULL AS has_stats_reset;

has_stats_reset
---------------
t              
(1 row)


starting permutation: s1_func_stats_nonexistent s1_func_stats_reset_nonexistent s1_func_stats_nonexistent
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_stats_nonexistent: 
    SELECT pg_stat_get_function_calls(12000);

pg_stat_get_function_calls
--------------------------
                          
(1 row)

step s1_func_stats_reset_nonexistent: SELECT pg_stat_reset_single_function_counters(12000);
pg_stat_reset_single_function_counters
--------------------------------------
                                      
(1 row)

step s1_func_stats_nonexistent: 
    SELECT pg_stat_get_function_calls(12000);

pg_stat_get_function_calls
--------------------------
                          
(1 row)


starting permutation: s1_track_funcs_all s2_track_funcs_all s1_func_call s2_func_call s2_func_call2 s1_ff s2_ff s1_func_stats s1_func_stats2 s1_func_stats s1_reset s1_func_stats s1_func_stats2 s1_func_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_track_funcs_all: SET track_functions = 'all';
step s2_track_funcs_all: SET track_functions = 'all';
step s1_func_call: SELECT test_stat_func();
test_stat_func
--------------
              
(1 row)

step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s2_func_call2: SELECT test_stat_func2()
test_stat_func2
---------------
               
(1 row)

step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         2|t               |t              
(1 row)

step s1_func_stats2: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func2'

name           |pg_stat_get_function_calls|total_above_zero|self_above_zero
---------------+--------------------------+----------------+---------------
test_stat_func2|                         1|t               |t              
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         2|t               |t              
(1 row)

step s1_reset: SELECT pg_stat_reset();
pg_stat_reset
-------------
             
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         0|f               |f              
(1 row)

step s1_func_stats2: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func2'

name           |pg_stat_get_function_calls|total_above_zero|self_above_zero
---------------+--------------------------+----------------+---------------
test_stat_func2|                         0|f               |f              
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         0|f               |f              
(1 row)


starting permutation: s1_track_funcs_all s1_fetch_consistency_none s1_func_call s1_ff s1_func_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_track_funcs_all: SET track_functions = 'all';
step s1_fetch_consistency_none: SET stats_fetch_consistency = 'none';
step s1_func_call: SELECT test_stat_func();
test_stat_func
--------------
              
(1 row)

step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         1|t               |t              
(1 row)


starting permutation: s1_track_funcs_all s1_fetch_consistency_cache s1_func_call s1_ff s1_func_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_track_funcs_all: SET track_functions = 'all';
step s1_fetch_consistency_cache: SET stats_fetch_consistency = 'cache';
step s1_func_call: SELECT test_stat_func();
test_stat_func
--------------
              
(1 row)

step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         1|t               |t              
(1 row)


starting permutation: s1_track_funcs_all s1_fetch_consistency_snapshot s1_func_call s1_ff s1_func_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_track_funcs_all: SET track_functions = 'all';
step s1_fetch_consistency_snapshot: SET stats_fetch_consistency = 'snapshot';
step s1_func_call: SELECT test_stat_func();
test_stat_func
--------------
              
(1 row)

step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         1|t               |t              
(1 row)


starting permutation: s1_track_funcs_all s2_track_funcs_all s1_fetch_consistency_none s2_func_call s2_ff s1_begin s1_func_stats s2_func_call s2_ff s1_func_stats s1_commit
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_track_funcs_all: SET track_functions = 'all';
step s2_track_funcs_all: SET track_functions = 'all';
step s1_fetch_consistency_none: SET stats_fetch_consistency = 'none';
step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_begin: BEGIN;
step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         1|t               |t              
(1 row)

step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         2|t               |t              
(1 row)

step s1_commit: COMMIT;

starting permutation: s1_track_funcs_all s2_track_funcs_all s1_fetch_consistency_cache s2_func_call s2_func_call2 s2_ff s1_begin s1_func_stats s2_func_call s2_func_call2 s2_ff s1_func_stats s1_func_stats2 s1_commit
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_track_funcs_all: SET track_functions = 'all';
step s2_track_funcs_all: SET track_functions = 'all';
step s1_fetch_consistency_cache: SET stats_fetch_consistency = 'cache';
step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s2_func_call2: SELECT test_stat_func2()
test_stat_func2
---------------
               
(1 row)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_begin: BEGIN;
step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         1|t               |t              
(1 row)

step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s2_func_call2: SELECT test_stat_func2()
test_stat_func2
---------------
               
(1 row)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         1|t               |t              
(1 row)

step s1_func_stats2: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func2'

name           |pg_stat_get_function_calls|total_above_zero|self_above_zero
---------------+--------------------------+----------------+---------------
test_stat_func2|                         2|t               |t              
(1 row)

step s1_commit: COMMIT;

starting permutation: s1_track_funcs_all s2_track_funcs_all s1_fetch_consistency_snapshot s2_func_call s2_func_call2 s2_ff s1_begin s1_func_stats s2_func_call s2_func_call2 s2_ff s1_func_stats s1_func_stats2 s1_commit
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_track_funcs_all: SET track_functions = 'all';
step s2_track_funcs_all: SET track_functions = 'all';
step s1_fetch_consistency_snapshot: SET stats_fetch_consistency = 'snapshot';
step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s2_func_call2: SELECT test_stat_func2()
test_stat_func2
---------------
               
(1 row)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_begin: BEGIN;
step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         1|t               |t              
(1 row)

step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s2_func_call2: SELECT test_stat_func2()
test_stat_func2
---------------
               
(1 row)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         1|t               |t              
(1 row)

step s1_func_stats2: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func2'

name           |pg_stat_get_function_calls|total_above_zero|self_above_zero
---------------+--------------------------+----------------+---------------
test_stat_func2|                         1|t               |t              
(1 row)

step s1_commit: COMMIT;

starting permutation: s1_fetch_consistency_none s1_begin s1_func_stats_nonexistent s1_func_stats_nonexistent s1_commit
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_fetch_consistency_none: SET stats_fetch_consistency = 'none';
step s1_begin: BEGIN;
step s1_func_stats_nonexistent: 
    SELECT pg_stat_get_function_calls(12000);

pg_stat_get_function_calls
--------------------------
                          
(1 row)

step s1_func_stats_nonexistent: 
    SELECT pg_stat_get_function_calls(12000);

pg_stat_get_function_calls
--------------------------
                          
(1 row)

step s1_commit: COMMIT;

starting permutation: s1_fetch_consistency_cache s1_begin s1_func_stats_nonexistent s1_func_stats_nonexistent s1_commit
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_fetch_consistency_cache: SET stats_fetch_consistency = 'cache';
step s1_begin: BEGIN;
step s1_func_stats_nonexistent: 
    SELECT pg_stat_get_function_calls(12000);

pg_stat_get_function_calls
--------------------------
                          
(1 row)

step s1_func_stats_nonexistent: 
    SELECT pg_stat_get_function_calls(12000);

pg_stat_get_function_calls
--------------------------
                          
(1 row)

step s1_commit: COMMIT;

starting permutation: s1_fetch_consistency_snapshot s1_begin s1_func_stats_nonexistent s1_func_stats_nonexistent s1_commit
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_fetch_consistency_snapshot: SET stats_fetch_consistency = 'snapshot';
step s1_begin: BEGIN;
step s1_func_stats_nonexistent: 
    SELECT pg_stat_get_function_calls(12000);

pg_stat_get_function_calls
--------------------------
                          
(1 row)

step s1_func_stats_nonexistent: 
    SELECT pg_stat_get_function_calls(12000);

pg_stat_get_function_calls
--------------------------
                          
(1 row)

step s1_commit: COMMIT;

starting permutation: s1_track_funcs_all s2_track_funcs_all s1_begin s1_func_call s2_func_call s1_func_drop s2_func_call s2_ff s1_prepare_a s2_func_call s2_ff s1_func_call s1_ff s1_func_stats s1_commit_prepared_a s1_func_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_track_funcs_all: SET track_functions = 'all';
step s2_track_funcs_all: SET track_functions = 'all';
step s1_begin: BEGIN;
step s1_func_call: SELECT test_stat_func();
test_stat_func
--------------
              
(1 row)

step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s1_func_drop: DROP FUNCTION test_stat_func();
step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_prepare_a: PREPARE TRANSACTION 'a';
step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_call: SELECT test_stat_func();
test_stat_func
--------------
              
(1 row)

step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         5|t               |t              
(1 row)

step s1_commit_prepared_a: COMMIT PREPARED 'a';
step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)


starting permutation: s1_track_funcs_all s2_track_funcs_all s1_begin s1_func_call s2_func_call s1_func_drop s2_func_call s2_ff s1_prepare_a s2_func_call s2_ff s1_func_call s1_ff s1_func_stats s1_rollback_prepared_a s1_func_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_track_funcs_all: SET track_functions = 'all';
step s2_track_funcs_all: SET track_functions = 'all';
step s1_begin: BEGIN;
step s1_func_call: SELECT test_stat_func();
test_stat_func
--------------
              
(1 row)

step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s1_func_drop: DROP FUNCTION test_stat_func();
step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_prepare_a: PREPARE TRANSACTION 'a';
step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_call: SELECT test_stat_func();
test_stat_func
--------------
              
(1 row)

step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         5|t               |t              
(1 row)

step s1_rollback_prepared_a: ROLLBACK PREPARED 'a';
step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         5|t               |t              
(1 row)


starting permutation: s1_track_funcs_all s2_track_funcs_all s1_begin s1_func_call s2_func_call s1_func_drop s2_func_call s2_ff s1_prepare_a s2_func_call s2_ff s1_func_call s1_ff s1_func_stats s2_commit_prepared_a s1_func_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_track_funcs_all: SET track_functions = 'all';
step s2_track_funcs_all: SET track_functions = 'all';
step s1_begin: BEGIN;
step s1_func_call: SELECT test_stat_func();
test_stat_func
--------------
              
(1 row)

step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s1_func_drop: DROP FUNCTION test_stat_func();
step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_prepare_a: PREPARE TRANSACTION 'a';
step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_call: SELECT test_stat_func();
test_stat_func
--------------
              
(1 row)

step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         5|t               |t              
(1 row)

step s2_commit_prepared_a: COMMIT PREPARED 'a';
step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)


starting permutation: s1_track_funcs_all s2_track_funcs_all s1_begin s1_func_call s2_func_call s1_func_drop s2_func_call s2_ff s1_prepare_a s2_func_call s2_ff s1_func_call s1_ff s1_func_stats s2_rollback_prepared_a s1_func_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_track_funcs_all: SET track_functions = 'all';
step s2_track_funcs_all: SET track_functions = 'all';
step s1_begin: BEGIN;
step s1_func_call: SELECT test_stat_func();
test_stat_func
--------------
              
(1 row)

step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s1_func_drop: DROP FUNCTION test_stat_func();
step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_prepare_a: PREPARE TRANSACTION 'a';
step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_call: SELECT test_stat_func();
test_stat_func
--------------
              
(1 row)

step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         5|t               |t              
(1 row)

step s2_rollback_prepared_a: ROLLBACK PREPARED 'a';
step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         5|t               |t              
(1 row)


starting permutation: s1_table_select s1_table_insert s2_table_select s2_table_update_k1 s1_ff s2_table_update_k1 s1_table_drop s2_ff s1_table_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_table_select: SELECT * FROM test_stat_tab ORDER BY key, value;
key|value
---+-----
k0 |    1
(1 row)

step s1_table_insert: INSERT INTO test_stat_tab(key, value) VALUES('k1', 1), ('k2', 1), ('k3', 1);
step s2_table_select: SELECT * FROM test_stat_tab ORDER BY key, value;
key|value
---+-----
k0 |    1
k1 |    1
k2 |    1
k3 |    1
(4 rows)

step s2_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s2_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s1_table_drop: DROP TABLE test_stat_tab;
step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_table_stats: 
    SELECT
        pg_stat_get_numscans(tso.oid) AS seq_scan,
        pg_stat_get_tuples_returned(tso.oid) AS seq_tup_read,
        pg_stat_get_tuples_inserted(tso.oid) AS n_tup_ins,
        pg_stat_get_tuples_updated(tso.oid) AS n_tup_upd,
        pg_stat_get_tuples_deleted(tso.oid) AS n_tup_del,
        pg_stat_get_live_tuples(tso.oid) AS n_live_tup,
        pg_stat_get_dead_tuples(tso.oid) AS n_dead_tup,
        pg_stat_get_vacuum_count(tso.oid) AS vacuum_count
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_tab'

seq_scan|seq_tup_read|n_tup_ins|n_tup_upd|n_tup_del|n_live_tup|n_dead_tup|vacuum_count
--------+------------+---------+---------+---------+----------+----------+------------
       0|           0|        0|        0|        0|         0|         0|           0
(1 row)


starting permutation: s1_table_select s1_table_insert s2_table_select s2_table_update_k1 s2_table_update_k1 s1_table_drop s1_table_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_table_select: SELECT * FROM test_stat_tab ORDER BY key, value;
key|value
---+-----
k0 |    1
(1 row)

step s1_table_insert: INSERT INTO test_stat_tab(key, value) VALUES('k1', 1), ('k2', 1), ('k3', 1);
step s2_table_select: SELECT * FROM test_stat_tab ORDER BY key, value;
key|value
---+-----
k0 |    1
k1 |    1
k2 |    1
k3 |    1
(4 rows)

step s2_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s2_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s1_table_drop: DROP TABLE test_stat_tab;
step s1_table_stats: 
    SELECT
        pg_stat_get_numscans(tso.oid) AS seq_scan,
        pg_stat_get_tuples_returned(tso.oid) AS seq_tup_read,
        pg_stat_get_tuples_inserted(tso.oid) AS n_tup_ins,
        pg_stat_get_tuples_updated(tso.oid) AS n_tup_upd,
        pg_stat_get_tuples_deleted(tso.oid) AS n_tup_del,
        pg_stat_get_live_tuples(tso.oid) AS n_live_tup,
        pg_stat_get_dead_tuples(tso.oid) AS n_dead_tup,
        pg_stat_get_vacuum_count(tso.oid) AS vacuum_count
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_tab'

seq_scan|seq_tup_read|n_tup_ins|n_tup_upd|n_tup_del|n_live_tup|n_dead_tup|vacuum_count
--------+------------+---------+---------+---------+----------+----------+------------
       0|           0|        0|        0|        0|         0|         0|           0
(1 row)


starting permutation: s1_track_counts_off s1_table_stats s1_track_counts_on
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_track_counts_off: SET track_counts = off;
step s1_table_stats: 
    SELECT
        pg_stat_get_numscans(tso.oid) AS seq_scan,
        pg_stat_get_tuples_returned(tso.oid) AS seq_tup_read,
        pg_stat_get_tuples_inserted(tso.oid) AS n_tup_ins,
        pg_stat_get_tuples_updated(tso.oid) AS n_tup_upd,
        pg_stat_get_tuples_deleted(tso.oid) AS n_tup_del,
        pg_stat_get_live_tuples(tso.oid) AS n_live_tup,
        pg_stat_get_dead_tuples(tso.oid) AS n_dead_tup,
        pg_stat_get_vacuum_count(tso.oid) AS vacuum_count
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_tab'

seq_scan|seq_tup_read|n_tup_ins|n_tup_upd|n_tup_del|n_live_tup|n_dead_tup|vacuum_count
--------+------------+---------+---------+---------+----------+----------+------------
       0|           0|        1|        0|        0|         1|         0|           0
(1 row)

step s1_track_counts_on: SET track_counts = on;

starting permutation: s1_table_select s1_track_counts_off s1_ff s1_table_stats s1_track_counts_on
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_table_select: SELECT * FROM test_stat_tab ORDER BY key, value;
key|value
---+-----
k0 |    1
(1 row)

step s1_track_counts_off: SET track_counts = off;
step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_table_stats: 
    SELECT
        pg_stat_get_numscans(tso.oid) AS seq_scan,
        pg_stat_get_tuples_returned(tso.oid) AS seq_tup_read,
        pg_stat_get_tuples_inserted(tso.oid) AS n_tup_ins,
        pg_stat_get_tuples_updated(tso.oid) AS n_tup_upd,
        pg_stat_get_tuples_deleted(tso.oid) AS n_tup_del,
        pg_stat_get_live_tuples(tso.oid) AS n_live_tup,
        pg_stat_get_dead_tuples(tso.oid) AS n_dead_tup,
        pg_stat_get_vacuum_count(tso.oid) AS vacuum_count
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_tab'

seq_scan|seq_tup_read|n_tup_ins|n_tup_upd|n_tup_del|n_live_tup|n_dead_tup|vacuum_count
--------+------------+---------+---------+---------+----------+----------+------------
       1|           1|        1|        0|        0|         1|         0|           0
(1 row)

step s1_track_counts_on: SET track_counts = on;

starting permutation: s1_table_select s1_ff s1_track_counts_off s1_table_stats s1_track_counts_on
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_table_select: SELECT * FROM test_stat_tab ORDER BY key, value;
key|value
---+-----
k0 |    1
(1 row)

step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_track_counts_off: SET track_counts = off;
step s1_table_stats: 
    SELECT
        pg_stat_get_numscans(tso.oid) AS seq_scan,
        pg_stat_get_tuples_returned(tso.oid) AS seq_tup_read,
        pg_stat_get_tuples_inserted(tso.oid) AS n_tup_ins,
        pg_stat_get_tuples_updated(tso.oid) AS n_tup_upd,
        pg_stat_get_tuples_deleted(tso.oid) AS n_tup_del,
        pg_stat_get_live_tuples(tso.oid) AS n_live_tup,
        pg_stat_get_dead_tuples(tso.oid) AS n_dead_tup,
        pg_stat_get_vacuum_count(tso.oid) AS vacuum_count
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_tab'

seq_scan|seq_tup_read|n_tup_ins|n_tup_upd|n_tup_del|n_live_tup|n_dead_tup|vacuum_count
--------+------------+---------+---------+---------+----------+----------+------------
       1|           1|        1|        0|        0|         1|         0|           0
(1 row)

step s1_track_counts_on: SET track_counts = on;

starting permutation: s1_track_counts_off s1_table_select s1_table_insert_k1 s1_table_update_k1 s2_table_select s1_track_counts_on s1_ff s2_ff s1_table_stats s1_table_select s1_table_update_k1 s1_ff s1_table_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_track_counts_off: SET track_counts = off;
step s1_table_select: SELECT * FROM test_stat_tab ORDER BY key, value;
key|value
---+-----
k0 |    1
(1 row)

step s1_table_insert_k1: INSERT INTO test_stat_tab(key, value) VALUES('k1', 1);
step s1_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s2_table_select: SELECT * FROM test_stat_tab ORDER BY key, value;
key|value
---+-----
k0 |    1
k1 |    2
(2 rows)

step s1_track_counts_on: SET track_counts = on;
step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_table_stats: 
    SELECT
        pg_stat_get_numscans(tso.oid) AS seq_scan,
        pg_stat_get_tuples_returned(tso.oid) AS seq_tup_read,
        pg_stat_get_tuples_inserted(tso.oid) AS n_tup_ins,
        pg_stat_get_tuples_updated(tso.oid) AS n_tup_upd,
        pg_stat_get_tuples_deleted(tso.oid) AS n_tup_del,
        pg_stat_get_live_tuples(tso.oid) AS n_live_tup,
        pg_stat_get_dead_tuples(tso.oid) AS n_dead_tup,
        pg_stat_get_vacuum_count(tso.oid) AS vacuum_count
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_tab'

seq_scan|seq_tup_read|n_tup_ins|n_tup_upd|n_tup_del|n_live_tup|n_dead_tup|vacuum_count
--------+------------+---------+---------+---------+----------+----------+------------
       1|           2|        1|        0|        0|         1|         0|           0
(1 row)

step s1_table_select: SELECT * FROM test_stat_tab ORDER BY key, value;
key|value
---+-----
k0 |    1
k1 |    2
(2 rows)

step s1_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_table_stats: 
    SELECT
        pg_stat_get_numscans(tso.oid) AS seq_scan,
        pg_stat_get_tuples_returned(tso.oid) AS seq_tup_read,
        pg_stat_get_tuples_inserted(tso.oid) AS n_tup_ins,
        pg_stat_get_tuples_updated(tso.oid) AS n_tup_upd,
        pg_stat_get_tuples_deleted(tso.oid) AS n_tup_del,
        pg_stat_get_live_tuples(tso.oid) AS n_live_tup,
        pg_stat_get_dead_tuples(tso.oid) AS n_dead_tup,
        pg_stat_get_vacuum_count(tso.oid) AS vacuum_count
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_tab'

seq_scan|seq_tup_read|n_tup_ins|n_tup_upd|n_tup_del|n_live_tup|n_dead_tup|vacuum_count
--------+------------+---------+---------+---------+----------+----------+------------
       3|           6|        1|        1|        0|         1|         1|           0
(1 row)


starting permutation: s1_table_select s1_table_insert_k1 s1_table_delete_k1 s1_track_counts_off s1_table_select s1_table_insert_k1 s1_table_update_k1 s2_table_select s1_track_counts_on s1_ff s2_ff s1_table_stats s1_table_select s1_table_update_k1 s1_ff s1_table_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_table_select: SELECT * FROM test_stat_tab ORDER BY key, value;
key|value
---+-----
k0 |    1
(1 row)

step s1_table_insert_k1: INSERT INTO test_stat_tab(key, value) VALUES('k1', 1);
step s1_table_delete_k1: DELETE FROM test_stat_tab WHERE key = 'k1';
step s1_track_counts_off: SET track_counts = off;
step s1_table_select: SELECT * FROM test_stat_tab ORDER BY key, value;
key|value
---+-----
k0 |    1
(1 row)

step s1_table_insert_k1: INSERT INTO test_stat_tab(key, value) VALUES('k1', 1);
step s1_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s2_table_select: SELECT * FROM test_stat_tab ORDER BY key, value;
key|value
---+-----
k0 |    1
k1 |    2
(2 rows)

step s1_track_counts_on: SET track_counts = on;
step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_table_stats: 
    SELECT
        pg_stat_get_numscans(tso.oid) AS seq_scan,
        pg_stat_get_tuples_returned(tso.oid) AS seq_tup_read,
        pg_stat_get_tuples_inserted(tso.oid) AS n_tup_ins,
        pg_stat_get_tuples_updated(tso.oid) AS n_tup_upd,
        pg_stat_get_tuples_deleted(tso.oid) AS n_tup_del,
        pg_stat_get_live_tuples(tso.oid) AS n_live_tup,
        pg_stat_get_dead_tuples(tso.oid) AS n_dead_tup,
        pg_stat_get_vacuum_count(tso.oid) AS vacuum_count
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_tab'

seq_scan|seq_tup_read|n_tup_ins|n_tup_upd|n_tup_del|n_live_tup|n_dead_tup|vacuum_count
--------+------------+---------+---------+---------+----------+----------+------------
       3|           5|        2|        0|        1|         1|         1|           0
(1 row)

step s1_table_select: SELECT * FROM test_stat_tab ORDER BY key, value;
key|value
---+-----
k0 |    1
k1 |    2
(2 rows)

step s1_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_table_stats: 
    SELECT
        pg_stat_get_numscans(tso.oid) AS seq_scan,
        pg_stat_get_tuples_returned(tso.oid) AS seq_tup_read,
        pg_stat_get_tuples_inserted(tso.oid) AS n_tup_ins,
        pg_stat_get_tuples_updated(tso.oid) AS n_tup_upd,
        pg_stat_get_tuples_deleted(tso.oid) AS n_tup_del,
        pg_stat_get_live_tuples(tso.oid) AS n_live_tup,
        pg_stat_get_dead_tuples(tso.oid) AS n_dead_tup,
        pg_stat_get_vacuum_count(tso.oid) AS vacuum_count
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_tab'

seq_scan|seq_tup_read|n_tup_ins|n_tup_upd|n_tup_del|n_live_tup|n_dead_tup|vacuum_count
--------+------------+---------+---------+---------+----------+----------+------------
       5|           9|        2|        1|        1|         1|         2|           0
(1 row)


starting permutation: s1_begin s1_table_insert s1_table_update_k1 s1_table_update_k1 s1_table_update_k2 s1_table_update_k2 s1_table_update_k2 s1_table_delete_k1 s1_table_select s1_prepare_a s1_table_select s1_commit_prepared_a s1_table_select s1_ff s1_table_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_begin: BEGIN;
step s1_table_insert: INSERT INTO test_stat_tab(key, value) VALUES('k1', 1), ('k2', 1), ('k3', 1);
step s1_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s1_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s1_table_update_k2: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k2';
step s1_table_update_k2: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k2';
step s1_table_update_k2: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k2';
step s1_table_delete_k1: DELETE FROM test_stat_tab WHERE key = 'k1';
step s1_table_select: SELECT * FROM test_stat_tab ORDER BY key, value;
key|value
---+-----
k0 |    1
k2 |    4
k3 |    1
(3 rows)

step s1_prepare_a: PREPARE TRANSACTION 'a';
step s1_table_select: SELECT * FROM test_stat_tab ORDER BY key, value;
key|value
---+-----
k0 |    1
(1 row)

step s1_commit_prepared_a: COMMIT PREPARED 'a';
step s1_table_select: SELECT * FROM test_stat_tab ORDER BY key, value;
key|value
---+-----
k0 |    1
k2 |    4
k3 |    1
(3 rows)

step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_table_stats: 
    SELECT
        pg_stat_get_numscans(tso.oid) AS seq_scan,
        pg_stat_get_tuples_returned(tso.oid) AS seq_tup_read,
        pg_stat_get_tuples_inserted(tso.oid) AS n_tup_ins,
        pg_stat_get_tuples_updated(tso.oid) AS n_tup_upd,
        pg_stat_get_tuples_deleted(tso.oid) AS n_tup_del,
        pg_stat_get_live_tuples(tso.oid) AS n_live_tup,
        pg_stat_get_dead_tuples(tso.oid) AS n_dead_tup,
        pg_stat_get_vacuum_count(tso.oid) AS vacuum_count
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_tab'

seq_scan|seq_tup_read|n_tup_ins|n_tup_upd|n_tup_del|n_live_tup|n_dead_tup|vacuum_count
--------+------------+---------+---------+---------+----------+----------+------------
       9|          31|        4|        5|        1|         3|         6|           0
(1 row)


starting permutation: s1_begin s1_table_insert s1_table_update_k1 s1_table_update_k1 s1_table_update_k2 s1_table_update_k2 s1_table_update_k2 s1_table_delete_k1 s1_table_select s1_prepare_a s1_table_select s2_commit_prepared_a s1_table_select s1_ff s2_ff s1_table_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_begin: BEGIN;
step s1_table_insert: INSERT INTO test_stat_tab(key, value) VALUES('k1', 1), ('k2', 1), ('k3', 1);
step s1_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s1_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s1_table_update_k2: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k2';
step s1_table_update_k2: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k2';
step s1_table_update_k2: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k2';
step s1_table_delete_k1: DELETE FROM test_stat_tab WHERE key = 'k1';
step s1_table_select: SELECT * FROM test_stat_tab ORDER BY key, value;
key|value
---+-----
k0 |    1
k2 |    4
k3 |    1
(3 rows)

step s1_prepare_a: PREPARE TRANSACTION 'a';
step s1_table_select: SELECT * FROM test_stat_tab ORDER BY key, value;
key|value
---+-----
k0 |    1
(1 row)

step s2_commit_prepared_a: COMMIT PREPARED 'a';
step s1_table_select: SELECT * FROM test_stat_tab ORDER BY key, value;
key|value
---+-----
k0 |    1
k2 |    4
k3 |    1
(3 rows)

step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_table_stats: 
    SELECT
        pg_stat_get_numscans(tso.oid) AS seq_scan,
        pg_stat_get_tuples_returned(tso.oid) AS seq_tup_read,
        pg_stat_get_tuples_inserted(tso.oid) AS n_tup_ins,
        pg_stat_get_tuples_updated(tso.oid) AS n_tup_upd,
        pg_stat_get_tuples_deleted(tso.oid) AS n_tup_del,
        pg_stat_get_live_tuples(tso.oid) AS n_live_tup,
        pg_stat_get_dead_tuples(tso.oid) AS n_dead_tup,
        pg_stat_get_vacuum_count(tso.oid) AS vacuum_count
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_tab'

seq_scan|seq_tup_read|n_tup_ins|n_tup_upd|n_tup_del|n_live_tup|n_dead_tup|vacuum_count
--------+------------+---------+---------+---------+----------+----------+------------
       9|          31|        4|        5|        1|         3|         6|           0
(1 row)


starting permutation: s1_begin s1_table_insert s1_table_update_k1 s1_table_update_k1 s1_table_update_k2 s1_table_update_k2 s1_table_update_k2 s1_table_delete_k1 s1_table_select s1_prepare_a s1_table_select s1_rollback_prepared_a s1_table_select s1_ff s1_table_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_begin: BEGIN;
step s1_table_insert: INSERT INTO test_stat_tab(key, value) VALUES('k1', 1), ('k2', 1), ('k3', 1);
step s1_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s1_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s1_table_update_k2: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k2';
step s1_table_update_k2: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k2';
step s1_table_update_k2: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k2';
step s1_table_delete_k1: DELETE FROM test_stat_tab WHERE key = 'k1';
step s1_table_select: SELECT * FROM test_stat_tab ORDER BY key, value;
key|value
---+-----
k0 |    1
k2 |    4
k3 |    1
(3 rows)

step s1_prepare_a: PREPARE TRANSACTION 'a';
step s1_table_select: SELECT * FROM test_stat_tab ORDER BY key, value;
key|value
---+-----
k0 |    1
(1 row)

step s1_rollback_prepared_a: ROLLBACK PREPARED 'a';
step s1_table_select: SELECT * FROM test_stat_tab ORDER BY key, value;
key|value
---+-----
k0 |    1
(1 row)

step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_table_stats: 
    SELECT
        pg_stat_get_numscans(tso.oid) AS seq_scan,
        pg_stat_get_tuples_returned(tso.oid) AS seq_tup_read,
        pg_stat_get_tuples_inserted(tso.oid) AS n_tup_ins,
        pg_stat_get_tuples_updated(tso.oid) AS n_tup_upd,
        pg_stat_get_tuples_deleted(tso.oid) AS n_tup_del,
        pg_stat_get_live_tuples(tso.oid) AS n_live_tup,
        pg_stat_get_dead_tuples(tso.oid) AS n_dead_tup,
        pg_stat_get_vacuum_count(tso.oid) AS vacuum_count
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_tab'

seq_scan|seq_tup_read|n_tup_ins|n_tup_upd|n_tup_del|n_live_tup|n_dead_tup|vacuum_count
--------+------------+---------+---------+---------+----------+----------+------------
       9|          29|        4|        5|        1|         1|         8|           0
(1 row)


starting permutation: s1_begin s1_table_insert s1_table_update_k1 s1_table_update_k1 s1_table_update_k2 s1_table_update_k2 s1_table_update_k2 s1_table_delete_k1 s1_table_select s1_prepare_a s1_table_select s2_rollback_prepared_a s1_table_select s1_ff s2_ff s1_table_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_begin: BEGIN;
step s1_table_insert: INSERT INTO test_stat_tab(key, value) VALUES('k1', 1), ('k2', 1), ('k3', 1);
step s1_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s1_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s1_table_update_k2: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k2';
step s1_table_update_k2: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k2';
step s1_table_update_k2: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k2';
step s1_table_delete_k1: DELETE FROM test_stat_tab WHERE key = 'k1';
step s1_table_select: SELECT * FROM test_stat_tab ORDER BY key, value;
key|value
---+-----
k0 |    1
k2 |    4
k3 |    1
(3 rows)

step s1_prepare_a: PREPARE TRANSACTION 'a';
step s1_table_select: SELECT * FROM test_stat_tab ORDER BY key, value;
key|value
---+-----
k0 |    1
(1 row)

step s2_rollback_prepared_a: ROLLBACK PREPARED 'a';
step s1_table_select: SELECT * FROM test_stat_tab ORDER BY key, value;
key|value
---+-----
k0 |    1
(1 row)

step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_table_stats: 
    SELECT
        pg_stat_get_numscans(tso.oid) AS seq_scan,
        pg_stat_get_tuples_returned(tso.oid) AS seq_tup_read,
        pg_stat_get_tuples_inserted(tso.oid) AS n_tup_ins,
        pg_stat_get_tuples_updated(tso.oid) AS n_tup_upd,
        pg_stat_get_tuples_deleted(tso.oid) AS n_tup_del,
        pg_stat_get_live_tuples(tso.oid) AS n_live_tup,
        pg_stat_get_dead_tuples(tso.oid) AS n_dead_tup,
        pg_stat_get_vacuum_count(tso.oid) AS vacuum_count
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_tab'

seq_scan|seq_tup_read|n_tup_ins|n_tup_upd|n_tup_del|n_live_tup|n_dead_tup|vacuum_count
--------+------------+---------+---------+---------+----------+----------+------------
       9|          29|        4|        5|        1|         1|         8|           0
(1 row)


starting permutation: s1_table_insert s1_begin s1_table_update_k1 s1_table_update_k1 s1_table_truncate s1_table_insert_k1 s1_table_update_k1 s1_prepare_a s1_commit_prepared_a s1_ff s1_table_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_table_insert: INSERT INTO test_stat_tab(key, value) VALUES('k1', 1), ('k2', 1), ('k3', 1);
step s1_begin: BEGIN;
step s1_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s1_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s1_table_truncate: TRUNCATE test_stat_tab;
step s1_table_insert_k1: INSERT INTO test_stat_tab(key, value) VALUES('k1', 1);
step s1_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s1_prepare_a: PREPARE TRANSACTION 'a';
step s1_commit_prepared_a: COMMIT PREPARED 'a';
step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_table_stats: 
    SELECT
        pg_stat_get_numscans(tso.oid) AS seq_scan,
        pg_stat_get_tuples_returned(tso.oid) AS seq_tup_read,
        pg_stat_get_tuples_inserted(tso.oid) AS n_tup_ins,
        pg_stat_get_tuples_updated(tso.oid) AS n_tup_upd,
        pg_stat_get_tuples_deleted(tso.oid) AS n_tup_del,
        pg_stat_get_live_tuples(tso.oid) AS n_live_tup,
        pg_stat_get_dead_tuples(tso.oid) AS n_dead_tup,
        pg_stat_get_vacuum_count(tso.oid) AS vacuum_count
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_tab'

seq_scan|seq_tup_read|n_tup_ins|n_tup_upd|n_tup_del|n_live_tup|n_dead_tup|vacuum_count
--------+------------+---------+---------+---------+----------+----------+------------
       3|           9|        5|        1|        0|         1|         1|           0
(1 row)


starting permutation: s1_table_insert s1_begin s1_table_update_k1 s1_table_update_k1 s1_table_truncate s1_table_insert_k1 s1_table_update_k1 s1_prepare_a s1_ff s2_commit_prepared_a s2_ff s1_table_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_table_insert: INSERT INTO test_stat_tab(key, value) VALUES('k1', 1), ('k2', 1), ('k3', 1);
step s1_begin: BEGIN;
step s1_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s1_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s1_table_truncate: TRUNCATE test_stat_tab;
step s1_table_insert_k1: INSERT INTO test_stat_tab(key, value) VALUES('k1', 1);
step s1_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s1_prepare_a: PREPARE TRANSACTION 'a';
step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s2_commit_prepared_a: COMMIT PREPARED 'a';
step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_table_stats: 
    SELECT
        pg_stat_get_numscans(tso.oid) AS seq_scan,
        pg_stat_get_tuples_returned(tso.oid) AS seq_tup_read,
        pg_stat_get_tuples_inserted(tso.oid) AS n_tup_ins,
        pg_stat_get_tuples_updated(tso.oid) AS n_tup_upd,
        pg_stat_get_tuples_deleted(tso.oid) AS n_tup_del,
        pg_stat_get_live_tuples(tso.oid) AS n_live_tup,
        pg_stat_get_dead_tuples(tso.oid) AS n_dead_tup,
        pg_stat_get_vacuum_count(tso.oid) AS vacuum_count
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_tab'

seq_scan|seq_tup_read|n_tup_ins|n_tup_upd|n_tup_del|n_live_tup|n_dead_tup|vacuum_count
--------+------------+---------+---------+---------+----------+----------+------------
       3|           9|        5|        1|        0|         1|         1|           0
(1 row)


starting permutation: s1_table_insert s1_begin s1_table_update_k1 s1_table_update_k1 s1_table_truncate s1_table_insert_k1 s1_table_update_k1 s1_prepare_a s1_rollback_prepared_a s1_ff s1_table_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_table_insert: INSERT INTO test_stat_tab(key, value) VALUES('k1', 1), ('k2', 1), ('k3', 1);
step s1_begin: BEGIN;
step s1_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s1_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s1_table_truncate: TRUNCATE test_stat_tab;
step s1_table_insert_k1: INSERT INTO test_stat_tab(key, value) VALUES('k1', 1);
step s1_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s1_prepare_a: PREPARE TRANSACTION 'a';
step s1_rollback_prepared_a: ROLLBACK PREPARED 'a';
step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_table_stats: 
    SELECT
        pg_stat_get_numscans(tso.oid) AS seq_scan,
        pg_stat_get_tuples_returned(tso.oid) AS seq_tup_read,
        pg_stat_get_tuples_inserted(tso.oid) AS n_tup_ins,
        pg_stat_get_tuples_updated(tso.oid) AS n_tup_upd,
        pg_stat_get_tuples_deleted(tso.oid) AS n_tup_del,
        pg_stat_get_live_tuples(tso.oid) AS n_live_tup,
        pg_stat_get_dead_tuples(tso.oid) AS n_dead_tup,
        pg_stat_get_vacuum_count(tso.oid) AS vacuum_count
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_tab'

seq_scan|seq_tup_read|n_tup_ins|n_tup_upd|n_tup_del|n_live_tup|n_dead_tup|vacuum_count
--------+------------+---------+---------+---------+----------+----------+------------
       3|           9|        4|        2|        0|         4|         2|           0
(1 row)


starting permutation: s1_table_insert s1_begin s1_table_update_k1 s1_table_update_k1 s1_table_truncate s1_table_insert_k1 s1_table_update_k1 s1_prepare_a s2_rollback_prepared_a s1_ff s2_ff s1_table_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_table_insert: INSERT INTO test_stat_tab(key, value) VALUES('k1', 1), ('k2', 1), ('k3', 1);
step s1_begin: BEGIN;
step s1_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s1_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s1_table_truncate: TRUNCATE test_stat_tab;
step s1_table_insert_k1: INSERT INTO test_stat_tab(key, value) VALUES('k1', 1);
step s1_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s1_prepare_a: PREPARE TRANSACTION 'a';
step s2_rollback_prepared_a: ROLLBACK PREPARED 'a';
step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_table_stats: 
    SELECT
        pg_stat_get_numscans(tso.oid) AS seq_scan,
        pg_stat_get_tuples_returned(tso.oid) AS seq_tup_read,
        pg_stat_get_tuples_inserted(tso.oid) AS n_tup_ins,
        pg_stat_get_tuples_updated(tso.oid) AS n_tup_upd,
        pg_stat_get_tuples_deleted(tso.oid) AS n_tup_del,
        pg_stat_get_live_tuples(tso.oid) AS n_live_tup,
        pg_stat_get_dead_tuples(tso.oid) AS n_dead_tup,
        pg_stat_get_vacuum_count(tso.oid) AS vacuum_count
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_tab'

seq_scan|seq_tup_read|n_tup_ins|n_tup_upd|n_tup_del|n_live_tup|n_dead_tup|vacuum_count
--------+------------+---------+---------+---------+----------+----------+------------
       3|           9|        4|        2|        0|         4|         2|           0
(1 row)


starting permutation: s1_table_insert s1_table_update_k1 s1_begin s1_table_delete_k1 s1_table_insert_k1 s1_table_update_k1 s1_table_update_k1 s1_table_drop s1_prepare_a s1_rollback_prepared_a s1_ff s1_table_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_table_insert: INSERT INTO test_stat_tab(key, value) VALUES('k1', 1), ('k2', 1), ('k3', 1);
step s1_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s1_begin: BEGIN;
step s1_table_delete_k1: DELETE FROM test_stat_tab WHERE key = 'k1';
step s1_table_insert_k1: INSERT INTO test_stat_tab(key, value) VALUES('k1', 1);
step s1_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s1_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s1_table_drop: DROP TABLE test_stat_tab;
step s1_prepare_a: PREPARE TRANSACTION 'a';
step s1_rollback_prepared_a: ROLLBACK PREPARED 'a';
step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_table_stats: 
    SELECT
        pg_stat_get_numscans(tso.oid) AS seq_scan,
        pg_stat_get_tuples_returned(tso.oid) AS seq_tup_read,
        pg_stat_get_tuples_inserted(tso.oid) AS n_tup_ins,
        pg_stat_get_tuples_updated(tso.oid) AS n_tup_upd,
        pg_stat_get_tuples_deleted(tso.oid) AS n_tup_del,
        pg_stat_get_live_tuples(tso.oid) AS n_live_tup,
        pg_stat_get_dead_tuples(tso.oid) AS n_dead_tup,
        pg_stat_get_vacuum_count(tso.oid) AS vacuum_count
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_tab'

seq_scan|seq_tup_read|n_tup_ins|n_tup_upd|n_tup_del|n_live_tup|n_dead_tup|vacuum_count
--------+------------+---------+---------+---------+----------+----------+------------
       4|          16|        5|        3|        1|         4|         4|           0
(1 row)


starting permutation: s1_table_insert s1_table_update_k1 s1_begin s1_table_delete_k1 s1_table_insert_k1 s1_table_update_k1 s1_table_update_k1 s1_table_drop s1_prepare_a s2_rollback_prepared_a s1_ff s2_ff s1_table_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_table_insert: INSERT INTO test_stat_tab(key, value) VALUES('k1', 1), ('k2', 1), ('k3', 1);
step s1_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s1_begin: BEGIN;
step s1_table_delete_k1: DELETE FROM test_stat_tab WHERE key = 'k1';
step s1_table_insert_k1: INSERT INTO test_stat_tab(key, value) VALUES('k1', 1);
step s1_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s1_table_update_k1: UPDATE test_stat_tab SET value = value + 1 WHERE key = 'k1';
step s1_table_drop: DROP TABLE test_stat_tab;
step s1_prepare_a: PREPARE TRANSACTION 'a';
step s2_rollback_prepared_a: ROLLBACK PREPARED 'a';
step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_table_stats: 
    SELECT
        pg_stat_get_numscans(tso.oid) AS seq_scan,
        pg_stat_get_tuples_returned(tso.oid) AS seq_tup_read,
        pg_stat_get_tuples_inserted(tso.oid) AS n_tup_ins,
        pg_stat_get_tuples_updated(tso.oid) AS n_tup_upd,
        pg_stat_get_tuples_deleted(tso.oid) AS n_tup_del,
        pg_stat_get_live_tuples(tso.oid) AS n_live_tup,
        pg_stat_get_dead_tuples(tso.oid) AS n_dead_tup,
        pg_stat_get_vacuum_count(tso.oid) AS vacuum_count
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_tab'

seq_scan|seq_tup_read|n_tup_ins|n_tup_upd|n_tup_del|n_live_tup|n_dead_tup|vacuum_count
--------+------------+---------+---------+---------+----------+----------+------------
       4|          16|        5|        3|        1|         4|         4|           0
(1 row)


starting permutation: s1_slru_save_stats s1_listen s1_begin s1_big_notify s1_ff s1_slru_check_stats s1_commit s1_slru_check_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_slru_save_stats: 
	INSERT INTO test_slru_stats VALUES('notify', 'blks_zeroed',
    (SELECT blks_zeroed FROM pg_stat_slru WHERE name = 'notify'));

step s1_listen: LISTEN stats_test_nothing;
step s1_begin: BEGIN;
step s1_big_notify: SELECT pg_notify('stats_test_use',
                repeat(i::text, current_setting('block_size')::int / 2)) FROM generate_series(1, 3) g(i);

pg_notify
---------
         
         
         
(3 rows)

step s1_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_slru_check_stats: 
	SELECT current.blks_zeroed > before.value
  FROM test_slru_stats before
  INNER JOIN pg_stat_slru current
  ON before.slru = current.name
  WHERE before.stat = 'blks_zeroed';

?column?
--------
f       
(1 row)

step s1_commit: COMMIT;
step s1_slru_check_stats: 
	SELECT current.blks_zeroed > before.value
  FROM test_slru_stats before
  INNER JOIN pg_stat_slru current
  ON before.slru = current.name
  WHERE before.stat = 'blks_zeroed';

?column?
--------
t       
(1 row)


starting permutation: s1_slru_save_stats s1_listen s2_big_notify s2_ff s1_slru_check_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_slru_save_stats: 
	INSERT INTO test_slru_stats VALUES('notify', 'blks_zeroed',
    (SELECT blks_zeroed FROM pg_stat_slru WHERE name = 'notify'));

step s1_listen: LISTEN stats_test_nothing;
step s2_big_notify: SELECT pg_notify('stats_test_use',
                repeat(i::text, current_setting('block_size')::int / 2)) FROM generate_series(1, 3) g(i);

pg_notify
---------
         
         
         
(3 rows)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_slru_check_stats: 
	SELECT current.blks_zeroed > before.value
  FROM test_slru_stats before
  INNER JOIN pg_stat_slru current
  ON before.slru = current.name
  WHERE before.stat = 'blks_zeroed';

?column?
--------
t       
(1 row)


starting permutation: s1_slru_save_stats s1_listen s2_begin s2_big_notify s2_ff s1_slru_check_stats s2_commit
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_slru_save_stats: 
	INSERT INTO test_slru_stats VALUES('notify', 'blks_zeroed',
    (SELECT blks_zeroed FROM pg_stat_slru WHERE name = 'notify'));

step s1_listen: LISTEN stats_test_nothing;
step s2_begin: BEGIN;
step s2_big_notify: SELECT pg_notify('stats_test_use',
                repeat(i::text, current_setting('block_size')::int / 2)) FROM generate_series(1, 3) g(i);

pg_notify
---------
         
         
         
(3 rows)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_slru_check_stats: 
	SELECT current.blks_zeroed > before.value
  FROM test_slru_stats before
  INNER JOIN pg_stat_slru current
  ON before.slru = current.name
  WHERE before.stat = 'blks_zeroed';

?column?
--------
f       
(1 row)

step s2_commit: COMMIT;

starting permutation: s1_fetch_consistency_none s1_slru_save_stats s1_listen s1_begin s1_slru_check_stats s2_big_notify s2_ff s1_slru_check_stats s1_commit s1_slru_check_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_fetch_consistency_none: SET stats_fetch_consistency = 'none';
step s1_slru_save_stats: 
	INSERT INTO test_slru_stats VALUES('notify', 'blks_zeroed',
    (SELECT blks_zeroed FROM pg_stat_slru WHERE name = 'notify'));

step s1_listen: LISTEN stats_test_nothing;
step s1_begin: BEGIN;
step s1_slru_check_stats: 
	SELECT current.blks_zeroed > before.value
  FROM test_slru_stats before
  INNER JOIN pg_stat_slru current
  ON before.slru = current.name
  WHERE before.stat = 'blks_zeroed';

?column?
--------
f       
(1 row)

step s2_big_notify: SELECT pg_notify('stats_test_use',
                repeat(i::text, current_setting('block_size')::int / 2)) FROM generate_series(1, 3) g(i);

pg_notify
---------
         
         
         
(3 rows)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_slru_check_stats: 
	SELECT current.blks_zeroed > before.value
  FROM test_slru_stats before
  INNER JOIN pg_stat_slru current
  ON before.slru = current.name
  WHERE before.stat = 'blks_zeroed';

?column?
--------
t       
(1 row)

step s1_commit: COMMIT;
step s1_slru_check_stats: 
	SELECT current.blks_zeroed > before.value
  FROM test_slru_stats before
  INNER JOIN pg_stat_slru current
  ON before.slru = current.name
  WHERE before.stat = 'blks_zeroed';

?column?
--------
t       
(1 row)


starting permutation: s1_fetch_consistency_cache s1_slru_save_stats s1_listen s1_begin s1_slru_check_stats s2_big_notify s2_ff s1_slru_check_stats s1_commit s1_slru_check_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_fetch_consistency_cache: SET stats_fetch_consistency = 'cache';
step s1_slru_save_stats: 
	INSERT INTO test_slru_stats VALUES('notify', 'blks_zeroed',
    (SELECT blks_zeroed FROM pg_stat_slru WHERE name = 'notify'));

step s1_listen: LISTEN stats_test_nothing;
step s1_begin: BEGIN;
step s1_slru_check_stats: 
	SELECT current.blks_zeroed > before.value
  FROM test_slru_stats before
  INNER JOIN pg_stat_slru current
  ON before.slru = current.name
  WHERE before.stat = 'blks_zeroed';

?column?
--------
f       
(1 row)

step s2_big_notify: SELECT pg_notify('stats_test_use',
                repeat(i::text, current_setting('block_size')::int / 2)) FROM generate_series(1, 3) g(i);

pg_notify
---------
         
         
         
(3 rows)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_slru_check_stats: 
	SELECT current.blks_zeroed > before.value
  FROM test_slru_stats before
  INNER JOIN pg_stat_slru current
  ON before.slru = current.name
  WHERE before.stat = 'blks_zeroed';

?column?
--------
f       
(1 row)

step s1_commit: COMMIT;
step s1_slru_check_stats: 
	SELECT current.blks_zeroed > before.value
  FROM test_slru_stats before
  INNER JOIN pg_stat_slru current
  ON before.slru = current.name
  WHERE before.stat = 'blks_zeroed';

?column?
--------
t       
(1 row)


starting permutation: s1_fetch_consistency_snapshot s1_slru_save_stats s1_listen s1_begin s1_slru_check_stats s2_big_notify s2_ff s1_slru_check_stats s1_commit s1_slru_check_stats
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_fetch_consistency_snapshot: SET stats_fetch_consistency = 'snapshot';
step s1_slru_save_stats: 
	INSERT INTO test_slru_stats VALUES('notify', 'blks_zeroed',
    (SELECT blks_zeroed FROM pg_stat_slru WHERE name = 'notify'));

step s1_listen: LISTEN stats_test_nothing;
step s1_begin: BEGIN;
step s1_slru_check_stats: 
	SELECT current.blks_zeroed > before.value
  FROM test_slru_stats before
  INNER JOIN pg_stat_slru current
  ON before.slru = current.name
  WHERE before.stat = 'blks_zeroed';

?column?
--------
f       
(1 row)

step s2_big_notify: SELECT pg_notify('stats_test_use',
                repeat(i::text, current_setting('block_size')::int / 2)) FROM generate_series(1, 3) g(i);

pg_notify
---------
         
         
         
(3 rows)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_slru_check_stats: 
	SELECT current.blks_zeroed > before.value
  FROM test_slru_stats before
  INNER JOIN pg_stat_slru current
  ON before.slru = current.name
  WHERE before.stat = 'blks_zeroed';

?column?
--------
f       
(1 row)

step s1_commit: COMMIT;
step s1_slru_check_stats: 
	SELECT current.blks_zeroed > before.value
  FROM test_slru_stats before
  INNER JOIN pg_stat_slru current
  ON before.slru = current.name
  WHERE before.stat = 'blks_zeroed';

?column?
--------
t       
(1 row)


starting permutation: s1_fetch_consistency_none s1_slru_save_stats s1_listen s1_begin s1_slru_check_stats s2_big_notify s2_ff s1_slru_check_stats s1_clear_snapshot s1_slru_check_stats s1_commit
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_fetch_consistency_none: SET stats_fetch_consistency = 'none';
step s1_slru_save_stats: 
	INSERT INTO test_slru_stats VALUES('notify', 'blks_zeroed',
    (SELECT blks_zeroed FROM pg_stat_slru WHERE name = 'notify'));

step s1_listen: LISTEN stats_test_nothing;
step s1_begin: BEGIN;
step s1_slru_check_stats: 
	SELECT current.blks_zeroed > before.value
  FROM test_slru_stats before
  INNER JOIN pg_stat_slru current
  ON before.slru = current.name
  WHERE before.stat = 'blks_zeroed';

?column?
--------
f       
(1 row)

step s2_big_notify: SELECT pg_notify('stats_test_use',
                repeat(i::text, current_setting('block_size')::int / 2)) FROM generate_series(1, 3) g(i);

pg_notify
---------
         
         
         
(3 rows)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_slru_check_stats: 
	SELECT current.blks_zeroed > before.value
  FROM test_slru_stats before
  INNER JOIN pg_stat_slru current
  ON before.slru = current.name
  WHERE before.stat = 'blks_zeroed';

?column?
--------
t       
(1 row)

step s1_clear_snapshot: SELECT pg_stat_clear_snapshot();
pg_stat_clear_snapshot
----------------------
                      
(1 row)

step s1_slru_check_stats: 
	SELECT current.blks_zeroed > before.value
  FROM test_slru_stats before
  INNER JOIN pg_stat_slru current
  ON before.slru = current.name
  WHERE before.stat = 'blks_zeroed';

?column?
--------
t       
(1 row)

step s1_commit: COMMIT;

starting permutation: s1_fetch_consistency_cache s1_slru_save_stats s1_listen s1_begin s1_slru_check_stats s2_big_notify s2_ff s1_slru_check_stats s1_clear_snapshot s1_slru_check_stats s1_commit
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_fetch_consistency_cache: SET stats_fetch_consistency = 'cache';
step s1_slru_save_stats: 
	INSERT INTO test_slru_stats VALUES('notify', 'blks_zeroed',
    (SELECT blks_zeroed FROM pg_stat_slru WHERE name = 'notify'));

step s1_listen: LISTEN stats_test_nothing;
step s1_begin: BEGIN;
step s1_slru_check_stats: 
	SELECT current.blks_zeroed > before.value
  FROM test_slru_stats before
  INNER JOIN pg_stat_slru current
  ON before.slru = current.name
  WHERE before.stat = 'blks_zeroed';

?column?
--------
f       
(1 row)

step s2_big_notify: SELECT pg_notify('stats_test_use',
                repeat(i::text, current_setting('block_size')::int / 2)) FROM generate_series(1, 3) g(i);

pg_notify
---------
         
         
         
(3 rows)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_slru_check_stats: 
	SELECT current.blks_zeroed > before.value
  FROM test_slru_stats before
  INNER JOIN pg_stat_slru current
  ON before.slru = current.name
  WHERE before.stat = 'blks_zeroed';

?column?
--------
f       
(1 row)

step s1_clear_snapshot: SELECT pg_stat_clear_snapshot();
pg_stat_clear_snapshot
----------------------
                      
(1 row)

step s1_slru_check_stats: 
	SELECT current.blks_zeroed > before.value
  FROM test_slru_stats before
  INNER JOIN pg_stat_slru current
  ON before.slru = current.name
  WHERE before.stat = 'blks_zeroed';

?column?
--------
t       
(1 row)

step s1_commit: COMMIT;

starting permutation: s1_fetch_consistency_snapshot s1_slru_save_stats s1_listen s1_begin s1_slru_check_stats s2_big_notify s2_ff s1_slru_check_stats s1_clear_snapshot s1_slru_check_stats s1_commit
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_fetch_consistency_snapshot: SET stats_fetch_consistency = 'snapshot';
step s1_slru_save_stats: 
	INSERT INTO test_slru_stats VALUES('notify', 'blks_zeroed',
    (SELECT blks_zeroed FROM pg_stat_slru WHERE name = 'notify'));

step s1_listen: LISTEN stats_test_nothing;
step s1_begin: BEGIN;
step s1_slru_check_stats: 
	SELECT current.blks_zeroed > before.value
  FROM test_slru_stats before
  INNER JOIN pg_stat_slru current
  ON before.slru = current.name
  WHERE before.stat = 'blks_zeroed';

?column?
--------
f       
(1 row)

step s2_big_notify: SELECT pg_notify('stats_test_use',
                repeat(i::text, current_setting('block_size')::int / 2)) FROM generate_series(1, 3) g(i);

pg_notify
---------
         
         
         
(3 rows)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_slru_check_stats: 
	SELECT current.blks_zeroed > before.value
  FROM test_slru_stats before
  INNER JOIN pg_stat_slru current
  ON before.slru = current.name
  WHERE before.stat = 'blks_zeroed';

?column?
--------
f       
(1 row)

step s1_clear_snapshot: SELECT pg_stat_clear_snapshot();
pg_stat_clear_snapshot
----------------------
                      
(1 row)

step s1_slru_check_stats: 
	SELECT current.blks_zeroed > before.value
  FROM test_slru_stats before
  INNER JOIN pg_stat_slru current
  ON before.slru = current.name
  WHERE before.stat = 'blks_zeroed';

?column?
--------
t       
(1 row)

step s1_commit: COMMIT;

starting permutation: s1_fetch_consistency_snapshot s1_slru_save_stats s1_listen s1_begin s1_func_stats s2_big_notify s2_ff s1_slru_check_stats s1_commit
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_fetch_consistency_snapshot: SET stats_fetch_consistency = 'snapshot';
step s1_slru_save_stats: 
	INSERT INTO test_slru_stats VALUES('notify', 'blks_zeroed',
    (SELECT blks_zeroed FROM pg_stat_slru WHERE name = 'notify'));

step s1_listen: LISTEN stats_test_nothing;
step s1_begin: BEGIN;
step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)

step s2_big_notify: SELECT pg_notify('stats_test_use',
                repeat(i::text, current_setting('block_size')::int / 2)) FROM generate_series(1, 3) g(i);

pg_notify
---------
         
         
         
(3 rows)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_slru_check_stats: 
	SELECT current.blks_zeroed > before.value
  FROM test_slru_stats before
  INNER JOIN pg_stat_slru current
  ON before.slru = current.name
  WHERE before.stat = 'blks_zeroed';

?column?
--------
f       
(1 row)

step s1_commit: COMMIT;

starting permutation: s1_fetch_consistency_snapshot s1_slru_save_stats s1_listen s1_begin s2_big_notify s2_ff s1_slru_check_stats s2_func_call s2_ff s1_func_stats s1_clear_snapshot s1_func_stats s1_commit
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_fetch_consistency_snapshot: SET stats_fetch_consistency = 'snapshot';
step s1_slru_save_stats: 
	INSERT INTO test_slru_stats VALUES('notify', 'blks_zeroed',
    (SELECT blks_zeroed FROM pg_stat_slru WHERE name = 'notify'));

step s1_listen: LISTEN stats_test_nothing;
step s1_begin: BEGIN;
step s2_big_notify: SELECT pg_notify('stats_test_use',
                repeat(i::text, current_setting('block_size')::int / 2)) FROM generate_series(1, 3) g(i);

pg_notify
---------
         
         
         
(3 rows)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_slru_check_stats: 
	SELECT current.blks_zeroed > before.value
  FROM test_slru_stats before
  INNER JOIN pg_stat_slru current
  ON before.slru = current.name
  WHERE before.stat = 'blks_zeroed';

?column?
--------
t       
(1 row)

step s2_func_call: SELECT test_stat_func()
test_stat_func
--------------
              
(1 row)

step s2_ff: SELECT pg_stat_force_next_flush();
pg_stat_force_next_flush
------------------------
                        
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                          |                |               
(1 row)

step s1_clear_snapshot: SELECT pg_stat_clear_snapshot();
pg_stat_clear_snapshot
----------------------
                      
(1 row)

step s1_func_stats: 
    SELECT
        tso.name,
        pg_stat_get_function_calls(tso.oid),
        pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero,
        pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero
    FROM test_stat_oid AS tso
    WHERE tso.name = 'test_stat_func'

name          |pg_stat_get_function_calls|total_above_zero|self_above_zero
--------------+--------------------------+----------------+---------------
test_stat_func|                         1|t               |t              
(1 row)

step s1_commit: COMMIT;