pg_stat_statements.c File Reference

#include "postgres.h"
#include <math.h>
#include <sys/stat.h>
#include <unistd.h>
#include "access/hash.h"
#include "catalog/pg_authid.h"
#include "executor/instrument.h"
#include "funcapi.h"
#include "mb/pg_wchar.h"
#include "miscadmin.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/spin.h"
#include "tcop/utility.h"
#include "utils/builtins.h"
#include "utils/memutils.h"

Include dependency graph for pg_stat_statements.c:

Go to the source code of this file.

Data Structures
struct	pgssHashKey
struct	Counters
struct	pgssEntry
struct	pgssSharedState
struct	pgssLocationLen
struct	pgssJumbleState

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	JUMBLE_SIZE   1024 /* query serialization buffer size */
#define	pgss_enabled()
#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   23 /* maximum of above */
#define	APP_JUMB(item)   AppendJumble(jstate, (const unsigned char *) &(item), sizeof(item))
#define	APP_JUMB_STRING(str)   AppendJumble(jstate, (const unsigned char *) (str), strlen(str) + 1)

Typedefs
typedef enum pgssVersion	pgssVersion
typedef struct pgssHashKey	pgssHashKey
typedef struct Counters	Counters
typedef struct pgssEntry	pgssEntry
typedef struct pgssSharedState	pgssSharedState
typedef struct pgssLocationLen	pgssLocationLen
typedef struct pgssJumbleState	pgssJumbleState

Enumerations
enum	pgssVersion { PGSS_V1_0 = 0, PGSS_V1_1, PGSS_V1_2, PGSS_V1_3 }
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_1_2)
	PG_FUNCTION_INFO_V1 (pg_stat_statements_1_3)
	PG_FUNCTION_INFO_V1 (pg_stat_statements)
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)
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, char *completionTag)
static uint32	pgss_hash_fn (const void *key, Size keysize)
static int	pgss_match_fn (const void *key1, const void *key2, Size keysize)
static uint32	pgss_hash_string (const char *str, int len)
static void	pgss_store (const char *query, uint32 queryId, int query_location, int query_len, double total_time, uint64 rows, const BufferUsage *bufusage, pgssJumbleState *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 (void)
static void	AppendJumble (pgssJumbleState *jstate, const unsigned char *item, Size size)
static void	JumbleQuery (pgssJumbleState *jstate, Query *query)
static void	JumbleRangeTable (pgssJumbleState *jstate, List *rtable)
static void	JumbleExpr (pgssJumbleState *jstate, Node *node)
static void	RecordConstLocation (pgssJumbleState *jstate, int location)
static char *	generate_normalized_query (pgssJumbleState *jstate, const char *query, int query_loc, int *query_len_p, int encoding)
static void	fill_in_constant_lengths (pgssJumbleState *jstate, const char *query, int query_loc)
static int	comp_location (const void *a, const void *b)
Datum	pg_stat_statements_reset (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)
static int	entry_cmp (const void *lhs, const void *rhs)

Variables
	PG_MODULE_MAGIC
static const uint32	PGSS_FILE_HEADER = 0x20140125
static const uint32	PGSS_PG_MAJOR_VERSION = PG_VERSION_NUM / 100
static int	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 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_save

Macro Definition Documentation

#define APP_JUMB

(

item

)

AppendJumble(jstate, (const unsigned char *) &(item), sizeof(item))

Definition at line 2346 of file pg_stat_statements.c.

Referenced by JumbleExpr(), JumbleQuery(), and JumbleRangeTable().

#define APP_JUMB_STRING

(

str

)

AppendJumble(jstate, (const unsigned char *) (str), strlen(str) + 1)

Definition at line 2348 of file pg_stat_statements.c.

Referenced by JumbleExpr(), and JumbleRangeTable().

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

Definition at line 107 of file pg_stat_statements.c.

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

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

Definition at line 106 of file pg_stat_statements.c.

Referenced by pgss_shmem_startup().

#define JUMBLE_SIZE   1024 /* query serialization buffer size */

Definition at line 112 of file pg_stat_statements.c.

Referenced by AppendJumble(), and pgss_post_parse_analyze().

#define PG_STAT_STATEMENTS_COLS   23 /* maximum of above */

Definition at line 1340 of file pg_stat_statements.c.

Referenced by pg_stat_statements_internal().

#define PG_STAT_STATEMENTS_COLS_V1_0   14

Definition at line 1336 of file pg_stat_statements.c.

Referenced by pg_stat_statements_internal().

#define PG_STAT_STATEMENTS_COLS_V1_1   18

Definition at line 1337 of file pg_stat_statements.c.

Referenced by pg_stat_statements_internal().

#define PG_STAT_STATEMENTS_COLS_V1_2   19

Definition at line 1338 of file pg_stat_statements.c.

Referenced by pg_stat_statements_internal().

#define PG_STAT_STATEMENTS_COLS_V1_3   23

Definition at line 1339 of file pg_stat_statements.c.

Referenced by pg_stat_statements_internal().

#define PGSS_DUMP_FILE   PGSTAT_STAT_PERMANENT_DIRECTORY "/pg_stat_statements.stat"

Definition at line 85 of file pg_stat_statements.c.

Referenced by pgss_shmem_shutdown(), and pgss_shmem_startup().

#define pgss_enabled

(

)

Value:

(pgss_track == PGSS_TRACK_ALL || \
    (pgss_track == PGSS_TRACK_TOP && nested_level == 0))

Definition at line 269 of file pg_stat_statements.c.

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

#define PGSS_TEXT_FILE   PG_STAT_TMP_DIR "/pgss_query_texts.stat"

Definition at line 95 of file pg_stat_statements.c.

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

#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 273 of file pg_stat_statements.c.

Referenced by entry_reset(), and gc_qtexts().

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

Definition at line 109 of file pg_stat_statements.c.

Referenced by entry_dealloc().

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

Definition at line 110 of file pg_stat_statements.c.

Referenced by entry_dealloc().

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

Definition at line 108 of file pg_stat_statements.c.

Referenced by entry_dealloc().

#define USAGE_EXEC

(

duration

)

(1.0)

Definition at line 104 of file pg_stat_statements.c.

Referenced by pgss_store().

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

Definition at line 105 of file pg_stat_statements.c.

Referenced by entry_alloc(), and pgss_store().

Typedef Documentation

typedef struct Counters Counters

typedef struct pgssEntry pgssEntry

typedef struct pgssHashKey pgssHashKey

typedef struct pgssJumbleState pgssJumbleState

typedef struct pgssLocationLen pgssLocationLen

typedef struct pgssSharedState pgssSharedState

typedef enum pgssVersion pgssVersion

Enumeration Type Documentation

enum PGSSTrackLevel

Enumerator
PGSS_TRACK_NONE
PGSS_TRACK_TOP
PGSS_TRACK_ALL

Definition at line 248 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;

enum pgssVersion

Enumerator
PGSS_V1_0
PGSS_V1_1
PGSS_V1_2
PGSS_V1_3

Definition at line 117 of file pg_stat_statements.c.

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

Function Documentation

void _PG_fini

(

void

)

Definition at line 440 of file pg_stat_statements.c.

References ExecutorEnd_hook, ExecutorFinish_hook, ExecutorRun_hook, ExecutorStart_hook, post_parse_analyze_hook, prev_ExecutorEnd, prev_ExecutorFinish, prev_ExecutorRun, prev_ExecutorStart, 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;
    ExecutorStart_hook = prev_ExecutorStart;
    ExecutorRun_hook = prev_ExecutorRun;
    ExecutorFinish_hook = prev_ExecutorFinish;
    ExecutorEnd_hook = prev_ExecutorEnd;
    ProcessUtility_hook = prev_ProcessUtility;
}

void _PG_init

(

void

)

Definition at line 344 of file pg_stat_statements.c.

References DefineCustomBoolVariable(), DefineCustomEnumVariable(), DefineCustomIntVariable(), EmitWarningsOnPlaceholders(), ExecutorEnd_hook, ExecutorFinish_hook, ExecutorRun_hook, ExecutorStart_hook, NULL, PGC_POSTMASTER, PGC_SIGHUP, PGC_SUSET, pgss_ExecutorEnd(), pgss_ExecutorFinish(), pgss_ExecutorRun(), pgss_ExecutorStart(), pgss_max, pgss_memsize(), pgss_post_parse_analyze(), pgss_ProcessUtility(), pgss_save, pgss_shmem_startup(), pgss_track, PGSS_TRACK_TOP, pgss_track_utility, post_parse_analyze_hook, prev_ExecutorEnd, prev_ExecutorFinish, prev_ExecutorRun, prev_ExecutorStart, 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;

    /*
     * 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.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_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;
}

static void AppendJumble ( pgssJumbleState *  jstate, const unsigned char *  item, Size  size  )

static

Definition at line 2312 of file pg_stat_statements.c.

References hash_any(), pgssJumbleState::jumble, pgssJumbleState::jumble_len, JUMBLE_SIZE, and Min.

{
    unsigned char *jumble = jstate->jumble;
    Size        jumble_len = jstate->jumble_len;

    /*
     * Whenever the jumble buffer is full, we hash the current contents and
     * reset the buffer to contain just that hash value, thus relying on the
     * hash to summarize everything so far.
     */
    while (size > 0)
    {
        Size        part_size;

        if (jumble_len >= JUMBLE_SIZE)
        {
            uint32      start_hash = hash_any(jumble, JUMBLE_SIZE);

            memcpy(jumble, &start_hash, sizeof(start_hash));
            jumble_len = sizeof(start_hash);
        }
        part_size = Min(size, JUMBLE_SIZE - jumble_len);
        memcpy(jumble + jumble_len, item, part_size);
        jumble_len += part_size;
        item += part_size;
        size -= part_size;
    }
    jstate->jumble_len = jumble_len;
}

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

static

Definition at line 3171 of file pg_stat_statements.c.

Referenced by fill_in_constant_lengths().

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

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

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

static

Definition at line 1705 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;
}

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

static

Definition at line 1742 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;
}

static void entry_dealloc ( void  )

static

Definition at line 1761 of file pg_stat_statements.c.

References ASSUMED_LENGTH_INIT, Counters::calls, pgssEntry::counters, pgssSharedState::cur_median_usage, entry_cmp(), hash_get_num_entries(), HASH_REMOVE, hash_search(), hash_seq_init(), hash_seq_search(), i, Max, pgssSharedState::mean_query_len, Min, NULL, palloc(), pfree(), qsort, pgssEntry::query_len, 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 (entry->counters.calls == 0)
            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);
}

static void entry_reset ( void  )

static

Definition at line 2262 of file pg_stat_statements.c.

References AllocateFile(), ereport, errcode_for_file_access(), errmsg(), pgssSharedState::extent, FreeFile(), ftruncate, HASH_REMOVE, hash_search(), hash_seq_init(), hash_seq_search(), pgssEntry::key, pgssSharedState::lock, LOG, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), NULL, PG_BINARY_W, PGSS_TEXT_FILE, and record_gc_qtexts.

Referenced by pg_stat_statements_reset().

{
    HASH_SEQ_STATUS hash_seq;
    pgssEntry  *entry;
    FILE       *qfile;

    LWLockAcquire(pgss->lock, LW_EXCLUSIVE);

    hash_seq_init(&hash_seq, pgss_hash);
    while ((entry = hash_seq_search(&hash_seq)) != NULL)
    {
        hash_search(pgss_hash, &entry->key, HASH_REMOVE, NULL);
    }

    /*
     * 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 pg_stat_statement 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 pg_stat_statement 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();

    LWLockRelease(pgss->lock);
}

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

static

Definition at line 3071 of file pg_stat_statements.c.

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

Referenced by generate_normalized_query().

{
    pgssLocationLen *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(pgssLocationLen), comp_location);
    locs = jstate->clocations;

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

    /* 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);
}

static void gc_qtexts ( void  )

static

Definition at line 2078 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(), NULL, PG_BINARY_W, PGSS_TEXT_FILE, qtext_fetch(), qtext_load_file(), pgssEntry::query_len, pgssEntry::query_offset, record_gc_qtexts, and unlink().

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 pg_stat_statement 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 pg_stat_statement 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 pg_stat_statement file \"%s\": %m",
                      PGSS_TEXT_FILE)));

    if (FreeFile(qfile))
    {
        ereport(LOG,
                (errcode_for_file_access(),
                 errmsg("could not write pg_stat_statement 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 write new pg_stat_statement 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();
}

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

static

Definition at line 2964 of file pg_stat_statements.c.

References Assert, pgssJumbleState::clocations, pgssJumbleState::clocations_count, fill_in_constant_lengths(), pgssJumbleState::highest_extern_param_id, i, pgssLocationLen::length, pgssLocationLen::location, and palloc().

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;
}

static void JumbleExpr ( pgssJumbleState *  jstate, Node *  node  )

static

Definition at line 2454 of file pg_stat_statements.c.

References OnConflictExpr::action, Aggref::aggdirectargs, Aggref::aggdistinct, Aggref::aggfilter, WindowFunc::aggfilter, Aggref::aggfnoid, Aggref::aggorder, SetOperationStmt::all, APP_JUMB, APP_JUMB_STRING, OnConflictExpr::arbiterElems, OnConflictExpr::arbiterWhere, NamedArgExpr::arg, FieldSelect::arg, FieldStore::arg, RelabelType::arg, CoerceViaIO::arg, ArrayCoerceExpr::arg, ConvertRowtypeExpr::arg, CollateExpr::arg, CaseExpr::arg, NullTest::arg, BooleanTest::arg, CoerceToDomain::arg, NamedArgExpr::argnumber, generate_unaccent_rules::args, Aggref::args, WindowFunc::args, FuncExpr::args, OpExpr::args, ScalarArrayOpExpr::args, BoolExpr::args, CaseExpr::args, MinMaxExpr::args, TableSampleClause::args, XmlExpr::args, BoolExpr::boolop, BooleanTest::booltesttype, castNode, check_stack_depth(), TableFunc::colexprs, CollateExpr::collOid, OnConflictExpr::constraint, Const::consttype, GroupingSet::content, CommonTableExpr::ctename, CommonTableExpr::ctequery, CurrentOfExpr::cursor_name, CurrentOfExpr::cursor_param, CurrentOfExpr::cvarno, CaseExpr::defresult, TableFunc::docexpr, elog, WindowClause::endOffset, SortGroupClause::eqop, OnConflictExpr::exclRelIndex, OnConflictExpr::exclRelTlist, CaseWhen::expr, InferenceElem::expr, TargetEntry::expr, FieldSelect::fieldnum, WindowClause::frameOptions, FromExpr::fromlist, RangeTblFunction::funcexpr, FuncExpr::funcid, pgssJumbleState::highest_extern_param_id, InferenceElem::infercollid, InferenceElem::inferopclass, JoinExpr::isNatural, JoinExpr::jointype, JumbleQuery(), JoinExpr::larg, SetOperationStmt::larg, RowCompareExpr::largs, lfirst, lfirst_int, lfirst_node, Const::location, XmlExpr::named_args, FieldStore::newvals, nodeTag, NULL, SortGroupClause::nulls_first, NullTest::nulltesttype, OnConflictExpr::onConflictSet, OnConflictExpr::onConflictWhere, MinMaxExpr::op, SQLValueFunction::op, XmlExpr::op, SetOperationStmt::op, OpExpr::opno, ScalarArrayOpExpr::opno, WindowClause::orderClause, PARAM_EXTERN, Param::paramid, Param::paramkind, Param::paramtype, WindowClause::partitionClause, JoinExpr::quals, FromExpr::quals, JoinExpr::rarg, SetOperationStmt::rarg, RowCompareExpr::rargs, RowCompareExpr::rctype, RecordConstLocation(), ArrayRef::refassgnexpr, ArrayRef::refexpr, ArrayRef::reflowerindexpr, GroupingFunc::refs, ArrayRef::refupperindexpr, TableSampleClause::repeatable, TargetEntry::resno, TargetEntry::ressortgroupref, CaseWhen::result, RelabelType::resulttype, CoerceViaIO::resulttype, ArrayCoerceExpr::resulttype, ConvertRowtypeExpr::resulttype, CoerceToDomain::resulttype, TableFunc::rowexpr, RangeTblRef::rtindex, JoinExpr::rtindex, SortGroupClause::sortop, WindowClause::startOffset, SubLink::subLinkId, SubLink::subLinkType, SubLink::subselect, T_Aggref, T_ArrayCoerceExpr, T_ArrayExpr, T_ArrayRef, T_BooleanTest, T_BoolExpr, T_CaseExpr, T_CaseTestExpr, T_CoalesceExpr, T_CoerceToDomain, T_CoerceToDomainValue, T_CoerceViaIO, T_CollateExpr, T_CommonTableExpr, T_Const, T_ConvertRowtypeExpr, T_CurrentOfExpr, T_DistinctExpr, T_FieldSelect, T_FieldStore, T_FromExpr, T_FuncExpr, T_GroupingFunc, T_GroupingSet, T_InferenceElem, T_IntList, T_JoinExpr, T_List, T_MinMaxExpr, T_NamedArgExpr, T_NullIfExpr, T_NullTest, T_OnConflictExpr, T_OpExpr, T_Param, T_RangeTblFunction, T_RangeTblRef, T_RelabelType, T_RowCompareExpr, T_RowExpr, T_ScalarArrayOpExpr, T_SetOperationStmt, T_SetToDefault, T_SortGroupClause, T_SQLValueFunction, T_SubLink, T_TableFunc, T_TableSampleClause, T_TargetEntry, T_Var, T_WindowClause, T_WindowFunc, T_XmlExpr, SubLink::testexpr, SortGroupClause::tleSortGroupRef, TableSampleClause::tsmhandler, Node::type, CaseTestExpr::typeId, CoerceToDomainValue::typeId, SetToDefault::typeId, SQLValueFunction::typmod, ScalarArrayOpExpr::useOr, Var::varattno, Var::varlevelsup, Var::varno, WARNING, WindowFunc::winfnoid, WindowFunc::winref, and WindowClause::winref.

Referenced by JumbleQuery(), and JumbleRangeTable().

{
    ListCell   *temp;

    if (node == NULL)
        return;

    /* Guard against stack overflow due to overly complex expressions */
    check_stack_depth();

    /*
     * We always emit the node's NodeTag, then any additional fields that are
     * considered significant, and then we recurse to any child nodes.
     */
    APP_JUMB(node->type);

    switch (nodeTag(node))
    {
        case T_Var:
            {
                Var        *var = (Var *) node;

                APP_JUMB(var->varno);
                APP_JUMB(var->varattno);
                APP_JUMB(var->varlevelsup);
            }
            break;
        case T_Const:
            {
                Const      *c = (Const *) node;

                /* We jumble only the constant's type, not its value */
                APP_JUMB(c->consttype);
                /* Also, record its parse location for query normalization */
                RecordConstLocation(jstate, c->location);
            }
            break;
        case T_Param:
            {
                Param      *p = (Param *) node;

                APP_JUMB(p->paramkind);
                APP_JUMB(p->paramid);
                APP_JUMB(p->paramtype);
                /* Also, track the highest external Param id */
                if (p->paramkind == PARAM_EXTERN &&
                    p->paramid > jstate->highest_extern_param_id)
                    jstate->highest_extern_param_id = p->paramid;
            }
            break;
        case T_Aggref:
            {
                Aggref     *expr = (Aggref *) node;

                APP_JUMB(expr->aggfnoid);
                JumbleExpr(jstate, (Node *) expr->aggdirectargs);
                JumbleExpr(jstate, (Node *) expr->args);
                JumbleExpr(jstate, (Node *) expr->aggorder);
                JumbleExpr(jstate, (Node *) expr->aggdistinct);
                JumbleExpr(jstate, (Node *) expr->aggfilter);
            }
            break;
        case T_GroupingFunc:
            {
                GroupingFunc *grpnode = (GroupingFunc *) node;

                JumbleExpr(jstate, (Node *) grpnode->refs);
            }
            break;
        case T_WindowFunc:
            {
                WindowFunc *expr = (WindowFunc *) node;

                APP_JUMB(expr->winfnoid);
                APP_JUMB(expr->winref);
                JumbleExpr(jstate, (Node *) expr->args);
                JumbleExpr(jstate, (Node *) expr->aggfilter);
            }
            break;
        case T_ArrayRef:
            {
                ArrayRef   *aref = (ArrayRef *) node;

                JumbleExpr(jstate, (Node *) aref->refupperindexpr);
                JumbleExpr(jstate, (Node *) aref->reflowerindexpr);
                JumbleExpr(jstate, (Node *) aref->refexpr);
                JumbleExpr(jstate, (Node *) aref->refassgnexpr);
            }
            break;
        case T_FuncExpr:
            {
                FuncExpr   *expr = (FuncExpr *) node;

                APP_JUMB(expr->funcid);
                JumbleExpr(jstate, (Node *) expr->args);
            }
            break;
        case T_NamedArgExpr:
            {
                NamedArgExpr *nae = (NamedArgExpr *) node;

                APP_JUMB(nae->argnumber);
                JumbleExpr(jstate, (Node *) nae->arg);
            }
            break;
        case T_OpExpr:
        case T_DistinctExpr:    /* struct-equivalent to OpExpr */
        case T_NullIfExpr:      /* struct-equivalent to OpExpr */
            {
                OpExpr     *expr = (OpExpr *) node;

                APP_JUMB(expr->opno);
                JumbleExpr(jstate, (Node *) expr->args);
            }
            break;
        case T_ScalarArrayOpExpr:
            {
                ScalarArrayOpExpr *expr = (ScalarArrayOpExpr *) node;

                APP_JUMB(expr->opno);
                APP_JUMB(expr->useOr);
                JumbleExpr(jstate, (Node *) expr->args);
            }
            break;
        case T_BoolExpr:
            {
                BoolExpr   *expr = (BoolExpr *) node;

                APP_JUMB(expr->boolop);
                JumbleExpr(jstate, (Node *) expr->args);
            }
            break;
        case T_SubLink:
            {
                SubLink    *sublink = (SubLink *) node;

                APP_JUMB(sublink->subLinkType);
                APP_JUMB(sublink->subLinkId);
                JumbleExpr(jstate, (Node *) sublink->testexpr);
                JumbleQuery(jstate, castNode(Query, sublink->subselect));
            }
            break;
        case T_FieldSelect:
            {
                FieldSelect *fs = (FieldSelect *) node;

                APP_JUMB(fs->fieldnum);
                JumbleExpr(jstate, (Node *) fs->arg);
            }
            break;
        case T_FieldStore:
            {
                FieldStore *fstore = (FieldStore *) node;

                JumbleExpr(jstate, (Node *) fstore->arg);
                JumbleExpr(jstate, (Node *) fstore->newvals);
            }
            break;
        case T_RelabelType:
            {
                RelabelType *rt = (RelabelType *) node;

                APP_JUMB(rt->resulttype);
                JumbleExpr(jstate, (Node *) rt->arg);
            }
            break;
        case T_CoerceViaIO:
            {
                CoerceViaIO *cio = (CoerceViaIO *) node;

                APP_JUMB(cio->resulttype);
                JumbleExpr(jstate, (Node *) cio->arg);
            }
            break;
        case T_ArrayCoerceExpr:
            {
                ArrayCoerceExpr *acexpr = (ArrayCoerceExpr *) node;

                APP_JUMB(acexpr->resulttype);
                JumbleExpr(jstate, (Node *) acexpr->arg);
            }
            break;
        case T_ConvertRowtypeExpr:
            {
                ConvertRowtypeExpr *crexpr = (ConvertRowtypeExpr *) node;

                APP_JUMB(crexpr->resulttype);
                JumbleExpr(jstate, (Node *) crexpr->arg);
            }
            break;
        case T_CollateExpr:
            {
                CollateExpr *ce = (CollateExpr *) node;

                APP_JUMB(ce->collOid);
                JumbleExpr(jstate, (Node *) ce->arg);
            }
            break;
        case T_CaseExpr:
            {
                CaseExpr   *caseexpr = (CaseExpr *) node;

                JumbleExpr(jstate, (Node *) caseexpr->arg);
                foreach(temp, caseexpr->args)
                {
                    CaseWhen   *when = lfirst_node(CaseWhen, temp);

                    JumbleExpr(jstate, (Node *) when->expr);
                    JumbleExpr(jstate, (Node *) when->result);
                }
                JumbleExpr(jstate, (Node *) caseexpr->defresult);
            }
            break;
        case T_CaseTestExpr:
            {
                CaseTestExpr *ct = (CaseTestExpr *) node;

                APP_JUMB(ct->typeId);
            }
            break;
        case T_ArrayExpr:
            JumbleExpr(jstate, (Node *) ((ArrayExpr *) node)->elements);
            break;
        case T_RowExpr:
            JumbleExpr(jstate, (Node *) ((RowExpr *) node)->args);
            break;
        case T_RowCompareExpr:
            {
                RowCompareExpr *rcexpr = (RowCompareExpr *) node;

                APP_JUMB(rcexpr->rctype);
                JumbleExpr(jstate, (Node *) rcexpr->largs);
                JumbleExpr(jstate, (Node *) rcexpr->rargs);
            }
            break;
        case T_CoalesceExpr:
            JumbleExpr(jstate, (Node *) ((CoalesceExpr *) node)->args);
            break;
        case T_MinMaxExpr:
            {
                MinMaxExpr *mmexpr = (MinMaxExpr *) node;

                APP_JUMB(mmexpr->op);
                JumbleExpr(jstate, (Node *) mmexpr->args);
            }
            break;
        case T_SQLValueFunction:
            {
                SQLValueFunction *svf = (SQLValueFunction *) node;

                APP_JUMB(svf->op);
                /* type is fully determined by op */
                APP_JUMB(svf->typmod);
            }
            break;
        case T_XmlExpr:
            {
                XmlExpr    *xexpr = (XmlExpr *) node;

                APP_JUMB(xexpr->op);
                JumbleExpr(jstate, (Node *) xexpr->named_args);
                JumbleExpr(jstate, (Node *) xexpr->args);
            }
            break;
        case T_NullTest:
            {
                NullTest   *nt = (NullTest *) node;

                APP_JUMB(nt->nulltesttype);
                JumbleExpr(jstate, (Node *) nt->arg);
            }
            break;
        case T_BooleanTest:
            {
                BooleanTest *bt = (BooleanTest *) node;

                APP_JUMB(bt->booltesttype);
                JumbleExpr(jstate, (Node *) bt->arg);
            }
            break;
        case T_CoerceToDomain:
            {
                CoerceToDomain *cd = (CoerceToDomain *) node;

                APP_JUMB(cd->resulttype);
                JumbleExpr(jstate, (Node *) cd->arg);
            }
            break;
        case T_CoerceToDomainValue:
            {
                CoerceToDomainValue *cdv = (CoerceToDomainValue *) node;

                APP_JUMB(cdv->typeId);
            }
            break;
        case T_SetToDefault:
            {
                SetToDefault *sd = (SetToDefault *) node;

                APP_JUMB(sd->typeId);
            }
            break;
        case T_CurrentOfExpr:
            {
                CurrentOfExpr *ce = (CurrentOfExpr *) node;

                APP_JUMB(ce->cvarno);
                if (ce->cursor_name)
                    APP_JUMB_STRING(ce->cursor_name);
                APP_JUMB(ce->cursor_param);
            }
            break;
        case T_InferenceElem:
            {
                InferenceElem *ie = (InferenceElem *) node;

                APP_JUMB(ie->infercollid);
                APP_JUMB(ie->inferopclass);
                JumbleExpr(jstate, ie->expr);
            }
            break;
        case T_TargetEntry:
            {
                TargetEntry *tle = (TargetEntry *) node;

                APP_JUMB(tle->resno);
                APP_JUMB(tle->ressortgroupref);
                JumbleExpr(jstate, (Node *) tle->expr);
            }
            break;
        case T_RangeTblRef:
            {
                RangeTblRef *rtr = (RangeTblRef *) node;

                APP_JUMB(rtr->rtindex);
            }
            break;
        case T_JoinExpr:
            {
                JoinExpr   *join = (JoinExpr *) node;

                APP_JUMB(join->jointype);
                APP_JUMB(join->isNatural);
                APP_JUMB(join->rtindex);
                JumbleExpr(jstate, join->larg);
                JumbleExpr(jstate, join->rarg);
                JumbleExpr(jstate, join->quals);
            }
            break;
        case T_FromExpr:
            {
                FromExpr   *from = (FromExpr *) node;

                JumbleExpr(jstate, (Node *) from->fromlist);
                JumbleExpr(jstate, from->quals);
            }
            break;
        case T_OnConflictExpr:
            {
                OnConflictExpr *conf = (OnConflictExpr *) node;

                APP_JUMB(conf->action);
                JumbleExpr(jstate, (Node *) conf->arbiterElems);
                JumbleExpr(jstate, conf->arbiterWhere);
                JumbleExpr(jstate, (Node *) conf->onConflictSet);
                JumbleExpr(jstate, conf->onConflictWhere);
                APP_JUMB(conf->constraint);
                APP_JUMB(conf->exclRelIndex);
                JumbleExpr(jstate, (Node *) conf->exclRelTlist);
            }
            break;
        case T_List:
            foreach(temp, (List *) node)
            {
                JumbleExpr(jstate, (Node *) lfirst(temp));
            }
            break;
        case T_IntList:
            foreach(temp, (List *) node)
            {
                APP_JUMB(lfirst_int(temp));
            }
            break;
        case T_SortGroupClause:
            {
                SortGroupClause *sgc = (SortGroupClause *) node;

                APP_JUMB(sgc->tleSortGroupRef);
                APP_JUMB(sgc->eqop);
                APP_JUMB(sgc->sortop);
                APP_JUMB(sgc->nulls_first);
            }
            break;
        case T_GroupingSet:
            {
                GroupingSet *gsnode = (GroupingSet *) node;

                JumbleExpr(jstate, (Node *) gsnode->content);
            }
            break;
        case T_WindowClause:
            {
                WindowClause *wc = (WindowClause *) node;

                APP_JUMB(wc->winref);
                APP_JUMB(wc->frameOptions);
                JumbleExpr(jstate, (Node *) wc->partitionClause);
                JumbleExpr(jstate, (Node *) wc->orderClause);
                JumbleExpr(jstate, wc->startOffset);
                JumbleExpr(jstate, wc->endOffset);
            }
            break;
        case T_CommonTableExpr:
            {
                CommonTableExpr *cte = (CommonTableExpr *) node;

                /* we store the string name because RTE_CTE RTEs need it */
                APP_JUMB_STRING(cte->ctename);
                JumbleQuery(jstate, castNode(Query, cte->ctequery));
            }
            break;
        case T_SetOperationStmt:
            {
                SetOperationStmt *setop = (SetOperationStmt *) node;

                APP_JUMB(setop->op);
                APP_JUMB(setop->all);
                JumbleExpr(jstate, setop->larg);
                JumbleExpr(jstate, setop->rarg);
            }
            break;
        case T_RangeTblFunction:
            {
                RangeTblFunction *rtfunc = (RangeTblFunction *) node;

                JumbleExpr(jstate, rtfunc->funcexpr);
            }
            break;
        case T_TableFunc:
            {
                TableFunc  *tablefunc = (TableFunc *) node;

                JumbleExpr(jstate, tablefunc->docexpr);
                JumbleExpr(jstate, tablefunc->rowexpr);
                JumbleExpr(jstate, (Node *) tablefunc->colexprs);
            }
            break;
        case T_TableSampleClause:
            {
                TableSampleClause *tsc = (TableSampleClause *) node;

                APP_JUMB(tsc->tsmhandler);
                JumbleExpr(jstate, (Node *) tsc->args);
                JumbleExpr(jstate, (Node *) tsc->repeatable);
            }
            break;
        default:
            /* Only a warning, since we can stumble along anyway */
            elog(WARNING, "unrecognized node type: %d",
                 (int) nodeTag(node));
            break;
    }
}

static void JumbleQuery ( pgssJumbleState *  jstate, Query *  query  )

static

Definition at line 2361 of file pg_stat_statements.c.

References APP_JUMB, Assert, Query::commandType, Query::cteList, Query::distinctClause, Query::groupClause, Query::groupingSets, Query::havingQual, IsA, Query::jointree, JumbleExpr(), JumbleRangeTable(), Query::limitCount, Query::limitOffset, NULL, Query::onConflict, Query::returningList, Query::rtable, Query::setOperations, Query::sortClause, Query::targetList, Query::utilityStmt, and Query::windowClause.

Referenced by JumbleExpr(), JumbleRangeTable(), and pgss_post_parse_analyze().

{
    Assert(IsA(query, Query));
    Assert(query->utilityStmt == NULL);

    APP_JUMB(query->commandType);
    /* resultRelation is usually predictable from commandType */
    JumbleExpr(jstate, (Node *) query->cteList);
    JumbleRangeTable(jstate, query->rtable);
    JumbleExpr(jstate, (Node *) query->jointree);
    JumbleExpr(jstate, (Node *) query->targetList);
    JumbleExpr(jstate, (Node *) query->onConflict);
    JumbleExpr(jstate, (Node *) query->returningList);
    JumbleExpr(jstate, (Node *) query->groupClause);
    JumbleExpr(jstate, (Node *) query->groupingSets);
    JumbleExpr(jstate, query->havingQual);
    JumbleExpr(jstate, (Node *) query->windowClause);
    JumbleExpr(jstate, (Node *) query->distinctClause);
    JumbleExpr(jstate, (Node *) query->sortClause);
    JumbleExpr(jstate, query->limitOffset);
    JumbleExpr(jstate, query->limitCount);
    /* we ignore rowMarks */
    JumbleExpr(jstate, query->setOperations);
}

static void JumbleRangeTable ( pgssJumbleState *  jstate, List *  rtable  )

static

Definition at line 2390 of file pg_stat_statements.c.

References APP_JUMB, APP_JUMB_STRING, RangeTblEntry::ctelevelsup, RangeTblEntry::ctename, elog, RangeTblEntry::enrname, ERROR, RangeTblEntry::functions, RangeTblEntry::jointype, JumbleExpr(), JumbleQuery(), lfirst_node, RangeTblEntry::relid, RTE_CTE, RTE_FUNCTION, RTE_JOIN, RTE_NAMEDTUPLESTORE, RTE_RELATION, RTE_SUBQUERY, RTE_TABLEFUNC, RTE_VALUES, RangeTblEntry::rtekind, RangeTblEntry::subquery, RangeTblEntry::tablefunc, RangeTblEntry::tablesample, and RangeTblEntry::values_lists.

Referenced by JumbleQuery().

{
    ListCell   *lc;

    foreach(lc, rtable)
    {
        RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);

        APP_JUMB(rte->rtekind);
        switch (rte->rtekind)
        {
            case RTE_RELATION:
                APP_JUMB(rte->relid);
                JumbleExpr(jstate, (Node *) rte->tablesample);
                break;
            case RTE_SUBQUERY:
                JumbleQuery(jstate, rte->subquery);
                break;
            case RTE_JOIN:
                APP_JUMB(rte->jointype);
                break;
            case RTE_FUNCTION:
                JumbleExpr(jstate, (Node *) rte->functions);
                break;
            case RTE_TABLEFUNC:
                JumbleExpr(jstate, (Node *) rte->tablefunc);
                break;
            case RTE_VALUES:
                JumbleExpr(jstate, (Node *) rte->values_lists);
                break;
            case RTE_CTE:

                /*
                 * Depending on the CTE name here isn't ideal, but it's the
                 * only info we have to identify the referenced WITH item.
                 */
                APP_JUMB_STRING(rte->ctename);
                APP_JUMB(rte->ctelevelsup);
                break;
            case RTE_NAMEDTUPLESTORE:
                APP_JUMB_STRING(rte->enrname);
                break;
            default:
                elog(ERROR, "unrecognized RTE kind: %d", (int) rte->rtekind);
                break;
        }
    }
}

static bool need_gc_qtexts ( void  )

static

Definition at line 2031 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

(

pg_stat_statements_reset

)

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

)

Datum pg_stat_statements

(

PG_FUNCTION_ARGS

)

Definition at line 1377 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;
}

Datum pg_stat_statements_1_2

(

PG_FUNCTION_ARGS

)

Definition at line 1363 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;
}

Datum pg_stat_statements_1_3

(

PG_FUNCTION_ARGS

)

Definition at line 1353 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;
}

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

static

Definition at line 1387 of file pg_stat_statements.c.

References ReturnSetInfo::allowedModes, Assert, Counters::blk_read_time, Counters::blk_write_time, Counters::calls, pgssEntry::counters, CStringGetTextDatum, pgssHashKey::dbid, DEFAULT_ROLE_READ_ALL_STATS, 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, Int64GetDatumFast, is_member_of_role(), 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, NULL, 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, PGSS_V1_0, PGSS_V1_1, PGSS_V1_2, PGSS_V1_3, qtext_fetch(), qtext_load_file(), pgssEntry::query_len, pgssEntry::query_offset, pgssHashKey::queryid, FunctionCallInfoData::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, SpinLockAcquire, SpinLockRelease, Counters::sum_var_time, Counters::temp_blks_read, Counters::temp_blks_written, Counters::total_time, tuplestore_begin_heap(), tuplestore_donestoring, tuplestore_putvalues(), TYPEFUNC_COMPOSITE, pgssHashKey::userid, values, and work_mem.

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

{
    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(), DEFAULT_ROLE_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;
        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 (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 (tmp.calls == 0)
            continue;

        values[i++] = Int64GetDatumFast(tmp.calls);
        values[i++] = Float8GetDatumFast(tmp.total_time);
        if (api_version >= PGSS_V1_3)
        {
            values[i++] = Float8GetDatumFast(tmp.min_time);
            values[i++] = Float8GetDatumFast(tmp.max_time);
            values[i++] = Float8GetDatumFast(tmp.mean_time);

            /*
             * 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 > 1)
                stddev = sqrt(tmp.sum_var_time / tmp.calls);
            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);
        }

        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 :
                     -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);
}

Datum pg_stat_statements_reset

(

PG_FUNCTION_ARGS

)

Definition at line 1325 of file pg_stat_statements.c.

References entry_reset(), ereport, errcode(), errmsg(), ERROR, and PG_RETURN_VOID.

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

static void pgss_ExecutorEnd ( QueryDesc *  queryDesc )

static

Definition at line 927 of file pg_stat_statements.c.

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

Referenced by _PG_init().

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

    if (queryId != 0 && queryDesc->totaltime && pgss_enabled())
    {
        /*
         * 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,
                   queryDesc->totaltime->total * 1000.0,        /* convert to msec */
                   queryDesc->estate->es_processed,
                   &queryDesc->totaltime->bufusage,
                   NULL);
    }

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

static void pgss_ExecutorFinish ( QueryDesc *  queryDesc )

static

Definition at line 904 of file pg_stat_statements.c.

References nested_level, PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, prev_ExecutorFinish, and standard_ExecutorFinish().

Referenced by _PG_init().

{
    nested_level++;
    PG_TRY();
    {
        if (prev_ExecutorFinish)
            prev_ExecutorFinish(queryDesc);
        else
            standard_ExecutorFinish(queryDesc);
        nested_level--;
    }
    PG_CATCH();
    {
        nested_level--;
        PG_RE_THROW();
    }
    PG_END_TRY();
}

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

static

Definition at line 880 of file pg_stat_statements.c.

References nested_level, PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, prev_ExecutorRun, and standard_ExecutorRun().

Referenced by _PG_init().

{
    nested_level++;
    PG_TRY();
    {
        if (prev_ExecutorRun)
            prev_ExecutorRun(queryDesc, direction, count, execute_once);
        else
            standard_ExecutorRun(queryDesc, direction, count, execute_once);
        nested_level--;
    }
    PG_CATCH();
    {
        nested_level--;
        PG_RE_THROW();
    }
    PG_END_TRY();
}

static void pgss_ExecutorStart ( QueryDesc *  queryDesc, int  eflags  )

static

Definition at line 846 of file pg_stat_statements.c.

References EState::es_query_cxt, QueryDesc::estate, InstrAlloc(), INSTRUMENT_ALL, MemoryContextSwitchTo(), NULL, 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() && queryDesc->plannedstmt->queryId != 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);
            MemoryContextSwitchTo(oldcxt);
        }
    }
}

static uint32 pgss_hash_fn ( const void *  key, Size  keysize  )

static

Definition at line 1076 of file pg_stat_statements.c.

References pgssHashKey::dbid, hash_uint32(), pgssHashKey::queryid, and pgssHashKey::userid.

Referenced by pgss_shmem_startup().

{
    const pgssHashKey *k = (const pgssHashKey *) key;

    return hash_uint32((uint32) k->userid) ^
        hash_uint32((uint32) k->dbid) ^
        hash_uint32((uint32) k->queryid);
}

static uint32 pgss_hash_string ( const char *  str, int  len  )

static

Definition at line 1108 of file pg_stat_statements.c.

References hash_any().

Referenced by pgss_store().

{
    return hash_any((const unsigned char *) str, len);
}

static int pgss_match_fn ( const void *  key1, const void *  key2, Size  keysize  )

static

Definition at line 1089 of file pg_stat_statements.c.

References pgssHashKey::dbid, pgssHashKey::queryid, and pgssHashKey::userid.

Referenced by pgss_shmem_startup().

{
    const pgssHashKey *k1 = (const pgssHashKey *) key1;
    const pgssHashKey *k2 = (const pgssHashKey *) key2;

    if (k1->userid == k2->userid &&
        k1->dbid == k2->dbid &&
        k1->queryid == k2->queryid)
        return 0;
    else
        return 1;
}

static Size pgss_memsize ( void  )

static

Definition at line 1677 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;
}

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

static

Definition at line 776 of file pg_stat_statements.c.

References Assert, pgssJumbleState::clocations, pgssJumbleState::clocations_buf_size, pgssJumbleState::clocations_count, hash_any(), pgssJumbleState::highest_extern_param_id, pgssJumbleState::jumble, pgssJumbleState::jumble_len, JUMBLE_SIZE, JumbleQuery(), NULL, ParseState::p_sourcetext, palloc(), pgss_store(), prev_post_parse_analyze_hook, Query::queryId, Query::stmt_len, Query::stmt_location, and Query::utilityStmt.

Referenced by _PG_init().

{
    pgssJumbleState jstate;

    if (prev_post_parse_analyze_hook)
        prev_post_parse_analyze_hook(pstate, query);

    /* Assert we didn't do this already */
    Assert(query->queryId == 0);

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

    /*
     * Utility statements 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.
     */
    if (query->utilityStmt)
    {
        query->queryId = 0;
        return;
    }

    /* Set up workspace for query jumbling */
    jstate.jumble = (unsigned char *) palloc(JUMBLE_SIZE);
    jstate.jumble_len = 0;
    jstate.clocations_buf_size = 32;
    jstate.clocations = (pgssLocationLen *)
        palloc(jstate.clocations_buf_size * sizeof(pgssLocationLen));
    jstate.clocations_count = 0;
    jstate.highest_extern_param_id = 0;

    /* Compute query ID and mark the Query node with it */
    JumbleQuery(&jstate, query);
    query->queryId = hash_any(jstate.jumble, jstate.jumble_len);

    /*
     * If we are unlucky enough to get a hash of zero, use 1 instead, to
     * prevent confusion with the utility-statement case.
     */
    if (query->queryId == 0)
        query->queryId = 1;

    /*
     * If we 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.clocations_count > 0)
        pgss_store(pstate->p_sourcetext,
                   query->queryId,
                   query->stmt_location,
                   query->stmt_len,
                   0,
                   0,
                   NULL,
                   &jstate);
}

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

static

Definition at line 959 of file pg_stat_statements.c.

References BufferUsage::blk_read_time, BufferUsage::blk_write_time, duration, INSTR_TIME_GET_MILLISEC, INSTR_TIME_SET_CURRENT, INSTR_TIME_SUBTRACT, IsA, BufferUsage::local_blks_dirtied, BufferUsage::local_blks_hit, BufferUsage::local_blks_read, BufferUsage::local_blks_written, nested_level, NULL, PG_CATCH, PG_END_TRY, PG_RE_THROW, pg_strtouint64(), PG_TRY, pgBufferUsage, pgss_enabled, pgss_store(), pgss_track_utility, prev_ProcessUtility, BufferUsage::shared_blks_dirtied, BufferUsage::shared_blks_hit, BufferUsage::shared_blks_read, BufferUsage::shared_blks_written, standard_ProcessUtility(), PlannedStmt::stmt_len, PlannedStmt::stmt_location, BufferUsage::temp_blks_read, BufferUsage::temp_blks_written, and PlannedStmt::utilityStmt.

Referenced by _PG_init().

{
    Node       *parsetree = pstmt->utilityStmt;

    /*
     * 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() &&
        !IsA(parsetree, ExecuteStmt) &&
        !IsA(parsetree, PrepareStmt) &&
        !IsA(parsetree, DeallocateStmt))
    {
        instr_time  start;
        instr_time  duration;
        uint64      rows;
        BufferUsage bufusage_start,
                    bufusage;

        bufusage_start = pgBufferUsage;
        INSTR_TIME_SET_CURRENT(start);

        nested_level++;
        PG_TRY();
        {
            if (prev_ProcessUtility)
                prev_ProcessUtility(pstmt, queryString,
                                    context, params, queryEnv,
                                    dest, completionTag);
            else
                standard_ProcessUtility(pstmt, queryString,
                                        context, params, queryEnv,
                                        dest, completionTag);
            nested_level--;
        }
        PG_CATCH();
        {
            nested_level--;
            PG_RE_THROW();
        }
        PG_END_TRY();

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

        /* parse command tag to retrieve the number of affected rows. */
        if (completionTag &&
            strncmp(completionTag, "COPY ", 5) == 0)
            rows = pg_strtouint64(completionTag + 5, NULL, 10);
        else
            rows = 0;

        /* calc differences of buffer counters. */
        bufusage.shared_blks_hit =
            pgBufferUsage.shared_blks_hit - bufusage_start.shared_blks_hit;
        bufusage.shared_blks_read =
            pgBufferUsage.shared_blks_read - bufusage_start.shared_blks_read;
        bufusage.shared_blks_dirtied =
            pgBufferUsage.shared_blks_dirtied - bufusage_start.shared_blks_dirtied;
        bufusage.shared_blks_written =
            pgBufferUsage.shared_blks_written - bufusage_start.shared_blks_written;
        bufusage.local_blks_hit =
            pgBufferUsage.local_blks_hit - bufusage_start.local_blks_hit;
        bufusage.local_blks_read =
            pgBufferUsage.local_blks_read - bufusage_start.local_blks_read;
        bufusage.local_blks_dirtied =
            pgBufferUsage.local_blks_dirtied - bufusage_start.local_blks_dirtied;
        bufusage.local_blks_written =
            pgBufferUsage.local_blks_written - bufusage_start.local_blks_written;
        bufusage.temp_blks_read =
            pgBufferUsage.temp_blks_read - bufusage_start.temp_blks_read;
        bufusage.temp_blks_written =
            pgBufferUsage.temp_blks_written - bufusage_start.temp_blks_written;
        bufusage.blk_read_time = pgBufferUsage.blk_read_time;
        INSTR_TIME_SUBTRACT(bufusage.blk_read_time, bufusage_start.blk_read_time);
        bufusage.blk_write_time = pgBufferUsage.blk_write_time;
        INSTR_TIME_SUBTRACT(bufusage.blk_write_time, bufusage_start.blk_write_time);

        pgss_store(queryString,
                   0,           /* signal that it's a utility stmt */
                   pstmt->stmt_location,
                   pstmt->stmt_len,
                   INSTR_TIME_GET_MILLISEC(duration),
                   rows,
                   &bufusage,
                   NULL);
    }
    else
    {
        if (prev_ProcessUtility)
            prev_ProcessUtility(pstmt, queryString,
                                context, params, queryEnv,
                                dest, completionTag);
        else
            standard_ProcessUtility(pstmt, queryString,
                                    context, params, queryEnv,
                                    dest, completionTag);
    }
}

static void pgss_shmem_shutdown ( int  code, Datum  arg  )

static

Definition at line 680 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, NULL, 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 unlink().

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;
        }
    }

    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 pg_stat_statement file \"%s\": %m",
                    PGSS_DUMP_FILE ".tmp")));
    if (qbuffer)
        free(qbuffer);
    if (file)
        FreeFile(file);
    unlink(PGSS_DUMP_FILE ".tmp");
    unlink(PGSS_TEXT_FILE);
}

static void pgss_shmem_startup ( void  )

static

Definition at line 459 of file pg_stat_statements.c.

References AllocateFile(), ASSUMED_LENGTH_INIT, ASSUMED_MEDIAN_INIT, buffer, Counters::calls, pgssEntry::counters, pgssSharedState::cur_median_usage, pgssEntry::encoding, entry_alloc(), HASHCTL::entrysize, ereport, errcode(), errcode_for_file_access(), errmsg(), pgssSharedState::extent, FreeFile(), pgssSharedState::gc_count, GetNamedLWLockTranche(), HASHCTL::hash, HASH_COMPARE, HASH_ELEM, HASH_FUNCTION, header(), i, IsUnderPostmaster, pgssEntry::key, HASHCTL::keysize, pgssSharedState::lock, LOG, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), HASHCTL::match, Max, pgssSharedState::mean_query_len, pgssSharedState::mutex, pgssSharedState::n_writers, NULL, on_shmem_exit(), palloc(), pfree(), PG_BINARY_R, PG_BINARY_W, PG_VALID_BE_ENCODING, PGSS_DUMP_FILE, PGSS_FILE_HEADER, pgss_hash_fn(), pgss_match_fn(), 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, and unlink().

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;
    }

    memset(&info, 0, sizeof(info));
    info.keysize = sizeof(pgssHashKey);
    info.entrysize = sizeof(pgssEntry);
    info.hash = pgss_hash_fn;
    info.match = pgss_match_fn;
    pgss_hash = ShmemInitHash("pg_stat_statements hash",
                              pgss_max, pgss_max,
                              &info,
                              HASH_ELEM | HASH_FUNCTION | HASH_COMPARE);

    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 (temp.counters.calls == 0)
            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;
    }

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

    /*
     * Remove the persisted stats file so it's not included in
     * backups/replication slaves, 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 pg_stat_statement file \"%s\": %m",
                    PGSS_DUMP_FILE)));
    goto fail;
data_error:
    ereport(LOG,
            (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
             errmsg("ignoring invalid data in pg_stat_statement file \"%s\"",
                    PGSS_DUMP_FILE)));
    goto fail;
write_error:
    ereport(LOG,
            (errcode_for_file_access(),
             errmsg("could not write pg_stat_statement 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
     */
}

static void pgss_store ( const char *  query, uint32  queryId, int  query_location, int  query_len, double  total_time, uint64  rows, const BufferUsage *  bufusage, pgssJumbleState *  jstate  )

static

Definition at line 1124 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, pgssEntry::counters, pgssHashKey::dbid, encoding, entry_alloc(), pgssSharedState::gc_count, gc_qtexts(), generate_normalized_query(), GetDatabaseEncoding(), GetUserId(), HASH_FIND, hash_search(), INSTR_TIME_GET_MILLISEC, 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(), NULL, pfree(), pgss_hash_string(), qtext_store(), pgssHashKey::queryid, Counters::rows, scanner_isspace(), 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, Counters::total_time, Counters::usage, USAGE_EXEC, USAGE_INIT, and pgssHashKey::userid.

Referenced by pgss_ExecutorEnd(), 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;

    /*
     * Confine our attention to the relevant part of the string, if the query
     * is a portion of a multi-statement source string.
     *
     * First apply starting offset, unless it's -1 (unknown).
     */
    if (query_location >= 0)
    {
        Assert(query_location <= strlen(query));
        query += query_location;
        /* Length of 0 (or -1) means "rest of string" */
        if (query_len <= 0)
            query_len = strlen(query);
        else
            Assert(query_len <= strlen(query));
    }
    else
    {
        /* If query location is unknown, distrust query_len as well */
        query_location = 0;
        query_len = strlen(query);
    }

    /*
     * Discard leading and trailing whitespace, too.  Use scanner_isspace()
     * not libc's isspace(), because we want to match the lexer's behavior.
     */
    while (query_len > 0 && scanner_isspace(query[0]))
        query++, query_location++, query_len--;
    while (query_len > 0 && scanner_isspace(query[query_len - 1]))
        query_len--;

    /*
     * For utility statements, we just hash the query string to get an ID.
     */
    if (queryId == 0)
        queryId = pgss_hash_string(query, query_len);

    /* Set up key for hashtable search */
    key.userid = GetUserId();
    key.dbid = MyDatabaseId;
    key.queryid = queryId;

    /* 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,
                                                   encoding);
            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;

        SpinLockAcquire(&e->mutex);

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

        e->counters.calls += 1;
        e->counters.total_time += total_time;
        if (e->counters.calls == 1)
        {
            e->counters.min_time = total_time;
            e->counters.max_time = total_time;
            e->counters.mean_time = 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;

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

            /* calculate min and max time */
            if (e->counters.min_time > total_time)
                e->counters.min_time = total_time;
            if (e->counters.max_time < total_time)
                e->counters.max_time = 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);

        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);
}

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

static

Definition at line 2008 of file pg_stat_statements.c.

References NULL.

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;
}

static char * qtext_load_file ( Size *  buffer_size )

static

Definition at line 1931 of file pg_stat_statements.c.

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

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, 0);
    if (fd < 0)
    {
        if (errno != ENOENT)
            ereport(LOG,
                    (errcode_for_file_access(),
                   errmsg("could not read pg_stat_statement 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 pg_stat_statement 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 pg_stat_statement 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 pg_stat_statement file \"%s\": %m",
                          PGSS_TEXT_FILE)));
        free(buf);
        CloseTransientFile(fd);
        return NULL;
    }

    CloseTransientFile(fd);

    *buffer_size = stat.st_size;
    return buf;
}

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

static

Definition at line 1847 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, PGSS_TEXT_FILE, SpinLockAcquire, SpinLockRelease, and write.

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,
                           S_IRUSR | S_IWUSR);
    if (fd < 0)
        goto error;

    if (lseek(fd, off, SEEK_SET) != off)
        goto error;

    if (write(fd, query, query_len) != query_len)
        goto error;
    if (write(fd, "\0", 1) != 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 pg_stat_statement 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;
}

static void RecordConstLocation ( pgssJumbleState *  jstate, int  location  )

static

Definition at line 2923 of file pg_stat_statements.c.

References pgssJumbleState::clocations, pgssJumbleState::clocations_buf_size, pgssJumbleState::clocations_count, pgssLocationLen::length, pgssLocationLen::location, and repalloc().

Referenced by JumbleExpr().

{
    /* -1 indicates unknown or undefined location */
    if (location >= 0)
    {
        /* enlarge array if needed */
        if (jstate->clocations_count >= jstate->clocations_buf_size)
        {
            jstate->clocations_buf_size *= 2;
            jstate->clocations = (pgssLocationLen *)
                repalloc(jstate->clocations,
                         jstate->clocations_buf_size *
                         sizeof(pgssLocationLen));
        }
        jstate->clocations[jstate->clocations_count].location = location;
        /* initialize lengths to -1 to simplify fill_in_constant_lengths */
        jstate->clocations[jstate->clocations_count].length = -1;
        jstate->clocations_count++;
    }
}

Variable Documentation

int nested_level = 0

static

Definition at line 231 of file pg_stat_statements.c.

Referenced by pgss_ExecutorFinish(), pgss_ExecutorRun(), and pgss_ProcessUtility().

PG_MODULE_MAGIC

Definition at line 82 of file pg_stat_statements.c.

pgssSharedState* pgss = NULL

static

Definition at line 243 of file pg_stat_statements.c.

const uint32 PGSS_FILE_HEADER = 0x20140125

static

Definition at line 98 of file pg_stat_statements.c.

Referenced by pgss_shmem_shutdown(), and pgss_shmem_startup().

HTAB* pgss_hash = NULL

static

Definition at line 244 of file pg_stat_statements.c.

int pgss_max

static

Definition at line 263 of file pg_stat_statements.c.

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

const uint32 PGSS_PG_MAJOR_VERSION = PG_VERSION_NUM / 100

static

Definition at line 101 of file pg_stat_statements.c.

Referenced by pgss_shmem_shutdown(), and pgss_shmem_startup().

bool pgss_save

static

Definition at line 266 of file pg_stat_statements.c.

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

int pgss_track

static

Definition at line 264 of file pg_stat_statements.c.

Referenced by _PG_init().

bool pgss_track_utility

static

Definition at line 265 of file pg_stat_statements.c.

Referenced by _PG_init(), and pgss_ProcessUtility().

ExecutorEnd_hook_type prev_ExecutorEnd = NULL

static

Definition at line 239 of file pg_stat_statements.c.

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

ExecutorFinish_hook_type prev_ExecutorFinish = NULL

static

Definition at line 238 of file pg_stat_statements.c.

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

ExecutorRun_hook_type prev_ExecutorRun = NULL

static

Definition at line 237 of file pg_stat_statements.c.

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

ExecutorStart_hook_type prev_ExecutorStart = NULL

static

Definition at line 236 of file pg_stat_statements.c.

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

post_parse_analyze_hook_type prev_post_parse_analyze_hook = NULL

static

Definition at line 235 of file pg_stat_statements.c.

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

ProcessUtility_hook_type prev_ProcessUtility = NULL

static

Definition at line 240 of file pg_stat_statements.c.

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

shmem_startup_hook_type prev_shmem_startup_hook = NULL

static

Definition at line 234 of file pg_stat_statements.c.

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

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 255 of file pg_stat_statements.c.