pg_stat_statements.c File Reference

#include "postgres.h"
#include <math.h>
#include <sys/stat.h>
#include <unistd.h>
#include "access/parallel.h"
#include "catalog/pg_authid.h"
#include "common/hashfn.h"
#include "executor/instrument.h"
#include "funcapi.h"
#include "mb/pg_wchar.h"
#include "miscadmin.h"
#include "optimizer/planner.h"
#include "parser/analyze.h"
#include "parser/parsetree.h"
#include "parser/scanner.h"
#include "parser/scansup.h"
#include "pgstat.h"
#include "storage/fd.h"
#include "storage/ipc.h"
#include "storage/lwlock.h"
#include "storage/shmem.h"
#include "storage/spin.h"
#include "tcop/utility.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/queryjumble.h"
#include "utils/memutils.h"
#include "utils/timestamp.h"

Include dependency graph for pg_stat_statements.c:

Go to the source code of this file.

Data Structures
struct	pgssHashKey
struct	Counters
struct	pgssGlobalStats
struct	pgssEntry
struct	pgssSharedState

Macros
#define	PGSS_DUMP_FILE   PGSTAT_STAT_PERMANENT_DIRECTORY "/pg_stat_statements.stat"
#define	PGSS_TEXT_FILE   PG_STAT_TMP_DIR "/pgss_query_texts.stat"
#define	USAGE_EXEC(duration)   (1.0)
#define	USAGE_INIT   (1.0) /* including initial planning */
#define	ASSUMED_MEDIAN_INIT   (10.0) /* initial assumed median usage */
#define	ASSUMED_LENGTH_INIT   1024 /* initial assumed mean query length */
#define	USAGE_DECREASE_FACTOR   (0.99) /* decreased every entry_dealloc */
#define	STICKY_DECREASE_FACTOR   (0.50) /* factor for sticky entries */
#define	USAGE_DEALLOC_PERCENT   5 /* free this % of entries at once */
#define	IS_STICKY(c)   ((c.calls[PGSS_PLAN] + c.calls[PGSS_EXEC]) == 0)
#define	PGSS_HANDLED_UTILITY(n)
#define	pgss_enabled(level)
#define	record_gc_qtexts()
#define	PG_STAT_STATEMENTS_COLS_V1_0   14
#define	PG_STAT_STATEMENTS_COLS_V1_1   18
#define	PG_STAT_STATEMENTS_COLS_V1_2   19
#define	PG_STAT_STATEMENTS_COLS_V1_3   23
#define	PG_STAT_STATEMENTS_COLS_V1_8   32
#define	PG_STAT_STATEMENTS_COLS_V1_9   33
#define	PG_STAT_STATEMENTS_COLS   33 /* maximum of above */
#define	PG_STAT_STATEMENTS_INFO_COLS   2

Typedefs
typedef enum pgssVersion	pgssVersion
typedef enum pgssStoreKind	pgssStoreKind
typedef struct pgssHashKey	pgssHashKey
typedef struct Counters	Counters
typedef struct pgssGlobalStats	pgssGlobalStats
typedef struct pgssEntry	pgssEntry
typedef struct pgssSharedState	pgssSharedState

Enumerations
enum	pgssVersion {   PGSS_V1_0 = 0, PGSS_V1_1, PGSS_V1_2, PGSS_V1_3,   PGSS_V1_8, PGSS_V1_9 }
enum	pgssStoreKind { PGSS_INVALID = -1, PGSS_PLAN = 0, PGSS_EXEC, PGSS_NUMKIND }
enum	PGSSTrackLevel { PGSS_TRACK_NONE, PGSS_TRACK_TOP, PGSS_TRACK_ALL }

Functions
void	_PG_init (void)
void	_PG_fini (void)
	PG_FUNCTION_INFO_V1 (pg_stat_statements_reset)
	PG_FUNCTION_INFO_V1 (pg_stat_statements_reset_1_7)
	PG_FUNCTION_INFO_V1 (pg_stat_statements_1_2)
	PG_FUNCTION_INFO_V1 (pg_stat_statements_1_3)
	PG_FUNCTION_INFO_V1 (pg_stat_statements_1_8)
	PG_FUNCTION_INFO_V1 (pg_stat_statements_1_9)
	PG_FUNCTION_INFO_V1 (pg_stat_statements)
	PG_FUNCTION_INFO_V1 (pg_stat_statements_info)
static void	pgss_shmem_startup (void)
static void	pgss_shmem_shutdown (int code, Datum arg)
static void	pgss_post_parse_analyze (ParseState *pstate, Query *query, JumbleState *jstate)
static PlannedStmt *	pgss_planner (Query *parse, const char *query_string, int cursorOptions, ParamListInfo boundParams)
static void	pgss_ExecutorStart (QueryDesc *queryDesc, int eflags)
static void	pgss_ExecutorRun (QueryDesc *queryDesc, ScanDirection direction, uint64 count, bool execute_once)
static void	pgss_ExecutorFinish (QueryDesc *queryDesc)
static void	pgss_ExecutorEnd (QueryDesc *queryDesc)
static void	pgss_ProcessUtility (PlannedStmt *pstmt, const char *queryString, ProcessUtilityContext context, ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest, QueryCompletion *qc)
static void	pgss_store (const char *query, uint64 queryId, int query_location, int query_len, pgssStoreKind kind, double total_time, uint64 rows, const BufferUsage *bufusage, const WalUsage *walusage, JumbleState *jstate)
static void	pg_stat_statements_internal (FunctionCallInfo fcinfo, pgssVersion api_version, bool showtext)
static Size	pgss_memsize (void)
static pgssEntry *	entry_alloc (pgssHashKey *key, Size query_offset, int query_len, int encoding, bool sticky)
static void	entry_dealloc (void)
static bool	qtext_store (const char *query, int query_len, Size *query_offset, int *gc_count)
static char *	qtext_load_file (Size *buffer_size)
static char *	qtext_fetch (Size query_offset, int query_len, char *buffer, Size buffer_size)
static bool	need_gc_qtexts (void)
static void	gc_qtexts (void)
static void	entry_reset (Oid userid, Oid dbid, uint64 queryid)
static char *	generate_normalized_query (JumbleState *jstate, const char *query, int query_loc, int *query_len_p)
static void	fill_in_constant_lengths (JumbleState *jstate, const char *query, int query_loc)
static int	comp_location (const void *a, const void *b)
Datum	pg_stat_statements_reset_1_7 (PG_FUNCTION_ARGS)
Datum	pg_stat_statements_reset (PG_FUNCTION_ARGS)
Datum	pg_stat_statements_1_9 (PG_FUNCTION_ARGS)
Datum	pg_stat_statements_1_8 (PG_FUNCTION_ARGS)
Datum	pg_stat_statements_1_3 (PG_FUNCTION_ARGS)
Datum	pg_stat_statements_1_2 (PG_FUNCTION_ARGS)
Datum	pg_stat_statements (PG_FUNCTION_ARGS)
Datum	pg_stat_statements_info (PG_FUNCTION_ARGS)
static int	entry_cmp (const void *lhs, const void *rhs)

Variables
	PG_MODULE_MAGIC
static const uint32	PGSS_FILE_HEADER = 0x20201227
static const uint32	PGSS_PG_MAJOR_VERSION = PG_VERSION_NUM / 100
static int	exec_nested_level = 0
static int	plan_nested_level = 0
static shmem_startup_hook_type	prev_shmem_startup_hook = NULL
static post_parse_analyze_hook_type	prev_post_parse_analyze_hook = NULL
static planner_hook_type	prev_planner_hook = NULL
static ExecutorStart_hook_type	prev_ExecutorStart = NULL
static ExecutorRun_hook_type	prev_ExecutorRun = NULL
static ExecutorFinish_hook_type	prev_ExecutorFinish = NULL
static ExecutorEnd_hook_type	prev_ExecutorEnd = NULL
static ProcessUtility_hook_type	prev_ProcessUtility = NULL
static pgssSharedState *	pgss = NULL
static HTAB *	pgss_hash = NULL
static const struct config_enum_entry	track_options []
static int	pgss_max
static int	pgss_track
static bool	pgss_track_utility
static bool	pgss_track_planning
static bool	pgss_save

Macro Definition Documentation

ASSUMED_LENGTH_INIT

#define ASSUMED_LENGTH_INIT   1024 /* initial assumed mean query length */

Definition at line 100 of file pg_stat_statements.c.

Referenced by entry_dealloc(), gc_qtexts(), and pgss_shmem_startup().

ASSUMED_MEDIAN_INIT

#define ASSUMED_MEDIAN_INIT   (10.0) /* initial assumed median usage */

Definition at line 99 of file pg_stat_statements.c.

Referenced by pgss_shmem_startup().

IS_STICKY

#define IS_STICKY

(

c

)

((c.calls[PGSS_PLAN] + c.calls[PGSS_EXEC]) == 0)

Definition at line 104 of file pg_stat_statements.c.

Referenced by entry_dealloc(), pg_stat_statements_internal(), pgss_shmem_startup(), and pgss_store().

PG_STAT_STATEMENTS_COLS

#define PG_STAT_STATEMENTS_COLS   33 /* maximum of above */

Definition at line 1427 of file pg_stat_statements.c.

Referenced by pg_stat_statements_internal().

PG_STAT_STATEMENTS_COLS_V1_0

#define PG_STAT_STATEMENTS_COLS_V1_0   14

Definition at line 1421 of file pg_stat_statements.c.

Referenced by pg_stat_statements_internal().

PG_STAT_STATEMENTS_COLS_V1_1

#define PG_STAT_STATEMENTS_COLS_V1_1   18

Definition at line 1422 of file pg_stat_statements.c.

Referenced by pg_stat_statements_internal().

PG_STAT_STATEMENTS_COLS_V1_2

#define PG_STAT_STATEMENTS_COLS_V1_2   19

Definition at line 1423 of file pg_stat_statements.c.

Referenced by pg_stat_statements_internal().

PG_STAT_STATEMENTS_COLS_V1_3

#define PG_STAT_STATEMENTS_COLS_V1_3   23

Definition at line 1424 of file pg_stat_statements.c.

Referenced by pg_stat_statements_internal().

PG_STAT_STATEMENTS_COLS_V1_8

#define PG_STAT_STATEMENTS_COLS_V1_8   32

Definition at line 1425 of file pg_stat_statements.c.

Referenced by pg_stat_statements_internal().

PG_STAT_STATEMENTS_COLS_V1_9

#define PG_STAT_STATEMENTS_COLS_V1_9   33

Definition at line 1426 of file pg_stat_statements.c.

Referenced by pg_stat_statements_internal().

PG_STAT_STATEMENTS_INFO_COLS

#define PG_STAT_STATEMENTS_INFO_COLS   2

Definition at line 1818 of file pg_stat_statements.c.

Referenced by pg_stat_statements_info().

PGSS_DUMP_FILE

#define PGSS_DUMP_FILE   PGSTAT_STAT_PERMANENT_DIRECTORY "/pg_stat_statements.stat"

Definition at line 78 of file pg_stat_statements.c.

Referenced by pgss_shmem_shutdown(), and pgss_shmem_startup().

pgss_enabled

#define pgss_enabled

(

level

)

Value:

(!IsParallelWorker() && \
    (pgss_track == PGSS_TRACK_ALL || \
    (pgss_track == PGSS_TRACK_TOP && (level) == 0)))

Definition at line 281 of file pg_stat_statements.c.

Referenced by pgss_ExecutorEnd(), pgss_ExecutorStart(), pgss_planner(), pgss_post_parse_analyze(), and pgss_ProcessUtility().

PGSS_HANDLED_UTILITY

#define PGSS_HANDLED_UTILITY

(

n

)

Value:

(!IsA(n, ExecuteStmt) && \
                                    !IsA(n, PrepareStmt) && \
                                    !IsA(n, DeallocateStmt))

Definition at line 110 of file pg_stat_statements.c.

Referenced by pgss_post_parse_analyze(), and pgss_ProcessUtility().

PGSS_TEXT_FILE

#define PGSS_TEXT_FILE   PG_STAT_TMP_DIR "/pgss_query_texts.stat"

Definition at line 88 of file pg_stat_statements.c.

Referenced by entry_reset(), gc_qtexts(), pgss_shmem_shutdown(), pgss_shmem_startup(), qtext_load_file(), and qtext_store().

record_gc_qtexts

#define record_gc_qtexts

(

)

Value:

do { \
        volatile pgssSharedState *s = (volatile pgssSharedState *) pgss; \
        SpinLockAcquire(&s->mutex); \
        s->gc_count++; \
        SpinLockRelease(&s->mutex); \
    } while(0)

Definition at line 286 of file pg_stat_statements.c.

Referenced by entry_reset(), and gc_qtexts().

STICKY_DECREASE_FACTOR

#define STICKY_DECREASE_FACTOR   (0.50) /* factor for sticky entries */

Definition at line 102 of file pg_stat_statements.c.

Referenced by entry_dealloc().

USAGE_DEALLOC_PERCENT

#define USAGE_DEALLOC_PERCENT   5 /* free this % of entries at once */

Definition at line 103 of file pg_stat_statements.c.

Referenced by entry_dealloc().

USAGE_DECREASE_FACTOR

#define USAGE_DECREASE_FACTOR   (0.99) /* decreased every entry_dealloc */

Definition at line 101 of file pg_stat_statements.c.

Referenced by entry_dealloc().

USAGE_EXEC

#define USAGE_EXEC

(

duration

)

(1.0)

Definition at line 97 of file pg_stat_statements.c.

Referenced by pgss_store().

USAGE_INIT

#define USAGE_INIT   (1.0) /* including initial planning */

Definition at line 98 of file pg_stat_statements.c.

Referenced by entry_alloc(), and pgss_store().

Typedef Documentation

Counters

typedef struct Counters Counters

pgssEntry

typedef struct pgssEntry pgssEntry

pgssGlobalStats

typedef struct pgssGlobalStats pgssGlobalStats

pgssHashKey

typedef struct pgssHashKey pgssHashKey

pgssSharedState

typedef struct pgssSharedState pgssSharedState

pgssStoreKind

typedef enum pgssStoreKind pgssStoreKind

pgssVersion

typedef enum pgssVersion pgssVersion

Enumeration Type Documentation

pgssStoreKind

enum pgssStoreKind

Enumerator
PGSS_INVALID
PGSS_PLAN
PGSS_EXEC
PGSS_NUMKIND

Definition at line 127 of file pg_stat_statements.c.

{
    PGSS_INVALID = -1,

    /*
     * PGSS_PLAN and PGSS_EXEC must be respectively 0 and 1 as they're used to
     * reference the underlying values in the arrays in the Counters struct,
     * and this order is required in pg_stat_statements_internal().
     */
    PGSS_PLAN = 0,
    PGSS_EXEC,

    PGSS_NUMKIND                /* Must be last value of this enum */
} pgssStoreKind;

PGSSTrackLevel

enum PGSSTrackLevel

Enumerator
PGSS_TRACK_NONE
PGSS_TRACK_TOP
PGSS_TRACK_ALL

Definition at line 259 of file pg_stat_statements.c.

{
    PGSS_TRACK_NONE,            /* track no statements */
    PGSS_TRACK_TOP,             /* only top level statements */
    PGSS_TRACK_ALL              /* all statements, including nested ones */
}           PGSSTrackLevel;

pgssVersion

enum pgssVersion

Enumerator
PGSS_V1_0
PGSS_V1_1
PGSS_V1_2
PGSS_V1_3
PGSS_V1_8
PGSS_V1_9

Definition at line 117 of file pg_stat_statements.c.

{
    PGSS_V1_0 = 0,
    PGSS_V1_1,
    PGSS_V1_2,
    PGSS_V1_3,
    PGSS_V1_8,
    PGSS_V1_9
} pgssVersion;

Function Documentation

_PG_fini()

void _PG_fini

(

void

)

Definition at line 474 of file pg_stat_statements.c.

References ExecutorEnd_hook, ExecutorFinish_hook, ExecutorRun_hook, ExecutorStart_hook, planner_hook, post_parse_analyze_hook, prev_ExecutorEnd, prev_ExecutorFinish, prev_ExecutorRun, prev_ExecutorStart, prev_planner_hook, prev_post_parse_analyze_hook, prev_ProcessUtility, prev_shmem_startup_hook, ProcessUtility_hook, and shmem_startup_hook.

{
    /* Uninstall hooks. */
    shmem_startup_hook = prev_shmem_startup_hook;
    post_parse_analyze_hook = prev_post_parse_analyze_hook;
    planner_hook = prev_planner_hook;
    ExecutorStart_hook = prev_ExecutorStart;
    ExecutorRun_hook = prev_ExecutorRun;
    ExecutorFinish_hook = prev_ExecutorFinish;
    ExecutorEnd_hook = prev_ExecutorEnd;
    ProcessUtility_hook = prev_ProcessUtility;
}

_PG_init()

void _PG_init

(

void

)

Definition at line 359 of file pg_stat_statements.c.

References DefineCustomBoolVariable(), DefineCustomEnumVariable(), DefineCustomIntVariable(), EmitWarningsOnPlaceholders(), EnableQueryId(), ExecutorEnd_hook, ExecutorFinish_hook, ExecutorRun_hook, ExecutorStart_hook, PGC_POSTMASTER, PGC_SIGHUP, PGC_SUSET, pgss_ExecutorEnd(), pgss_ExecutorFinish(), pgss_ExecutorRun(), pgss_ExecutorStart(), pgss_max, pgss_memsize(), pgss_planner(), pgss_post_parse_analyze(), pgss_ProcessUtility(), pgss_save, pgss_shmem_startup(), pgss_track, pgss_track_planning, PGSS_TRACK_TOP, pgss_track_utility, planner_hook, post_parse_analyze_hook, prev_ExecutorEnd, prev_ExecutorFinish, prev_ExecutorRun, prev_ExecutorStart, prev_planner_hook, prev_post_parse_analyze_hook, prev_ProcessUtility, prev_shmem_startup_hook, process_shared_preload_libraries_in_progress, ProcessUtility_hook, RequestAddinShmemSpace(), RequestNamedLWLockTranche(), and shmem_startup_hook.

{
    /*
     * In order to create our shared memory area, we have to be loaded via
     * shared_preload_libraries.  If not, fall out without hooking into any of
     * the main system.  (We don't throw error here because it seems useful to
     * allow the pg_stat_statements functions to be created even when the
     * module isn't active.  The functions must protect themselves against
     * being called then, however.)
     */
    if (!process_shared_preload_libraries_in_progress)
        return;

    /*
     * Inform the postmaster that we want to enable query_id calculation if
     * compute_query_id is set to auto.
     */
    EnableQueryId();

    /*
     * Define (or redefine) custom GUC variables.
     */
    DefineCustomIntVariable("pg_stat_statements.max",
                            "Sets the maximum number of statements tracked by pg_stat_statements.",
                            NULL,
                            &pgss_max,
                            5000,
                            100,
                            INT_MAX,
                            PGC_POSTMASTER,
                            0,
                            NULL,
                            NULL,
                            NULL);

    DefineCustomEnumVariable("pg_stat_statements.track",
                             "Selects which statements are tracked by pg_stat_statements.",
                             NULL,
                             &pgss_track,
                             PGSS_TRACK_TOP,
                             track_options,
                             PGC_SUSET,
                             0,
                             NULL,
                             NULL,
                             NULL);

    DefineCustomBoolVariable("pg_stat_statements.track_utility",
                             "Selects whether utility commands are tracked by pg_stat_statements.",
                             NULL,
                             &pgss_track_utility,
                             true,
                             PGC_SUSET,
                             0,
                             NULL,
                             NULL,
                             NULL);

    DefineCustomBoolVariable("pg_stat_statements.track_planning",
                             "Selects whether planning duration is tracked by pg_stat_statements.",
                             NULL,
                             &pgss_track_planning,
                             false,
                             PGC_SUSET,
                             0,
                             NULL,
                             NULL,
                             NULL);

    DefineCustomBoolVariable("pg_stat_statements.save",
                             "Save pg_stat_statements statistics across server shutdowns.",
                             NULL,
                             &pgss_save,
                             true,
                             PGC_SIGHUP,
                             0,
                             NULL,
                             NULL,
                             NULL);

    EmitWarningsOnPlaceholders("pg_stat_statements");

    /*
     * Request additional shared resources.  (These are no-ops if we're not in
     * the postmaster process.)  We'll allocate or attach to the shared
     * resources in pgss_shmem_startup().
     */
    RequestAddinShmemSpace(pgss_memsize());
    RequestNamedLWLockTranche("pg_stat_statements", 1);

    /*
     * Install hooks.
     */
    prev_shmem_startup_hook = shmem_startup_hook;
    shmem_startup_hook = pgss_shmem_startup;
    prev_post_parse_analyze_hook = post_parse_analyze_hook;
    post_parse_analyze_hook = pgss_post_parse_analyze;
    prev_planner_hook = planner_hook;
    planner_hook = pgss_planner;
    prev_ExecutorStart = ExecutorStart_hook;
    ExecutorStart_hook = pgss_ExecutorStart;
    prev_ExecutorRun = ExecutorRun_hook;
    ExecutorRun_hook = pgss_ExecutorRun;
    prev_ExecutorFinish = ExecutorFinish_hook;
    ExecutorFinish_hook = pgss_ExecutorFinish;
    prev_ExecutorEnd = ExecutorEnd_hook;
    ExecutorEnd_hook = pgss_ExecutorEnd;
    prev_ProcessUtility = ProcessUtility_hook;
    ProcessUtility_hook = pgss_ProcessUtility;
}

comp_location()

static int comp_location ( const void *  a, const void *  b  )

static

Definition at line 2797 of file pg_stat_statements.c.

Referenced by fill_in_constant_lengths().

{
    int         l = ((const LocationLen *) a)->location;
    int         r = ((const LocationLen *) b)->location;

    if (l < r)
        return -1;
    else if (l > r)
        return +1;
    else
        return 0;
}

entry_alloc()

static pgssEntry * entry_alloc ( pgssHashKey *  key, Size  query_offset, int  query_len, int  encoding, bool  sticky  )

static

Definition at line 1890 of file pg_stat_statements.c.

References Assert, pgssEntry::counters, pgssSharedState::cur_median_usage, encoding, pgssEntry::encoding, entry_dealloc(), HASH_ENTER, hash_get_num_entries(), hash_search(), pgssEntry::mutex, pgss_max, pgssEntry::query_len, pgssEntry::query_offset, SpinLockInit, Counters::usage, and USAGE_INIT.

Referenced by pgss_shmem_startup(), and pgss_store().

{
    pgssEntry  *entry;
    bool        found;

    /* Make space if needed */
    while (hash_get_num_entries(pgss_hash) >= pgss_max)
        entry_dealloc();

    /* Find or create an entry with desired hash code */
    entry = (pgssEntry *) hash_search(pgss_hash, key, HASH_ENTER, &found);

    if (!found)
    {
        /* New entry, initialize it */

        /* reset the statistics */
        memset(&entry->counters, 0, sizeof(Counters));
        /* set the appropriate initial usage count */
        entry->counters.usage = sticky ? pgss->cur_median_usage : USAGE_INIT;
        /* re-initialize the mutex each time ... we assume no one using it */
        SpinLockInit(&entry->mutex);
        /* ... and don't forget the query text metadata */
        Assert(query_len >= 0);
        entry->query_offset = query_offset;
        entry->query_len = query_len;
        entry->encoding = encoding;
    }

    return entry;
}

entry_cmp()

static int entry_cmp ( const void *  lhs, const void *  rhs  )

static

Definition at line 1927 of file pg_stat_statements.c.

Referenced by entry_dealloc().

{
    double      l_usage = (*(pgssEntry *const *) lhs)->counters.usage;
    double      r_usage = (*(pgssEntry *const *) rhs)->counters.usage;

    if (l_usage < r_usage)
        return -1;
    else if (l_usage > r_usage)
        return +1;
    else
        return 0;
}

entry_dealloc()

static void entry_dealloc ( void  )

static

Definition at line 1946 of file pg_stat_statements.c.

References ASSUMED_LENGTH_INIT, pgssEntry::counters, pgssSharedState::cur_median_usage, pgssGlobalStats::dealloc, entry_cmp(), hash_get_num_entries(), HASH_REMOVE, hash_search(), hash_seq_init(), hash_seq_search(), i, IS_STICKY, sort-test::key, Max, pgssSharedState::mean_query_len, Min, pgssSharedState::mutex, palloc(), pfree(), qsort, pgssEntry::query_len, SpinLockAcquire, SpinLockRelease, pgssSharedState::stats, STICKY_DECREASE_FACTOR, Counters::usage, USAGE_DEALLOC_PERCENT, and USAGE_DECREASE_FACTOR.

Referenced by entry_alloc().

{
    HASH_SEQ_STATUS hash_seq;
    pgssEntry **entries;
    pgssEntry  *entry;
    int         nvictims;
    int         i;
    Size        tottextlen;
    int         nvalidtexts;

    /*
     * Sort entries by usage and deallocate USAGE_DEALLOC_PERCENT of them.
     * While we're scanning the table, apply the decay factor to the usage
     * values, and update the mean query length.
     *
     * Note that the mean query length is almost immediately obsolete, since
     * we compute it before not after discarding the least-used entries.
     * Hopefully, that doesn't affect the mean too much; it doesn't seem worth
     * making two passes to get a more current result.  Likewise, the new
     * cur_median_usage includes the entries we're about to zap.
     */

    entries = palloc(hash_get_num_entries(pgss_hash) * sizeof(pgssEntry *));

    i = 0;
    tottextlen = 0;
    nvalidtexts = 0;

    hash_seq_init(&hash_seq, pgss_hash);
    while ((entry = hash_seq_search(&hash_seq)) != NULL)
    {
        entries[i++] = entry;
        /* "Sticky" entries get a different usage decay rate. */
        if (IS_STICKY(entry->counters))
            entry->counters.usage *= STICKY_DECREASE_FACTOR;
        else
            entry->counters.usage *= USAGE_DECREASE_FACTOR;
        /* In the mean length computation, ignore dropped texts. */
        if (entry->query_len >= 0)
        {
            tottextlen += entry->query_len + 1;
            nvalidtexts++;
        }
    }

    /* Sort into increasing order by usage */
    qsort(entries, i, sizeof(pgssEntry *), entry_cmp);

    /* Record the (approximate) median usage */
    if (i > 0)
        pgss->cur_median_usage = entries[i / 2]->counters.usage;
    /* Record the mean query length */
    if (nvalidtexts > 0)
        pgss->mean_query_len = tottextlen / nvalidtexts;
    else
        pgss->mean_query_len = ASSUMED_LENGTH_INIT;

    /* Now zap an appropriate fraction of lowest-usage entries */
    nvictims = Max(10, i * USAGE_DEALLOC_PERCENT / 100);
    nvictims = Min(nvictims, i);

    for (i = 0; i < nvictims; i++)
    {
        hash_search(pgss_hash, &entries[i]->key, HASH_REMOVE, NULL);
    }

    pfree(entries);

    /* Increment the number of times entries are deallocated */
    {
        volatile pgssSharedState *s = (volatile pgssSharedState *) pgss;

        SpinLockAcquire(&s->mutex);
        s->stats.dealloc += 1;
        SpinLockRelease(&s->mutex);
    }
}

entry_reset()

static void entry_reset ( Oid  userid, Oid  dbid, uint64  queryid  )

static

Definition at line 2455 of file pg_stat_statements.c.

References AllocateFile(), pgssHashKey::dbid, pgssGlobalStats::dealloc, ereport, errcode(), errcode_for_file_access(), errmsg(), ERROR, pgssSharedState::extent, FreeFile(), ftruncate, GetCurrentTimestamp(), hash_get_num_entries(), HASH_REMOVE, hash_search(), hash_seq_init(), hash_seq_search(), sort-test::key, pgssEntry::key, pgssSharedState::lock, LOG, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), pgssSharedState::mutex, PG_BINARY_W, PGSS_TEXT_FILE, pgssHashKey::queryid, record_gc_qtexts, SpinLockAcquire, SpinLockRelease, pgssSharedState::stats, pgssGlobalStats::stats_reset, pgssHashKey::toplevel, and pgssHashKey::userid.

Referenced by pg_stat_statements_reset(), and pg_stat_statements_reset_1_7().

{
    HASH_SEQ_STATUS hash_seq;
    pgssEntry  *entry;
    FILE       *qfile;
    long        num_entries;
    long        num_remove = 0;
    pgssHashKey key;

    if (!pgss || !pgss_hash)
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("pg_stat_statements must be loaded via shared_preload_libraries")));

    LWLockAcquire(pgss->lock, LW_EXCLUSIVE);
    num_entries = hash_get_num_entries(pgss_hash);

    if (userid != 0 && dbid != 0 && queryid != UINT64CONST(0))
    {
        /* If all the parameters are available, use the fast path. */
        memset(&key, 0, sizeof(pgssHashKey));
        key.userid = userid;
        key.dbid = dbid;
        key.queryid = queryid;

        /* Remove the key if it exists, starting with the top-level entry  */
        key.toplevel = false;
        entry = (pgssEntry *) hash_search(pgss_hash, &key, HASH_REMOVE, NULL);
        if (entry)              /* found */
            num_remove++;

        /* Also remove entries for top level statements */
        key.toplevel = true;

        /* Remove the key if exists */
        entry = (pgssEntry *) hash_search(pgss_hash, &key, HASH_REMOVE, NULL);
        if (entry)              /* found */
            num_remove++;
    }
    else if (userid != 0 || dbid != 0 || queryid != UINT64CONST(0))
    {
        /* Remove entries corresponding to valid parameters. */
        hash_seq_init(&hash_seq, pgss_hash);
        while ((entry = hash_seq_search(&hash_seq)) != NULL)
        {
            if ((!userid || entry->key.userid == userid) &&
                (!dbid || entry->key.dbid == dbid) &&
                (!queryid || entry->key.queryid == queryid))
            {
                hash_search(pgss_hash, &entry->key, HASH_REMOVE, NULL);
                num_remove++;
            }
        }
    }
    else
    {
        /* Remove all entries. */
        hash_seq_init(&hash_seq, pgss_hash);
        while ((entry = hash_seq_search(&hash_seq)) != NULL)
        {
            hash_search(pgss_hash, &entry->key, HASH_REMOVE, NULL);
            num_remove++;
        }
    }

    /* All entries are removed? */
    if (num_entries != num_remove)
        goto release_lock;

    /*
     * Reset global statistics for pg_stat_statements since all entries are
     * removed.
     */
    {
        volatile pgssSharedState *s = (volatile pgssSharedState *) pgss;
        TimestampTz stats_reset = GetCurrentTimestamp();

        SpinLockAcquire(&s->mutex);
        s->stats.dealloc = 0;
        s->stats.stats_reset = stats_reset;
        SpinLockRelease(&s->mutex);
    }

    /*
     * Write new empty query file, perhaps even creating a new one to recover
     * if the file was missing.
     */
    qfile = AllocateFile(PGSS_TEXT_FILE, PG_BINARY_W);
    if (qfile == NULL)
    {
        ereport(LOG,
                (errcode_for_file_access(),
                 errmsg("could not create file \"%s\": %m",
                        PGSS_TEXT_FILE)));
        goto done;
    }

    /* If ftruncate fails, log it, but it's not a fatal problem */
    if (ftruncate(fileno(qfile), 0) != 0)
        ereport(LOG,
                (errcode_for_file_access(),
                 errmsg("could not truncate file \"%s\": %m",
                        PGSS_TEXT_FILE)));

    FreeFile(qfile);

done:
    pgss->extent = 0;
    /* This counts as a query text garbage collection for our purposes */
    record_gc_qtexts();

release_lock:
    LWLockRelease(pgss->lock);
}

fill_in_constant_lengths()

static void fill_in_constant_lengths ( JumbleState *  jstate, const char *  query, int  query_loc  )

static

Definition at line 2697 of file pg_stat_statements.c.

References Assert, JumbleState::clocations, JumbleState::clocations_count, comp_location(), core_yylex(), core_yy_extra_type::escape_string_warning, i, LocationLen::length, LocationLen::location, qsort, core_yy_extra_type::scanbuf, ScanKeywords, ScanKeywordTokens, scanner_finish(), scanner_init(), YYLTYPE, and yyscanner.

Referenced by generate_normalized_query().

{
    LocationLen *locs;
    core_yyscan_t yyscanner;
    core_yy_extra_type yyextra;
    core_YYSTYPE yylval;
    YYLTYPE     yylloc;
    int         last_loc = -1;
    int         i;

    /*
     * Sort the records by location so that we can process them in order while
     * scanning the query text.
     */
    if (jstate->clocations_count > 1)
        qsort(jstate->clocations, jstate->clocations_count,
              sizeof(LocationLen), comp_location);
    locs = jstate->clocations;

    /* initialize the flex scanner --- should match raw_parser() */
    yyscanner = scanner_init(query,
                             &yyextra,
                             &ScanKeywords,
                             ScanKeywordTokens);

    /* we don't want to re-emit any escape string warnings */
    yyextra.escape_string_warning = false;

    /* Search for each constant, in sequence */
    for (i = 0; i < jstate->clocations_count; i++)
    {
        int         loc = locs[i].location;
        int         tok;

        /* Adjust recorded location if we're dealing with partial string */
        loc -= query_loc;

        Assert(loc >= 0);

        if (loc <= last_loc)
            continue;           /* Duplicate constant, ignore */

        /* Lex tokens until we find the desired constant */
        for (;;)
        {
            tok = core_yylex(&yylval, &yylloc, yyscanner);

            /* We should not hit end-of-string, but if we do, behave sanely */
            if (tok == 0)
                break;          /* out of inner for-loop */

            /*
             * We should find the token position exactly, but if we somehow
             * run past it, work with that.
             */
            if (yylloc >= loc)
            {
                if (query[loc] == '-')
                {
                    /*
                     * It's a negative value - this is the one and only case
                     * where we replace more than a single token.
                     *
                     * Do not compensate for the core system's special-case
                     * adjustment of location to that of the leading '-'
                     * operator in the event of a negative constant.  It is
                     * also useful for our purposes to start from the minus
                     * symbol.  In this way, queries like "select * from foo
                     * where bar = 1" and "select * from foo where bar = -2"
                     * will have identical normalized query strings.
                     */
                    tok = core_yylex(&yylval, &yylloc, yyscanner);
                    if (tok == 0)
                        break;  /* out of inner for-loop */
                }

                /*
                 * We now rely on the assumption that flex has placed a zero
                 * byte after the text of the current token in scanbuf.
                 */
                locs[i].length = strlen(yyextra.scanbuf + loc);
                break;          /* out of inner for-loop */
            }
        }

        /* If we hit end-of-string, give up, leaving remaining lengths -1 */
        if (tok == 0)
            break;

        last_loc = loc;
    }

    scanner_finish(yyscanner);
}

gc_qtexts()

static void gc_qtexts ( void  )

static

Definition at line 2271 of file pg_stat_statements.c.

References AllocateFile(), ASSUMED_LENGTH_INIT, DEBUG1, elog, ereport, errcode_for_file_access(), errmsg(), pgssSharedState::extent, free, FreeFile(), ftruncate, hash_seq_init(), hash_seq_search(), hash_seq_term(), LOG, pgssSharedState::mean_query_len, need_gc_qtexts(), PG_BINARY_W, PGSS_TEXT_FILE, qtext_fetch(), qtext_load_file(), pgssEntry::query_len, pgssEntry::query_offset, and record_gc_qtexts.

Referenced by pgss_store().

{
    char       *qbuffer;
    Size        qbuffer_size;
    FILE       *qfile = NULL;
    HASH_SEQ_STATUS hash_seq;
    pgssEntry  *entry;
    Size        extent;
    int         nentries;

    /*
     * When called from pgss_store, some other session might have proceeded
     * with garbage collection in the no-lock-held interim of lock strength
     * escalation.  Check once more that this is actually necessary.
     */
    if (!need_gc_qtexts())
        return;

    /*
     * Load the old texts file.  If we fail (out of memory, for instance),
     * invalidate query texts.  Hopefully this is rare.  It might seem better
     * to leave things alone on an OOM failure, but the problem is that the
     * file is only going to get bigger; hoping for a future non-OOM result is
     * risky and can easily lead to complete denial of service.
     */
    qbuffer = qtext_load_file(&qbuffer_size);
    if (qbuffer == NULL)
        goto gc_fail;

    /*
     * We overwrite the query texts file in place, so as to reduce the risk of
     * an out-of-disk-space failure.  Since the file is guaranteed not to get
     * larger, this should always work on traditional filesystems; though we
     * could still lose on copy-on-write filesystems.
     */
    qfile = AllocateFile(PGSS_TEXT_FILE, PG_BINARY_W);
    if (qfile == NULL)
    {
        ereport(LOG,
                (errcode_for_file_access(),
                 errmsg("could not write file \"%s\": %m",
                        PGSS_TEXT_FILE)));
        goto gc_fail;
    }

    extent = 0;
    nentries = 0;

    hash_seq_init(&hash_seq, pgss_hash);
    while ((entry = hash_seq_search(&hash_seq)) != NULL)
    {
        int         query_len = entry->query_len;
        char       *qry = qtext_fetch(entry->query_offset,
                                      query_len,
                                      qbuffer,
                                      qbuffer_size);

        if (qry == NULL)
        {
            /* Trouble ... drop the text */
            entry->query_offset = 0;
            entry->query_len = -1;
            /* entry will not be counted in mean query length computation */
            continue;
        }

        if (fwrite(qry, 1, query_len + 1, qfile) != query_len + 1)
        {
            ereport(LOG,
                    (errcode_for_file_access(),
                     errmsg("could not write file \"%s\": %m",
                            PGSS_TEXT_FILE)));
            hash_seq_term(&hash_seq);
            goto gc_fail;
        }

        entry->query_offset = extent;
        extent += query_len + 1;
        nentries++;
    }

    /*
     * Truncate away any now-unused space.  If this fails for some odd reason,
     * we log it, but there's no need to fail.
     */
    if (ftruncate(fileno(qfile), extent) != 0)
        ereport(LOG,
                (errcode_for_file_access(),
                 errmsg("could not truncate file \"%s\": %m",
                        PGSS_TEXT_FILE)));

    if (FreeFile(qfile))
    {
        ereport(LOG,
                (errcode_for_file_access(),
                 errmsg("could not write file \"%s\": %m",
                        PGSS_TEXT_FILE)));
        qfile = NULL;
        goto gc_fail;
    }

    elog(DEBUG1, "pgss gc of queries file shrunk size from %zu to %zu",
         pgss->extent, extent);

    /* Reset the shared extent pointer */
    pgss->extent = extent;

    /*
     * Also update the mean query length, to be sure that need_gc_qtexts()
     * won't still think we have a problem.
     */
    if (nentries > 0)
        pgss->mean_query_len = extent / nentries;
    else
        pgss->mean_query_len = ASSUMED_LENGTH_INIT;

    free(qbuffer);

    /*
     * OK, count a garbage collection cycle.  (Note: even though we have
     * exclusive lock on pgss->lock, we must take pgss->mutex for this, since
     * other processes may examine gc_count while holding only the mutex.
     * Also, we have to advance the count *after* we've rewritten the file,
     * else other processes might not realize they read a stale file.)
     */
    record_gc_qtexts();

    return;

gc_fail:
    /* clean up resources */
    if (qfile)
        FreeFile(qfile);
    if (qbuffer)
        free(qbuffer);

    /*
     * Since the contents of the external file are now uncertain, mark all
     * hashtable entries as having invalid texts.
     */
    hash_seq_init(&hash_seq, pgss_hash);
    while ((entry = hash_seq_search(&hash_seq)) != NULL)
    {
        entry->query_offset = 0;
        entry->query_len = -1;
    }

    /*
     * Destroy the query text file and create a new, empty one
     */
    (void) unlink(PGSS_TEXT_FILE);
    qfile = AllocateFile(PGSS_TEXT_FILE, PG_BINARY_W);
    if (qfile == NULL)
        ereport(LOG,
                (errcode_for_file_access(),
                 errmsg("could not recreate file \"%s\": %m",
                        PGSS_TEXT_FILE)));
    else
        FreeFile(qfile);

    /* Reset the shared extent pointer */
    pgss->extent = 0;

    /* Reset mean_query_len to match the new state */
    pgss->mean_query_len = ASSUMED_LENGTH_INIT;

    /*
     * Bump the GC count even though we failed.
     *
     * This is needed to make concurrent readers of file without any lock on
     * pgss->lock notice existence of new version of file.  Once readers
     * subsequently observe a change in GC count with pgss->lock held, that
     * forces a safe reopen of file.  Writers also require that we bump here,
     * of course.  (As required by locking protocol, readers and writers don't
     * trust earlier file contents until gc_count is found unchanged after
     * pgss->lock acquired in shared or exclusive mode respectively.)
     */
    record_gc_qtexts();
}

generate_normalized_query()

static char * generate_normalized_query ( JumbleState *  jstate, const char *  query, int  query_loc, int *  query_len_p  )

static

Definition at line 2590 of file pg_stat_statements.c.

References Assert, JumbleState::clocations, JumbleState::clocations_count, fill_in_constant_lengths(), JumbleState::highest_extern_param_id, i, LocationLen::length, LocationLen::location, palloc(), and sprintf.

Referenced by pgss_store().

{
    char       *norm_query;
    int         query_len = *query_len_p;
    int         i,
                norm_query_buflen,  /* Space allowed for norm_query */
                len_to_wrt,     /* Length (in bytes) to write */
                quer_loc = 0,   /* Source query byte location */
                n_quer_loc = 0, /* Normalized query byte location */
                last_off = 0,   /* Offset from start for previous tok */
                last_tok_len = 0;   /* Length (in bytes) of that tok */

    /*
     * Get constants' lengths (core system only gives us locations).  Note
     * this also ensures the items are sorted by location.
     */
    fill_in_constant_lengths(jstate, query, query_loc);

    /*
     * Allow for $n symbols to be longer than the constants they replace.
     * Constants must take at least one byte in text form, while a $n symbol
     * certainly isn't more than 11 bytes, even if n reaches INT_MAX.  We
     * could refine that limit based on the max value of n for the current
     * query, but it hardly seems worth any extra effort to do so.
     */
    norm_query_buflen = query_len + jstate->clocations_count * 10;

    /* Allocate result buffer */
    norm_query = palloc(norm_query_buflen + 1);

    for (i = 0; i < jstate->clocations_count; i++)
    {
        int         off,        /* Offset from start for cur tok */
                    tok_len;    /* Length (in bytes) of that tok */

        off = jstate->clocations[i].location;
        /* Adjust recorded location if we're dealing with partial string */
        off -= query_loc;

        tok_len = jstate->clocations[i].length;

        if (tok_len < 0)
            continue;           /* ignore any duplicates */

        /* Copy next chunk (what precedes the next constant) */
        len_to_wrt = off - last_off;
        len_to_wrt -= last_tok_len;

        Assert(len_to_wrt >= 0);
        memcpy(norm_query + n_quer_loc, query + quer_loc, len_to_wrt);
        n_quer_loc += len_to_wrt;

        /* And insert a param symbol in place of the constant token */
        n_quer_loc += sprintf(norm_query + n_quer_loc, "$%d",
                              i + 1 + jstate->highest_extern_param_id);

        quer_loc = off + tok_len;
        last_off = off;
        last_tok_len = tok_len;
    }

    /*
     * We've copied up until the last ignorable constant.  Copy over the
     * remaining bytes of the original query string.
     */
    len_to_wrt = query_len - quer_loc;

    Assert(len_to_wrt >= 0);
    memcpy(norm_query + n_quer_loc, query + quer_loc, len_to_wrt);
    n_quer_loc += len_to_wrt;

    Assert(n_quer_loc <= norm_query_buflen);
    norm_query[n_quer_loc] = '\0';

    *query_len_p = n_quer_loc;
    return norm_query;
}

need_gc_qtexts()

static bool need_gc_qtexts ( void  )

static

Definition at line 2224 of file pg_stat_statements.c.

References pgssSharedState::extent, pgssSharedState::mutex, pgss_max, SpinLockAcquire, and SpinLockRelease.

Referenced by gc_qtexts(), and pgss_store().

{
    Size        extent;

    /* Read shared extent pointer */
    {
        volatile pgssSharedState *s = (volatile pgssSharedState *) pgss;

        SpinLockAcquire(&s->mutex);
        extent = s->extent;
        SpinLockRelease(&s->mutex);
    }

    /* Don't proceed if file does not exceed 512 bytes per possible entry */
    if (extent < 512 * pgss_max)
        return false;

    /*
     * Don't proceed if file is less than about 50% bloat.  Nothing can or
     * should be done in the event of unusually large query texts accounting
     * for file's large size.  We go to the trouble of maintaining the mean
     * query length in order to prevent garbage collection from thrashing
     * uselessly.
     */
    if (extent < pgss->mean_query_len * pgss_max * 2)
        return false;

    return true;
}

PG_FUNCTION_INFO_V1() [1/8]

PG_FUNCTION_INFO_V1

(

pg_stat_statements_reset

)

PG_FUNCTION_INFO_V1() [2/8]

PG_FUNCTION_INFO_V1

(

pg_stat_statements_reset_1_7

)

PG_FUNCTION_INFO_V1() [3/8]

PG_FUNCTION_INFO_V1

(

pg_stat_statements_1_2

)

PG_FUNCTION_INFO_V1() [4/8]

PG_FUNCTION_INFO_V1

(

pg_stat_statements_1_3

)

PG_FUNCTION_INFO_V1() [5/8]

PG_FUNCTION_INFO_V1

(

pg_stat_statements_1_8

)

PG_FUNCTION_INFO_V1() [6/8]

PG_FUNCTION_INFO_V1

(

pg_stat_statements_1_9

)

PG_FUNCTION_INFO_V1() [7/8]

PG_FUNCTION_INFO_V1

(

pg_stat_statements

)

PG_FUNCTION_INFO_V1() [8/8]

PG_FUNCTION_INFO_V1

(

pg_stat_statements_info

)

pg_stat_statements()

Datum pg_stat_statements

(

PG_FUNCTION_ARGS

)

Definition at line 1484 of file pg_stat_statements.c.

References pg_stat_statements_internal(), and PGSS_V1_0.

{
    /* If it's really API 1.1, we'll figure that out below */
    pg_stat_statements_internal(fcinfo, PGSS_V1_0, true);

    return (Datum) 0;
}

pg_stat_statements_1_2()

Datum pg_stat_statements_1_2

(

PG_FUNCTION_ARGS

)

Definition at line 1470 of file pg_stat_statements.c.

References PG_GETARG_BOOL, pg_stat_statements_internal(), and PGSS_V1_2.

{
    bool        showtext = PG_GETARG_BOOL(0);

    pg_stat_statements_internal(fcinfo, PGSS_V1_2, showtext);

    return (Datum) 0;
}

pg_stat_statements_1_3()

Datum pg_stat_statements_1_3

(

PG_FUNCTION_ARGS

)

Definition at line 1460 of file pg_stat_statements.c.

References PG_GETARG_BOOL, pg_stat_statements_internal(), and PGSS_V1_3.

{
    bool        showtext = PG_GETARG_BOOL(0);

    pg_stat_statements_internal(fcinfo, PGSS_V1_3, showtext);

    return (Datum) 0;
}

pg_stat_statements_1_8()

Datum pg_stat_statements_1_8

(

PG_FUNCTION_ARGS

)

Definition at line 1450 of file pg_stat_statements.c.

References PG_GETARG_BOOL, pg_stat_statements_internal(), and PGSS_V1_8.

{
    bool        showtext = PG_GETARG_BOOL(0);

    pg_stat_statements_internal(fcinfo, PGSS_V1_8, showtext);

    return (Datum) 0;
}

pg_stat_statements_1_9()

Datum pg_stat_statements_1_9

(

PG_FUNCTION_ARGS

)

Definition at line 1440 of file pg_stat_statements.c.

References PG_GETARG_BOOL, pg_stat_statements_internal(), and PGSS_V1_9.

{
    bool        showtext = PG_GETARG_BOOL(0);

    pg_stat_statements_internal(fcinfo, PGSS_V1_9, showtext);

    return (Datum) 0;
}

pg_stat_statements_info()

Datum pg_stat_statements_info

(

PG_FUNCTION_ARGS

)

Definition at line 1824 of file pg_stat_statements.c.

References pgssGlobalStats::dealloc, elog, ereport, errcode(), errmsg(), ERROR, get_call_result_type(), heap_form_tuple(), HeapTupleGetDatum, Int64GetDatum(), MemSet, pgssSharedState::mutex, PG_RETURN_DATUM, PG_STAT_STATEMENTS_INFO_COLS, SpinLockAcquire, SpinLockRelease, pgssSharedState::stats, pgssGlobalStats::stats_reset, TimestampTzGetDatum, TYPEFUNC_COMPOSITE, and values.

{
    pgssGlobalStats stats;
    TupleDesc   tupdesc;
    Datum       values[PG_STAT_STATEMENTS_INFO_COLS];
    bool        nulls[PG_STAT_STATEMENTS_INFO_COLS];

    if (!pgss || !pgss_hash)
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("pg_stat_statements must be loaded via shared_preload_libraries")));

    /* Build a tuple descriptor for our result type */
    if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
        elog(ERROR, "return type must be a row type");

    MemSet(values, 0, sizeof(values));
    MemSet(nulls, 0, sizeof(nulls));

    /* Read global statistics for pg_stat_statements */
    {
        volatile pgssSharedState *s = (volatile pgssSharedState *) pgss;

        SpinLockAcquire(&s->mutex);
        stats = s->stats;
        SpinLockRelease(&s->mutex);
    }

    values[0] = Int64GetDatum(stats.dealloc);
    values[1] = TimestampTzGetDatum(stats.stats_reset);

    PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)));
}

pg_stat_statements_internal()

static void pg_stat_statements_internal ( FunctionCallInfo  fcinfo, pgssVersion  api_version, bool  showtext  )

static

Definition at line 1494 of file pg_stat_statements.c.

References ReturnSetInfo::allowedModes, Assert, Counters::blk_read_time, Counters::blk_write_time, BoolGetDatum, buf, Counters::calls, pgssEntry::counters, CStringGetDatum, CStringGetTextDatum, pgssHashKey::dbid, DirectFunctionCall3, ReturnSetInfo::econtext, ExprContext::ecxt_per_query_memory, elog, enc, pgssEntry::encoding, ereport, errcode(), errmsg(), ERROR, pgssSharedState::extent, Float8GetDatumFast, free, pgssSharedState::gc_count, get_call_result_type(), GetUserId(), hash_seq_init(), hash_seq_search(), i, Int32GetDatum, Int64GetDatumFast, is_member_of_role(), IS_STICKY, IsA, pgssEntry::key, Counters::local_blks_dirtied, Counters::local_blks_hit, Counters::local_blks_read, Counters::local_blks_written, pgssSharedState::lock, LW_SHARED, LWLockAcquire(), LWLockRelease(), Counters::max_time, Counters::mean_time, MemoryContextSwitchTo(), Counters::min_time, pgssEntry::mutex, pgssSharedState::mutex, pgssSharedState::n_writers, numeric_in(), ObjectIdGetDatum, pfree(), pg_any_to_server(), PG_STAT_STATEMENTS_COLS, PG_STAT_STATEMENTS_COLS_V1_0, PG_STAT_STATEMENTS_COLS_V1_1, PG_STAT_STATEMENTS_COLS_V1_2, PG_STAT_STATEMENTS_COLS_V1_3, PG_STAT_STATEMENTS_COLS_V1_8, PG_STAT_STATEMENTS_COLS_V1_9, PGSS_EXEC, PGSS_NUMKIND, PGSS_V1_0, PGSS_V1_1, PGSS_V1_2, PGSS_V1_3, PGSS_V1_8, PGSS_V1_9, qtext_fetch(), qtext_load_file(), pgssEntry::query_len, pgssEntry::query_offset, pgssHashKey::queryid, FunctionCallInfoBaseData::resultinfo, ReturnSetInfo::returnMode, Counters::rows, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, SFRM_Materialize, Counters::shared_blks_dirtied, Counters::shared_blks_hit, Counters::shared_blks_read, Counters::shared_blks_written, snprintf, SpinLockAcquire, SpinLockRelease, Counters::sum_var_time, Counters::temp_blks_read, Counters::temp_blks_written, pgssHashKey::toplevel, Counters::total_time, tuplestore_begin_heap(), tuplestore_donestoring, tuplestore_putvalues(), TYPEFUNC_COMPOSITE, UINT64_FORMAT, pgssHashKey::userid, values, Counters::wal_bytes, Counters::wal_fpi, Counters::wal_records, and work_mem.

Referenced by pg_stat_statements(), pg_stat_statements_1_2(), pg_stat_statements_1_3(), pg_stat_statements_1_8(), and pg_stat_statements_1_9().

{
    ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
    TupleDesc   tupdesc;
    Tuplestorestate *tupstore;
    MemoryContext per_query_ctx;
    MemoryContext oldcontext;
    Oid         userid = GetUserId();
    bool        is_allowed_role = false;
    char       *qbuffer = NULL;
    Size        qbuffer_size = 0;
    Size        extent = 0;
    int         gc_count = 0;
    HASH_SEQ_STATUS hash_seq;
    pgssEntry  *entry;

    /* Superusers or members of pg_read_all_stats members are allowed */
    is_allowed_role = is_member_of_role(GetUserId(), ROLE_PG_READ_ALL_STATS);

    /* hash table must exist already */
    if (!pgss || !pgss_hash)
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("pg_stat_statements must be loaded via shared_preload_libraries")));

    /* check to see if caller supports us returning a tuplestore */
    if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("set-valued function called in context that cannot accept a set")));
    if (!(rsinfo->allowedModes & SFRM_Materialize))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("materialize mode required, but it is not allowed in this context")));

    /* Switch into long-lived context to construct returned data structures */
    per_query_ctx = rsinfo->econtext->ecxt_per_query_memory;
    oldcontext = MemoryContextSwitchTo(per_query_ctx);

    /* Build a tuple descriptor for our result type */
    if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
        elog(ERROR, "return type must be a row type");

    /*
     * Check we have the expected number of output arguments.  Aside from
     * being a good safety check, we need a kluge here to detect API version
     * 1.1, which was wedged into the code in an ill-considered way.
     */
    switch (tupdesc->natts)
    {
        case PG_STAT_STATEMENTS_COLS_V1_0:
            if (api_version != PGSS_V1_0)
                elog(ERROR, "incorrect number of output arguments");
            break;
        case PG_STAT_STATEMENTS_COLS_V1_1:
            /* pg_stat_statements() should have told us 1.0 */
            if (api_version != PGSS_V1_0)
                elog(ERROR, "incorrect number of output arguments");
            api_version = PGSS_V1_1;
            break;
        case PG_STAT_STATEMENTS_COLS_V1_2:
            if (api_version != PGSS_V1_2)
                elog(ERROR, "incorrect number of output arguments");
            break;
        case PG_STAT_STATEMENTS_COLS_V1_3:
            if (api_version != PGSS_V1_3)
                elog(ERROR, "incorrect number of output arguments");
            break;
        case PG_STAT_STATEMENTS_COLS_V1_8:
            if (api_version != PGSS_V1_8)
                elog(ERROR, "incorrect number of output arguments");
            break;
        case PG_STAT_STATEMENTS_COLS_V1_9:
            if (api_version != PGSS_V1_9)
                elog(ERROR, "incorrect number of output arguments");
            break;
        default:
            elog(ERROR, "incorrect number of output arguments");
    }

    tupstore = tuplestore_begin_heap(true, false, work_mem);
    rsinfo->returnMode = SFRM_Materialize;
    rsinfo->setResult = tupstore;
    rsinfo->setDesc = tupdesc;

    MemoryContextSwitchTo(oldcontext);

    /*
     * We'd like to load the query text file (if needed) while not holding any
     * lock on pgss->lock.  In the worst case we'll have to do this again
     * after we have the lock, but it's unlikely enough to make this a win
     * despite occasional duplicated work.  We need to reload if anybody
     * writes to the file (either a retail qtext_store(), or a garbage
     * collection) between this point and where we've gotten shared lock.  If
     * a qtext_store is actually in progress when we look, we might as well
     * skip the speculative load entirely.
     */
    if (showtext)
    {
        int         n_writers;

        /* Take the mutex so we can examine variables */
        {
            volatile pgssSharedState *s = (volatile pgssSharedState *) pgss;

            SpinLockAcquire(&s->mutex);
            extent = s->extent;
            n_writers = s->n_writers;
            gc_count = s->gc_count;
            SpinLockRelease(&s->mutex);
        }

        /* No point in loading file now if there are active writers */
        if (n_writers == 0)
            qbuffer = qtext_load_file(&qbuffer_size);
    }

    /*
     * Get shared lock, load or reload the query text file if we must, and
     * iterate over the hashtable entries.
     *
     * With a large hash table, we might be holding the lock rather longer
     * than one could wish.  However, this only blocks creation of new hash
     * table entries, and the larger the hash table the less likely that is to
     * be needed.  So we can hope this is okay.  Perhaps someday we'll decide
     * we need to partition the hash table to limit the time spent holding any
     * one lock.
     */
    LWLockAcquire(pgss->lock, LW_SHARED);

    if (showtext)
    {
        /*
         * Here it is safe to examine extent and gc_count without taking the
         * mutex.  Note that although other processes might change
         * pgss->extent just after we look at it, the strings they then write
         * into the file cannot yet be referenced in the hashtable, so we
         * don't care whether we see them or not.
         *
         * If qtext_load_file fails, we just press on; we'll return NULL for
         * every query text.
         */
        if (qbuffer == NULL ||
            pgss->extent != extent ||
            pgss->gc_count != gc_count)
        {
            if (qbuffer)
                free(qbuffer);
            qbuffer = qtext_load_file(&qbuffer_size);
        }
    }

    hash_seq_init(&hash_seq, pgss_hash);
    while ((entry = hash_seq_search(&hash_seq)) != NULL)
    {
        Datum       values[PG_STAT_STATEMENTS_COLS];
        bool        nulls[PG_STAT_STATEMENTS_COLS];
        int         i = 0;
        Counters    tmp;
        double      stddev;
        int64       queryid = entry->key.queryid;

        memset(values, 0, sizeof(values));
        memset(nulls, 0, sizeof(nulls));

        values[i++] = ObjectIdGetDatum(entry->key.userid);
        values[i++] = ObjectIdGetDatum(entry->key.dbid);
        if (api_version >= PGSS_V1_9)
            values[i++] = BoolGetDatum(entry->key.toplevel);

        if (is_allowed_role || entry->key.userid == userid)
        {
            if (api_version >= PGSS_V1_2)
                values[i++] = Int64GetDatumFast(queryid);

            if (showtext)
            {
                char       *qstr = qtext_fetch(entry->query_offset,
                                               entry->query_len,
                                               qbuffer,
                                               qbuffer_size);

                if (qstr)
                {
                    char       *enc;

                    enc = pg_any_to_server(qstr,
                                           entry->query_len,
                                           entry->encoding);

                    values[i++] = CStringGetTextDatum(enc);

                    if (enc != qstr)
                        pfree(enc);
                }
                else
                {
                    /* Just return a null if we fail to find the text */
                    nulls[i++] = true;
                }
            }
            else
            {
                /* Query text not requested */
                nulls[i++] = true;
            }
        }
        else
        {
            /* Don't show queryid */
            if (api_version >= PGSS_V1_2)
                nulls[i++] = true;

            /*
             * Don't show query text, but hint as to the reason for not doing
             * so if it was requested
             */
            if (showtext)
                values[i++] = CStringGetTextDatum("<insufficient privilege>");
            else
                nulls[i++] = true;
        }

        /* copy counters to a local variable to keep locking time short */
        {
            volatile pgssEntry *e = (volatile pgssEntry *) entry;

            SpinLockAcquire(&e->mutex);
            tmp = e->counters;
            SpinLockRelease(&e->mutex);
        }

        /* Skip entry if unexecuted (ie, it's a pending "sticky" entry) */
        if (IS_STICKY(tmp))
            continue;

        /* Note that we rely on PGSS_PLAN being 0 and PGSS_EXEC being 1. */
        for (int kind = 0; kind < PGSS_NUMKIND; kind++)
        {
            if (kind == PGSS_EXEC || api_version >= PGSS_V1_8)
            {
                values[i++] = Int64GetDatumFast(tmp.calls[kind]);
                values[i++] = Float8GetDatumFast(tmp.total_time[kind]);
            }

            if ((kind == PGSS_EXEC && api_version >= PGSS_V1_3) ||
                api_version >= PGSS_V1_8)
            {
                values[i++] = Float8GetDatumFast(tmp.min_time[kind]);
                values[i++] = Float8GetDatumFast(tmp.max_time[kind]);
                values[i++] = Float8GetDatumFast(tmp.mean_time[kind]);

                /*
                 * Note we are calculating the population variance here, not
                 * the sample variance, as we have data for the whole
                 * population, so Bessel's correction is not used, and we
                 * don't divide by tmp.calls - 1.
                 */
                if (tmp.calls[kind] > 1)
                    stddev = sqrt(tmp.sum_var_time[kind] / tmp.calls[kind]);
                else
                    stddev = 0.0;
                values[i++] = Float8GetDatumFast(stddev);
            }
        }
        values[i++] = Int64GetDatumFast(tmp.rows);
        values[i++] = Int64GetDatumFast(tmp.shared_blks_hit);
        values[i++] = Int64GetDatumFast(tmp.shared_blks_read);
        if (api_version >= PGSS_V1_1)
            values[i++] = Int64GetDatumFast(tmp.shared_blks_dirtied);
        values[i++] = Int64GetDatumFast(tmp.shared_blks_written);
        values[i++] = Int64GetDatumFast(tmp.local_blks_hit);
        values[i++] = Int64GetDatumFast(tmp.local_blks_read);
        if (api_version >= PGSS_V1_1)
            values[i++] = Int64GetDatumFast(tmp.local_blks_dirtied);
        values[i++] = Int64GetDatumFast(tmp.local_blks_written);
        values[i++] = Int64GetDatumFast(tmp.temp_blks_read);
        values[i++] = Int64GetDatumFast(tmp.temp_blks_written);
        if (api_version >= PGSS_V1_1)
        {
            values[i++] = Float8GetDatumFast(tmp.blk_read_time);
            values[i++] = Float8GetDatumFast(tmp.blk_write_time);
        }
        if (api_version >= PGSS_V1_8)
        {
            char        buf[256];
            Datum       wal_bytes;

            values[i++] = Int64GetDatumFast(tmp.wal_records);
            values[i++] = Int64GetDatumFast(tmp.wal_fpi);

            snprintf(buf, sizeof buf, UINT64_FORMAT, tmp.wal_bytes);

            /* Convert to numeric. */
            wal_bytes = DirectFunctionCall3(numeric_in,
                                            CStringGetDatum(buf),
                                            ObjectIdGetDatum(0),
                                            Int32GetDatum(-1));
            values[i++] = wal_bytes;
        }

        Assert(i == (api_version == PGSS_V1_0 ? PG_STAT_STATEMENTS_COLS_V1_0 :
                     api_version == PGSS_V1_1 ? PG_STAT_STATEMENTS_COLS_V1_1 :
                     api_version == PGSS_V1_2 ? PG_STAT_STATEMENTS_COLS_V1_2 :
                     api_version == PGSS_V1_3 ? PG_STAT_STATEMENTS_COLS_V1_3 :
                     api_version == PGSS_V1_8 ? PG_STAT_STATEMENTS_COLS_V1_8 :
                     api_version == PGSS_V1_9 ? PG_STAT_STATEMENTS_COLS_V1_9 :
                     -1 /* fail if you forget to update this assert */ ));

        tuplestore_putvalues(tupstore, tupdesc, values, nulls);
    }

    /* clean up and return the tuplestore */
    LWLockRelease(pgss->lock);

    if (qbuffer)
        free(qbuffer);

    tuplestore_donestoring(tupstore);
}

pg_stat_statements_reset()

Datum pg_stat_statements_reset

(

PG_FUNCTION_ARGS

)

Definition at line 1413 of file pg_stat_statements.c.

References entry_reset(), and PG_RETURN_VOID.

{
    entry_reset(0, 0, 0);

    PG_RETURN_VOID();
}

pg_stat_statements_reset_1_7()

Datum pg_stat_statements_reset_1_7

(

PG_FUNCTION_ARGS

)

Definition at line 1394 of file pg_stat_statements.c.

References pgssHashKey::dbid, entry_reset(), PG_GETARG_INT64, PG_GETARG_OID, PG_RETURN_VOID, pgssHashKey::queryid, and pgssHashKey::userid.

{
    Oid         userid;
    Oid         dbid;
    uint64      queryid;

    userid = PG_GETARG_OID(0);
    dbid = PG_GETARG_OID(1);
    queryid = (uint64) PG_GETARG_INT64(2);

    entry_reset(userid, dbid, queryid);

    PG_RETURN_VOID();
}

pgss_ExecutorEnd()

static void pgss_ExecutorEnd ( QueryDesc *  queryDesc )

static

Definition at line 1036 of file pg_stat_statements.c.

References Instrumentation::bufusage, EState::es_processed, QueryDesc::estate, exec_nested_level, InstrEndLoop(), pgss_enabled, PGSS_EXEC, pgss_store(), QueryDesc::plannedstmt, prev_ExecutorEnd, PlannedStmt::queryId, QueryDesc::sourceText, standard_ExecutorEnd(), PlannedStmt::stmt_len, PlannedStmt::stmt_location, Instrumentation::total, QueryDesc::totaltime, and Instrumentation::walusage.

Referenced by _PG_init().

{
    uint64      queryId = queryDesc->plannedstmt->queryId;

    if (queryId != UINT64CONST(0) && queryDesc->totaltime &&
        pgss_enabled(exec_nested_level))
    {
        /*
         * Make sure stats accumulation is done.  (Note: it's okay if several
         * levels of hook all do this.)
         */
        InstrEndLoop(queryDesc->totaltime);

        pgss_store(queryDesc->sourceText,
                   queryId,
                   queryDesc->plannedstmt->stmt_location,
                   queryDesc->plannedstmt->stmt_len,
                   PGSS_EXEC,
                   queryDesc->totaltime->total * 1000.0,    /* convert to msec */
                   queryDesc->estate->es_processed,
                   &queryDesc->totaltime->bufusage,
                   &queryDesc->totaltime->walusage,
                   NULL);
    }

    if (prev_ExecutorEnd)
        prev_ExecutorEnd(queryDesc);
    else
        standard_ExecutorEnd(queryDesc);
}

pgss_ExecutorFinish()

static void pgss_ExecutorFinish ( QueryDesc *  queryDesc )

static

Definition at line 1015 of file pg_stat_statements.c.

References exec_nested_level, PG_END_TRY, PG_FINALLY, PG_TRY, prev_ExecutorFinish, and standard_ExecutorFinish().

Referenced by _PG_init().

{
    exec_nested_level++;
    PG_TRY();
    {
        if (prev_ExecutorFinish)
            prev_ExecutorFinish(queryDesc);
        else
            standard_ExecutorFinish(queryDesc);
    }
    PG_FINALLY();
    {
        exec_nested_level--;
    }
    PG_END_TRY();
}

pgss_ExecutorRun()

static void pgss_ExecutorRun ( QueryDesc *  queryDesc, ScanDirection  direction, uint64  count, bool  execute_once  )

static

Definition at line 993 of file pg_stat_statements.c.

References exec_nested_level, PG_END_TRY, PG_FINALLY, PG_TRY, prev_ExecutorRun, and standard_ExecutorRun().

Referenced by _PG_init().

{
    exec_nested_level++;
    PG_TRY();
    {
        if (prev_ExecutorRun)
            prev_ExecutorRun(queryDesc, direction, count, execute_once);
        else
            standard_ExecutorRun(queryDesc, direction, count, execute_once);
    }
    PG_FINALLY();
    {
        exec_nested_level--;
    }
    PG_END_TRY();
}

pgss_ExecutorStart()

static void pgss_ExecutorStart ( QueryDesc *  queryDesc, int  eflags  )

static

Definition at line 959 of file pg_stat_statements.c.

References EState::es_query_cxt, QueryDesc::estate, exec_nested_level, InstrAlloc(), INSTRUMENT_ALL, MemoryContextSwitchTo(), pgss_enabled, QueryDesc::plannedstmt, prev_ExecutorStart, PlannedStmt::queryId, standard_ExecutorStart(), and QueryDesc::totaltime.

Referenced by _PG_init().

{
    if (prev_ExecutorStart)
        prev_ExecutorStart(queryDesc, eflags);
    else
        standard_ExecutorStart(queryDesc, eflags);

    /*
     * If query has queryId zero, don't track it.  This prevents double
     * counting of optimizable statements that are directly contained in
     * utility statements.
     */
    if (pgss_enabled(exec_nested_level) && queryDesc->plannedstmt->queryId != UINT64CONST(0))
    {
        /*
         * Set up to track total elapsed time in ExecutorRun.  Make sure the
         * space is allocated in the per-query context so it will go away at
         * ExecutorEnd.
         */
        if (queryDesc->totaltime == NULL)
        {
            MemoryContext oldcxt;

            oldcxt = MemoryContextSwitchTo(queryDesc->estate->es_query_cxt);
            queryDesc->totaltime = InstrAlloc(1, INSTRUMENT_ALL, false);
            MemoryContextSwitchTo(oldcxt);
        }
    }
}

pgss_memsize()

static Size pgss_memsize ( void  )

static

Definition at line 1862 of file pg_stat_statements.c.

References add_size(), hash_estimate_size(), MAXALIGN, and pgss_max.

Referenced by _PG_init().

{
    Size        size;

    size = MAXALIGN(sizeof(pgssSharedState));
    size = add_size(size, hash_estimate_size(pgss_max, sizeof(pgssEntry)));

    return size;
}

pgss_planner()

static PlannedStmt * pgss_planner ( Query *  parse, const char *  query_string, int  cursorOptions, ParamListInfo  boundParams  )

static

Definition at line 864 of file pg_stat_statements.c.

References BufferUsageAccumDiff(), duration, exec_nested_level, INSTR_TIME_GET_MILLISEC, INSTR_TIME_SET_CURRENT, INSTR_TIME_SUBTRACT, PG_END_TRY, PG_FINALLY, PG_TRY, pgBufferUsage, pgss_enabled, PGSS_PLAN, pgss_store(), pgss_track_planning, pgWalUsage, plan_nested_level, prev_planner_hook, Query::queryId, standard_planner(), Query::stmt_len, Query::stmt_location, and WalUsageAccumDiff().

Referenced by _PG_init().

{
    PlannedStmt *result;

    /*
     * We can't process the query if no query_string is provided, as
     * pgss_store needs it.  We also ignore query without queryid, as it would
     * be treated as a utility statement, which may not be the case.
     *
     * Note that planner_hook can be called from the planner itself, so we
     * have a specific nesting level for the planner.  However, utility
     * commands containing optimizable statements can also call the planner,
     * same for regular DML (for instance for underlying foreign key queries).
     * So testing the planner nesting level only is not enough to detect real
     * top level planner call.
     */
    if (pgss_enabled(plan_nested_level + exec_nested_level)
        && pgss_track_planning && query_string
        && parse->queryId != UINT64CONST(0))
    {
        instr_time  start;
        instr_time  duration;
        BufferUsage bufusage_start,
                    bufusage;
        WalUsage    walusage_start,
                    walusage;

        /* We need to track buffer usage as the planner can access them. */
        bufusage_start = pgBufferUsage;

        /*
         * Similarly the planner could write some WAL records in some cases
         * (e.g. setting a hint bit with those being WAL-logged)
         */
        walusage_start = pgWalUsage;
        INSTR_TIME_SET_CURRENT(start);

        plan_nested_level++;
        PG_TRY();
        {
            if (prev_planner_hook)
                result = prev_planner_hook(parse, query_string, cursorOptions,
                                           boundParams);
            else
                result = standard_planner(parse, query_string, cursorOptions,
                                          boundParams);
        }
        PG_FINALLY();
        {
            plan_nested_level--;
        }
        PG_END_TRY();

        INSTR_TIME_SET_CURRENT(duration);
        INSTR_TIME_SUBTRACT(duration, start);

        /* calc differences of buffer counters. */
        memset(&bufusage, 0, sizeof(BufferUsage));
        BufferUsageAccumDiff(&bufusage, &pgBufferUsage, &bufusage_start);

        /* calc differences of WAL counters. */
        memset(&walusage, 0, sizeof(WalUsage));
        WalUsageAccumDiff(&walusage, &pgWalUsage, &walusage_start);

        pgss_store(query_string,
                   parse->queryId,
                   parse->stmt_location,
                   parse->stmt_len,
                   PGSS_PLAN,
                   INSTR_TIME_GET_MILLISEC(duration),
                   0,
                   &bufusage,
                   &walusage,
                   NULL);
    }
    else
    {
        if (prev_planner_hook)
            result = prev_planner_hook(parse, query_string, cursorOptions,
                                       boundParams);
        else
            result = standard_planner(parse, query_string, cursorOptions,
                                      boundParams);
    }

    return result;
}

pgss_post_parse_analyze()

static void pgss_post_parse_analyze ( ParseState *  pstate, Query *  query, JumbleState *  jstate  )

static

Definition at line 818 of file pg_stat_statements.c.

References JumbleState::clocations_count, exec_nested_level, ParseState::p_sourcetext, pgss_enabled, PGSS_HANDLED_UTILITY, PGSS_INVALID, pgss_store(), pgss_track_utility, prev_post_parse_analyze_hook, Query::queryId, Query::stmt_len, Query::stmt_location, and Query::utilityStmt.

Referenced by _PG_init().

{
    if (prev_post_parse_analyze_hook)
        prev_post_parse_analyze_hook(pstate, query, jstate);

    /* Safety check... */
    if (!pgss || !pgss_hash || !pgss_enabled(exec_nested_level))
        return;

    /*
     * Clear queryId for prepared statements related utility, as those will
     * inherit from the underlying statement's one (except DEALLOCATE which is
     * entirely untracked).
     */
    if (query->utilityStmt)
    {
        if (pgss_track_utility && !PGSS_HANDLED_UTILITY(query->utilityStmt))
            query->queryId = UINT64CONST(0);
        return;
    }

    /*
     * If query jumbling were able to identify any ignorable constants, we
     * immediately create a hash table entry for the query, so that we can
     * record the normalized form of the query string.  If there were no such
     * constants, the normalized string would be the same as the query text
     * anyway, so there's no need for an early entry.
     */
    if (jstate && jstate->clocations_count > 0)
        pgss_store(pstate->p_sourcetext,
                   query->queryId,
                   query->stmt_location,
                   query->stmt_len,
                   PGSS_INVALID,
                   0,
                   0,
                   NULL,
                   NULL,
                   jstate);
}

pgss_ProcessUtility()

static void pgss_ProcessUtility ( PlannedStmt *  pstmt, const char *  queryString, ProcessUtilityContext  context, ParamListInfo  params, QueryEnvironment *  queryEnv, DestReceiver *  dest, QueryCompletion *  qc  )

static

Definition at line 1071 of file pg_stat_statements.c.

References BufferUsageAccumDiff(), QueryCompletion::commandTag, duration, exec_nested_level, INSTR_TIME_GET_MILLISEC, INSTR_TIME_SET_CURRENT, INSTR_TIME_SUBTRACT, QueryCompletion::nprocessed, PG_END_TRY, PG_FINALLY, PG_TRY, pgBufferUsage, pgss_enabled, PGSS_EXEC, PGSS_HANDLED_UTILITY, pgss_store(), pgss_track_utility, pgWalUsage, prev_ProcessUtility, PlannedStmt::queryId, standard_ProcessUtility(), PlannedStmt::stmt_len, PlannedStmt::stmt_location, PlannedStmt::utilityStmt, and WalUsageAccumDiff().

Referenced by _PG_init().

{
    Node       *parsetree = pstmt->utilityStmt;
    uint64      saved_queryId = pstmt->queryId;

    /*
     * Force utility statements to get queryId zero.  We do this even in cases
     * where the statement contains an optimizable statement for which a
     * queryId could be derived (such as EXPLAIN or DECLARE CURSOR).  For such
     * cases, runtime control will first go through ProcessUtility and then
     * the executor, and we don't want the executor hooks to do anything,
     * since we are already measuring the statement's costs at the utility
     * level.
     *
     * Note that this is only done if pg_stat_statements is enabled and
     * configured to track utility statements, in the unlikely possibility
     * that user configured another extension to handle utility statements
     * only.
     */
    if (pgss_enabled(exec_nested_level) && pgss_track_utility)
        pstmt->queryId = UINT64CONST(0);

    /*
     * If it's an EXECUTE statement, we don't track it and don't increment the
     * nesting level.  This allows the cycles to be charged to the underlying
     * PREPARE instead (by the Executor hooks), which is much more useful.
     *
     * We also don't track execution of PREPARE.  If we did, we would get one
     * hash table entry for the PREPARE (with hash calculated from the query
     * string), and then a different one with the same query string (but hash
     * calculated from the query tree) would be used to accumulate costs of
     * ensuing EXECUTEs.  This would be confusing, and inconsistent with other
     * cases where planning time is not included at all.
     *
     * Likewise, we don't track execution of DEALLOCATE.
     */
    if (pgss_track_utility && pgss_enabled(exec_nested_level) &&
        PGSS_HANDLED_UTILITY(parsetree))
    {
        instr_time  start;
        instr_time  duration;
        uint64      rows;
        BufferUsage bufusage_start,
                    bufusage;
        WalUsage    walusage_start,
                    walusage;

        bufusage_start = pgBufferUsage;
        walusage_start = pgWalUsage;
        INSTR_TIME_SET_CURRENT(start);

        exec_nested_level++;
        PG_TRY();
        {
            if (prev_ProcessUtility)
                prev_ProcessUtility(pstmt, queryString,
                                    context, params, queryEnv,
                                    dest, qc);
            else
                standard_ProcessUtility(pstmt, queryString,
                                        context, params, queryEnv,
                                        dest, qc);
        }
        PG_FINALLY();
        {
            exec_nested_level--;
        }
        PG_END_TRY();

        INSTR_TIME_SET_CURRENT(duration);
        INSTR_TIME_SUBTRACT(duration, start);

        /*
         * Track the total number of rows retrieved or affected by the utility
         * statements of COPY, FETCH, CREATE TABLE AS, CREATE MATERIALIZED
         * VIEW, REFRESH MATERIALIZED VIEW and SELECT INTO.
         */
        rows = (qc && (qc->commandTag == CMDTAG_COPY ||
                       qc->commandTag == CMDTAG_FETCH ||
                       qc->commandTag == CMDTAG_SELECT ||
                       qc->commandTag == CMDTAG_REFRESH_MATERIALIZED_VIEW)) ?
            qc->nprocessed : 0;

        /* calc differences of buffer counters. */
        memset(&bufusage, 0, sizeof(BufferUsage));
        BufferUsageAccumDiff(&bufusage, &pgBufferUsage, &bufusage_start);

        /* calc differences of WAL counters. */
        memset(&walusage, 0, sizeof(WalUsage));
        WalUsageAccumDiff(&walusage, &pgWalUsage, &walusage_start);

        pgss_store(queryString,
                   saved_queryId,
                   pstmt->stmt_location,
                   pstmt->stmt_len,
                   PGSS_EXEC,
                   INSTR_TIME_GET_MILLISEC(duration),
                   rows,
                   &bufusage,
                   &walusage,
                   NULL);
    }
    else
    {
        if (prev_ProcessUtility)
            prev_ProcessUtility(pstmt, queryString,
                                context, params, queryEnv,
                                dest, qc);
        else
            standard_ProcessUtility(pstmt, queryString,
                                    context, params, queryEnv,
                                    dest, qc);
    }
}

pgss_shmem_shutdown()

static void pgss_shmem_shutdown ( int  code, Datum  arg  )

static

Definition at line 718 of file pg_stat_statements.c.

References AllocateFile(), durable_rename(), ereport, errcode_for_file_access(), errmsg(), error(), free, FreeFile(), hash_get_num_entries(), hash_seq_init(), hash_seq_search(), hash_seq_term(), LOG, PG_BINARY_W, PGSS_DUMP_FILE, PGSS_FILE_HEADER, PGSS_PG_MAJOR_VERSION, pgss_save, PGSS_TEXT_FILE, qtext_fetch(), qtext_load_file(), pgssEntry::query_len, pgssEntry::query_offset, and pgssSharedState::stats.

Referenced by pgss_shmem_startup().

{
    FILE       *file;
    char       *qbuffer = NULL;
    Size        qbuffer_size = 0;
    HASH_SEQ_STATUS hash_seq;
    int32       num_entries;
    pgssEntry  *entry;

    /* Don't try to dump during a crash. */
    if (code)
        return;

    /* Safety check ... shouldn't get here unless shmem is set up. */
    if (!pgss || !pgss_hash)
        return;

    /* Don't dump if told not to. */
    if (!pgss_save)
        return;

    file = AllocateFile(PGSS_DUMP_FILE ".tmp", PG_BINARY_W);
    if (file == NULL)
        goto error;

    if (fwrite(&PGSS_FILE_HEADER, sizeof(uint32), 1, file) != 1)
        goto error;
    if (fwrite(&PGSS_PG_MAJOR_VERSION, sizeof(uint32), 1, file) != 1)
        goto error;
    num_entries = hash_get_num_entries(pgss_hash);
    if (fwrite(&num_entries, sizeof(int32), 1, file) != 1)
        goto error;

    qbuffer = qtext_load_file(&qbuffer_size);
    if (qbuffer == NULL)
        goto error;

    /*
     * When serializing to disk, we store query texts immediately after their
     * entry data.  Any orphaned query texts are thereby excluded.
     */
    hash_seq_init(&hash_seq, pgss_hash);
    while ((entry = hash_seq_search(&hash_seq)) != NULL)
    {
        int         len = entry->query_len;
        char       *qstr = qtext_fetch(entry->query_offset, len,
                                       qbuffer, qbuffer_size);

        if (qstr == NULL)
            continue;           /* Ignore any entries with bogus texts */

        if (fwrite(entry, sizeof(pgssEntry), 1, file) != 1 ||
            fwrite(qstr, 1, len + 1, file) != len + 1)
        {
            /* note: we assume hash_seq_term won't change errno */
            hash_seq_term(&hash_seq);
            goto error;
        }
    }

    /* Dump global statistics for pg_stat_statements */
    if (fwrite(&pgss->stats, sizeof(pgssGlobalStats), 1, file) != 1)
        goto error;

    free(qbuffer);
    qbuffer = NULL;

    if (FreeFile(file))
    {
        file = NULL;
        goto error;
    }

    /*
     * Rename file into place, so we atomically replace any old one.
     */
    (void) durable_rename(PGSS_DUMP_FILE ".tmp", PGSS_DUMP_FILE, LOG);

    /* Unlink query-texts file; it's not needed while shutdown */
    unlink(PGSS_TEXT_FILE);

    return;

error:
    ereport(LOG,
            (errcode_for_file_access(),
             errmsg("could not write file \"%s\": %m",
                    PGSS_DUMP_FILE ".tmp")));
    if (qbuffer)
        free(qbuffer);
    if (file)
        FreeFile(file);
    unlink(PGSS_DUMP_FILE ".tmp");
    unlink(PGSS_TEXT_FILE);
}

pgss_shmem_startup()

static void pgss_shmem_startup ( void  )

static

Definition at line 494 of file pg_stat_statements.c.

References AllocateFile(), ASSUMED_LENGTH_INIT, ASSUMED_MEDIAN_INIT, pgssEntry::counters, pgssSharedState::cur_median_usage, pgssGlobalStats::dealloc, pgssEntry::encoding, entry_alloc(), HASHCTL::entrysize, ereport, errcode(), errcode_for_file_access(), errmsg(), pgssSharedState::extent, FreeFile(), pgssSharedState::gc_count, GetCurrentTimestamp(), GetNamedLWLockTranche(), HASH_BLOBS, HASH_ELEM, header(), i, IS_STICKY, IsUnderPostmaster, pgssEntry::key, HASHCTL::keysize, pgssSharedState::lock, LOG, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), Max, pgssSharedState::mean_query_len, pgssSharedState::mutex, pgssSharedState::n_writers, on_shmem_exit(), palloc(), pfree(), PG_BINARY_R, PG_BINARY_W, PG_VALID_BE_ENCODING, PGSS_DUMP_FILE, PGSS_FILE_HEADER, pgss_max, PGSS_PG_MAJOR_VERSION, pgss_save, pgss_shmem_shutdown(), PGSS_TEXT_FILE, prev_shmem_startup_hook, pgssEntry::query_len, repalloc(), ShmemInitHash(), ShmemInitStruct(), SpinLockInit, pgssSharedState::stats, and pgssGlobalStats::stats_reset.

Referenced by _PG_init().

{
    bool        found;
    HASHCTL     info;
    FILE       *file = NULL;
    FILE       *qfile = NULL;
    uint32      header;
    int32       num;
    int32       pgver;
    int32       i;
    int         buffer_size;
    char       *buffer = NULL;

    if (prev_shmem_startup_hook)
        prev_shmem_startup_hook();

    /* reset in case this is a restart within the postmaster */
    pgss = NULL;
    pgss_hash = NULL;

    /*
     * Create or attach to the shared memory state, including hash table
     */
    LWLockAcquire(AddinShmemInitLock, LW_EXCLUSIVE);

    pgss = ShmemInitStruct("pg_stat_statements",
                           sizeof(pgssSharedState),
                           &found);

    if (!found)
    {
        /* First time through ... */
        pgss->lock = &(GetNamedLWLockTranche("pg_stat_statements"))->lock;
        pgss->cur_median_usage = ASSUMED_MEDIAN_INIT;
        pgss->mean_query_len = ASSUMED_LENGTH_INIT;
        SpinLockInit(&pgss->mutex);
        pgss->extent = 0;
        pgss->n_writers = 0;
        pgss->gc_count = 0;
        pgss->stats.dealloc = 0;
        pgss->stats.stats_reset = GetCurrentTimestamp();
    }

    info.keysize = sizeof(pgssHashKey);
    info.entrysize = sizeof(pgssEntry);
    pgss_hash = ShmemInitHash("pg_stat_statements hash",
                              pgss_max, pgss_max,
                              &info,
                              HASH_ELEM | HASH_BLOBS);

    LWLockRelease(AddinShmemInitLock);

    /*
     * If we're in the postmaster (or a standalone backend...), set up a shmem
     * exit hook to dump the statistics to disk.
     */
    if (!IsUnderPostmaster)
        on_shmem_exit(pgss_shmem_shutdown, (Datum) 0);

    /*
     * Done if some other process already completed our initialization.
     */
    if (found)
        return;

    /*
     * Note: we don't bother with locks here, because there should be no other
     * processes running when this code is reached.
     */

    /* Unlink query text file possibly left over from crash */
    unlink(PGSS_TEXT_FILE);

    /* Allocate new query text temp file */
    qfile = AllocateFile(PGSS_TEXT_FILE, PG_BINARY_W);
    if (qfile == NULL)
        goto write_error;

    /*
     * If we were told not to load old statistics, we're done.  (Note we do
     * not try to unlink any old dump file in this case.  This seems a bit
     * questionable but it's the historical behavior.)
     */
    if (!pgss_save)
    {
        FreeFile(qfile);
        return;
    }

    /*
     * Attempt to load old statistics from the dump file.
     */
    file = AllocateFile(PGSS_DUMP_FILE, PG_BINARY_R);
    if (file == NULL)
    {
        if (errno != ENOENT)
            goto read_error;
        /* No existing persisted stats file, so we're done */
        FreeFile(qfile);
        return;
    }

    buffer_size = 2048;
    buffer = (char *) palloc(buffer_size);

    if (fread(&header, sizeof(uint32), 1, file) != 1 ||
        fread(&pgver, sizeof(uint32), 1, file) != 1 ||
        fread(&num, sizeof(int32), 1, file) != 1)
        goto read_error;

    if (header != PGSS_FILE_HEADER ||
        pgver != PGSS_PG_MAJOR_VERSION)
        goto data_error;

    for (i = 0; i < num; i++)
    {
        pgssEntry   temp;
        pgssEntry  *entry;
        Size        query_offset;

        if (fread(&temp, sizeof(pgssEntry), 1, file) != 1)
            goto read_error;

        /* Encoding is the only field we can easily sanity-check */
        if (!PG_VALID_BE_ENCODING(temp.encoding))
            goto data_error;

        /* Resize buffer as needed */
        if (temp.query_len >= buffer_size)
        {
            buffer_size = Max(buffer_size * 2, temp.query_len + 1);
            buffer = repalloc(buffer, buffer_size);
        }

        if (fread(buffer, 1, temp.query_len + 1, file) != temp.query_len + 1)
            goto read_error;

        /* Should have a trailing null, but let's make sure */
        buffer[temp.query_len] = '\0';

        /* Skip loading "sticky" entries */
        if (IS_STICKY(temp.counters))
            continue;

        /* Store the query text */
        query_offset = pgss->extent;
        if (fwrite(buffer, 1, temp.query_len + 1, qfile) != temp.query_len + 1)
            goto write_error;
        pgss->extent += temp.query_len + 1;

        /* make the hashtable entry (discards old entries if too many) */
        entry = entry_alloc(&temp.key, query_offset, temp.query_len,
                            temp.encoding,
                            false);

        /* copy in the actual stats */
        entry->counters = temp.counters;
    }

    /* Read global statistics for pg_stat_statements */
    if (fread(&pgss->stats, sizeof(pgssGlobalStats), 1, file) != 1)
        goto read_error;

    pfree(buffer);
    FreeFile(file);
    FreeFile(qfile);

    /*
     * Remove the persisted stats file so it's not included in
     * backups/replication standbys, etc.  A new file will be written on next
     * shutdown.
     *
     * Note: it's okay if the PGSS_TEXT_FILE is included in a basebackup,
     * because we remove that file on startup; it acts inversely to
     * PGSS_DUMP_FILE, in that it is only supposed to be around when the
     * server is running, whereas PGSS_DUMP_FILE is only supposed to be around
     * when the server is not running.  Leaving the file creates no danger of
     * a newly restored database having a spurious record of execution costs,
     * which is what we're really concerned about here.
     */
    unlink(PGSS_DUMP_FILE);

    return;

read_error:
    ereport(LOG,
            (errcode_for_file_access(),
             errmsg("could not read file \"%s\": %m",
                    PGSS_DUMP_FILE)));
    goto fail;
data_error:
    ereport(LOG,
            (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
             errmsg("ignoring invalid data in file \"%s\"",
                    PGSS_DUMP_FILE)));
    goto fail;
write_error:
    ereport(LOG,
            (errcode_for_file_access(),
             errmsg("could not write file \"%s\": %m",
                    PGSS_TEXT_FILE)));
fail:
    if (buffer)
        pfree(buffer);
    if (file)
        FreeFile(file);
    if (qfile)
        FreeFile(qfile);
    /* If possible, throw away the bogus file; ignore any error */
    unlink(PGSS_DUMP_FILE);

    /*
     * Don't unlink PGSS_TEXT_FILE here; it should always be around while the
     * server is running with pg_stat_statements enabled
     */
}

pgss_store()

static void pgss_store ( const char *  query, uint64  queryId, int  query_location, int  query_len, pgssStoreKind  kind, double  total_time, uint64  rows, const BufferUsage *  bufusage, const WalUsage *  walusage, JumbleState *  jstate  )

static

Definition at line 1205 of file pg_stat_statements.c.

References Assert, BufferUsage::blk_read_time, Counters::blk_read_time, BufferUsage::blk_write_time, Counters::blk_write_time, Counters::calls, CleanQuerytext(), pgssEntry::counters, pgssHashKey::dbid, encoding, entry_alloc(), exec_nested_level, pgssSharedState::gc_count, gc_qtexts(), generate_normalized_query(), GetDatabaseEncoding(), GetUserId(), HASH_FIND, hash_search(), INSTR_TIME_GET_MILLISEC, IS_STICKY, sort-test::key, BufferUsage::local_blks_dirtied, Counters::local_blks_dirtied, BufferUsage::local_blks_hit, Counters::local_blks_hit, BufferUsage::local_blks_read, Counters::local_blks_read, BufferUsage::local_blks_written, Counters::local_blks_written, pgssSharedState::lock, LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), Counters::max_time, Counters::mean_time, Counters::min_time, pgssEntry::mutex, MyDatabaseId, need_gc_qtexts(), pfree(), PGSS_EXEC, PGSS_PLAN, qtext_store(), pgssHashKey::queryid, Counters::rows, BufferUsage::shared_blks_dirtied, Counters::shared_blks_dirtied, BufferUsage::shared_blks_hit, Counters::shared_blks_hit, BufferUsage::shared_blks_read, Counters::shared_blks_read, BufferUsage::shared_blks_written, Counters::shared_blks_written, SpinLockAcquire, SpinLockRelease, Counters::sum_var_time, BufferUsage::temp_blks_read, Counters::temp_blks_read, BufferUsage::temp_blks_written, Counters::temp_blks_written, pgssHashKey::toplevel, Counters::total_time, Counters::usage, USAGE_EXEC, USAGE_INIT, pgssHashKey::userid, WalUsage::wal_bytes, Counters::wal_bytes, WalUsage::wal_fpi, Counters::wal_fpi, WalUsage::wal_records, and Counters::wal_records.

Referenced by pgss_ExecutorEnd(), pgss_planner(), pgss_post_parse_analyze(), and pgss_ProcessUtility().

{
    pgssHashKey key;
    pgssEntry  *entry;
    char       *norm_query = NULL;
    int         encoding = GetDatabaseEncoding();

    Assert(query != NULL);

    /* Safety check... */
    if (!pgss || !pgss_hash)
        return;

    /*
     * Nothing to do if compute_query_id isn't enabled and no other module
     * computed a query identifier.
     */
    if (queryId == UINT64CONST(0))
        return;

    /*
     * Confine our attention to the relevant part of the string, if the query
     * is a portion of a multi-statement source string, and update query
     * location and length if needed.
     */
    query = CleanQuerytext(query, &query_location, &query_len);

    /* Set up key for hashtable search */

    /* memset() is required when pgssHashKey is without padding only */
    memset(&key, 0, sizeof(pgssHashKey));

    key.userid = GetUserId();
    key.dbid = MyDatabaseId;
    key.queryid = queryId;
    key.toplevel = (exec_nested_level == 0);

    /* Lookup the hash table entry with shared lock. */
    LWLockAcquire(pgss->lock, LW_SHARED);

    entry = (pgssEntry *) hash_search(pgss_hash, &key, HASH_FIND, NULL);

    /* Create new entry, if not present */
    if (!entry)
    {
        Size        query_offset;
        int         gc_count;
        bool        stored;
        bool        do_gc;

        /*
         * Create a new, normalized query string if caller asked.  We don't
         * need to hold the lock while doing this work.  (Note: in any case,
         * it's possible that someone else creates a duplicate hashtable entry
         * in the interval where we don't hold the lock below.  That case is
         * handled by entry_alloc.)
         */
        if (jstate)
        {
            LWLockRelease(pgss->lock);
            norm_query = generate_normalized_query(jstate, query,
                                                   query_location,
                                                   &query_len);
            LWLockAcquire(pgss->lock, LW_SHARED);
        }

        /* Append new query text to file with only shared lock held */
        stored = qtext_store(norm_query ? norm_query : query, query_len,
                             &query_offset, &gc_count);

        /*
         * Determine whether we need to garbage collect external query texts
         * while the shared lock is still held.  This micro-optimization
         * avoids taking the time to decide this while holding exclusive lock.
         */
        do_gc = need_gc_qtexts();

        /* Need exclusive lock to make a new hashtable entry - promote */
        LWLockRelease(pgss->lock);
        LWLockAcquire(pgss->lock, LW_EXCLUSIVE);

        /*
         * A garbage collection may have occurred while we weren't holding the
         * lock.  In the unlikely event that this happens, the query text we
         * stored above will have been garbage collected, so write it again.
         * This should be infrequent enough that doing it while holding
         * exclusive lock isn't a performance problem.
         */
        if (!stored || pgss->gc_count != gc_count)
            stored = qtext_store(norm_query ? norm_query : query, query_len,
                                 &query_offset, NULL);

        /* If we failed to write to the text file, give up */
        if (!stored)
            goto done;

        /* OK to create a new hashtable entry */
        entry = entry_alloc(&key, query_offset, query_len, encoding,
                            jstate != NULL);

        /* If needed, perform garbage collection while exclusive lock held */
        if (do_gc)
            gc_qtexts();
    }

    /* Increment the counts, except when jstate is not NULL */
    if (!jstate)
    {
        /*
         * Grab the spinlock while updating the counters (see comment about
         * locking rules at the head of the file)
         */
        volatile pgssEntry *e = (volatile pgssEntry *) entry;

        Assert(kind == PGSS_PLAN || kind == PGSS_EXEC);

        SpinLockAcquire(&e->mutex);

        /* "Unstick" entry if it was previously sticky */
        if (IS_STICKY(e->counters))
            e->counters.usage = USAGE_INIT;

        e->counters.calls[kind] += 1;
        e->counters.total_time[kind] += total_time;

        if (e->counters.calls[kind] == 1)
        {
            e->counters.min_time[kind] = total_time;
            e->counters.max_time[kind] = total_time;
            e->counters.mean_time[kind] = total_time;
        }
        else
        {
            /*
             * Welford's method for accurately computing variance. See
             * <http://www.johndcook.com/blog/standard_deviation/>
             */
            double      old_mean = e->counters.mean_time[kind];

            e->counters.mean_time[kind] +=
                (total_time - old_mean) / e->counters.calls[kind];
            e->counters.sum_var_time[kind] +=
                (total_time - old_mean) * (total_time - e->counters.mean_time[kind]);

            /* calculate min and max time */
            if (e->counters.min_time[kind] > total_time)
                e->counters.min_time[kind] = total_time;
            if (e->counters.max_time[kind] < total_time)
                e->counters.max_time[kind] = total_time;
        }
        e->counters.rows += rows;
        e->counters.shared_blks_hit += bufusage->shared_blks_hit;
        e->counters.shared_blks_read += bufusage->shared_blks_read;
        e->counters.shared_blks_dirtied += bufusage->shared_blks_dirtied;
        e->counters.shared_blks_written += bufusage->shared_blks_written;
        e->counters.local_blks_hit += bufusage->local_blks_hit;
        e->counters.local_blks_read += bufusage->local_blks_read;
        e->counters.local_blks_dirtied += bufusage->local_blks_dirtied;
        e->counters.local_blks_written += bufusage->local_blks_written;
        e->counters.temp_blks_read += bufusage->temp_blks_read;
        e->counters.temp_blks_written += bufusage->temp_blks_written;
        e->counters.blk_read_time += INSTR_TIME_GET_MILLISEC(bufusage->blk_read_time);
        e->counters.blk_write_time += INSTR_TIME_GET_MILLISEC(bufusage->blk_write_time);
        e->counters.usage += USAGE_EXEC(total_time);
        e->counters.wal_records += walusage->wal_records;
        e->counters.wal_fpi += walusage->wal_fpi;
        e->counters.wal_bytes += walusage->wal_bytes;

        SpinLockRelease(&e->mutex);
    }

done:
    LWLockRelease(pgss->lock);

    /* We postpone this clean-up until we're out of the lock */
    if (norm_query)
        pfree(norm_query);
}

qtext_fetch()

static char * qtext_fetch ( Size  query_offset, int  query_len, char *  buffer, Size  buffer_size  )

static

Definition at line 2201 of file pg_stat_statements.c.

Referenced by gc_qtexts(), pg_stat_statements_internal(), and pgss_shmem_shutdown().

{
    /* File read failed? */
    if (buffer == NULL)
        return NULL;
    /* Bogus offset/length? */
    if (query_len < 0 ||
        query_offset + query_len >= buffer_size)
        return NULL;
    /* As a further sanity check, make sure there's a trailing null */
    if (buffer[query_offset + query_len] != '\0')
        return NULL;
    /* Looks OK */
    return buffer + query_offset;
}

qtext_load_file()

static char * qtext_load_file ( Size *  buffer_size )

static

Definition at line 2121 of file pg_stat_statements.c.

References buf, CloseTransientFile(), ereport, errcode(), errcode_for_file_access(), errdetail(), errmsg(), fd(), free, fstat, LOG, malloc, MaxAllocHugeSize, OpenTransientFile(), PG_BINARY, PGSS_TEXT_FILE, read, and stat::st_size.

Referenced by gc_qtexts(), pg_stat_statements_internal(), and pgss_shmem_shutdown().

{
    char       *buf;
    int         fd;
    struct stat stat;

    fd = OpenTransientFile(PGSS_TEXT_FILE, O_RDONLY | PG_BINARY);
    if (fd < 0)
    {
        if (errno != ENOENT)
            ereport(LOG,
                    (errcode_for_file_access(),
                     errmsg("could not read file \"%s\": %m",
                            PGSS_TEXT_FILE)));
        return NULL;
    }

    /* Get file length */
    if (fstat(fd, &stat))
    {
        ereport(LOG,
                (errcode_for_file_access(),
                 errmsg("could not stat file \"%s\": %m",
                        PGSS_TEXT_FILE)));
        CloseTransientFile(fd);
        return NULL;
    }

    /* Allocate buffer; beware that off_t might be wider than size_t */
    if (stat.st_size <= MaxAllocHugeSize)
        buf = (char *) malloc(stat.st_size);
    else
        buf = NULL;
    if (buf == NULL)
    {
        ereport(LOG,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of memory"),
                 errdetail("Could not allocate enough memory to read file \"%s\".",
                           PGSS_TEXT_FILE)));
        CloseTransientFile(fd);
        return NULL;
    }

    /*
     * OK, slurp in the file.  If we get a short read and errno doesn't get
     * set, the reason is probably that garbage collection truncated the file
     * since we did the fstat(), so we don't log a complaint --- but we don't
     * return the data, either, since it's most likely corrupt due to
     * concurrent writes from garbage collection.
     */
    errno = 0;
    if (read(fd, buf, stat.st_size) != stat.st_size)
    {
        if (errno)
            ereport(LOG,
                    (errcode_for_file_access(),
                     errmsg("could not read file \"%s\": %m",
                            PGSS_TEXT_FILE)));
        free(buf);
        CloseTransientFile(fd);
        return NULL;
    }

    if (CloseTransientFile(fd) != 0)
        ereport(LOG,
                (errcode_for_file_access(),
                 errmsg("could not close file \"%s\": %m", PGSS_TEXT_FILE)));

    *buffer_size = stat.st_size;
    return buf;
}

qtext_store()

static bool qtext_store ( const char *  query, int  query_len, Size *  query_offset, int *  gc_count  )

static

Definition at line 2041 of file pg_stat_statements.c.

References CloseTransientFile(), ereport, errcode_for_file_access(), errmsg(), error(), pgssSharedState::extent, fd(), pgssSharedState::gc_count, LOG, pgssSharedState::mutex, pgssSharedState::n_writers, OpenTransientFile(), PG_BINARY, pg_pwrite(), PGSS_TEXT_FILE, SpinLockAcquire, and SpinLockRelease.

Referenced by pgss_store().

{
    Size        off;
    int         fd;

    /*
     * We use a spinlock to protect extent/n_writers/gc_count, so that
     * multiple processes may execute this function concurrently.
     */
    {
        volatile pgssSharedState *s = (volatile pgssSharedState *) pgss;

        SpinLockAcquire(&s->mutex);
        off = s->extent;
        s->extent += query_len + 1;
        s->n_writers++;
        if (gc_count)
            *gc_count = s->gc_count;
        SpinLockRelease(&s->mutex);
    }

    *query_offset = off;

    /* Now write the data into the successfully-reserved part of the file */
    fd = OpenTransientFile(PGSS_TEXT_FILE, O_RDWR | O_CREAT | PG_BINARY);
    if (fd < 0)
        goto error;

    if (pg_pwrite(fd, query, query_len, off) != query_len)
        goto error;
    if (pg_pwrite(fd, "\0", 1, off + query_len) != 1)
        goto error;

    CloseTransientFile(fd);

    /* Mark our write complete */
    {
        volatile pgssSharedState *s = (volatile pgssSharedState *) pgss;

        SpinLockAcquire(&s->mutex);
        s->n_writers--;
        SpinLockRelease(&s->mutex);
    }

    return true;

error:
    ereport(LOG,
            (errcode_for_file_access(),
             errmsg("could not write file \"%s\": %m",
                    PGSS_TEXT_FILE)));

    if (fd >= 0)
        CloseTransientFile(fd);

    /* Mark our write complete */
    {
        volatile pgssSharedState *s = (volatile pgssSharedState *) pgss;

        SpinLockAcquire(&s->mutex);
        s->n_writers--;
        SpinLockRelease(&s->mutex);
    }

    return false;
}

Variable Documentation

exec_nested_level

int exec_nested_level = 0

static

Definition at line 238 of file pg_stat_statements.c.

Referenced by pgss_ExecutorEnd(), pgss_ExecutorFinish(), pgss_ExecutorRun(), pgss_ExecutorStart(), pgss_planner(), pgss_post_parse_analyze(), pgss_ProcessUtility(), and pgss_store().

PG_MODULE_MAGIC

PG_MODULE_MAGIC

Definition at line 75 of file pg_stat_statements.c.

pgss

pgssSharedState* pgss = NULL

static

Definition at line 254 of file pg_stat_statements.c.

PGSS_FILE_HEADER

const uint32 PGSS_FILE_HEADER = 0x20201227

static

Definition at line 91 of file pg_stat_statements.c.

Referenced by pgss_shmem_shutdown(), and pgss_shmem_startup().

pgss_hash

HTAB* pgss_hash = NULL

static

Definition at line 255 of file pg_stat_statements.c.

pgss_max

int pgss_max

static

Definition at line 274 of file pg_stat_statements.c.

Referenced by _PG_init(), entry_alloc(), need_gc_qtexts(), pgss_memsize(), and pgss_shmem_startup().

PGSS_PG_MAJOR_VERSION

const uint32 PGSS_PG_MAJOR_VERSION = PG_VERSION_NUM / 100

static

Definition at line 94 of file pg_stat_statements.c.

Referenced by pgss_shmem_shutdown(), and pgss_shmem_startup().

pgss_save

bool pgss_save

static

Definition at line 278 of file pg_stat_statements.c.

Referenced by _PG_init(), pgss_shmem_shutdown(), and pgss_shmem_startup().

pgss_track

int pgss_track

static

Definition at line 275 of file pg_stat_statements.c.

Referenced by _PG_init().

pgss_track_planning

bool pgss_track_planning

static

Definition at line 277 of file pg_stat_statements.c.

Referenced by _PG_init(), and pgss_planner().

pgss_track_utility

bool pgss_track_utility

static

Definition at line 276 of file pg_stat_statements.c.

Referenced by _PG_init(), pgss_post_parse_analyze(), and pgss_ProcessUtility().

plan_nested_level

int plan_nested_level = 0

static

Definition at line 241 of file pg_stat_statements.c.

Referenced by pgss_planner().

prev_ExecutorEnd

ExecutorEnd_hook_type prev_ExecutorEnd = NULL

static

Definition at line 250 of file pg_stat_statements.c.

Referenced by _PG_fini(), _PG_init(), and pgss_ExecutorEnd().

prev_ExecutorFinish

ExecutorFinish_hook_type prev_ExecutorFinish = NULL

static

Definition at line 249 of file pg_stat_statements.c.

Referenced by _PG_fini(), _PG_init(), and pgss_ExecutorFinish().

prev_ExecutorRun

ExecutorRun_hook_type prev_ExecutorRun = NULL

static

Definition at line 248 of file pg_stat_statements.c.

Referenced by _PG_fini(), _PG_init(), and pgss_ExecutorRun().

prev_ExecutorStart

ExecutorStart_hook_type prev_ExecutorStart = NULL

static

Definition at line 247 of file pg_stat_statements.c.

Referenced by _PG_fini(), _PG_init(), and pgss_ExecutorStart().

prev_planner_hook

planner_hook_type prev_planner_hook = NULL

static

Definition at line 246 of file pg_stat_statements.c.

Referenced by _PG_fini(), _PG_init(), and pgss_planner().

prev_post_parse_analyze_hook

post_parse_analyze_hook_type prev_post_parse_analyze_hook = NULL

static

Definition at line 245 of file pg_stat_statements.c.

Referenced by _PG_fini(), _PG_init(), and pgss_post_parse_analyze().

prev_ProcessUtility

ProcessUtility_hook_type prev_ProcessUtility = NULL

static

Definition at line 251 of file pg_stat_statements.c.

Referenced by _PG_fini(), _PG_init(), and pgss_ProcessUtility().

prev_shmem_startup_hook

shmem_startup_hook_type prev_shmem_startup_hook = NULL

static

Definition at line 244 of file pg_stat_statements.c.

Referenced by _PG_fini(), _PG_init(), and pgss_shmem_startup().

track_options

const struct config_enum_entry track_options[]

static

Initial value:

=
{
    {"none", PGSS_TRACK_NONE, false},
    {"top", PGSS_TRACK_TOP, false},
    {"all", PGSS_TRACK_ALL, false},
    {NULL, 0, false}
}

Definition at line 266 of file pg_stat_statements.c.