PostgreSQL Source Code  git master
pg_stat_statements.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * pg_stat_statements.c
4  * Track statement execution times across a whole database cluster.
5  *
6  * Execution costs are totalled for each distinct source query, and kept in
7  * a shared hashtable. (We track only as many distinct queries as will fit
8  * in the designated amount of shared memory.)
9  *
10  * As of Postgres 9.2, this module normalizes query entries. Normalization
11  * is a process whereby similar queries, typically differing only in their
12  * constants (though the exact rules are somewhat more subtle than that) are
13  * recognized as equivalent, and are tracked as a single entry. This is
14  * particularly useful for non-prepared queries.
15  *
16  * Normalization is implemented by fingerprinting queries, selectively
17  * serializing those fields of each query tree's nodes that are judged to be
18  * essential to the query. This is referred to as a query jumble. This is
19  * distinct from a regular serialization in that various extraneous
20  * information is ignored as irrelevant or not essential to the query, such
21  * as the collations of Vars and, most notably, the values of constants.
22  *
23  * This jumble is acquired at the end of parse analysis of each query, and
24  * a 64-bit hash of it is stored into the query's Query.queryId field.
25  * The server then copies this value around, making it available in plan
26  * tree(s) generated from the query. The executor can then use this value
27  * to blame query costs on the proper queryId.
28  *
29  * To facilitate presenting entries to users, we create "representative" query
30  * strings in which constants are replaced with parameter symbols ($n), to
31  * make it clearer what a normalized entry can represent. To save on shared
32  * memory, and to avoid having to truncate oversized query strings, we store
33  * these strings in a temporary external query-texts file. Offsets into this
34  * file are kept in shared memory.
35  *
36  * Note about locking issues: to create or delete an entry in the shared
37  * hashtable, one must hold pgss->lock exclusively. Modifying any field
38  * in an entry except the counters requires the same. To look up an entry,
39  * one must hold the lock shared. To read or update the counters within
40  * an entry, one must hold the lock shared or exclusive (so the entry doesn't
41  * disappear!) and also take the entry's mutex spinlock.
42  * The shared state variable pgss->extent (the next free spot in the external
43  * query-text file) should be accessed only while holding either the
44  * pgss->mutex spinlock, or exclusive lock on pgss->lock. We use the mutex to
45  * allow reserving file space while holding only shared lock on pgss->lock.
46  * Rewriting the entire external query-text file, eg for garbage collection,
47  * requires holding pgss->lock exclusively; this allows individual entries
48  * in the file to be read or written while holding only shared lock.
49  *
50  *
51  * Copyright (c) 2008-2020, PostgreSQL Global Development Group
52  *
53  * IDENTIFICATION
54  * contrib/pg_stat_statements/pg_stat_statements.c
55  *
56  *-------------------------------------------------------------------------
57  */
58 #include "postgres.h"
59 
60 #include <math.h>
61 #include <sys/stat.h>
62 #include <unistd.h>
63 
64 #include "catalog/pg_authid.h"
65 #include "executor/instrument.h"
66 #include "funcapi.h"
67 #include "mb/pg_wchar.h"
68 #include "miscadmin.h"
69 #include "parser/analyze.h"
70 #include "parser/parsetree.h"
71 #include "parser/scanner.h"
72 #include "parser/scansup.h"
73 #include "pgstat.h"
74 #include "storage/fd.h"
75 #include "storage/ipc.h"
76 #include "storage/spin.h"
77 #include "tcop/utility.h"
78 #include "utils/acl.h"
79 #include "utils/builtins.h"
80 #include "utils/hashutils.h"
81 #include "utils/memutils.h"
82 
83 PG_MODULE_MAGIC;
84 
85 /* Location of permanent stats file (valid when database is shut down) */
86 #define PGSS_DUMP_FILE PGSTAT_STAT_PERMANENT_DIRECTORY "/pg_stat_statements.stat"
87 
88 /*
89  * Location of external query text file. We don't keep it in the core
90  * system's stats_temp_directory. The core system can safely use that GUC
91  * setting, because the statistics collector temp file paths are set only once
92  * as part of changing the GUC, but pg_stat_statements has no way of avoiding
93  * race conditions. Besides, we only expect modest, infrequent I/O for query
94  * strings, so placing the file on a faster filesystem is not compelling.
95  */
96 #define PGSS_TEXT_FILE PG_STAT_TMP_DIR "/pgss_query_texts.stat"
97 
98 /* Magic number identifying the stats file format */
99 static const uint32 PGSS_FILE_HEADER = 0x20171004;
100 
101 /* PostgreSQL major version number, changes in which invalidate all entries */
102 static const uint32 PGSS_PG_MAJOR_VERSION = PG_VERSION_NUM / 100;
103 
104 /* XXX: Should USAGE_EXEC reflect execution time and/or buffer usage? */
105 #define USAGE_EXEC(duration) (1.0)
106 #define USAGE_INIT (1.0) /* including initial planning */
107 #define ASSUMED_MEDIAN_INIT (10.0) /* initial assumed median usage */
108 #define ASSUMED_LENGTH_INIT 1024 /* initial assumed mean query length */
109 #define USAGE_DECREASE_FACTOR (0.99) /* decreased every entry_dealloc */
110 #define STICKY_DECREASE_FACTOR (0.50) /* factor for sticky entries */
111 #define USAGE_DEALLOC_PERCENT 5 /* free this % of entries at once */
112 
113 #define JUMBLE_SIZE 1024 /* query serialization buffer size */
114 
115 /*
116  * Extension version number, for supporting older extension versions' objects
117  */
118 typedef enum pgssVersion
119 {
120  PGSS_V1_0 = 0,
121  PGSS_V1_1,
122  PGSS_V1_2,
123  PGSS_V1_3
124 } pgssVersion;
125 
126 /*
127  * Hashtable key that defines the identity of a hashtable entry. We separate
128  * queries by user and by database even if they are otherwise identical.
129  *
130  * Right now, this structure contains no padding. If you add any, make sure
131  * to teach pgss_store() to zero the padding bytes. Otherwise, things will
132  * break, because pgss_hash is created using HASH_BLOBS, and thus tag_hash
133  * is used to hash this.
134  */
135 typedef struct pgssHashKey
136 {
137  Oid userid; /* user OID */
138  Oid dbid; /* database OID */
139  uint64 queryid; /* query identifier */
140 } pgssHashKey;
141 
142 /*
143  * The actual stats counters kept within pgssEntry.
144  */
145 typedef struct Counters
146 {
147  int64 calls; /* # of times executed */
148  double total_time; /* total execution time, in msec */
149  double min_time; /* minimum execution time in msec */
150  double max_time; /* maximum execution time in msec */
151  double mean_time; /* mean execution time in msec */
152  double sum_var_time; /* sum of variances in execution time in msec */
153  int64 rows; /* total # of retrieved or affected rows */
154  int64 shared_blks_hit; /* # of shared buffer hits */
155  int64 shared_blks_read; /* # of shared disk blocks read */
156  int64 shared_blks_dirtied; /* # of shared disk blocks dirtied */
157  int64 shared_blks_written; /* # of shared disk blocks written */
158  int64 local_blks_hit; /* # of local buffer hits */
159  int64 local_blks_read; /* # of local disk blocks read */
160  int64 local_blks_dirtied; /* # of local disk blocks dirtied */
161  int64 local_blks_written; /* # of local disk blocks written */
162  int64 temp_blks_read; /* # of temp blocks read */
163  int64 temp_blks_written; /* # of temp blocks written */
164  double blk_read_time; /* time spent reading, in msec */
165  double blk_write_time; /* time spent writing, in msec */
166  double usage; /* usage factor */
167 } Counters;
168 
169 /*
170  * Statistics per statement
171  *
172  * Note: in event of a failure in garbage collection of the query text file,
173  * we reset query_offset to zero and query_len to -1. This will be seen as
174  * an invalid state by qtext_fetch().
175  */
176 typedef struct pgssEntry
177 {
178  pgssHashKey key; /* hash key of entry - MUST BE FIRST */
179  Counters counters; /* the statistics for this query */
180  Size query_offset; /* query text offset in external file */
181  int query_len; /* # of valid bytes in query string, or -1 */
182  int encoding; /* query text encoding */
183  slock_t mutex; /* protects the counters only */
184 } pgssEntry;
185 
186 /*
187  * Global shared state
188  */
189 typedef struct pgssSharedState
190 {
191  LWLock *lock; /* protects hashtable search/modification */
192  double cur_median_usage; /* current median usage in hashtable */
193  Size mean_query_len; /* current mean entry text length */
194  slock_t mutex; /* protects following fields only: */
195  Size extent; /* current extent of query file */
196  int n_writers; /* number of active writers to query file */
197  int gc_count; /* query file garbage collection cycle count */
198 } pgssSharedState;
199 
200 /*
201  * Struct for tracking locations/lengths of constants during normalization
202  */
203 typedef struct pgssLocationLen
204 {
205  int location; /* start offset in query text */
206  int length; /* length in bytes, or -1 to ignore */
207 } pgssLocationLen;
208 
209 /*
210  * Working state for computing a query jumble and producing a normalized
211  * query string
212  */
213 typedef struct pgssJumbleState
214 {
215  /* Jumble of current query tree */
216  unsigned char *jumble;
217 
218  /* Number of bytes used in jumble[] */
219  Size jumble_len;
220 
221  /* Array of locations of constants that should be removed */
222  pgssLocationLen *clocations;
223 
224  /* Allocated length of clocations array */
225  int clocations_buf_size;
226 
227  /* Current number of valid entries in clocations array */
228  int clocations_count;
229 
230  /* highest Param id we've seen, in order to start normalization correctly */
231  int highest_extern_param_id;
232 } pgssJumbleState;
233 
234 /*---- Local variables ----*/
235 
236 /* Current nesting depth of ExecutorRun+ProcessUtility calls */
237 static int nested_level = 0;
238 
239 /* Saved hook values in case of unload */
240 static shmem_startup_hook_type prev_shmem_startup_hook = NULL;
241 static post_parse_analyze_hook_type prev_post_parse_analyze_hook = NULL;
242 static ExecutorStart_hook_type prev_ExecutorStart = NULL;
243 static ExecutorRun_hook_type prev_ExecutorRun = NULL;
244 static ExecutorFinish_hook_type prev_ExecutorFinish = NULL;
245 static ExecutorEnd_hook_type prev_ExecutorEnd = NULL;
246 static ProcessUtility_hook_type prev_ProcessUtility = NULL;
247 
248 /* Links to shared memory state */
249 static pgssSharedState *pgss = NULL;
250 static HTAB *pgss_hash = NULL;
251 
252 /*---- GUC variables ----*/
253 
254 typedef enum
255 {
256  PGSS_TRACK_NONE, /* track no statements */
257  PGSS_TRACK_TOP, /* only top level statements */
258  PGSS_TRACK_ALL /* all statements, including nested ones */
259 } PGSSTrackLevel;
260 
261 static const struct config_enum_entry track_options[] =
262 {
263  {"none", PGSS_TRACK_NONE, false},
264  {"top", PGSS_TRACK_TOP, false},
265  {"all", PGSS_TRACK_ALL, false},
266  {NULL, 0, false}
267 };
268 
269 static int pgss_max; /* max # statements to track */
270 static int pgss_track; /* tracking level */
271 static bool pgss_track_utility; /* whether to track utility commands */
272 static bool pgss_save; /* whether to save stats across shutdown */
273 
274 
275 #define pgss_enabled() \
276  (pgss_track == PGSS_TRACK_ALL || \
277  (pgss_track == PGSS_TRACK_TOP && nested_level == 0))
278 
279 #define record_gc_qtexts() \
280  do { \
281  volatile pgssSharedState *s = (volatile pgssSharedState *) pgss; \
282  SpinLockAcquire(&s->mutex); \
283  s->gc_count++; \
284  SpinLockRelease(&s->mutex); \
285  } while(0)
286 
287 /*---- Function declarations ----*/
288 
289 void _PG_init(void);
290 void _PG_fini(void);
291 
292 PG_FUNCTION_INFO_V1(pg_stat_statements_reset);
293 PG_FUNCTION_INFO_V1(pg_stat_statements_reset_1_7);
294 PG_FUNCTION_INFO_V1(pg_stat_statements_1_2);
295 PG_FUNCTION_INFO_V1(pg_stat_statements_1_3);
296 PG_FUNCTION_INFO_V1(pg_stat_statements);
297 
298 static void pgss_shmem_startup(void);
299 static void pgss_shmem_shutdown(int code, Datum arg);
300 static void pgss_post_parse_analyze(ParseState *pstate, Query *query);
301 static void pgss_ExecutorStart(QueryDesc *queryDesc, int eflags);
302 static void pgss_ExecutorRun(QueryDesc *queryDesc,
303  ScanDirection direction,
304  uint64 count, bool execute_once);
305 static void pgss_ExecutorFinish(QueryDesc *queryDesc);
306 static void pgss_ExecutorEnd(QueryDesc *queryDesc);
307 static void pgss_ProcessUtility(PlannedStmt *pstmt, const char *queryString,
308  ProcessUtilityContext context, ParamListInfo params,
309  QueryEnvironment *queryEnv,
310  DestReceiver *dest, char *completionTag);
311 static uint64 pgss_hash_string(const char *str, int len);
312 static void pgss_store(const char *query, uint64 queryId,
313  int query_location, int query_len,
314  double total_time, uint64 rows,
315  const BufferUsage *bufusage,
316  pgssJumbleState *jstate);
317 static void pg_stat_statements_internal(FunctionCallInfo fcinfo,
318  pgssVersion api_version,
319  bool showtext);
320 static Size pgss_memsize(void);
321 static pgssEntry *entry_alloc(pgssHashKey *key, Size query_offset, int query_len,
322  int encoding, bool sticky);
323 static void entry_dealloc(void);
324 static bool qtext_store(const char *query, int query_len,
325  Size *query_offset, int *gc_count);
326 static char *qtext_load_file(Size *buffer_size);
327 static char *qtext_fetch(Size query_offset, int query_len,
328  char *buffer, Size buffer_size);
329 static bool need_gc_qtexts(void);
330 static void gc_qtexts(void);
331 static void entry_reset(Oid userid, Oid dbid, uint64 queryid);
332 static void AppendJumble(pgssJumbleState *jstate,
333  const unsigned char *item, Size size);
334 static void JumbleQuery(pgssJumbleState *jstate, Query *query);
335 static void JumbleRangeTable(pgssJumbleState *jstate, List *rtable);
336 static void JumbleRowMarks(pgssJumbleState *jstate, List *rowMarks);
337 static void JumbleExpr(pgssJumbleState *jstate, Node *node);
338 static void RecordConstLocation(pgssJumbleState *jstate, int location);
339 static char *generate_normalized_query(pgssJumbleState *jstate, const char *query,
340  int query_loc, int *query_len_p, int encoding);
341 static void fill_in_constant_lengths(pgssJumbleState *jstate, const char *query,
342  int query_loc);
343 static int comp_location(const void *a, const void *b);
344 
345 
346 /*
347  * Module load callback
348  */
349 void
350 _PG_init(void)
351 {
352  /*
353  * In order to create our shared memory area, we have to be loaded via
354  * shared_preload_libraries. If not, fall out without hooking into any of
355  * the main system. (We don't throw error here because it seems useful to
356  * allow the pg_stat_statements functions to be created even when the
357  * module isn't active. The functions must protect themselves against
358  * being called then, however.)
359  */
360  if (!process_shared_preload_libraries_in_progress)
361  return;
362 
363  /*
364  * Define (or redefine) custom GUC variables.
365  */
366  DefineCustomIntVariable("pg_stat_statements.max",
367  "Sets the maximum number of statements tracked by pg_stat_statements.",
368  NULL,
369  &pgss_max,
370  5000,
371  100,
372  INT_MAX,
373  PGC_POSTMASTER,
374  0,
375  NULL,
376  NULL,
377  NULL);
378 
379  DefineCustomEnumVariable("pg_stat_statements.track",
380  "Selects which statements are tracked by pg_stat_statements.",
381  NULL,
382  &pgss_track,
383  PGSS_TRACK_TOP,
384  track_options,
385  PGC_SUSET,
386  0,
387  NULL,
388  NULL,
389  NULL);
390 
391  DefineCustomBoolVariable("pg_stat_statements.track_utility",
392  "Selects whether utility commands are tracked by pg_stat_statements.",
393  NULL,
394  &pgss_track_utility,
395  true,
396  PGC_SUSET,
397  0,
398  NULL,
399  NULL,
400  NULL);
401 
402  DefineCustomBoolVariable("pg_stat_statements.save",
403  "Save pg_stat_statements statistics across server shutdowns.",
404  NULL,
405  &pgss_save,
406  true,
407  PGC_SIGHUP,
408  0,
409  NULL,
410  NULL,
411  NULL);
412 
413  EmitWarningsOnPlaceholders("pg_stat_statements");
414 
415  /*
416  * Request additional shared resources. (These are no-ops if we're not in
417  * the postmaster process.) We'll allocate or attach to the shared
418  * resources in pgss_shmem_startup().
419  */
420  RequestAddinShmemSpace(pgss_memsize());
421  RequestNamedLWLockTranche("pg_stat_statements", 1);
422 
423  /*
424  * Install hooks.
425  */
426  prev_shmem_startup_hook = shmem_startup_hook;
427  shmem_startup_hook = pgss_shmem_startup;
428  prev_post_parse_analyze_hook = post_parse_analyze_hook;
429  post_parse_analyze_hook = pgss_post_parse_analyze;
430  prev_ExecutorStart = ExecutorStart_hook;
431  ExecutorStart_hook = pgss_ExecutorStart;
432  prev_ExecutorRun = ExecutorRun_hook;
433  ExecutorRun_hook = pgss_ExecutorRun;
434  prev_ExecutorFinish = ExecutorFinish_hook;
435  ExecutorFinish_hook = pgss_ExecutorFinish;
436  prev_ExecutorEnd = ExecutorEnd_hook;
437  ExecutorEnd_hook = pgss_ExecutorEnd;
438  prev_ProcessUtility = ProcessUtility_hook;
439  ProcessUtility_hook = pgss_ProcessUtility;
440 }
441 
442 /*
443  * Module unload callback
444  */
445 void
446 _PG_fini(void)
447 {
448  /* Uninstall hooks. */
449  shmem_startup_hook = prev_shmem_startup_hook;
450  post_parse_analyze_hook = prev_post_parse_analyze_hook;
451  ExecutorStart_hook = prev_ExecutorStart;
452  ExecutorRun_hook = prev_ExecutorRun;
453  ExecutorFinish_hook = prev_ExecutorFinish;
454  ExecutorEnd_hook = prev_ExecutorEnd;
455  ProcessUtility_hook = prev_ProcessUtility;
456 }
457 
458 /*
459  * shmem_startup hook: allocate or attach to shared memory,
460  * then load any pre-existing statistics from file.
461  * Also create and load the query-texts file, which is expected to exist
462  * (even if empty) while the module is enabled.
463  */
464 static void
465 pgss_shmem_startup(void)
466 {
467  bool found;
468  HASHCTL info;
469  FILE *file = NULL;
470  FILE *qfile = NULL;
471  uint32 header;
472  int32 num;
473  int32 pgver;
474  int32 i;
475  int buffer_size;
476  char *buffer = NULL;
477 
478  if (prev_shmem_startup_hook)
479  prev_shmem_startup_hook();
480 
481  /* reset in case this is a restart within the postmaster */
482  pgss = NULL;
483  pgss_hash = NULL;
484 
485  /*
486  * Create or attach to the shared memory state, including hash table
487  */
488  LWLockAcquire(AddinShmemInitLock, LW_EXCLUSIVE);
489 
490  pgss = ShmemInitStruct("pg_stat_statements",
491  sizeof(pgssSharedState),
492  &found);
493 
494  if (!found)
495  {
496  /* First time through ... */
497  pgss->lock = &(GetNamedLWLockTranche("pg_stat_statements"))->lock;
498  pgss->cur_median_usage = ASSUMED_MEDIAN_INIT;
499  pgss->mean_query_len = ASSUMED_LENGTH_INIT;
500  SpinLockInit(&pgss->mutex);
501  pgss->extent = 0;
502  pgss->n_writers = 0;
503  pgss->gc_count = 0;
504  }
505 
506  memset(&info, 0, sizeof(info));
507  info.keysize = sizeof(pgssHashKey);
508  info.entrysize = sizeof(pgssEntry);
509  pgss_hash = ShmemInitHash("pg_stat_statements hash",
510  pgss_max, pgss_max,
511  &info,
512  HASH_ELEM | HASH_BLOBS);
513 
514  LWLockRelease(AddinShmemInitLock);
515 
516  /*
517  * If we're in the postmaster (or a standalone backend...), set up a shmem
518  * exit hook to dump the statistics to disk.
519  */
520  if (!IsUnderPostmaster)
521  on_shmem_exit(pgss_shmem_shutdown, (Datum) 0);
522 
523  /*
524  * Done if some other process already completed our initialization.
525  */
526  if (found)
527  return;
528 
529  /*
530  * Note: we don't bother with locks here, because there should be no other
531  * processes running when this code is reached.
532  */
533 
534  /* Unlink query text file possibly left over from crash */
535  unlink(PGSS_TEXT_FILE);
536 
537  /* Allocate new query text temp file */
538  qfile = AllocateFile(PGSS_TEXT_FILE, PG_BINARY_W);
539  if (qfile == NULL)
540  goto write_error;
541 
542  /*
543  * If we were told not to load old statistics, we're done. (Note we do
544  * not try to unlink any old dump file in this case. This seems a bit
545  * questionable but it's the historical behavior.)
546  */
547  if (!pgss_save)
548  {
549  FreeFile(qfile);
550  return;
551  }
552 
553  /*
554  * Attempt to load old statistics from the dump file.
555  */
556  file = AllocateFile(PGSS_DUMP_FILE, PG_BINARY_R);
557  if (file == NULL)
558  {
559  if (errno != ENOENT)
560  goto read_error;
561  /* No existing persisted stats file, so we're done */
562  FreeFile(qfile);
563  return;
564  }
565 
566  buffer_size = 2048;
567  buffer = (char *) palloc(buffer_size);
568 
569  if (fread(&header, sizeof(uint32), 1, file) != 1 ||
570  fread(&pgver, sizeof(uint32), 1, file) != 1 ||
571  fread(&num, sizeof(int32), 1, file) != 1)
572  goto read_error;
573 
574  if (header != PGSS_FILE_HEADER ||
575  pgver != PGSS_PG_MAJOR_VERSION)
576  goto data_error;
577 
578  for (i = 0; i < num; i++)
579  {
580  pgssEntry temp;
581  pgssEntry *entry;
582  Size query_offset;
583 
584  if (fread(&temp, sizeof(pgssEntry), 1, file) != 1)
585  goto read_error;
586 
587  /* Encoding is the only field we can easily sanity-check */
588  if (!PG_VALID_BE_ENCODING(temp.encoding))
589  goto data_error;
590 
591  /* Resize buffer as needed */
592  if (temp.query_len >= buffer_size)
593  {
594  buffer_size = Max(buffer_size * 2, temp.query_len + 1);
595  buffer = repalloc(buffer, buffer_size);
596  }
597 
598  if (fread(buffer, 1, temp.query_len + 1, file) != temp.query_len + 1)
599  goto read_error;
600 
601  /* Should have a trailing null, but let's make sure */
602  buffer[temp.query_len] = '\0';
603 
604  /* Skip loading "sticky" entries */
605  if (temp.counters.calls == 0)
606  continue;
607 
608  /* Store the query text */
609  query_offset = pgss->extent;
610  if (fwrite(buffer, 1, temp.query_len + 1, qfile) != temp.query_len + 1)
611  goto write_error;
612  pgss->extent += temp.query_len + 1;
613 
614  /* make the hashtable entry (discards old entries if too many) */
615  entry = entry_alloc(&temp.key, query_offset, temp.query_len,
616  temp.encoding,
617  false);
618 
619  /* copy in the actual stats */
620  entry->counters = temp.counters;
621  }
622 
623  pfree(buffer);
624  FreeFile(file);
625  FreeFile(qfile);
626 
627  /*
628  * Remove the persisted stats file so it's not included in
629  * backups/replication standbys, etc. A new file will be written on next
630  * shutdown.
631  *
632  * Note: it's okay if the PGSS_TEXT_FILE is included in a basebackup,
633  * because we remove that file on startup; it acts inversely to
634  * PGSS_DUMP_FILE, in that it is only supposed to be around when the
635  * server is running, whereas PGSS_DUMP_FILE is only supposed to be around
636  * when the server is not running. Leaving the file creates no danger of
637  * a newly restored database having a spurious record of execution costs,
638  * which is what we're really concerned about here.
639  */
640  unlink(PGSS_DUMP_FILE);
641 
642  return;
643 
644 read_error:
645  ereport(LOG,
646  (errcode_for_file_access(),
647  errmsg("could not read file \"%s\": %m",
648  PGSS_DUMP_FILE)));
649  goto fail;
650 data_error:
651  ereport(LOG,
652  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
653  errmsg("ignoring invalid data in file \"%s\"",
654  PGSS_DUMP_FILE)));
655  goto fail;
656 write_error:
657  ereport(LOG,
658  (errcode_for_file_access(),
659  errmsg("could not write file \"%s\": %m",
660  PGSS_TEXT_FILE)));
661 fail:
662  if (buffer)
663  pfree(buffer);
664  if (file)
665  FreeFile(file);
666  if (qfile)
667  FreeFile(qfile);
668  /* If possible, throw away the bogus file; ignore any error */
669  unlink(PGSS_DUMP_FILE);
670 
671  /*
672  * Don't unlink PGSS_TEXT_FILE here; it should always be around while the
673  * server is running with pg_stat_statements enabled
674  */
675 }
676 
677 /*
678  * shmem_shutdown hook: Dump statistics into file.
679  *
680  * Note: we don't bother with acquiring lock, because there should be no
681  * other processes running when this is called.
682  */
683 static void
684 pgss_shmem_shutdown(int code, Datum arg)
685 {
686  FILE *file;
687  char *qbuffer = NULL;
688  Size qbuffer_size = 0;
689  HASH_SEQ_STATUS hash_seq;
690  int32 num_entries;
691  pgssEntry *entry;
692 
693  /* Don't try to dump during a crash. */
694  if (code)
695  return;
696 
697  /* Safety check ... shouldn't get here unless shmem is set up. */
698  if (!pgss || !pgss_hash)
699  return;
700 
701  /* Don't dump if told not to. */
702  if (!pgss_save)
703  return;
704 
705  file = AllocateFile(PGSS_DUMP_FILE ".tmp", PG_BINARY_W);
706  if (file == NULL)
707  goto error;
708 
709  if (fwrite(&PGSS_FILE_HEADER, sizeof(uint32), 1, file) != 1)
710  goto error;
711  if (fwrite(&PGSS_PG_MAJOR_VERSION, sizeof(uint32), 1, file) != 1)
712  goto error;
713  num_entries = hash_get_num_entries(pgss_hash);
714  if (fwrite(&num_entries, sizeof(int32), 1, file) != 1)
715  goto error;
716 
717  qbuffer = qtext_load_file(&qbuffer_size);
718  if (qbuffer == NULL)
719  goto error;
720 
721  /*
722  * When serializing to disk, we store query texts immediately after their
723  * entry data. Any orphaned query texts are thereby excluded.
724  */
725  hash_seq_init(&hash_seq, pgss_hash);
726  while ((entry = hash_seq_search(&hash_seq)) != NULL)
727  {
728  int len = entry->query_len;
729  char *qstr = qtext_fetch(entry->query_offset, len,
730  qbuffer, qbuffer_size);
731 
732  if (qstr == NULL)
733  continue; /* Ignore any entries with bogus texts */
734 
735  if (fwrite(entry, sizeof(pgssEntry), 1, file) != 1 ||
736  fwrite(qstr, 1, len + 1, file) != len + 1)
737  {
738  /* note: we assume hash_seq_term won't change errno */
739  hash_seq_term(&hash_seq);
740  goto error;
741  }
742  }
743 
744  free(qbuffer);
745  qbuffer = NULL;
746 
747  if (FreeFile(file))
748  {
749  file = NULL;
750  goto error;
751  }
752 
753  /*
754  * Rename file into place, so we atomically replace any old one.
755  */
756  (void) durable_rename(PGSS_DUMP_FILE ".tmp", PGSS_DUMP_FILE, LOG);
757 
758  /* Unlink query-texts file; it's not needed while shutdown */
759  unlink(PGSS_TEXT_FILE);
760 
761  return;
762 
763 error:
764  ereport(LOG,
765  (errcode_for_file_access(),
766  errmsg("could not write file \"%s\": %m",
767  PGSS_DUMP_FILE ".tmp")));
768  if (qbuffer)
769  free(qbuffer);
770  if (file)
771  FreeFile(file);
772  unlink(PGSS_DUMP_FILE ".tmp");
773  unlink(PGSS_TEXT_FILE);
774 }
775 
776 /*
777  * Post-parse-analysis hook: mark query with a queryId
778  */
779 static void
780 pgss_post_parse_analyze(ParseState *pstate, Query *query)
781 {
782  pgssJumbleState jstate;
783 
784  if (prev_post_parse_analyze_hook)
785  prev_post_parse_analyze_hook(pstate, query);
786 
787  /* Assert we didn't do this already */
788  Assert(query->queryId == UINT64CONST(0));
789 
790  /* Safety check... */
791  if (!pgss || !pgss_hash || !pgss_enabled())
792  return;
793 
794  /*
795  * Utility statements get queryId zero. We do this even in cases where
796  * the statement contains an optimizable statement for which a queryId
797  * could be derived (such as EXPLAIN or DECLARE CURSOR). For such cases,
798  * runtime control will first go through ProcessUtility and then the
799  * executor, and we don't want the executor hooks to do anything, since we
800  * are already measuring the statement's costs at the utility level.
801  */
802  if (query->utilityStmt)
803  {
804  query->queryId = UINT64CONST(0);
805  return;
806  }
807 
808  /* Set up workspace for query jumbling */
809  jstate.jumble = (unsigned char *) palloc(JUMBLE_SIZE);
810  jstate.jumble_len = 0;
811  jstate.clocations_buf_size = 32;
812  jstate.clocations = (pgssLocationLen *)
813  palloc(jstate.clocations_buf_size * sizeof(pgssLocationLen));
814  jstate.clocations_count = 0;
815  jstate.highest_extern_param_id = 0;
816 
817  /* Compute query ID and mark the Query node with it */
818  JumbleQuery(&jstate, query);
819  query->queryId =
820  DatumGetUInt64(hash_any_extended(jstate.jumble, jstate.jumble_len, 0));
821 
822  /*
823  * If we are unlucky enough to get a hash of zero, use 1 instead, to
824  * prevent confusion with the utility-statement case.
825  */
826  if (query->queryId == UINT64CONST(0))
827  query->queryId = UINT64CONST(1);
828 
829  /*
830  * If we were able to identify any ignorable constants, we immediately
831  * create a hash table entry for the query, so that we can record the
832  * normalized form of the query string. If there were no such constants,
833  * the normalized string would be the same as the query text anyway, so
834  * there's no need for an early entry.
835  */
836  if (jstate.clocations_count > 0)
837  pgss_store(pstate->p_sourcetext,
838  query->queryId,
839  query->stmt_location,
840  query->stmt_len,
841  0,
842  0,
843  NULL,
844  &jstate);
845 }
846 
847 /*
848  * ExecutorStart hook: start up tracking if needed
849  */
850 static void
851 pgss_ExecutorStart(QueryDesc *queryDesc, int eflags)
852 {
853  if (prev_ExecutorStart)
854  prev_ExecutorStart(queryDesc, eflags);
855  else
856  standard_ExecutorStart(queryDesc, eflags);
857 
858  /*
859  * If query has queryId zero, don't track it. This prevents double
860  * counting of optimizable statements that are directly contained in
861  * utility statements.
862  */
863  if (pgss_enabled() && queryDesc->plannedstmt->queryId != UINT64CONST(0))
864  {
865  /*
866  * Set up to track total elapsed time in ExecutorRun. Make sure the
867  * space is allocated in the per-query context so it will go away at
868  * ExecutorEnd.
869  */
870  if (queryDesc->totaltime == NULL)
871  {
872  MemoryContext oldcxt;
873 
874  oldcxt = MemoryContextSwitchTo(queryDesc->estate->es_query_cxt);
875  queryDesc->totaltime = InstrAlloc(1, INSTRUMENT_ALL);
876  MemoryContextSwitchTo(oldcxt);
877  }
878  }
879 }
880 
881 /*
882  * ExecutorRun hook: all we need do is track nesting depth
883  */
884 static void
885 pgss_ExecutorRun(QueryDesc *queryDesc, ScanDirection direction, uint64 count,
886  bool execute_once)
887 {
888  nested_level++;
889  PG_TRY();
890  {
891  if (prev_ExecutorRun)
892  prev_ExecutorRun(queryDesc, direction, count, execute_once);
893  else
894  standard_ExecutorRun(queryDesc, direction, count, execute_once);
895  }
896  PG_FINALLY();
897  {
898  nested_level--;
899  }
900  PG_END_TRY();
901 }
902 
903 /*
904  * ExecutorFinish hook: all we need do is track nesting depth
905  */
906 static void
907 pgss_ExecutorFinish(QueryDesc *queryDesc)
908 {
909  nested_level++;
910  PG_TRY();
911  {
912  if (prev_ExecutorFinish)
913  prev_ExecutorFinish(queryDesc);
914  else
915  standard_ExecutorFinish(queryDesc);
916  }
917  PG_FINALLY();
918  {
919  nested_level--;
920  }
921  PG_END_TRY();
922 }
923 
924 /*
925  * ExecutorEnd hook: store results if needed
926  */
927 static void
928 pgss_ExecutorEnd(QueryDesc *queryDesc)
929 {
930  uint64 queryId = queryDesc->plannedstmt->queryId;
931 
932  if (queryId != UINT64CONST(0) && queryDesc->totaltime && pgss_enabled())
933  {
934  /*
935  * Make sure stats accumulation is done. (Note: it's okay if several
936  * levels of hook all do this.)
937  */
938  InstrEndLoop(queryDesc->totaltime);
939 
940  pgss_store(queryDesc->sourceText,
941  queryId,
942  queryDesc->plannedstmt->stmt_location,
943  queryDesc->plannedstmt->stmt_len,
944  queryDesc->totaltime->total * 1000.0, /* convert to msec */
945  queryDesc->estate->es_processed,
946  &queryDesc->totaltime->bufusage,
947  NULL);
948  }
949 
950  if (prev_ExecutorEnd)
951  prev_ExecutorEnd(queryDesc);
952  else
953  standard_ExecutorEnd(queryDesc);
954 }
955 
956 /*
957  * ProcessUtility hook
958  */
959 static void
960 pgss_ProcessUtility(PlannedStmt *pstmt, const char *queryString,
961  ProcessUtilityContext context,
962  ParamListInfo params, QueryEnvironment *queryEnv,
963  DestReceiver *dest, char *completionTag)
964 {
965  Node *parsetree = pstmt->utilityStmt;
966 
967  /*
968  * If it's an EXECUTE statement, we don't track it and don't increment the
969  * nesting level. This allows the cycles to be charged to the underlying
970  * PREPARE instead (by the Executor hooks), which is much more useful.
971  *
972  * We also don't track execution of PREPARE. If we did, we would get one
973  * hash table entry for the PREPARE (with hash calculated from the query
974  * string), and then a different one with the same query string (but hash
975  * calculated from the query tree) would be used to accumulate costs of
976  * ensuing EXECUTEs. This would be confusing, and inconsistent with other
977  * cases where planning time is not included at all.
978  *
979  * Likewise, we don't track execution of DEALLOCATE.
980  */
981  if (pgss_track_utility && pgss_enabled() &&
982  !IsA(parsetree, ExecuteStmt) &&
983  !IsA(parsetree, PrepareStmt) &&
984  !IsA(parsetree, DeallocateStmt))
985  {
986  instr_time start;
987  instr_time duration;
988  uint64 rows;
989  BufferUsage bufusage_start,
990  bufusage;
991 
992  bufusage_start = pgBufferUsage;
993  INSTR_TIME_SET_CURRENT(start);
994 
995  nested_level++;
996  PG_TRY();
997  {
998  if (prev_ProcessUtility)
999  prev_ProcessUtility(pstmt, queryString,
1000  context, params, queryEnv,
1001  dest, completionTag);
1002  else
1003  standard_ProcessUtility(pstmt, queryString,
1004  context, params, queryEnv,
1005  dest, completionTag);
1006  }
1007  PG_FINALLY();
1008  {
1009  nested_level--;
1010  }
1011  PG_END_TRY();
1012 
1013  INSTR_TIME_SET_CURRENT(duration);
1014  INSTR_TIME_SUBTRACT(duration, start);
1015 
1016  /* parse command tag to retrieve the number of affected rows. */
1017  if (completionTag &&
1018  strncmp(completionTag, "COPY ", 5) == 0)
1019  rows = pg_strtouint64(completionTag + 5, NULL, 10);
1020  else
1021  rows = 0;
1022 
1023  /* calc differences of buffer counters. */
1024  bufusage.shared_blks_hit =
1025  pgBufferUsage.shared_blks_hit - bufusage_start.shared_blks_hit;
1026  bufusage.shared_blks_read =
1027  pgBufferUsage.shared_blks_read - bufusage_start.shared_blks_read;
1028  bufusage.shared_blks_dirtied =
1029  pgBufferUsage.shared_blks_dirtied - bufusage_start.shared_blks_dirtied;
1030  bufusage.shared_blks_written =
1031  pgBufferUsage.shared_blks_written - bufusage_start.shared_blks_written;
1032  bufusage.local_blks_hit =
1033  pgBufferUsage.local_blks_hit - bufusage_start.local_blks_hit;
1034  bufusage.local_blks_read =
1035  pgBufferUsage.local_blks_read - bufusage_start.local_blks_read;
1036  bufusage.local_blks_dirtied =
1037  pgBufferUsage.local_blks_dirtied - bufusage_start.local_blks_dirtied;
1038  bufusage.local_blks_written =
1039  pgBufferUsage.local_blks_written - bufusage_start.local_blks_written;
1040  bufusage.temp_blks_read =
1041  pgBufferUsage.temp_blks_read - bufusage_start.temp_blks_read;
1042  bufusage.temp_blks_written =
1043  pgBufferUsage.temp_blks_written - bufusage_start.temp_blks_written;
1044  bufusage.blk_read_time = pgBufferUsage.blk_read_time;
1045  INSTR_TIME_SUBTRACT(bufusage.blk_read_time, bufusage_start.blk_read_time);
1046  bufusage.blk_write_time = pgBufferUsage.blk_write_time;
1047  INSTR_TIME_SUBTRACT(bufusage.blk_write_time, bufusage_start.blk_write_time);
1048 
1049  pgss_store(queryString,
1050  0, /* signal that it's a utility stmt */
1051  pstmt->stmt_location,
1052  pstmt->stmt_len,
1053  INSTR_TIME_GET_MILLISEC(duration),
1054  rows,
1055  &bufusage,
1056  NULL);
1057  }
1058  else
1059  {
1060  if (prev_ProcessUtility)
1061  prev_ProcessUtility(pstmt, queryString,
1062  context, params, queryEnv,
1063  dest, completionTag);
1064  else
1065  standard_ProcessUtility(pstmt, queryString,
1066  context, params, queryEnv,
1067  dest, completionTag);
1068  }
1069 }
1070 
1071 /*
1072  * Given an arbitrarily long query string, produce a hash for the purposes of
1073  * identifying the query, without normalizing constants. Used when hashing
1074  * utility statements.
1075  */
1076 static uint64
1077 pgss_hash_string(const char *str, int len)
1078 {
1079  return DatumGetUInt64(hash_any_extended((const unsigned char *) str,
1080  len, 0));
1081 }
1082 
1083 /*
1084  * Store some statistics for a statement.
1085  *
1086  * If queryId is 0 then this is a utility statement and we should compute
1087  * a suitable queryId internally.
1088  *
1089  * If jstate is not NULL then we're trying to create an entry for which
1090  * we have no statistics as yet; we just want to record the normalized
1091  * query string. total_time, rows, bufusage are ignored in this case.
1092  */
1093 static void
1094 pgss_store(const char *query, uint64 queryId,
1095  int query_location, int query_len,
1096  double total_time, uint64 rows,
1097  const BufferUsage *bufusage,
1098  pgssJumbleState *jstate)
1099 {
1100  pgssHashKey key;
1101  pgssEntry *entry;
1102  char *norm_query = NULL;
1103  int encoding = GetDatabaseEncoding();
1104 
1105  Assert(query != NULL);
1106 
1107  /* Safety check... */
1108  if (!pgss || !pgss_hash)
1109  return;
1110 
1111  /*
1112  * Confine our attention to the relevant part of the string, if the query
1113  * is a portion of a multi-statement source string.
1114  *
1115  * First apply starting offset, unless it's -1 (unknown).
1116  */
1117  if (query_location >= 0)
1118  {
1119  Assert(query_location <= strlen(query));
1120  query += query_location;
1121  /* Length of 0 (or -1) means "rest of string" */
1122  if (query_len <= 0)
1123  query_len = strlen(query);
1124  else
1125  Assert(query_len <= strlen(query));
1126  }
1127  else
1128  {
1129  /* If query location is unknown, distrust query_len as well */
1130  query_location = 0;
1131  query_len = strlen(query);
1132  }
1133 
1134  /*
1135  * Discard leading and trailing whitespace, too. Use scanner_isspace()
1136  * not libc's isspace(), because we want to match the lexer's behavior.
1137  */
1138  while (query_len > 0 && scanner_isspace(query[0]))
1139  query++, query_location++, query_len--;
1140  while (query_len > 0 && scanner_isspace(query[query_len - 1]))
1141  query_len--;
1142 
1143  /*
1144  * For utility statements, we just hash the query string to get an ID.
1145  */
1146  if (queryId == UINT64CONST(0))
1147  {
1148  queryId = pgss_hash_string(query, query_len);
1149 
1150  /*
1151  * If we are unlucky enough to get a hash of zero(invalid), use
1152  * queryID as 2 instead, queryID 1 is already in use for normal
1153  * statements.
1154  */
1155  if (queryId == UINT64CONST(0))
1156  queryId = UINT64CONST(2);
1157  }
1158 
1159  /* Set up key for hashtable search */
1160  key.userid = GetUserId();
1161  key.dbid = MyDatabaseId;
1162  key.queryid = queryId;
1163 
1164  /* Lookup the hash table entry with shared lock. */
1165  LWLockAcquire(pgss->lock, LW_SHARED);
1166 
1167  entry = (pgssEntry *) hash_search(pgss_hash, &key, HASH_FIND, NULL);
1168 
1169  /* Create new entry, if not present */
1170  if (!entry)
1171  {
1172  Size query_offset;
1173  int gc_count;
1174  bool stored;
1175  bool do_gc;
1176 
1177  /*
1178  * Create a new, normalized query string if caller asked. We don't
1179  * need to hold the lock while doing this work. (Note: in any case,
1180  * it's possible that someone else creates a duplicate hashtable entry
1181  * in the interval where we don't hold the lock below. That case is
1182  * handled by entry_alloc.)
1183  */
1184  if (jstate)
1185  {
1186  LWLockRelease(pgss->lock);
1187  norm_query = generate_normalized_query(jstate, query,
1188  query_location,
1189  &query_len,
1190  encoding);
1191  LWLockAcquire(pgss->lock, LW_SHARED);
1192  }
1193 
1194  /* Append new query text to file with only shared lock held */
1195  stored = qtext_store(norm_query ? norm_query : query, query_len,
1196  &query_offset, &gc_count);
1197 
1198  /*
1199  * Determine whether we need to garbage collect external query texts
1200  * while the shared lock is still held. This micro-optimization
1201  * avoids taking the time to decide this while holding exclusive lock.
1202  */
1203  do_gc = need_gc_qtexts();
1204 
1205  /* Need exclusive lock to make a new hashtable entry - promote */
1206  LWLockRelease(pgss->lock);
1207  LWLockAcquire(pgss->lock, LW_EXCLUSIVE);
1208 
1209  /*
1210  * A garbage collection may have occurred while we weren't holding the
1211  * lock. In the unlikely event that this happens, the query text we
1212  * stored above will have been garbage collected, so write it again.
1213  * This should be infrequent enough that doing it while holding
1214  * exclusive lock isn't a performance problem.
1215  */
1216  if (!stored || pgss->gc_count != gc_count)
1217  stored = qtext_store(norm_query ? norm_query : query, query_len,
1218  &query_offset, NULL);
1219 
1220  /* If we failed to write to the text file, give up */
1221  if (!stored)
1222  goto done;
1223 
1224  /* OK to create a new hashtable entry */
1225  entry = entry_alloc(&key, query_offset, query_len, encoding,
1226  jstate != NULL);
1227 
1228  /* If needed, perform garbage collection while exclusive lock held */
1229  if (do_gc)
1230  gc_qtexts();
1231  }
1232 
1233  /* Increment the counts, except when jstate is not NULL */
1234  if (!jstate)
1235  {
1236  /*
1237  * Grab the spinlock while updating the counters (see comment about
1238  * locking rules at the head of the file)
1239  */
1240  volatile pgssEntry *e = (volatile pgssEntry *) entry;
1241 
1242  SpinLockAcquire(&e->mutex);
1243 
1244  /* "Unstick" entry if it was previously sticky */
1245  if (e->counters.calls == 0)
1246  e->counters.usage = USAGE_INIT;
1247 
1248  e->counters.calls += 1;
1249  e->counters.total_time += total_time;
1250  if (e->counters.calls == 1)
1251  {
1252  e->counters.min_time = total_time;
1253  e->counters.max_time = total_time;
1254  e->counters.mean_time = total_time;
1255  }
1256  else
1257  {
1258  /*
1259  * Welford's method for accurately computing variance. See
1260  * <http://www.johndcook.com/blog/standard_deviation/>
1261  */
1262  double old_mean = e->counters.mean_time;
1263 
1264  e->counters.mean_time +=
1265  (total_time - old_mean) / e->counters.calls;
1266  e->counters.sum_var_time +=
1267  (total_time - old_mean) * (total_time - e->counters.mean_time);
1268 
1269  /* calculate min and max time */
1270  if (e->counters.min_time > total_time)
1271  e->counters.min_time = total_time;
1272  if (e->counters.max_time < total_time)
1273  e->counters.max_time = total_time;
1274  }
1275  e->counters.rows += rows;
1276  e->counters.shared_blks_hit += bufusage->shared_blks_hit;
1277  e->counters.shared_blks_read += bufusage->shared_blks_read;
1278  e->counters.shared_blks_dirtied += bufusage->shared_blks_dirtied;
1279  e->counters.shared_blks_written += bufusage->shared_blks_written;
1280  e->counters.local_blks_hit += bufusage->local_blks_hit;
1281  e->counters.local_blks_read += bufusage->local_blks_read;
1282  e->counters.local_blks_dirtied += bufusage->local_blks_dirtied;
1283  e->counters.local_blks_written += bufusage->local_blks_written;
1284  e->counters.temp_blks_read += bufusage->temp_blks_read;
1285  e->counters.temp_blks_written += bufusage->temp_blks_written;
1286  e->counters.blk_read_time += INSTR_TIME_GET_MILLISEC(bufusage->blk_read_time);
1287  e->counters.blk_write_time += INSTR_TIME_GET_MILLISEC(bufusage->blk_write_time);
1288  e->counters.usage += USAGE_EXEC(total_time);
1289 
1290  SpinLockRelease(&e->mutex);
1291  }
1292 
1293 done:
1294  LWLockRelease(pgss->lock);
1295 
1296  /* We postpone this clean-up until we're out of the lock */
1297  if (norm_query)
1298  pfree(norm_query);
1299 }
1300 
1301 /*
1302  * Reset statement statistics corresponding to userid, dbid, and queryid.
1303  */
1304 Datum
1305 pg_stat_statements_reset_1_7(PG_FUNCTION_ARGS)
1306 {
1307  Oid userid;
1308  Oid dbid;
1309  uint64 queryid;
1310 
1311  userid = PG_GETARG_OID(0);
1312  dbid = PG_GETARG_OID(1);
1313  queryid = (uint64) PG_GETARG_INT64(2);
1314 
1315  entry_reset(userid, dbid, queryid);
1316 
1317  PG_RETURN_VOID();
1318 }
1319 
1320 /*
1321  * Reset statement statistics.
1322  */
1323 Datum
1324 pg_stat_statements_reset(PG_FUNCTION_ARGS)
1325 {
1326  entry_reset(0, 0, 0);
1327 
1328  PG_RETURN_VOID();
1329 }
1330 
1331 /* Number of output arguments (columns) for various API versions */
1332 #define PG_STAT_STATEMENTS_COLS_V1_0 14
1333 #define PG_STAT_STATEMENTS_COLS_V1_1 18
1334 #define PG_STAT_STATEMENTS_COLS_V1_2 19
1335 #define PG_STAT_STATEMENTS_COLS_V1_3 23
1336 #define PG_STAT_STATEMENTS_COLS 23 /* maximum of above */
1337 
1338 /*
1339  * Retrieve statement statistics.
1340  *
1341  * The SQL API of this function has changed multiple times, and will likely
1342  * do so again in future. To support the case where a newer version of this
1343  * loadable module is being used with an old SQL declaration of the function,
1344  * we continue to support the older API versions. For 1.2 and later, the
1345  * expected API version is identified by embedding it in the C name of the
1346  * function. Unfortunately we weren't bright enough to do that for 1.1.
1347  */
1348 Datum
1349 pg_stat_statements_1_3(PG_FUNCTION_ARGS)
1350 {
1351  bool showtext = PG_GETARG_BOOL(0);
1352 
1353  pg_stat_statements_internal(fcinfo, PGSS_V1_3, showtext);
1354 
1355  return (Datum) 0;
1356 }
1357 
1358 Datum
1359 pg_stat_statements_1_2(PG_FUNCTION_ARGS)
1360 {
1361  bool showtext = PG_GETARG_BOOL(0);
1362 
1363  pg_stat_statements_internal(fcinfo, PGSS_V1_2, showtext);
1364 
1365  return (Datum) 0;
1366 }
1367 
1368 /*
1369  * Legacy entry point for pg_stat_statements() API versions 1.0 and 1.1.
1370  * This can be removed someday, perhaps.
1371  */
1372 Datum
1373 pg_stat_statements(PG_FUNCTION_ARGS)
1374 {
1375  /* If it's really API 1.1, we'll figure that out below */
1376  pg_stat_statements_internal(fcinfo, PGSS_V1_0, true);
1377 
1378  return (Datum) 0;
1379 }
1380 
1381 /* Common code for all versions of pg_stat_statements() */
1382 static void
1383 pg_stat_statements_internal(FunctionCallInfo fcinfo,
1384  pgssVersion api_version,
1385  bool showtext)
1386 {
1387  ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
1388  TupleDesc tupdesc;
1389  Tuplestorestate *tupstore;
1390  MemoryContext per_query_ctx;
1391  MemoryContext oldcontext;
1392  Oid userid = GetUserId();
1393  bool is_allowed_role = false;
1394  char *qbuffer = NULL;
1395  Size qbuffer_size = 0;
1396  Size extent = 0;
1397  int gc_count = 0;
1398  HASH_SEQ_STATUS hash_seq;
1399  pgssEntry *entry;
1400 
1401  /* Superusers or members of pg_read_all_stats members are allowed */
1402  is_allowed_role = is_member_of_role(GetUserId(), DEFAULT_ROLE_READ_ALL_STATS);
1403 
1404  /* hash table must exist already */
1405  if (!pgss || !pgss_hash)
1406  ereport(ERROR,
1407  (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
1408  errmsg("pg_stat_statements must be loaded via shared_preload_libraries")));
1409 
1410  /* check to see if caller supports us returning a tuplestore */
1411  if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo))
1412  ereport(ERROR,
1413  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1414  errmsg("set-valued function called in context that cannot accept a set")));
1415  if (!(rsinfo->allowedModes & SFRM_Materialize))
1416  ereport(ERROR,
1417  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1418  errmsg("materialize mode required, but it is not allowed in this context")));
1419 
1420  /* Switch into long-lived context to construct returned data structures */
1421  per_query_ctx = rsinfo->econtext->ecxt_per_query_memory;
1422  oldcontext = MemoryContextSwitchTo(per_query_ctx);
1423 
1424  /* Build a tuple descriptor for our result type */
1425  if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
1426  elog(ERROR, "return type must be a row type");
1427 
1428  /*
1429  * Check we have the expected number of output arguments. Aside from
1430  * being a good safety check, we need a kluge here to detect API version
1431  * 1.1, which was wedged into the code in an ill-considered way.
1432  */
1433  switch (tupdesc->natts)
1434  {
1435  case PG_STAT_STATEMENTS_COLS_V1_0:
1436  if (api_version != PGSS_V1_0)
1437  elog(ERROR, "incorrect number of output arguments");
1438  break;
1439  case PG_STAT_STATEMENTS_COLS_V1_1:
1440  /* pg_stat_statements() should have told us 1.0 */
1441  if (api_version != PGSS_V1_0)
1442  elog(ERROR, "incorrect number of output arguments");
1443  api_version = PGSS_V1_1;
1444  break;
1445  case PG_STAT_STATEMENTS_COLS_V1_2:
1446  if (api_version != PGSS_V1_2)
1447  elog(ERROR, "incorrect number of output arguments");
1448  break;
1449  case PG_STAT_STATEMENTS_COLS_V1_3:
1450  if (api_version != PGSS_V1_3)
1451  elog(ERROR, "incorrect number of output arguments");
1452  break;
1453  default:
1454  elog(ERROR, "incorrect number of output arguments");
1455  }
1456 
1457  tupstore = tuplestore_begin_heap(true, false, work_mem);
1458  rsinfo->returnMode = SFRM_Materialize;
1459  rsinfo->setResult = tupstore;
1460  rsinfo->setDesc = tupdesc;
1461 
1462  MemoryContextSwitchTo(oldcontext);
1463 
1464  /*
1465  * We'd like to load the query text file (if needed) while not holding any
1466  * lock on pgss->lock. In the worst case we'll have to do this again
1467  * after we have the lock, but it's unlikely enough to make this a win
1468  * despite occasional duplicated work. We need to reload if anybody
1469  * writes to the file (either a retail qtext_store(), or a garbage
1470  * collection) between this point and where we've gotten shared lock. If
1471  * a qtext_store is actually in progress when we look, we might as well
1472  * skip the speculative load entirely.
1473  */
1474  if (showtext)
1475  {
1476  int n_writers;
1477 
1478  /* Take the mutex so we can examine variables */
1479  {
1480  volatile pgssSharedState *s = (volatile pgssSharedState *) pgss;
1481 
1482  SpinLockAcquire(&s->mutex);
1483  extent = s->extent;
1484  n_writers = s->n_writers;
1485  gc_count = s->gc_count;
1486  SpinLockRelease(&s->mutex);
1487  }
1488 
1489  /* No point in loading file now if there are active writers */
1490  if (n_writers == 0)
1491  qbuffer = qtext_load_file(&qbuffer_size);
1492  }
1493 
1494  /*
1495  * Get shared lock, load or reload the query text file if we must, and
1496  * iterate over the hashtable entries.
1497  *
1498  * With a large hash table, we might be holding the lock rather longer
1499  * than one could wish. However, this only blocks creation of new hash
1500  * table entries, and the larger the hash table the less likely that is to
1501  * be needed. So we can hope this is okay. Perhaps someday we'll decide
1502  * we need to partition the hash table to limit the time spent holding any
1503  * one lock.
1504  */
1505  LWLockAcquire(pgss->lock, LW_SHARED);
1506 
1507  if (showtext)
1508  {
1509  /*
1510  * Here it is safe to examine extent and gc_count without taking the
1511  * mutex. Note that although other processes might change
1512  * pgss->extent just after we look at it, the strings they then write
1513  * into the file cannot yet be referenced in the hashtable, so we
1514  * don't care whether we see them or not.
1515  *
1516  * If qtext_load_file fails, we just press on; we'll return NULL for
1517  * every query text.
1518  */
1519  if (qbuffer == NULL ||
1520  pgss->extent != extent ||
1521  pgss->gc_count != gc_count)
1522  {
1523  if (qbuffer)
1524  free(qbuffer);
1525  qbuffer = qtext_load_file(&qbuffer_size);
1526  }
1527  }
1528 
1529  hash_seq_init(&hash_seq, pgss_hash);
1530  while ((entry = hash_seq_search(&hash_seq)) != NULL)
1531  {
1532  Datum values[PG_STAT_STATEMENTS_COLS];
1533  bool nulls[PG_STAT_STATEMENTS_COLS];
1534  int i = 0;
1535  Counters tmp;
1536  double stddev;
1537  int64 queryid = entry->key.queryid;
1538 
1539  memset(values, 0, sizeof(values));
1540  memset(nulls, 0, sizeof(nulls));
1541 
1542  values[i++] = ObjectIdGetDatum(entry->key.userid);
1543  values[i++] = ObjectIdGetDatum(entry->key.dbid);
1544 
1545  if (is_allowed_role || entry->key.userid == userid)
1546  {
1547  if (api_version >= PGSS_V1_2)
1548  values[i++] = Int64GetDatumFast(queryid);
1549 
1550  if (showtext)
1551  {
1552  char *qstr = qtext_fetch(entry->query_offset,
1553  entry->query_len,
1554  qbuffer,
1555  qbuffer_size);
1556 
1557  if (qstr)
1558  {
1559  char *enc;
1560 
1561  enc = pg_any_to_server(qstr,
1562  entry->query_len,
1563  entry->encoding);
1564 
1565  values[i++] = CStringGetTextDatum(enc);
1566 
1567  if (enc != qstr)
1568  pfree(enc);
1569  }
1570  else
1571  {
1572  /* Just return a null if we fail to find the text */
1573  nulls[i++] = true;
1574  }
1575  }
1576  else
1577  {
1578  /* Query text not requested */
1579  nulls[i++] = true;
1580  }
1581  }
1582  else
1583  {
1584  /* Don't show queryid */
1585  if (api_version >= PGSS_V1_2)
1586  nulls[i++] = true;
1587 
1588  /*
1589  * Don't show query text, but hint as to the reason for not doing
1590  * so if it was requested
1591  */
1592  if (showtext)
1593  values[i++] = CStringGetTextDatum("<insufficient privilege>");
1594  else
1595  nulls[i++] = true;
1596  }
1597 
1598  /* copy counters to a local variable to keep locking time short */
1599  {
1600  volatile pgssEntry *e = (volatile pgssEntry *) entry;
1601 
1602  SpinLockAcquire(&e->mutex);
1603  tmp = e->counters;
1604  SpinLockRelease(&e->mutex);
1605  }
1606 
1607  /* Skip entry if unexecuted (ie, it's a pending "sticky" entry) */
1608  if (tmp.calls == 0)
1609  continue;
1610 
1611  values[i++] = Int64GetDatumFast(tmp.calls);
1612  values[i++] = Float8GetDatumFast(tmp.total_time);
1613  if (api_version >= PGSS_V1_3)
1614  {
1615  values[i++] = Float8GetDatumFast(tmp.min_time);
1616  values[i++] = Float8GetDatumFast(tmp.max_time);
1617  values[i++] = Float8GetDatumFast(tmp.mean_time);
1618 
1619  /*
1620  * Note we are calculating the population variance here, not the
1621  * sample variance, as we have data for the whole population, so
1622  * Bessel's correction is not used, and we don't divide by
1623  * tmp.calls - 1.
1624  */
1625  if (tmp.calls > 1)
1626  stddev = sqrt(tmp.sum_var_time / tmp.calls);
1627  else
1628  stddev = 0.0;
1629  values[i++] = Float8GetDatumFast(stddev);
1630  }
1631  values[i++] = Int64GetDatumFast(tmp.rows);
1632  values[i++] = Int64GetDatumFast(tmp.shared_blks_hit);
1633  values[i++] = Int64GetDatumFast(tmp.shared_blks_read);
1634  if (api_version >= PGSS_V1_1)
1635  values[i++] = Int64GetDatumFast(tmp.shared_blks_dirtied);
1636  values[i++] = Int64GetDatumFast(tmp.shared_blks_written);
1637  values[i++] = Int64GetDatumFast(tmp.local_blks_hit);
1638  values[i++] = Int64GetDatumFast(tmp.local_blks_read);
1639  if (api_version >= PGSS_V1_1)
1640  values[i++] = Int64GetDatumFast(tmp.local_blks_dirtied);
1641  values[i++] = Int64GetDatumFast(tmp.local_blks_written);
1642  values[i++] = Int64GetDatumFast(tmp.temp_blks_read);
1643  values[i++] = Int64GetDatumFast(tmp.temp_blks_written);
1644  if (api_version >= PGSS_V1_1)
1645  {
1646  values[i++] = Float8GetDatumFast(tmp.blk_read_time);
1647  values[i++] = Float8GetDatumFast(tmp.blk_write_time);
1648  }
1649 
1650  Assert(i == (api_version == PGSS_V1_0 ? PG_STAT_STATEMENTS_COLS_V1_0 :
1651  api_version == PGSS_V1_1 ? PG_STAT_STATEMENTS_COLS_V1_1 :
1652  api_version == PGSS_V1_2 ? PG_STAT_STATEMENTS_COLS_V1_2 :
1653  api_version == PGSS_V1_3 ? PG_STAT_STATEMENTS_COLS_V1_3 :
1654  -1 /* fail if you forget to update this assert */ ));
1655 
1656  tuplestore_putvalues(tupstore, tupdesc, values, nulls);
1657  }
1658 
1659  /* clean up and return the tuplestore */
1660  LWLockRelease(pgss->lock);
1661 
1662  if (qbuffer)
1663  free(qbuffer);
1664 
1665  tuplestore_donestoring(tupstore);
1666 }
1667 
1668 /*
1669  * Estimate shared memory space needed.
1670  */
1671 static Size
1672 pgss_memsize(void)
1673 {
1674  Size size;
1675 
1676  size = MAXALIGN(sizeof(pgssSharedState));
1677  size = add_size(size, hash_estimate_size(pgss_max, sizeof(pgssEntry)));
1678 
1679  return size;
1680 }
1681 
1682 /*
1683  * Allocate a new hashtable entry.
1684  * caller must hold an exclusive lock on pgss->lock
1685  *
1686  * "query" need not be null-terminated; we rely on query_len instead
1687  *
1688  * If "sticky" is true, make the new entry artificially sticky so that it will
1689  * probably still be there when the query finishes execution. We do this by
1690  * giving it a median usage value rather than the normal value. (Strictly
1691  * speaking, query strings are normalized on a best effort basis, though it
1692  * would be difficult to demonstrate this even under artificial conditions.)
1693  *
1694  * Note: despite needing exclusive lock, it's not an error for the target
1695  * entry to already exist. This is because pgss_store releases and
1696  * reacquires lock after failing to find a match; so someone else could
1697  * have made the entry while we waited to get exclusive lock.
1698  */
1699 static pgssEntry *
1700 entry_alloc(pgssHashKey *key, Size query_offset, int query_len, int encoding,
1701  bool sticky)
1702 {
1703  pgssEntry *entry;
1704  bool found;
1705 
1706  /* Make space if needed */
1707  while (hash_get_num_entries(pgss_hash) >= pgss_max)
1708  entry_dealloc();
1709 
1710  /* Find or create an entry with desired hash code */
1711  entry = (pgssEntry *) hash_search(pgss_hash, key, HASH_ENTER, &found);
1712 
1713  if (!found)
1714  {
1715  /* New entry, initialize it */
1716 
1717  /* reset the statistics */
1718  memset(&entry->counters, 0, sizeof(Counters));
1719  /* set the appropriate initial usage count */
1720  entry->counters.usage = sticky ? pgss->cur_median_usage : USAGE_INIT;
1721  /* re-initialize the mutex each time ... we assume no one using it */
1722  SpinLockInit(&entry->mutex);
1723  /* ... and don't forget the query text metadata */
1724  Assert(query_len >= 0);
1725  entry->query_offset = query_offset;
1726  entry->query_len = query_len;
1727  entry->encoding = encoding;
1728  }
1729 
1730  return entry;
1731 }
1732 
1733 /*
1734  * qsort comparator for sorting into increasing usage order
1735  */
1736 static int
1737 entry_cmp(const void *lhs, const void *rhs)
1738 {
1739  double l_usage = (*(pgssEntry *const *) lhs)->counters.usage;
1740  double r_usage = (*(pgssEntry *const *) rhs)->counters.usage;
1741 
1742  if (l_usage < r_usage)
1743  return -1;
1744  else if (l_usage > r_usage)
1745  return +1;
1746  else
1747  return 0;
1748 }
1749 
1750 /*
1751  * Deallocate least-used entries.
1752  *
1753  * Caller must hold an exclusive lock on pgss->lock.
1754  */
1755 static void
1756 entry_dealloc(void)
1757 {
1758  HASH_SEQ_STATUS hash_seq;
1759  pgssEntry **entries;
1760  pgssEntry *entry;
1761  int nvictims;
1762  int i;
1763  Size tottextlen;
1764  int nvalidtexts;
1765 
1766  /*
1767  * Sort entries by usage and deallocate USAGE_DEALLOC_PERCENT of them.
1768  * While we're scanning the table, apply the decay factor to the usage
1769  * values, and update the mean query length.
1770  *
1771  * Note that the mean query length is almost immediately obsolete, since
1772  * we compute it before not after discarding the least-used entries.
1773  * Hopefully, that doesn't affect the mean too much; it doesn't seem worth
1774  * making two passes to get a more current result. Likewise, the new
1775  * cur_median_usage includes the entries we're about to zap.
1776  */
1777 
1778  entries = palloc(hash_get_num_entries(pgss_hash) * sizeof(pgssEntry *));
1779 
1780  i = 0;
1781  tottextlen = 0;
1782  nvalidtexts = 0;
1783 
1784  hash_seq_init(&hash_seq, pgss_hash);
1785  while ((entry = hash_seq_search(&hash_seq)) != NULL)
1786  {
1787  entries[i++] = entry;
1788  /* "Sticky" entries get a different usage decay rate. */
1789  if (entry->counters.calls == 0)
1790  entry->counters.usage *= STICKY_DECREASE_FACTOR;
1791  else
1792  entry->counters.usage *= USAGE_DECREASE_FACTOR;
1793  /* In the mean length computation, ignore dropped texts. */
1794  if (entry->query_len >= 0)
1795  {
1796  tottextlen += entry->query_len + 1;
1797  nvalidtexts++;
1798  }
1799  }
1800 
1801  /* Sort into increasing order by usage */
1802  qsort(entries, i, sizeof(pgssEntry *), entry_cmp);
1803 
1804  /* Record the (approximate) median usage */
1805  if (i > 0)
1806  pgss->cur_median_usage = entries[i / 2]->counters.usage;
1807  /* Record the mean query length */
1808  if (nvalidtexts > 0)
1809  pgss->mean_query_len = tottextlen / nvalidtexts;
1810  else
1811  pgss->mean_query_len = ASSUMED_LENGTH_INIT;
1812 
1813  /* Now zap an appropriate fraction of lowest-usage entries */
1814  nvictims = Max(10, i * USAGE_DEALLOC_PERCENT / 100);
1815  nvictims = Min(nvictims, i);
1816 
1817  for (i = 0; i < nvictims; i++)
1818  {
1819  hash_search(pgss_hash, &entries[i]->key, HASH_REMOVE, NULL);
1820  }
1821 
1822  pfree(entries);
1823 }
1824 
1825 /*
1826  * Given a query string (not necessarily null-terminated), allocate a new
1827  * entry in the external query text file and store the string there.
1828  *
1829  * If successful, returns true, and stores the new entry's offset in the file
1830  * into *query_offset. Also, if gc_count isn't NULL, *gc_count is set to the
1831  * number of garbage collections that have occurred so far.
1832  *
1833  * On failure, returns false.
1834  *
1835  * At least a shared lock on pgss->lock must be held by the caller, so as
1836  * to prevent a concurrent garbage collection. Share-lock-holding callers
1837  * should pass a gc_count pointer to obtain the number of garbage collections,
1838  * so that they can recheck the count after obtaining exclusive lock to
1839  * detect whether a garbage collection occurred (and removed this entry).
1840  */
1841 static bool
1842 qtext_store(const char *query, int query_len,
1843  Size *query_offset, int *gc_count)
1844 {
1845  Size off;
1846  int fd;
1847 
1848  /*
1849  * We use a spinlock to protect extent/n_writers/gc_count, so that
1850  * multiple processes may execute this function concurrently.
1851  */
1852  {
1853  volatile pgssSharedState *s = (volatile pgssSharedState *) pgss;
1854 
1855  SpinLockAcquire(&s->mutex);
1856  off = s->extent;
1857  s->extent += query_len + 1;
1858  s->n_writers++;
1859  if (gc_count)
1860  *gc_count = s->gc_count;
1861  SpinLockRelease(&s->mutex);
1862  }
1863 
1864  *query_offset = off;
1865 
1866  /* Now write the data into the successfully-reserved part of the file */
1867  fd = OpenTransientFile(PGSS_TEXT_FILE, O_RDWR | O_CREAT | PG_BINARY);
1868  if (fd < 0)
1869  goto error;
1870 
1871  if (lseek(fd, off, SEEK_SET) != off)
1872  goto error;
1873 
1874  if (write(fd, query, query_len) != query_len)
1875  goto error;
1876  if (write(fd, "\0", 1) != 1)
1877  goto error;
1878 
1879  CloseTransientFile(fd);
1880 
1881  /* Mark our write complete */
1882  {
1883  volatile pgssSharedState *s = (volatile pgssSharedState *) pgss;
1884 
1885  SpinLockAcquire(&s->mutex);
1886  s->n_writers--;
1887  SpinLockRelease(&s->mutex);
1888  }
1889 
1890  return true;
1891 
1892 error:
1893  ereport(LOG,
1894  (errcode_for_file_access(),
1895  errmsg("could not write file \"%s\": %m",
1896  PGSS_TEXT_FILE)));
1897 
1898  if (fd >= 0)
1899  CloseTransientFile(fd);
1900 
1901  /* Mark our write complete */
1902  {
1903  volatile pgssSharedState *s = (volatile pgssSharedState *) pgss;
1904 
1905  SpinLockAcquire(&s->mutex);
1906  s->n_writers--;
1907  SpinLockRelease(&s->mutex);
1908  }
1909 
1910  return false;
1911 }
1912 
1913 /*
1914  * Read the external query text file into a malloc'd buffer.
1915  *
1916  * Returns NULL (without throwing an error) if unable to read, eg
1917  * file not there or insufficient memory.
1918  *
1919  * On success, the buffer size is also returned into *buffer_size.
1920  *
1921  * This can be called without any lock on pgss->lock, but in that case
1922  * the caller is responsible for verifying that the result is sane.
1923  */
1924 static char *
1925 qtext_load_file(Size *buffer_size)
1926 {
1927  char *buf;
1928  int fd;
1929  struct stat stat;
1930 
1931  fd = OpenTransientFile(PGSS_TEXT_FILE, O_RDONLY | PG_BINARY);
1932  if (fd < 0)
1933  {
1934  if (errno != ENOENT)
1935  ereport(LOG,
1936  (errcode_for_file_access(),
1937  errmsg("could not read file \"%s\": %m",
1938  PGSS_TEXT_FILE)));
1939  return NULL;
1940  }
1941 
1942  /* Get file length */
1943  if (fstat(fd, &stat))
1944  {
1945  ereport(LOG,
1946  (errcode_for_file_access(),
1947  errmsg("could not stat file \"%s\": %m",
1948  PGSS_TEXT_FILE)));
1949  CloseTransientFile(fd);
1950  return NULL;
1951  }
1952 
1953  /* Allocate buffer; beware that off_t might be wider than size_t */
1954  if (stat.st_size <= MaxAllocHugeSize)
1955  buf = (char *) malloc(stat.st_size);
1956  else
1957  buf = NULL;
1958  if (buf == NULL)
1959  {
1960  ereport(LOG,
1961  (errcode(ERRCODE_OUT_OF_MEMORY),
1962  errmsg("out of memory"),
1963  errdetail("Could not allocate enough memory to read file \"%s\".",
1964  PGSS_TEXT_FILE)));
1965  CloseTransientFile(fd);
1966  return NULL;
1967  }
1968 
1969  /*
1970  * OK, slurp in the file. If we get a short read and errno doesn't get
1971  * set, the reason is probably that garbage collection truncated the file
1972  * since we did the fstat(), so we don't log a complaint --- but we don't
1973  * return the data, either, since it's most likely corrupt due to
1974  * concurrent writes from garbage collection.
1975  */
1976  errno = 0;
1977  if (read(fd, buf, stat.st_size) != stat.st_size)
1978  {
1979  if (errno)
1980  ereport(LOG,
1981  (errcode_for_file_access(),
1982  errmsg("could not read file \"%s\": %m",
1983  PGSS_TEXT_FILE)));
1984  free(buf);
1985  CloseTransientFile(fd);
1986  return NULL;
1987  }
1988 
1989  if (CloseTransientFile(fd) != 0)
1990  ereport(LOG,
1991  (errcode_for_file_access(),
1992  errmsg("could not close file \"%s\": %m", PGSS_TEXT_FILE)));
1993 
1994  *buffer_size = stat.st_size;
1995  return buf;
1996 }
1997 
1998 /*
1999  * Locate a query text in the file image previously read by qtext_load_file().
2000  *
2001  * We validate the given offset/length, and return NULL if bogus. Otherwise,
2002  * the result points to a null-terminated string within the buffer.
2003  */
2004 static char *
2005 qtext_fetch(Size query_offset, int query_len,
2006  char *buffer, Size buffer_size)
2007 {
2008  /* File read failed? */
2009  if (buffer == NULL)
2010  return NULL;
2011  /* Bogus offset/length? */
2012  if (query_len < 0 ||
2013  query_offset + query_len >= buffer_size)
2014  return NULL;
2015  /* As a further sanity check, make sure there's a trailing null */
2016  if (buffer[query_offset + query_len] != '\0')
2017  return NULL;
2018  /* Looks OK */
2019  return buffer + query_offset;
2020 }
2021 
2022 /*
2023  * Do we need to garbage-collect the external query text file?
2024  *
2025  * Caller should hold at least a shared lock on pgss->lock.
2026  */
2027 static bool
2028 need_gc_qtexts(void)
2029 {
2030  Size extent;
2031 
2032  /* Read shared extent pointer */
2033  {
2034  volatile pgssSharedState *s = (volatile pgssSharedState *) pgss;
2035 
2036  SpinLockAcquire(&s->mutex);
2037  extent = s->extent;
2038  SpinLockRelease(&s->mutex);
2039  }
2040 
2041  /* Don't proceed if file does not exceed 512 bytes per possible entry */
2042  if (extent < 512 * pgss_max)
2043  return false;
2044 
2045  /*
2046  * Don't proceed if file is less than about 50% bloat. Nothing can or
2047  * should be done in the event of unusually large query texts accounting
2048  * for file's large size. We go to the trouble of maintaining the mean
2049  * query length in order to prevent garbage collection from thrashing
2050  * uselessly.
2051  */
2052  if (extent < pgss->mean_query_len * pgss_max * 2)
2053  return false;
2054 
2055  return true;
2056 }
2057 
2058 /*
2059  * Garbage-collect orphaned query texts in external file.
2060  *
2061  * This won't be called often in the typical case, since it's likely that
2062  * there won't be too much churn, and besides, a similar compaction process
2063  * occurs when serializing to disk at shutdown or as part of resetting.
2064  * Despite this, it seems prudent to plan for the edge case where the file
2065  * becomes unreasonably large, with no other method of compaction likely to
2066  * occur in the foreseeable future.
2067  *
2068  * The caller must hold an exclusive lock on pgss->lock.
2069  *
2070  * At the first sign of trouble we unlink the query text file to get a clean
2071  * slate (although existing statistics are retained), rather than risk
2072  * thrashing by allowing the same problem case to recur indefinitely.
2073  */
2074 static void
2075 gc_qtexts(void)
2076 {
2077  char *qbuffer;
2078  Size qbuffer_size;
2079  FILE *qfile = NULL;
2080  HASH_SEQ_STATUS hash_seq;
2081  pgssEntry *entry;
2082  Size extent;
2083  int nentries;
2084 
2085  /*
2086  * When called from pgss_store, some other session might have proceeded
2087  * with garbage collection in the no-lock-held interim of lock strength
2088  * escalation. Check once more that this is actually necessary.
2089  */
2090  if (!need_gc_qtexts())
2091  return;
2092 
2093  /*
2094  * Load the old texts file. If we fail (out of memory, for instance),
2095  * invalidate query texts. Hopefully this is rare. It might seem better
2096  * to leave things alone on an OOM failure, but the problem is that the
2097  * file is only going to get bigger; hoping for a future non-OOM result is
2098  * risky and can easily lead to complete denial of service.
2099  */
2100  qbuffer = qtext_load_file(&qbuffer_size);
2101  if (qbuffer == NULL)
2102  goto gc_fail;
2103 
2104  /*
2105  * We overwrite the query texts file in place, so as to reduce the risk of
2106  * an out-of-disk-space failure. Since the file is guaranteed not to get
2107  * larger, this should always work on traditional filesystems; though we
2108  * could still lose on copy-on-write filesystems.
2109  */
2110  qfile = AllocateFile(PGSS_TEXT_FILE, PG_BINARY_W);
2111  if (qfile == NULL)
2112  {
2113  ereport(LOG,
2114  (errcode_for_file_access(),
2115  errmsg("could not write file \"%s\": %m",
2116  PGSS_TEXT_FILE)));
2117  goto gc_fail;
2118  }
2119 
2120  extent = 0;
2121  nentries = 0;
2122 
2123  hash_seq_init(&hash_seq, pgss_hash);
2124  while ((entry = hash_seq_search(&hash_seq)) != NULL)
2125  {
2126  int query_len = entry->query_len;
2127  char *qry = qtext_fetch(entry->query_offset,
2128  query_len,
2129  qbuffer,
2130  qbuffer_size);
2131 
2132  if (qry == NULL)
2133  {
2134  /* Trouble ... drop the text */
2135  entry->query_offset = 0;
2136  entry->query_len = -1;
2137  /* entry will not be counted in mean query length computation */
2138  continue;
2139  }
2140 
2141  if (fwrite(qry, 1, query_len + 1, qfile) != query_len + 1)
2142  {
2143  ereport(LOG,
2144  (errcode_for_file_access(),
2145  errmsg("could not write file \"%s\": %m",
2146  PGSS_TEXT_FILE)));
2147  hash_seq_term(&hash_seq);
2148  goto gc_fail;
2149  }
2150 
2151  entry->query_offset = extent;
2152  extent += query_len + 1;
2153  nentries++;
2154  }
2155 
2156  /*
2157  * Truncate away any now-unused space. If this fails for some odd reason,
2158  * we log it, but there's no need to fail.
2159  */
2160  if (ftruncate(fileno(qfile), extent) != 0)
2161  ereport(LOG,
2162  (errcode_for_file_access(),
2163  errmsg("could not truncate file \"%s\": %m",
2164  PGSS_TEXT_FILE)));
2165 
2166  if (FreeFile(qfile))
2167  {
2168  ereport(LOG,
2169  (errcode_for_file_access(),
2170  errmsg("could not write file \"%s\": %m",
2171  PGSS_TEXT_FILE)));
2172  qfile = NULL;
2173  goto gc_fail;
2174  }
2175 
2176  elog(DEBUG1, "pgss gc of queries file shrunk size from %zu to %zu",
2177  pgss->extent, extent);
2178 
2179  /* Reset the shared extent pointer */
2180  pgss->extent = extent;
2181 
2182  /*
2183  * Also update the mean query length, to be sure that need_gc_qtexts()
2184  * won't still think we have a problem.
2185  */
2186  if (nentries > 0)
2187  pgss->mean_query_len = extent / nentries;
2188  else
2189  pgss->mean_query_len = ASSUMED_LENGTH_INIT;
2190 
2191  free(qbuffer);
2192 
2193  /*
2194  * OK, count a garbage collection cycle. (Note: even though we have
2195  * exclusive lock on pgss->lock, we must take pgss->mutex for this, since
2196  * other processes may examine gc_count while holding only the mutex.
2197  * Also, we have to advance the count *after* we've rewritten the file,
2198  * else other processes might not realize they read a stale file.)
2199  */
2200  record_gc_qtexts();
2201 
2202  return;
2203 
2204 gc_fail:
2205  /* clean up resources */
2206  if (qfile)
2207  FreeFile(qfile);
2208  if (qbuffer)
2209  free(qbuffer);
2210 
2211  /*
2212  * Since the contents of the external file are now uncertain, mark all
2213  * hashtable entries as having invalid texts.
2214  */
2215  hash_seq_init(&hash_seq, pgss_hash);
2216  while ((entry = hash_seq_search(&hash_seq)) != NULL)
2217  {
2218  entry->query_offset = 0;
2219  entry->query_len = -1;
2220  }
2221 
2222  /*
2223  * Destroy the query text file and create a new, empty one
2224  */
2225  (void) unlink(PGSS_TEXT_FILE);
2226  qfile = AllocateFile(PGSS_TEXT_FILE, PG_BINARY_W);
2227  if (qfile == NULL)
2228  ereport(LOG,
2229  (errcode_for_file_access(),
2230  errmsg("could not recreate file \"%s\": %m",
2231  PGSS_TEXT_FILE)));
2232  else
2233  FreeFile(qfile);
2234 
2235  /* Reset the shared extent pointer */
2236  pgss->extent = 0;
2237 
2238  /* Reset mean_query_len to match the new state */
2239  pgss->mean_query_len = ASSUMED_LENGTH_INIT;
2240 
2241  /*
2242  * Bump the GC count even though we failed.
2243  *
2244  * This is needed to make concurrent readers of file without any lock on
2245  * pgss->lock notice existence of new version of file. Once readers
2246  * subsequently observe a change in GC count with pgss->lock held, that
2247  * forces a safe reopen of file. Writers also require that we bump here,
2248  * of course. (As required by locking protocol, readers and writers don't
2249  * trust earlier file contents until gc_count is found unchanged after
2250  * pgss->lock acquired in shared or exclusive mode respectively.)
2251  */
2252  record_gc_qtexts();
2253 }
2254 
2255 /*
2256  * Release entries corresponding to parameters passed.
2257  */
2258 static void
2259 entry_reset(Oid userid, Oid dbid, uint64 queryid)
2260 {
2261  HASH_SEQ_STATUS hash_seq;
2262  pgssEntry *entry;
2263  FILE *qfile;
2264  long num_entries;
2265  long num_remove = 0;
2266  pgssHashKey key;
2267 
2268  if (!pgss || !pgss_hash)
2269  ereport(ERROR,
2270  (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
2271  errmsg("pg_stat_statements must be loaded via shared_preload_libraries")));
2272 
2273  LWLockAcquire(pgss->lock, LW_EXCLUSIVE);
2274  num_entries = hash_get_num_entries(pgss_hash);
2275 
2276  if (userid != 0 && dbid != 0 && queryid != UINT64CONST(0))
2277  {
2278  /* If all the parameters are available, use the fast path. */
2279  key.userid = userid;
2280  key.dbid = dbid;
2281  key.queryid = queryid;
2282 
2283  /* Remove the key if exists */
2284  entry = (pgssEntry *) hash_search(pgss_hash, &key, HASH_REMOVE, NULL);
2285  if (entry) /* found */
2286  num_remove++;
2287  }
2288  else if (userid != 0 || dbid != 0 || queryid != UINT64CONST(0))
2289  {
2290  /* Remove entries corresponding to valid parameters. */
2291  hash_seq_init(&hash_seq, pgss_hash);
2292  while ((entry = hash_seq_search(&hash_seq)) != NULL)
2293  {
2294  if ((!userid || entry->key.userid == userid) &&
2295  (!dbid || entry->key.dbid == dbid) &&
2296  (!queryid || entry->key.queryid == queryid))
2297  {
2298  hash_search(pgss_hash, &entry->key, HASH_REMOVE, NULL);
2299  num_remove++;
2300  }
2301  }
2302  }
2303  else
2304  {
2305  /* Remove all entries. */
2306  hash_seq_init(&hash_seq, pgss_hash);
2307  while ((entry = hash_seq_search(&hash_seq)) != NULL)
2308  {
2309  hash_search(pgss_hash, &entry->key, HASH_REMOVE, NULL);
2310  num_remove++;
2311  }
2312  }
2313 
2314  /* All entries are removed? */
2315  if (num_entries != num_remove)
2316  goto release_lock;
2317 
2318  /*
2319  * Write new empty query file, perhaps even creating a new one to recover
2320  * if the file was missing.
2321  */
2322  qfile = AllocateFile(PGSS_TEXT_FILE, PG_BINARY_W);
2323  if (qfile == NULL)
2324  {
2325  ereport(LOG,
2326  (errcode_for_file_access(),
2327  errmsg("could not create file \"%s\": %m",
2328  PGSS_TEXT_FILE)));
2329  goto done;
2330  }
2331 
2332  /* If ftruncate fails, log it, but it's not a fatal problem */
2333  if (ftruncate(fileno(qfile), 0) != 0)
2334  ereport(LOG,
2335  (errcode_for_file_access(),
2336  errmsg("could not truncate file \"%s\": %m",
2337  PGSS_TEXT_FILE)));
2338 
2339  FreeFile(qfile);
2340 
2341 done:
2342  pgss->extent = 0;
2343  /* This counts as a query text garbage collection for our purposes */
2344  record_gc_qtexts();
2345 
2346 release_lock:
2347  LWLockRelease(pgss->lock);
2348 }
2349 
2350 /*
2351  * AppendJumble: Append a value that is substantive in a given query to
2352  * the current jumble.
2353  */
2354 static void
2355 AppendJumble(pgssJumbleState *jstate, const unsigned char *item, Size size)
2356 {
2357  unsigned char *jumble = jstate->jumble;
2358  Size jumble_len = jstate->jumble_len;
2359 
2360  /*
2361  * Whenever the jumble buffer is full, we hash the current contents and
2362  * reset the buffer to contain just that hash value, thus relying on the
2363  * hash to summarize everything so far.
2364  */
2365  while (size > 0)
2366  {
2367  Size part_size;
2368 
2369  if (jumble_len >= JUMBLE_SIZE)
2370  {
2371  uint64 start_hash;
2372 
2373  start_hash = DatumGetUInt64(hash_any_extended(jumble,
2374  JUMBLE_SIZE, 0));
2375  memcpy(jumble, &start_hash, sizeof(start_hash));
2376  jumble_len = sizeof(start_hash);
2377  }
2378  part_size = Min(size, JUMBLE_SIZE - jumble_len);
2379  memcpy(jumble + jumble_len, item, part_size);
2380  jumble_len += part_size;
2381  item += part_size;
2382  size -= part_size;
2383  }
2384  jstate->jumble_len = jumble_len;
2385 }
2386 
2387 /*
2388  * Wrappers around AppendJumble to encapsulate details of serialization
2389  * of individual local variable elements.
2390  */
2391 #define APP_JUMB(item) \
2392  AppendJumble(jstate, (const unsigned char *) &(item), sizeof(item))
2393 #define APP_JUMB_STRING(str) \
2394  AppendJumble(jstate, (const unsigned char *) (str), strlen(str) + 1)
2395 
2396 /*
2397  * JumbleQuery: Selectively serialize the query tree, appending significant
2398  * data to the "query jumble" while ignoring nonsignificant data.
2399  *
2400  * Rule of thumb for what to include is that we should ignore anything not
2401  * semantically significant (such as alias names) as well as anything that can
2402  * be deduced from child nodes (else we'd just be double-hashing that piece
2403  * of information).
2404  */
2405 static void
2406 JumbleQuery(pgssJumbleState *jstate, Query *query)
2407 {
2408  Assert(IsA(query, Query));
2409  Assert(query->utilityStmt == NULL);
2410 
2411  APP_JUMB(query->commandType);
2412  /* resultRelation is usually predictable from commandType */
2413  JumbleExpr(jstate, (Node *) query->cteList);
2414  JumbleRangeTable(jstate, query->rtable);
2415  JumbleExpr(jstate, (Node *) query->jointree);
2416  JumbleExpr(jstate, (Node *) query->targetList);
2417  JumbleExpr(jstate, (Node *) query->onConflict);
2418  JumbleExpr(jstate, (Node *) query->returningList);
2419  JumbleExpr(jstate, (Node *) query->groupClause);
2420  JumbleExpr(jstate, (Node *) query->groupingSets);
2421  JumbleExpr(jstate, query->havingQual);
2422  JumbleExpr(jstate, (Node *) query->windowClause);
2423  JumbleExpr(jstate, (Node *) query->distinctClause);
2424  JumbleExpr(jstate, (Node *) query->sortClause);
2425  JumbleExpr(jstate, query->limitOffset);
2426  JumbleExpr(jstate, query->limitCount);
2427  JumbleRowMarks(jstate, query->rowMarks);
2428  JumbleExpr(jstate, query->setOperations);
2429 }
2430 
2431 /*
2432  * Jumble a range table
2433  */
2434 static void
2435 JumbleRangeTable(pgssJumbleState *jstate, List *rtable)
2436 {
2437  ListCell *lc;
2438 
2439  foreach(lc, rtable)
2440  {
2441  RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
2442 
2443  APP_JUMB(rte->rtekind);
2444  switch (rte->rtekind)
2445  {
2446  case RTE_RELATION:
2447  APP_JUMB(rte->relid);
2448  JumbleExpr(jstate, (Node *) rte->tablesample);
2449  break;
2450  case RTE_SUBQUERY:
2451  JumbleQuery(jstate, rte->subquery);
2452  break;
2453  case RTE_JOIN:
2454  APP_JUMB(rte->jointype);
2455  break;
2456  case RTE_FUNCTION:
2457  JumbleExpr(jstate, (Node *) rte->functions);
2458  break;
2459  case RTE_TABLEFUNC:
2460  JumbleExpr(jstate, (Node *) rte->tablefunc);
2461  break;
2462  case RTE_VALUES:
2463  JumbleExpr(jstate, (Node *) rte->values_lists);
2464  break;
2465  case RTE_CTE:
2466 
2467  /*
2468  * Depending on the CTE name here isn't ideal, but it's the
2469  * only info we have to identify the referenced WITH item.
2470  */
2471  APP_JUMB_STRING(rte->ctename);
2472  APP_JUMB(rte->ctelevelsup);
2473  break;
2474  case RTE_NAMEDTUPLESTORE:
2475  APP_JUMB_STRING(rte->enrname);
2476  break;
2477  case RTE_RESULT:
2478  break;
2479  default:
2480  elog(ERROR, "unrecognized RTE kind: %d", (int) rte->rtekind);
2481  break;
2482  }
2483  }
2484 }
2485 
2486 /*
2487  * Jumble a rowMarks list
2488  */
2489 static void
2490 JumbleRowMarks(pgssJumbleState *jstate, List *rowMarks)
2491 {
2492  ListCell *lc;
2493 
2494  foreach(lc, rowMarks)
2495  {
2496  RowMarkClause *rowmark = lfirst_node(RowMarkClause, lc);
2497  if (!rowmark->pushedDown)
2498  {
2499  APP_JUMB(rowmark->rti);
2500  APP_JUMB(rowmark->strength);
2501  APP_JUMB(rowmark->waitPolicy);
2502  }
2503  }
2504 }
2505 
2506 /*
2507  * Jumble an expression tree
2508  *
2509  * In general this function should handle all the same node types that
2510  * expression_tree_walker() does, and therefore it's coded to be as parallel
2511  * to that function as possible. However, since we are only invoked on
2512  * queries immediately post-parse-analysis, we need not handle node types
2513  * that only appear in planning.
2514  *
2515  * Note: the reason we don't simply use expression_tree_walker() is that the
2516  * point of that function is to support tree walkers that don't care about
2517  * most tree node types, but here we care about all types. We should complain
2518  * about any unrecognized node type.
2519  */
2520 static void
2521 JumbleExpr(pgssJumbleState *jstate, Node *node)
2522 {
2523  ListCell *temp;
2524 
2525  if (node == NULL)
2526  return;
2527 
2528  /* Guard against stack overflow due to overly complex expressions */
2529  check_stack_depth();
2530 
2531  /*
2532  * We always emit the node's NodeTag, then any additional fields that are
2533  * considered significant, and then we recurse to any child nodes.
2534  */
2535  APP_JUMB(node->type);
2536 
2537  switch (nodeTag(node))
2538  {
2539  case T_Var:
2540  {
2541  Var *var = (Var *) node;
2542 
2543  APP_JUMB(var->varno);
2544  APP_JUMB(var->varattno);
2545  APP_JUMB(var->varlevelsup);
2546  }
2547  break;
2548  case T_Const:
2549  {
2550  Const *c = (Const *) node;
2551 
2552  /* We jumble only the constant's type, not its value */
2553  APP_JUMB(c->consttype);
2554  /* Also, record its parse location for query normalization */
2555  RecordConstLocation(jstate, c->location);
2556  }
2557  break;
2558  case T_Param:
2559  {
2560  Param *p = (Param *) node;
2561 
2562  APP_JUMB(p->paramkind);
2563  APP_JUMB(p->paramid);
2564  APP_JUMB(p->paramtype);
2565  /* Also, track the highest external Param id */
2566  if (p->paramkind == PARAM_EXTERN &&
2567  p->paramid > jstate->highest_extern_param_id)
2568  jstate->highest_extern_param_id = p->paramid;
2569  }
2570  break;
2571  case T_Aggref:
2572  {
2573  Aggref *expr = (Aggref *) node;
2574 
2575  APP_JUMB(expr->aggfnoid);
2576  JumbleExpr(jstate, (Node *) expr->aggdirectargs);
2577  JumbleExpr(jstate, (Node *) expr->args);
2578  JumbleExpr(jstate, (Node *) expr->aggorder);
2579  JumbleExpr(jstate, (Node *) expr->aggdistinct);
2580  JumbleExpr(jstate, (Node *) expr->aggfilter);
2581  }
2582  break;
2583  case T_GroupingFunc:
2584  {
2585  GroupingFunc *grpnode = (GroupingFunc *) node;
2586 
2587  JumbleExpr(jstate, (Node *) grpnode->refs);
2588  }
2589  break;
2590  case T_WindowFunc:
2591  {
2592  WindowFunc *expr = (WindowFunc *) node;
2593 
2594  APP_JUMB(expr->winfnoid);
2595  APP_JUMB(expr->winref);
2596  JumbleExpr(jstate, (Node *) expr->args);
2597  JumbleExpr(jstate, (Node *) expr->aggfilter);
2598  }
2599  break;
2600  case T_SubscriptingRef:
2601  {
2602  SubscriptingRef *sbsref = (SubscriptingRef *) node;
2603 
2604  JumbleExpr(jstate, (Node *) sbsref->refupperindexpr);
2605  JumbleExpr(jstate, (Node *) sbsref->reflowerindexpr);
2606  JumbleExpr(jstate, (Node *) sbsref->refexpr);
2607  JumbleExpr(jstate, (Node *) sbsref->refassgnexpr);
2608  }
2609  break;
2610  case T_FuncExpr:
2611  {
2612  FuncExpr *expr = (FuncExpr *) node;
2613 
2614  APP_JUMB(expr->funcid);
2615  JumbleExpr(jstate, (Node *) expr->args);
2616  }
2617  break;
2618  case T_NamedArgExpr:
2619  {
2620  NamedArgExpr *nae = (NamedArgExpr *) node;
2621 
2622  APP_JUMB(nae->argnumber);
2623  JumbleExpr(jstate, (Node *) nae->arg);
2624  }
2625  break;
2626  case T_OpExpr:
2627  case T_DistinctExpr: /* struct-equivalent to OpExpr */
2628  case T_NullIfExpr: /* struct-equivalent to OpExpr */
2629  {
2630  OpExpr *expr = (OpExpr *) node;
2631 
2632  APP_JUMB(expr->opno);
2633  JumbleExpr(jstate, (Node *) expr->args);
2634  }
2635  break;
2636  case T_ScalarArrayOpExpr:
2637  {
2638  ScalarArrayOpExpr *expr = (ScalarArrayOpExpr *) node;
2639 
2640  APP_JUMB(expr->opno);
2641  APP_JUMB(expr->useOr);
2642  JumbleExpr(jstate, (Node *) expr->args);
2643  }
2644  break;
2645  case T_BoolExpr:
2646  {
2647  BoolExpr *expr = (BoolExpr *) node;
2648 
2649  APP_JUMB(expr->boolop);
2650  JumbleExpr(jstate, (Node *) expr->args);
2651  }
2652  break;
2653  case T_SubLink:
2654  {
2655  SubLink *sublink = (SubLink *) node;
2656 
2657  APP_JUMB(sublink->subLinkType);
2658  APP_JUMB(sublink->subLinkId);
2659  JumbleExpr(jstate, (Node *) sublink->testexpr);
2660  JumbleQuery(jstate, castNode(Query, sublink->subselect));
2661  }
2662  break;
2663  case T_FieldSelect:
2664  {
2665  FieldSelect *fs = (FieldSelect *) node;
2666 
2667  APP_JUMB(fs->fieldnum);
2668  JumbleExpr(jstate, (Node *) fs->arg);
2669  }
2670  break;
2671  case T_FieldStore:
2672  {
2673  FieldStore *fstore = (FieldStore *) node;
2674 
2675  JumbleExpr(jstate, (Node *) fstore->arg);
2676  JumbleExpr(jstate, (Node *) fstore->newvals);
2677  }
2678  break;
2679  case T_RelabelType:
2680  {
2681  RelabelType *rt = (RelabelType *) node;
2682 
2683  APP_JUMB(rt->resulttype);
2684  JumbleExpr(jstate, (Node *) rt->arg);
2685  }
2686  break;
2687  case T_CoerceViaIO:
2688  {
2689  CoerceViaIO *cio = (CoerceViaIO *) node;
2690 
2691  APP_JUMB(cio->resulttype);
2692  JumbleExpr(jstate, (Node *) cio->arg);
2693  }
2694  break;
2695  case T_ArrayCoerceExpr:
2696  {
2697  ArrayCoerceExpr *acexpr = (ArrayCoerceExpr *) node;
2698 
2699  APP_JUMB(acexpr->resulttype);
2700  JumbleExpr(jstate, (Node *) acexpr->arg);
2701  JumbleExpr(jstate, (Node *) acexpr->elemexpr);
2702  }
2703  break;
2704  case T_ConvertRowtypeExpr:
2705  {
2706  ConvertRowtypeExpr *crexpr = (ConvertRowtypeExpr *) node;
2707 
2708  APP_JUMB(crexpr->resulttype);
2709  JumbleExpr(jstate, (Node *) crexpr->arg);
2710  }
2711  break;
2712  case T_CollateExpr:
2713  {
2714  CollateExpr *ce = (CollateExpr *) node;
2715 
2716  APP_JUMB(ce->collOid);
2717  JumbleExpr(jstate, (Node *) ce->arg);
2718  }
2719  break;
2720  case T_CaseExpr:
2721  {
2722  CaseExpr *caseexpr = (CaseExpr *) node;
2723 
2724  JumbleExpr(jstate, (Node *) caseexpr->arg);
2725  foreach(temp, caseexpr->args)
2726  {
2727  CaseWhen *when = lfirst_node(CaseWhen, temp);
2728 
2729  JumbleExpr(jstate, (Node *) when->expr);
2730  JumbleExpr(jstate, (Node *) when->result);
2731  }
2732  JumbleExpr(jstate, (Node *) caseexpr->defresult);
2733  }
2734  break;
2735  case T_CaseTestExpr:
2736  {
2737  CaseTestExpr *ct = (CaseTestExpr *) node;
2738 
2739  APP_JUMB(ct->typeId);
2740  }
2741  break;
2742  case T_ArrayExpr:
2743  JumbleExpr(jstate, (Node *) ((ArrayExpr *) node)->elements);
2744  break;
2745  case T_RowExpr:
2746  JumbleExpr(jstate, (Node *) ((RowExpr *) node)->args);
2747  break;
2748  case T_RowCompareExpr:
2749  {
2750  RowCompareExpr *rcexpr = (RowCompareExpr *) node;
2751 
2752  APP_JUMB(rcexpr->rctype);
2753  JumbleExpr(jstate, (Node *) rcexpr->largs);
2754  JumbleExpr(jstate, (Node *) rcexpr->rargs);
2755  }
2756  break;
2757  case T_CoalesceExpr:
2758  JumbleExpr(jstate, (Node *) ((CoalesceExpr *) node)->args);
2759  break;
2760  case T_MinMaxExpr:
2761  {
2762  MinMaxExpr *mmexpr = (MinMaxExpr *) node;
2763 
2764  APP_JUMB(mmexpr->op);
2765  JumbleExpr(jstate, (Node *) mmexpr->args);
2766  }
2767  break;
2768  case T_SQLValueFunction:
2769  {
2770  SQLValueFunction *svf = (SQLValueFunction *) node;
2771 
2772  APP_JUMB(svf->op);
2773  /* type is fully determined by op */
2774  APP_JUMB(svf->typmod);
2775  }
2776  break;
2777  case T_XmlExpr:
2778  {
2779  XmlExpr *xexpr = (XmlExpr *) node;
2780 
2781  APP_JUMB(xexpr->op);
2782  JumbleExpr(jstate, (Node *) xexpr->named_args);
2783  JumbleExpr(jstate, (Node *) xexpr->args);
2784  }
2785  break;
2786  case T_NullTest:
2787  {
2788  NullTest *nt = (NullTest *) node;
2789 
2790  APP_JUMB(nt->nulltesttype);
2791  JumbleExpr(jstate, (Node *) nt->arg);
2792  }
2793  break;
2794  case T_BooleanTest:
2795  {
2796  BooleanTest *bt = (BooleanTest *) node;
2797 
2798  APP_JUMB(bt->booltesttype);
2799  JumbleExpr(jstate, (Node *) bt->arg);
2800  }
2801  break;
2802  case T_CoerceToDomain:
2803  {
2804  CoerceToDomain *cd = (CoerceToDomain *) node;
2805 
2806  APP_JUMB(cd->resulttype);
2807  JumbleExpr(jstate, (Node *) cd->arg);
2808  }
2809  break;
2810  case T_CoerceToDomainValue:
2811  {
2812  CoerceToDomainValue *cdv = (CoerceToDomainValue *) node;
2813 
2814  APP_JUMB(cdv->typeId);
2815  }
2816  break;
2817  case T_SetToDefault:
2818  {
2819  SetToDefault *sd = (SetToDefault *) node;
2820 
2821  APP_JUMB(sd->typeId);
2822  }
2823  break;
2824  case T_CurrentOfExpr:
2825  {
2826  CurrentOfExpr *ce = (CurrentOfExpr *) node;
2827 
2828  APP_JUMB(ce->cvarno);
2829  if (ce->cursor_name)
2830  APP_JUMB_STRING(ce->cursor_name);
2831  APP_JUMB(ce->cursor_param);
2832  }
2833  break;
2834  case T_NextValueExpr:
2835  {
2836  NextValueExpr *nve = (NextValueExpr *) node;
2837 
2838  APP_JUMB(nve->seqid);
2839  APP_JUMB(nve->typeId);
2840  }
2841  break;
2842  case T_InferenceElem:
2843  {
2844  InferenceElem *ie = (InferenceElem *) node;
2845 
2846  APP_JUMB(ie->infercollid);
2847  APP_JUMB(ie->inferopclass);
2848  JumbleExpr(jstate, ie->expr);
2849  }
2850  break;
2851  case T_TargetEntry:
2852  {
2853  TargetEntry *tle = (TargetEntry *) node;
2854 
2855  APP_JUMB(tle->resno);
2856  APP_JUMB(tle->ressortgroupref);
2857  JumbleExpr(jstate, (Node *) tle->expr);
2858  }
2859  break;
2860  case T_RangeTblRef:
2861  {
2862  RangeTblRef *rtr = (RangeTblRef *) node;
2863 
2864  APP_JUMB(rtr->rtindex);
2865  }
2866  break;
2867  case T_JoinExpr:
2868  {
2869  JoinExpr *join = (JoinExpr *) node;
2870 
2871  APP_JUMB(join->jointype);
2872  APP_JUMB(join->isNatural);
2873  APP_JUMB(join->rtindex);
2874  JumbleExpr(jstate, join->larg);
2875  JumbleExpr(jstate, join->rarg);
2876  JumbleExpr(jstate, join->quals);
2877  }
2878  break;
2879  case T_FromExpr:
2880  {
2881  FromExpr *from = (FromExpr *) node;
2882 
2883  JumbleExpr(jstate, (Node *) from->fromlist);
2884  JumbleExpr(jstate, from->quals);
2885  }
2886  break;
2887  case T_OnConflictExpr:
2888  {
2889  OnConflictExpr *conf = (OnConflictExpr *) node;
2890 
2891  APP_JUMB(conf->action);
2892  JumbleExpr(jstate, (Node *) conf->arbiterElems);
2893  JumbleExpr(jstate, conf->arbiterWhere);
2894  JumbleExpr(jstate, (Node *) conf->onConflictSet);
2895  JumbleExpr(jstate, conf->onConflictWhere);
2896  APP_JUMB(conf->constraint);
2897  APP_JUMB(conf->exclRelIndex);
2898  JumbleExpr(jstate, (Node *) conf->exclRelTlist);
2899  }
2900  break;
2901  case T_List:
2902  foreach(temp, (List *) node)
2903  {
2904  JumbleExpr(jstate, (Node *) lfirst(temp));
2905  }
2906  break;
2907  case T_IntList:
2908  foreach(temp, (List *) node)
2909  {
2910  APP_JUMB(lfirst_int(temp));
2911  }
2912  break;
2913  case T_SortGroupClause:
2914  {
2915  SortGroupClause *sgc = (SortGroupClause *) node;
2916 
2917  APP_JUMB(sgc->tleSortGroupRef);
2918  APP_JUMB(sgc->eqop);
2919  APP_JUMB(sgc->sortop);
2920  APP_JUMB(sgc->nulls_first);
2921  }
2922  break;
2923  case T_GroupingSet:
2924  {
2925  GroupingSet *gsnode = (GroupingSet *) node;
2926 
2927  JumbleExpr(jstate, (Node *) gsnode->content);
2928  }
2929  break;
2930  case T_WindowClause:
2931  {
2932  WindowClause *wc = (WindowClause *) node;
2933 
2934  APP_JUMB(wc->winref);
2935  APP_JUMB(wc->frameOptions);
2936  JumbleExpr(jstate, (Node *) wc->partitionClause);
2937  JumbleExpr(jstate, (Node *) wc->orderClause);
2938  JumbleExpr(jstate, wc->startOffset);
2939  JumbleExpr(jstate, wc->endOffset);
2940  }
2941  break;
2942  case T_CommonTableExpr:
2943  {
2944  CommonTableExpr *cte = (CommonTableExpr *) node;
2945 
2946  /* we store the string name because RTE_CTE RTEs need it */
2947  APP_JUMB_STRING(cte->ctename);
2948  APP_JUMB(cte->ctematerialized);
2949  JumbleQuery(jstate, castNode(Query, cte->ctequery));
2950  }
2951  break;
2952  case T_SetOperationStmt:
2953  {
2954  SetOperationStmt *setop = (SetOperationStmt *) node;
2955 
2956  APP_JUMB(setop->op);
2957  APP_JUMB(setop->all);
2958  JumbleExpr(jstate, setop->larg);
2959  JumbleExpr(jstate, setop->rarg);
2960  }
2961  break;
2962  case T_RangeTblFunction:
2963  {
2964  RangeTblFunction *rtfunc = (RangeTblFunction *) node;
2965 
2966  JumbleExpr(jstate, rtfunc->funcexpr);
2967  }
2968  break;
2969  case T_TableFunc:
2970  {
2971  TableFunc *tablefunc = (TableFunc *) node;
2972 
2973  JumbleExpr(jstate, tablefunc->docexpr);
2974  JumbleExpr(jstate, tablefunc->rowexpr);
2975  JumbleExpr(jstate, (Node *) tablefunc->colexprs);
2976  }
2977  break;
2978  case T_TableSampleClause:
2979  {
2980  TableSampleClause *tsc = (TableSampleClause *) node;
2981 
2982  APP_JUMB(tsc->tsmhandler);
2983  JumbleExpr(jstate, (Node *) tsc->args);
2984  JumbleExpr(jstate, (Node *) tsc->repeatable);
2985  }
2986  break;
2987  default:
2988  /* Only a warning, since we can stumble along anyway */
2989  elog(WARNING, "unrecognized node type: %d",
2990  (int) nodeTag(node));
2991  break;
2992  }
2993 }
2994 
2995 /*
2996  * Record location of constant within query string of query tree
2997  * that is currently being walked.
2998  */
2999 static void
3000 RecordConstLocation(pgssJumbleState *jstate, int location)
3001 {
3002  /* -1 indicates unknown or undefined location */
3003  if (location >= 0)
3004  {
3005  /* enlarge array if needed */
3006  if (jstate->clocations_count >= jstate->clocations_buf_size)
3007  {
3008  jstate->clocations_buf_size *= 2;
3009  jstate->clocations = (pgssLocationLen *)
3010  repalloc(jstate->clocations,
3011  jstate->clocations_buf_size *
3012  sizeof(pgssLocationLen));
3013  }
3014  jstate->clocations[jstate->clocations_count].location = location;
3015  /* initialize lengths to -1 to simplify fill_in_constant_lengths */
3016  jstate->clocations[jstate->clocations_count].length = -1;
3017  jstate->clocations_count++;
3018  }
3019 }
3020 
3021 /*
3022  * Generate a normalized version of the query string that will be used to
3023  * represent all similar queries.
3024  *
3025  * Note that the normalized representation may well vary depending on
3026  * just which "equivalent" query is used to create the hashtable entry.
3027  * We assume this is OK.
3028  *
3029  * If query_loc > 0, then "query" has been advanced by that much compared to
3030  * the original string start, so we need to translate the provided locations
3031  * to compensate. (This lets us avoid re-scanning statements before the one
3032  * of interest, so it's worth doing.)
3033  *
3034  * *query_len_p contains the input string length, and is updated with
3035  * the result string length on exit. The resulting string might be longer
3036  * or shorter depending on what happens with replacement of constants.
3037  *
3038  * Returns a palloc'd string.
3039  */
3040 static char *
3041 generate_normalized_query(pgssJumbleState *jstate, const char *query,
3042  int query_loc, int *query_len_p, int encoding)
3043 {
3044  char *norm_query;
3045  int query_len = *query_len_p;
3046  int i,
3047  norm_query_buflen, /* Space allowed for norm_query */
3048  len_to_wrt, /* Length (in bytes) to write */
3049  quer_loc = 0, /* Source query byte location */
3050  n_quer_loc = 0, /* Normalized query byte location */
3051  last_off = 0, /* Offset from start for previous tok */
3052  last_tok_len = 0; /* Length (in bytes) of that tok */
3053 
3054  /*
3055  * Get constants' lengths (core system only gives us locations). Note
3056  * this also ensures the items are sorted by location.
3057  */
3058  fill_in_constant_lengths(jstate, query, query_loc);
3059 
3060  /*
3061  * Allow for $n symbols to be longer than the constants they replace.
3062  * Constants must take at least one byte in text form, while a $n symbol
3063  * certainly isn't more than 11 bytes, even if n reaches INT_MAX. We
3064  * could refine that limit based on the max value of n for the current
3065  * query, but it hardly seems worth any extra effort to do so.
3066  */
3067  norm_query_buflen = query_len + jstate->clocations_count * 10;
3068 
3069  /* Allocate result buffer */
3070  norm_query = palloc(norm_query_buflen + 1);
3071 
3072  for (i = 0; i < jstate->clocations_count; i++)
3073  {
3074  int off, /* Offset from start for cur tok */
3075  tok_len; /* Length (in bytes) of that tok */
3076 
3077  off = jstate->clocations[i].location;
3078  /* Adjust recorded location if we're dealing with partial string */
3079  off -= query_loc;
3080 
3081  tok_len = jstate->clocations[i].length;
3082 
3083  if (tok_len < 0)
3084  continue; /* ignore any duplicates */
3085 
3086  /* Copy next chunk (what precedes the next constant) */
3087  len_to_wrt = off - last_off;
3088  len_to_wrt -= last_tok_len;
3089 
3090  Assert(len_to_wrt >= 0);
3091  memcpy(norm_query + n_quer_loc, query + quer_loc, len_to_wrt);
3092  n_quer_loc += len_to_wrt;
3093 
3094  /* And insert a param symbol in place of the constant token */
3095  n_quer_loc += sprintf(norm_query + n_quer_loc, "$%d",
3096  i + 1 + jstate->highest_extern_param_id);
3097 
3098  quer_loc = off + tok_len;
3099  last_off = off;
3100  last_tok_len = tok_len;
3101  }
3102 
3103  /*
3104  * We've copied up until the last ignorable constant. Copy over the
3105  * remaining bytes of the original query string.
3106  */
3107  len_to_wrt = query_len - quer_loc;
3108 
3109  Assert(len_to_wrt >= 0);
3110  memcpy(norm_query + n_quer_loc, query + quer_loc, len_to_wrt);
3111  n_quer_loc += len_to_wrt;
3112 
3113  Assert(n_quer_loc <= norm_query_buflen);
3114  norm_query[n_quer_loc] = '\0';
3115 
3116  *query_len_p = n_quer_loc;
3117  return norm_query;
3118 }
3119 
3120 /*
3121  * Given a valid SQL string and an array of constant-location records,
3122  * fill in the textual lengths of those constants.
3123  *
3124  * The constants may use any allowed constant syntax, such as float literals,
3125  * bit-strings, single-quoted strings and dollar-quoted strings. This is
3126  * accomplished by using the public API for the core scanner.
3127  *
3128  * It is the caller's job to ensure that the string is a valid SQL statement
3129  * with constants at the indicated locations. Since in practice the string
3130  * has already been parsed, and the locations that the caller provides will
3131  * have originated from within the authoritative parser, this should not be
3132  * a problem.
3133  *
3134  * Duplicate constant pointers are possible, and will have their lengths
3135  * marked as '-1', so that they are later ignored. (Actually, we assume the
3136  * lengths were initialized as -1 to start with, and don't change them here.)
3137  *
3138  * If query_loc > 0, then "query" has been advanced by that much compared to
3139  * the original string start, so we need to translate the provided locations
3140  * to compensate. (This lets us avoid re-scanning statements before the one
3141  * of interest, so it's worth doing.)
3142  *
3143  * N.B. There is an assumption that a '-' character at a Const location begins
3144  * a negative numeric constant. This precludes there ever being another
3145  * reason for a constant to start with a '-'.
3146  */
3147 static void
3148 fill_in_constant_lengths(pgssJumbleState *jstate, const char *query,
3149  int query_loc)
3150 {
3151  pgssLocationLen *locs;
3152  core_yyscan_t yyscanner;
3153  core_yy_extra_type yyextra;
3154  core_YYSTYPE yylval;
3155  YYLTYPE yylloc;
3156  int last_loc = -1;
3157  int i;
3158 
3159  /*
3160  * Sort the records by location so that we can process them in order while
3161  * scanning the query text.
3162  */
3163  if (jstate->clocations_count > 1)
3164  qsort(jstate->clocations, jstate->clocations_count,
3165  sizeof(pgssLocationLen), comp_location);
3166  locs = jstate->clocations;
3167 
3168  /* initialize the flex scanner --- should match raw_parser() */
3169  yyscanner = scanner_init(query,
3170  &yyextra,
3171  &ScanKeywords,
3172  ScanKeywordTokens);
3173 
3174  /* we don't want to re-emit any escape string warnings */
3175  yyextra.escape_string_warning = false;
3176 
3177  /* Search for each constant, in sequence */
3178  for (i = 0; i < jstate->clocations_count; i++)
3179  {
3180  int loc = locs[i].location;
3181  int tok;
3182 
3183  /* Adjust recorded location if we're dealing with partial string */
3184  loc -= query_loc;
3185 
3186  Assert(loc >= 0);
3187 
3188  if (loc <= last_loc)
3189  continue; /* Duplicate constant, ignore */
3190 
3191  /* Lex tokens until we find the desired constant */
3192  for (;;)
3193  {
3194  tok = core_yylex(&yylval, &yylloc, yyscanner);
3195 
3196  /* We should not hit end-of-string, but if we do, behave sanely */
3197  if (tok == 0)
3198  break; /* out of inner for-loop */
3199 
3200  /*
3201  * We should find the token position exactly, but if we somehow
3202  * run past it, work with that.
3203  */
3204  if (yylloc >= loc)
3205  {
3206  if (query[loc] == '-')
3207  {
3208  /*
3209  * It's a negative value - this is the one and only case
3210  * where we replace more than a single token.
3211  *
3212  * Do not compensate for the core system's special-case
3213  * adjustment of location to that of the leading '-'
3214  * operator in the event of a negative constant. It is
3215  * also useful for our purposes to start from the minus
3216  * symbol. In this way, queries like "select * from foo
3217  * where bar = 1" and "select * from foo where bar = -2"
3218  * will have identical normalized query strings.
3219  */
3220  tok = core_yylex(&yylval, &yylloc, yyscanner);
3221  if (tok == 0)
3222  break; /* out of inner for-loop */
3223  }
3224 
3225  /*
3226  * We now rely on the assumption that flex has placed a zero
3227  * byte after the text of the current token in scanbuf.
3228  */
3229  locs[i].length = strlen(yyextra.scanbuf + loc);
3230  break; /* out of inner for-loop */
3231  }
3232  }
3233 
3234  /* If we hit end-of-string, give up, leaving remaining lengths -1 */
3235  if (tok == 0)
3236  break;
3237 
3238  last_loc = loc;
3239  }
3240 
3241  scanner_finish(yyscanner);
3242 }
3243 
3244 /*
3245  * comp_location: comparator for qsorting pgssLocationLen structs by location
3246  */
3247 static int
3248 comp_location(const void *a, const void *b)
3249 {
3250  int l = ((const pgssLocationLen *) a)->location;
3251  int r = ((const pgssLocationLen *) b)->location;
3252 
3253  if (l < r)
3254  return -1;
3255  else if (l > r)
3256  return +1;
3257  else
3258  return 0;
3259 }
tuplestore_putvalues
void tuplestore_putvalues(Tuplestorestate *state, TupleDesc tdesc, Datum *values, bool *isnull)
Definition: tuplestore.c:750
Aggref::aggdistinct
List * aggdistinct
Definition: primnodes.h:321
Query::limitOffset
Node * limitOffset
Definition: parsenodes.h:160
slock_t
int slock_t
Definition: s_lock.h:934
DefineCustomIntVariable
void DefineCustomIntVariable(const char *name, const char *short_desc, const char *long_desc, int *valueAddr, int bootValue, int minValue, int maxValue, GucContext context, int flags, GucIntCheckHook check_hook, GucIntAssignHook assign_hook, GucShowHook show_hook)
Definition: guc.c:8675
ExecutorRun_hook_type
void(* ExecutorRun_hook_type)(QueryDesc *queryDesc, ScanDirection direction, uint64 count, bool execute_once)
Definition: executor.h:69
BufferUsage::local_blks_hit
long local_blks_hit
Definition: instrument.h:25
MinMaxExpr::args
List * args
Definition: primnodes.h:1106
standard_ExecutorRun
void standard_ExecutorRun(QueryDesc *queryDesc, ScanDirection direction, uint64 count, bool execute_once)
Definition: execMain.c:312
_PG_init
void _PG_init(void)
Definition: pg_stat_statements.c:350
PGSS_V1_2
Definition: pg_stat_statements.c:122
LWLock
Definition: lwlock.h:32
pgss_hash_string
static uint64 pgss_hash_string(const char *str, int len)
Definition: pg_stat_statements.c:1077
JumbleExpr
static void JumbleExpr(pgssJumbleState *jstate, Node *node)
Definition: pg_stat_statements.c:2521
IsA
#define IsA(nodeptr, _type_)
Definition: nodes.h:576
TableFunc::docexpr
Node * docexpr
Definition: primnodes.h:87
RequestAddinShmemSpace
void RequestAddinShmemSpace(Size size)
Definition: ipci.c:70
BufferUsage::local_blks_dirtied
long local_blks_dirtied
Definition: instrument.h:27
PG_STAT_STATEMENTS_COLS_V1_3
#define PG_STAT_STATEMENTS_COLS_V1_3
Definition: pg_stat_statements.c:1335
DEBUG1
#define DEBUG1
Definition: elog.h:25
get_call_result_type
TypeFuncClass get_call_result_type(FunctionCallInfo fcinfo, Oid *resultTypeId, TupleDesc *resultTupleDesc)
Definition: funcapi.c:196
FieldStore::arg
Expr * arg
Definition: primnodes.h:791
Var::varlevelsup
Index varlevelsup
Definition: primnodes.h:191
BufferUsage::local_blks_read
long local_blks_read
Definition: instrument.h:26
Query::stmt_location
int stmt_location
Definition: parsenodes.h:180
Query::sortClause
List * sortClause
Definition: parsenodes.h:158
PGSS_TRACK_ALL
Definition: pg_stat_statements.c:258
QueryDesc::estate
EState * estate
Definition: execdesc.h:48
GroupingSet::content
List * content
Definition: parsenodes.h:1325
GroupingFunc::refs
List * refs
Definition: primnodes.h:361
core_yyscan_t
void * core_yyscan_t
Definition: scanner.h:117
WindowFunc::args
List * args
Definition: primnodes.h:377
HASH_ELEM
#define HASH_ELEM
Definition: hsearch.h:87
FuncExpr::args
List * args
Definition: primnodes.h:477
JumbleRowMarks
static void JumbleRowMarks(pgssJumbleState *jstate, List *rowMarks)
Definition: pg_stat_statements.c:2490
error
static void error(void)
Definition: sql-dyntest.c:147
PG_STAT_STATEMENTS_COLS_V1_0
#define PG_STAT_STATEMENTS_COLS_V1_0
Definition: pg_stat_statements.c:1332
process_shared_preload_libraries_in_progress
bool process_shared_preload_libraries_in_progress
Definition: miscinit.c:1522
USAGE_DEALLOC_PERCENT
#define USAGE_DEALLOC_PERCENT
Definition: pg_stat_statements.c:111
Counters::shared_blks_read
int64 shared_blks_read
Definition: pg_stat_statements.c:155
PGSS_PG_MAJOR_VERSION
static const uint32 PGSS_PG_MAJOR_VERSION
Definition: pg_stat_statements.c:102
Query::jointree
FromExpr * jointree
Definition: parsenodes.h:138
Counters::local_blks_written
int64 local_blks_written
Definition: pg_stat_statements.c:161
config_enum_entry
Definition: guc.h:164
RequestNamedLWLockTranche
void RequestNamedLWLockTranche(const char *tranche_name, int num_lwlocks)
Definition: lwlock.c:638
GetUserId
Oid GetUserId(void)
Definition: miscinit.c:380
Query::onConflict
OnConflictExpr * onConflict
Definition: parsenodes.h:144
BufferUsage::blk_read_time
instr_time blk_read_time
Definition: instrument.h:31
castNode
#define castNode(_type_, nodeptr)
Definition: nodes.h:594
prev_ProcessUtility
static ProcessUtility_hook_type prev_ProcessUtility
Definition: pg_stat_statements.c:246
write
#define write(a, b, c)
Definition: win32.h:14
pgssSharedState
struct pgssSharedState pgssSharedState
AppendJumble
static void AppendJumble(pgssJumbleState *jstate, const unsigned char *item, Size size)
Definition: pg_stat_statements.c:2355
Counters::shared_blks_dirtied
int64 shared_blks_dirtied
Definition: pg_stat_statements.c:156
pgss_shmem_startup
static void pgss_shmem_startup(void)
Definition: pg_stat_statements.c:465
SpinLockInit
#define SpinLockInit(lock)
Definition: spin.h:60
INSTR_TIME_GET_MILLISEC
#define INSTR_TIME_GET_MILLISEC(t)
Definition: instr_time.h:202
CoerceViaIO::resulttype
Oid resulttype
Definition: primnodes.h:835
ScanKeywordTokens
PGDLLIMPORT const uint16 ScanKeywordTokens[]
instr_time
struct timeval instr_time
Definition: instr_time.h:150
RowCompareExpr::rctype
RowCompareType rctype
Definition: primnodes.h:1070
BufferUsage::shared_blks_read
long shared_blks_read
Definition: instrument.h:22
standard_ExecutorStart
void standard_ExecutorStart(QueryDesc *queryDesc, int eflags)
Definition: execMain.c:152
Min
#define Min(x, y)
Definition: c.h:911
tuplestore_donestoring
#define tuplestore_donestoring(state)
Definition: tuplestore.h:60
MemoryContextSwitchTo
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
prev_ExecutorRun
static ExecutorRun_hook_type prev_ExecutorRun
Definition: pg_stat_statements.c:243
SortGroupClause::tleSortGroupRef
Index tleSortGroupRef
Definition: parsenodes.h:1255
RelabelType::arg
Expr * arg
Definition: primnodes.h:814
Query::groupingSets
List * groupingSets
Definition: parsenodes.h:150
prev_ExecutorEnd
static ExecutorEnd_hook_type prev_ExecutorEnd
Definition: pg_stat_statements.c:245
HASHCTL::entrysize
Size entrysize
Definition: hsearch.h:73
PGSS_DUMP_FILE
#define PGSS_DUMP_FILE
Definition: pg_stat_statements.c:86
Param::paramkind
ParamKind paramkind
Definition: primnodes.h:262
ProcessUtility_hook
ProcessUtility_hook_type ProcessUtility_hook
Definition: utility.c:75
Node
Definition: nodes.h:525
pgss_track
static int pgss_track
Definition: pg_stat_statements.c:270
entry_cmp
static int entry_cmp(const void *lhs, const void *rhs)
Definition: pg_stat_statements.c:1737
errcode
int errcode(int sqlerrcode)
Definition: elog.c:608
standard_ExecutorEnd
void standard_ExecutorEnd(QueryDesc *queryDesc)
Definition: execMain.c:471
pgssEntry
struct pgssEntry pgssEntry
PG_BINARY_W
#define PG_BINARY_W
Definition: c.h:1224
ProcessUtilityContext
ProcessUtilityContext
Definition: utility.h:19
InstrAlloc
Instrumentation * InstrAlloc(int n, int instrument_options)
Definition: instrument.c:30
Aggref::args
List * args
Definition: primnodes.h:319
prev_ExecutorStart
static ExecutorStart_hook_type prev_ExecutorStart
Definition: pg_stat_statements.c:242
ExecutorFinish_hook_type
void(* ExecutorFinish_hook_type)(QueryDesc *queryDesc)
Definition: executor.h:76
Var::varattno
AttrNumber varattno
Definition: primnodes.h:186
generate_unaccent_rules.dest
dest
Definition: generate_unaccent_rules.py:282
FieldSelect::arg
Expr * arg
Definition: primnodes.h:762
hash_get_num_entries
long hash_get_num_entries(HTAB *hashp)
Definition: dynahash.c:1335
hash_any_extended
Datum hash_any_extended(const unsigned char *k, int keylen, uint64 seed)
Definition: hashfn.c:374
pgss_enabled
#define pgss_enabled()
Definition: pg_stat_statements.c:275
FromExpr::fromlist
List * fromlist
Definition: primnodes.h:1510
pgssJumbleState::jumble
unsigned char * jumble
Definition: pg_stat_statements.c:216
PG_GETARG_BOOL
#define PG_GETARG_BOOL(n)
Definition: fmgr.h:269
BufferUsage::temp_blks_written
long temp_blks_written
Definition: instrument.h:30
hash_search
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:906
pgssEntry::counters
Counters counters
Definition: pg_stat_statements.c:179
pgss_ExecutorStart
static void pgss_ExecutorStart(QueryDesc *queryDesc, int eflags)
Definition: pg_stat_statements.c:851
Counters::temp_blks_read
int64 temp_blks_read
Definition: pg_stat_statements.c:162
JUMBLE_SIZE
#define JUMBLE_SIZE
Definition: pg_stat_statements.c:113
PG_STAT_STATEMENTS_COLS_V1_1
#define PG_STAT_STATEMENTS_COLS_V1_1
Definition: pg_stat_statements.c:1333
LOG
#define LOG
Definition: elog.h:26
Oid
unsigned int Oid
Definition: postgres_ext.h:31
Query::rowMarks
List * rowMarks
Definition: parsenodes.h:163
WindowFunc::winref
Index winref
Definition: primnodes.h:379
Query::utilityStmt
Node * utilityStmt
Definition: parsenodes.h:120
prev_post_parse_analyze_hook
static post_parse_analyze_hook_type prev_post_parse_analyze_hook
Definition: pg_stat_statements.c:241
Var
Definition: primnodes.h:181
pg_wchar.h
SubscriptingRef::refupperindexpr
List * refupperindexpr
Definition: primnodes.h:422
PG_BINARY_R
#define PG_BINARY_R
Definition: c.h:1223
fd
static int fd(const char *x, int i)
Definition: preproc-init.c:105
_DestReceiver
Definition: dest.h:115
PG_BINARY
#define PG_BINARY
Definition: c.h:1221
PlannedStmt::stmt_len
int stmt_len
Definition: plannodes.h:96
core_yy_extra_type::scanbuf
char * scanbuf
Definition: scanner.h:72
RangeTblEntry::values_lists
List * values_lists
Definition: parsenodes.h:1072
FromExpr::quals
Node * quals
Definition: primnodes.h:1511
standard_ExecutorFinish
void standard_ExecutorFinish(QueryDesc *queryDesc)
Definition: execMain.c:411
SQLValueFunction::op
SQLValueFunctionOp op
Definition: primnodes.h:1143
duration
int duration
Definition: pgbench.c:146
RowMarkClause::strength
LockClauseStrength strength
Definition: parsenodes.h:1381
pg_stat_statements_1_3
Datum pg_stat_statements_1_3(PG_FUNCTION_ARGS)
Definition: pg_stat_statements.c:1349
DefineCustomEnumVariable
void DefineCustomEnumVariable(const char *name, const char *short_desc, const char *long_desc, int *valueAddr, int bootValue, const struct config_enum_entry *options, GucContext context, int flags, GucEnumCheckHook check_hook, GucEnumAssignHook assign_hook, GucShowHook show_hook)
Definition: guc.c:8760
MaxAllocHugeSize
#define MaxAllocHugeSize
Definition: memutils.h:44
int32
signed int int32
Definition: c.h:347
APP_JUMB_STRING
#define APP_JUMB_STRING(str)
Definition: pg_stat_statements.c:2393
Query::windowClause
List * windowClause
Definition: parsenodes.h:154
Query::targetList
List * targetList
Definition: parsenodes.h:140
RecordConstLocation
static void RecordConstLocation(pgssJumbleState *jstate, int location)
Definition: pg_stat_statements.c:3000
OnConflictExpr::arbiterElems
List * arbiterElems
Definition: primnodes.h:1529
JumbleRangeTable
static void JumbleRangeTable(pgssJumbleState *jstate, List *rtable)
Definition: pg_stat_statements.c:2435
ExecutorStart_hook
ExecutorStart_hook_type ExecutorStart_hook
Definition: execMain.c:70
InstrEndLoop
void InstrEndLoop(Instrumentation *instr)
Definition: instrument.c:110
JoinExpr::larg
Node * larg
Definition: primnodes.h:1490
ScanKeywords
PGDLLIMPORT const ScanKeywordList ScanKeywords
malloc
#define malloc(a)
Definition: header.h:50
LWLockRelease
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1726
ASSUMED_LENGTH_INIT
#define ASSUMED_LENGTH_INIT
Definition: pg_stat_statements.c:108
Const::consttype
Oid consttype
Definition: primnodes.h:210
sprintf
#define sprintf
Definition: port.h:194
BufferUsage::shared_blks_written
long shared_blks_written
Definition: instrument.h:24
pgss
static pgssSharedState * pgss
Definition: pg_stat_statements.c:249
SpinLockAcquire
#define SpinLockAcquire(lock)
Definition: spin.h:62
HTAB
Definition: dynahash.c:208
pgss_ExecutorRun
static void pgss_ExecutorRun(QueryDesc *queryDesc, ScanDirection direction, uint64 count, bool execute_once)
Definition: pg_stat_statements.c:885
standard_ProcessUtility
void standard_ProcessUtility(PlannedStmt *pstmt, const char *queryString, ProcessUtilityContext context, ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest, char *completionTag)
Definition: utility.c:543
pfree
void pfree(void *pointer)
Definition: mcxt.c:1056
EState::es_query_cxt
MemoryContext es_query_cxt
Definition: execnodes.h:549
Counters::shared_blks_hit
int64 shared_blks_hit
Definition: pg_stat_statements.c:154
pgssJumbleState::clocations
pgssLocationLen * clocations
Definition: pg_stat_statements.c:222
pgss_max
static int pgss_max
Definition: pg_stat_statements.c:269
entry_dealloc
static void entry_dealloc(void)
Definition: pg_stat_statements.c:1756
Query::rtable
List * rtable
Definition: parsenodes.h:137
pgss_hash
static HTAB * pgss_hash
Definition: pg_stat_statements.c:250
Query::distinctClause
List * distinctClause
Definition: parsenodes.h:156
FuncExpr::funcid
Oid funcid
Definition: primnodes.h:469
ObjectIdGetDatum
#define ObjectIdGetDatum(X)
Definition: postgres.h:507
ERROR
#define ERROR
Definition: elog.h:43
ExecutorRun_hook
ExecutorRun_hook_type ExecutorRun_hook
Definition: execMain.c:71
ExecutorEnd_hook
ExecutorEnd_hook_type ExecutorEnd_hook
Definition: execMain.c:73
OpenTransientFile
int OpenTransientFile(const char *fileName, int fileFlags)
Definition: fd.c:2291
pgss_post_parse_analyze
static void pgss_post_parse_analyze(ParseState *pstate, Query *query)
Definition: pg_stat_statements.c:780
enc
struct pg_encoding enc
Definition: encode.c:522
FunctionCallInfoBaseData::resultinfo
fmNodePtr resultinfo
Definition: fmgr.h:89
pg_stat_statements_internal
static void pg_stat_statements_internal(FunctionCallInfo fcinfo, pgssVersion api_version, bool showtext)
Definition: pg_stat_statements.c:1383
RangeTblEntry::tablefunc
TableFunc * tablefunc
Definition: parsenodes.h:1067
lfirst_int
#define lfirst_int(lc)
Definition: pg_list.h:191
WindowClause::partitionClause
List * partitionClause
Definition: parsenodes.h:1351
INSTR_TIME_SUBTRACT
#define INSTR_TIME_SUBTRACT(x, y)
Definition: instr_time.h:170
ShmemInitStruct
void * ShmemInitStruct(const char *name, Size size, bool *foundPtr)
Definition: shmem.c:392
BoolExpr::boolop
BoolExprType boolop
Definition: primnodes.h:582
PGC_SUSET
Definition: guc.h:75
EmitWarningsOnPlaceholders
void EmitWarningsOnPlaceholders(const char *className)
Definition: guc.c:8788
NullTest::arg
Expr * arg
Definition: primnodes.h:1219
pgssVersion
pgssVersion
Definition: pg_stat_statements.c:118
lfirst_node
#define lfirst_node(type, lc)
Definition: pg_list.h:193
USAGE_EXEC
#define USAGE_EXEC(duration)
Definition: pg_stat_statements.c:105
APP_JUMB
#define APP_JUMB(item)
Definition: pg_stat_statements.c:2391
TableFunc::rowexpr
Node * rowexpr
Definition: primnodes.h:88
Query::limitCount
Node * limitCount
Definition: parsenodes.h:161
generate_unaccent_rules.str
str
Definition: generate_unaccent_rules.py:282
c
char * c
Definition: preproc-cursor.c:31
on_shmem_exit
void on_shmem_exit(pg_on_exit_callback function, Datum arg)
Definition: ipc.c:361
PlannedStmt::stmt_location
int stmt_location
Definition: plannodes.h:95
Node::type
NodeTag type
Definition: nodes.h:527
buf
static char * buf
Definition: pg_test_fsync.c:67
JumbleQuery
static void JumbleQuery(pgssJumbleState *jstate, Query *query)
Definition: pg_stat_statements.c:2406
PG_GETARG_OID
#define PG_GETARG_OID(n)
Definition: fmgr.h:270
OnConflictExpr::exclRelTlist
List * exclRelTlist
Definition: primnodes.h:1538
PGSS_TRACK_TOP
Definition: pg_stat_statements.c:257
check_stack_depth
void check_stack_depth(void)
Definition: postgres.c:3288
IsUnderPostmaster
bool IsUnderPostmaster
Definition: globals.c:109
RangeTblEntry::jointype
JoinType jointype
Definition: parsenodes.h:1047
shmem_startup_hook_type
void(* shmem_startup_hook_type)(void)
Definition: ipc.h:22
Aggref::aggorder
List * aggorder
Definition: primnodes.h:320
entry_alloc
static pgssEntry * entry_alloc(pgssHashKey *key, Size query_offset, int query_len, int encoding, bool sticky)
Definition: pg_stat_statements.c:1700
errdetail
int errdetail(const char *fmt,...)
Definition: elog.c:955
BooleanTest::arg
Expr * arg
Definition: primnodes.h:1242
errcode_for_file_access
int errcode_for_file_access(void)
Definition: elog.c:631
ScanDirection
ScanDirection
Definition: sdir.h:22
TargetEntry::resno
AttrNumber resno
Definition: primnodes.h:1408
generate_unaccent_rules.args
args
Definition: generate_unaccent_rules.py:285
PlannedStmt::utilityStmt
Node * utilityStmt
Definition: plannodes.h:92
core_YYSTYPE
Definition: scanner.h:29
qtext_load_file
static char * qtext_load_file(Size *buffer_size)
Definition: pg_stat_statements.c:1925
AllocateFile
FILE * AllocateFile(const char *name, const char *mode)
Definition: fd.c:2241
generate_normalized_query
static char * generate_normalized_query(pgssJumbleState *jstate, const char *query, int query_loc, int *query_len_p, int encoding)
Definition: pg_stat_statements.c:3041
BufferUsage::shared_blks_dirtied
long shared_blks_dirtied
Definition: instrument.h:23
CurrentOfExpr::cursor_name
char * cursor_name
Definition: primnodes.h:1317
YYLTYPE
#define YYLTYPE
Definition: scanner.h:44
ProcessUtility_hook_type
void(* ProcessUtility_hook_type)(PlannedStmt *pstmt, const char *queryString, ProcessUtilityContext context, ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest, char *completionTag)
Definition: utility.h:70
uint32
unsigned int uint32
Definition: c.h:359
Aggref::aggdirectargs
List * aggdirectargs
Definition: primnodes.h:318
prev_ExecutorFinish
static ExecutorFinish_hook_type prev_ExecutorFinish
Definition: pg_stat_statements.c:244
_PG_fini
void _PG_fini(void)
Definition: pg_stat_statements.c:446
WindowFunc::winfnoid
Oid winfnoid
Definition: primnodes.h:373
CoerceViaIO::arg
Expr * arg
Definition: primnodes.h:834
ParseState::p_sourcetext
const char * p_sourcetext
Definition: parse_node.h:179
BufferUsage::temp_blks_read
long temp_blks_read
Definition: instrument.h:29
ArrayCoerceExpr::elemexpr
Expr * elemexpr
Definition: primnodes.h:859
when
Definition: type.h:82
Query::returningList
List * returningList
Definition: parsenodes.h:146
Counters::temp_blks_written
int64 temp_blks_written
Definition: pg_stat_statements.c:163
pg_stat_statements_reset
Datum pg_stat_statements_reset(PG_FUNCTION_ARGS)
Definition: pg_stat_statements.c:1324
qtext_store
static bool qtext_store(const char *query, int query_len, Size *query_offset, int *gc_count)
Definition: pg_stat_statements.c:1842
Counters::shared_blks_written
int64 shared_blks_written
Definition: pg_stat_statements.c:157
STICKY_DECREASE_FACTOR
#define STICKY_DECREASE_FACTOR
Definition: pg_stat_statements.c:110
ereport
#define ereport(elevel, rest)
Definition: elog.h:141
RangeTblEntry::enrname
char * enrname
Definition: parsenodes.h:1106
USAGE_DECREASE_FACTOR
#define USAGE_DECREASE_FACTOR
Definition: pg_stat_statements.c:109
durable_rename
int durable_rename(const char *oldfile, const char *newfile, int elevel)
Definition: fd.c:642
T_List
Definition: nodes.h:297
FieldStore::newvals
List * newvals
Definition: primnodes.h:792
PGC_SIGHUP
Definition: guc.h:72
T_Const
Definition: nodes.h:152
OnConflictExpr::action
OnConflictAction action
Definition: primnodes.h:1526
JoinExpr::isNatural
bool isNatural
Definition: primnodes.h:1489
scanner_init
core_yyscan_t scanner_init(const char *str, core_yy_extra_type *yyext, const ScanKeywordList *keywordlist, const uint16 *keyword_tokens)
pgss_memsize
static Size pgss_memsize(void)
Definition: pg_stat_statements.c:1672
Query::queryId
uint64 queryId
Definition: parsenodes.h:116
CloseTransientFile
int CloseTransientFile(int fd)
Definition: fd.c:2468
WARNING
#define WARNING
Definition: elog.h:40
shmem_startup_hook
shmem_startup_hook_type shmem_startup_hook
Definition: ipci.c:52
Var::varno
Index varno
Definition: primnodes.h:184
T_Var
Definition: nodes.h:151
stat
#define stat(a, b)
Definition: win32_port.h:255
hash_estimate_size
Size hash_estimate_size(long num_entries, Size entrysize)
Definition: dynahash.c:732
fill_in_constant_lengths
static void fill_in_constant_lengths(pgssJumbleState *jstate, const char *query, int query_loc)
Definition: pg_stat_statements.c:3148
XmlExpr::op
XmlExprOp op
Definition: primnodes.h:1181
comp_location
static int comp_location(const void *a, const void *b)
Definition: pg_stat_statements.c:3248
WindowClause::startOffset
Node * startOffset
Definition: parsenodes.h:1354
SpinLockRelease
#define SpinLockRelease(lock)
Definition: spin.h:64
tuplestore_begin_heap
Tuplestorestate * tuplestore_begin_heap(bool randomAccess, bool interXact, int maxKBytes)
Definition: tuplestore.c:318
HASH_BLOBS
#define HASH_BLOBS
Definition: hsearch.h:88
Counters::local_blks_read
int64 local_blks_read
Definition: pg_stat_statements.c:159
CaseExpr::args
List * args
Definition: primnodes.h:933
need_gc_qtexts
static bool need_gc_qtexts(void)
Definition: pg_stat_statements.c:2028
pg_strtouint64
uint64 pg_strtouint64(const char *str, char **endptr, int base)
Definition: numutils.c:558
PG_FINALLY
#define PG_FINALLY()
Definition: elog.h:339
PGSS_V1_0
Definition: pg_stat_statements.c:120
Const::location
int location
Definition: primnodes.h:221
JoinExpr::quals
Node * quals
Definition: primnodes.h:1493
BooleanTest::booltesttype
BoolTestType booltesttype
Definition: primnodes.h:1243
Datum
uintptr_t Datum
Definition: postgres.h:367
pg_stat_statements_reset_1_7
Datum pg_stat_statements_reset_1_7(PG_FUNCTION_ARGS)
Definition: pg_stat_statements.c:1305
GetDatabaseEncoding
int GetDatabaseEncoding(void)
Definition: mbutils.c:1046
pgss_shmem_shutdown
static void pgss_shmem_shutdown(int code, Datum arg)
Definition: pg_stat_statements.c:684
gc_qtexts
static void gc_qtexts(void)
Definition: pg_stat_statements.c:2075
add_size
Size add_size(Size s1, Size s2)
Definition: shmem.c:498
pgssLocationLen
struct pgssLocationLen pgssLocationLen
Counters::sum_var_time
double sum_var_time
Definition: pg_stat_statements.c:152
MyDatabaseId
Oid MyDatabaseId
Definition: globals.c:85
PGSSTrackLevel
PGSSTrackLevel
Definition: pg_stat_statements.c:254
Int64GetDatumFast
#define Int64GetDatumFast(X)
Definition: postgres.h:760
entry_reset
static void entry_reset(Oid userid, Oid dbid, uint64 queryid)
Definition: pg_stat_statements.c:2259
scanner_isspace
bool scanner_isspace(char ch)
Definition: scansup.c:220
HASHCTL::keysize
Size keysize
Definition: hsearch.h:72
RelabelType::resulttype
Oid resulttype
Definition: primnodes.h:815
work_mem
int work_mem
Definition: globals.c:121
Instrumentation::bufusage
BufferUsage bufusage
Definition: instrument.h:64
USAGE_INIT
#define USAGE_INIT
Definition: pg_stat_statements.c:106
core_yy_extra_type
Definition: scanner.h:66
core_yylex
int core_yylex(core_YYSTYPE *lvalp, YYLTYPE *llocp, core_yyscan_t yyscanner)
NullTest::nulltesttype
NullTestType nulltesttype
Definition: primnodes.h:1220
pgssEntry::key
pgssHashKey key
Definition: pg_stat_statements.c:178
PGSS_V1_1
Definition: pg_stat_statements.c:121
Aggref::aggfnoid
Oid aggfnoid
Definition: primnodes.h:312
TableFunc::colexprs
List * colexprs
Definition: primnodes.h:93
XmlExpr::named_args
List * named_args
Definition: primnodes.h:1183
ReturnSetInfo::allowedModes
int allowedModes
Definition: execnodes.h:302
PG_STAT_STATEMENTS_COLS
#define PG_STAT_STATEMENTS_COLS
Definition: pg_stat_statements.c:1336
free
#define free(a)
Definition: header.h:65
Query::commandType
CmdType commandType
Definition: parsenodes.h:112
XmlExpr::args
List * args
Definition: primnodes.h:1185
PG_RETURN_VOID
#define PG_RETURN_VOID()
Definition: fmgr.h:339
is_member_of_role
bool is_member_of_role(Oid member, Oid role)
Definition: acl.c:4924
Float8GetDatumFast
#define Float8GetDatumFast(X)
Definition: postgres.h:761
DatumGetUInt64
#define DatumGetUInt64(X)
Definition: postgres.h:634
ReturnSetInfo::returnMode
SetFunctionReturnMode returnMode
Definition: execnodes.h:304
QueryDesc::totaltime
struct Instrumentation * totaltime
Definition: execdesc.h:55
Max
#define Max(x, y)
Definition: c.h:905
ExecutorEnd_hook_type
void(* ExecutorEnd_hook_type)(QueryDesc *queryDesc)
Definition: executor.h:80
Counters::blk_read_time
double blk_read_time
Definition: pg_stat_statements.c:164
JoinExpr::rarg
Node * rarg
Definition: primnodes.h:1491
PG_VALID_BE_ENCODING
#define PG_VALID_BE_ENCODING(_enc)
Definition: pg_wchar.h:295
NamedArgExpr::arg
Expr * arg
Definition: primnodes.h:498
JoinExpr::jointype
JoinType jointype
Definition: primnodes.h:1488
pgss_track_utility
static bool pgss_track_utility
Definition: pg_stat_statements.c:271
Assert
#define Assert(condition)
Definition: c.h:739
lfirst
#define lfirst(lc)
Definition: pg_list.h:190
GetNamedLWLockTranche
LWLockPadded * GetNamedLWLockTranche(const char *tranche_name)
Definition: lwlock.c:552
CommonTableExpr::ctematerialized
CTEMaterialize ctematerialized
Definition: parsenodes.h:1450
RangeTblEntry::functions
List * functions
Definition: parsenodes.h:1061
WindowFunc::aggfilter
Expr * aggfilter
Definition: primnodes.h:378
Counters::local_blks_dirtied
int64 local_blks_dirtied
Definition: pg_stat_statements.c:160
TargetEntry::expr
Expr * expr
Definition: primnodes.h:1407
Param::paramid
int paramid
Definition: primnodes.h:263
EState::es_processed
uint64 es_processed
Definition: execnodes.h:553
PG_MODULE_MAGIC
PG_MODULE_MAGIC
Definition: pg_stat_statements.c:83
BufferUsage::blk_write_time
instr_time blk_write_time
Definition: instrument.h:32
Counters::local_blks_hit
int64 local_blks_hit
Definition: pg_stat_statements.c:158
Size
size_t Size
Definition: c.h:467
Counters
struct Counters Counters
WindowClause::endOffset
Node * endOffset
Definition: parsenodes.h:1355
CollateExpr::arg
Expr * arg
Definition: primnodes.h:900
Aggref::aggfilter
Expr * aggfilter
Definition: primnodes.h:322
LWLockAcquire
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1122
SetOperationStmt::op
SetOperation op
Definition: parsenodes.h:1655
Counters::blk_write_time
double blk_write_time
Definition: pg_stat_statements.c:165
RangeTblEntry::ctelevelsup
Index ctelevelsup
Definition: parsenodes.h:1078
MAXALIGN
#define MAXALIGN(LEN)
Definition: c.h:692
pgss_ProcessUtility
static void pgss_ProcessUtility(PlannedStmt *pstmt, const char *queryString, ProcessUtilityContext context, ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest, char *completionTag)
Definition: pg_stat_statements.c:960
record_gc_qtexts
#define record_gc_qtexts()
Definition: pg_stat_statements.c:279
RowMarkClause::waitPolicy
LockWaitPolicy waitPolicy
Definition: parsenodes.h:1382
pgssJumbleState
struct pgssJumbleState pgssJumbleState
hash_seq_search
void * hash_seq_search(HASH_SEQ_STATUS *status)
Definition: dynahash.c:1389
encoding
int32 encoding
Definition: pg_database.h:41
ExprContext::ecxt_per_query_memory
MemoryContext ecxt_per_query_memory
Definition: execnodes.h:230
post_parse_analyze_hook_type
void(* post_parse_analyze_hook_type)(ParseState *pstate, Query *query)
Definition: analyze.h:20
BoolExpr::args
List * args
Definition: primnodes.h:583
header
static void header(const char *fmt,...) pg_attribute_printf(1
Definition: pg_regress.c:209
repalloc
void * repalloc(void *pointer, Size size)
Definition: mcxt.c:1069
hash_seq_init
void hash_seq_init(HASH_SEQ_STATUS *status, HTAB *hashp)
Definition: dynahash.c:1379
INSTR_TIME_SET_CURRENT
#define INSTR_TIME_SET_CURRENT(t)
Definition: instr_time.h:156
nodeTag
#define nodeTag(nodeptr)
Definition: nodes.h:530
ReturnSetInfo::setResult
Tuplestorestate * setResult
Definition: execnodes.h:307
prev_shmem_startup_hook
static shmem_startup_hook_type prev_shmem_startup_hook
Definition: pg_stat_statements.c:240
QueryDesc::sourceText
const char * sourceText
Definition: execdesc.h:38
RangeTblEntry::rtekind
RTEKind rtekind
Definition: parsenodes.h:974
yyscanner
static core_yyscan_t yyscanner
Definition: pl_scanner.c:106
FreeFile
int FreeFile(FILE *file)
Definition: fd.c:2440
values
static Datum values[MAXATTR]
Definition: bootstrap.c:167
WindowClause::orderClause
List * orderClause
Definition: parsenodes.h:1352
OnConflictExpr::arbiterWhere
Node * arbiterWhere
Definition: primnodes.h:1531
SubscriptingRef::refassgnexpr
Expr * refassgnexpr
Definition: primnodes.h:430
ReturnSetInfo::econtext
ExprContext * econtext
Definition: execnodes.h:300
RangeTblEntry::ctename
char * ctename
Definition: parsenodes.h:1077
Query::cteList
List * cteList
Definition: parsenodes.h:135
Query::setOperations
Node * setOperations
Definition: parsenodes.h:165
e
e
Definition: preproc-init.c:82
RangeTblEntry::subquery
Query * subquery
Definition: parsenodes.h:1009
Query::groupClause
List * groupClause
Definition: parsenodes.h:148
ReturnSetInfo::setDesc
TupleDesc setDesc
Definition: execnodes.h:308
pgss_ExecutorFinish
static void pgss_ExecutorFinish(QueryDesc *queryDesc)
Definition: pg_stat_statements.c:907
palloc
void * palloc(Size size)
Definition: mcxt.c:949
PlannedStmt::queryId
uint64 queryId
Definition: plannodes.h:48
errmsg
int errmsg(const char *fmt,...)
Definition: elog.c:822
pgss_store
static void pgss_store(const char *query, uint64 queryId, int query_location, int query_len, double total_time, uint64 rows, const BufferUsage *bufusage, pgssJumbleState *jstate)
Definition: pg_stat_statements.c:1094
BufferUsage::shared_blks_hit
long shared_blks_hit
Definition: instrument.h:21
pg_stat_statements
Datum pg_stat_statements(PG_FUNCTION_ARGS)
Definition: pg_stat_statements.c:1373
ExecutorStart_hook_type
void(* ExecutorStart_hook_type)(QueryDesc *queryDesc, int eflags)
Definition: executor.h:65
BufferUsage::local_blks_written
long local_blks_written
Definition: instrument.h:28
SubscriptingRef::reflowerindexpr
List * reflowerindexpr
Definition: primnodes.h:424
elog
#define elog(elevel,...)
Definition: elog.h:228
i
int i
Definition: preproc-comment.c:23
pg_authid.h
OnConflictExpr::onConflictSet
List * onConflictSet
Definition: primnodes.h:1535
core_yy_extra_type::escape_string_warning
bool escape_string_warning
Definition: scanner.h:88
HASH_SEQ_STATUS
Definition: hsearch.h:112
PGSS_FILE_HEADER
static const uint32 PGSS_FILE_HEADER
Definition: pg_stat_statements.c:99
TargetEntry::ressortgroupref
Index ressortgroupref
Definition: primnodes.h:1410
CStringGetTextDatum
#define CStringGetTextDatum(s)
Definition: builtins.h:83
arg
void * arg
Definition: pg_backup_utils.c:27
PG_FUNCTION_ARGS
#define PG_FUNCTION_ARGS
Definition: fmgr.h:188
MinMaxExpr::op
MinMaxOp op
Definition: primnodes.h:1105
scanner_finish
void scanner_finish(core_yyscan_t yyscanner)
SubscriptingRef::refexpr
Expr * refexpr
Definition: primnodes.h:427
ExecutorFinish_hook
ExecutorFinish_hook_type ExecutorFinish_hook
Definition: execMain.c:72
PGSS_TRACK_NONE
Definition: pg_stat_statements.c:256
CaseExpr::arg
Expr * arg
Definition: primnodes.h:932
OpExpr::opno
Oid opno
Definition: primnodes.h:516
PGSS_V1_3
Definition: pg_stat_statements.c:123
ShmemInitHash
HTAB * ShmemInitHash(const char *name, long init_size, long max_size, HASHCTL *infoP, int hash_flags)
Definition: shmem.c:337
CaseWhen::result
Expr * result
Definition: primnodes.h:945
pgssHashKey
struct pgssHashKey pgssHashKey
QueryDesc::plannedstmt
PlannedStmt * plannedstmt
Definition: execdesc.h:37
qsort
#define qsort(a, b, c, d)
Definition: port.h:491
OpExpr::args
List * args
Definition: primnodes.h:522
Query::havingQual
Node * havingQual
Definition: parsenodes.h:152
CaseExpr::defresult
Expr * defresult
Definition: primnodes.h:934
pg_any_to_server
char * pg_any_to_server(const char *s, int len, int encoding)
Definition: mbutils.c:581
CaseWhen::expr
Expr * expr
Definition: primnodes.h:944
PG_TRY
#define PG_TRY()
Definition: elog.h:322
PG_GETARG_INT64
#define PG_GETARG_INT64(n)
Definition: fmgr.h:277
pgss_ExecutorEnd
static void pgss_ExecutorEnd(QueryDesc *queryDesc)
Definition: pg_stat_statements.c:928
OnConflictExpr::onConflictWhere
Node * onConflictWhere
Definition: primnodes.h:1536
PGSS_TEXT_FILE
#define PGSS_TEXT_FILE
Definition: pg_stat_statements.c:96
DefineCustomBoolVariable
void DefineCustomBoolVariable(const char *name, const char *short_desc, const char *long_desc, bool *valueAddr, bool bootValue, GucContext context, int flags, GucBoolCheckHook check_hook, GucBoolAssignHook assign_hook, GucShowHook show_hook)
Definition: guc.c:8649
JoinExpr::rtindex
int rtindex
Definition: primnodes.h:1495
List
Definition: pg_list.h:50
RangeTblEntry::tablesample
struct TableSampleClause * tablesample
Definition: parsenodes.h:1004
Query::stmt_len
int stmt_len
Definition: parsenodes.h:181
nested_level
static int nested_level
Definition: pg_stat_statements.c:237
Param::paramtype
Oid paramtype
Definition: primnodes.h:264
post_parse_analyze_hook
post_parse_analyze_hook_type post_parse_analyze_hook
Definition: analyze.c:51
pg_stat_statements_1_2
Datum pg_stat_statements_1_2(PG_FUNCTION_ARGS)
Definition: pg_stat_statements.c:1359
PG_END_TRY
#define PG_END_TRY()
Definition: elog.h:347
ASSUMED_MEDIAN_INIT
#define ASSUMED_MEDIAN_INIT
Definition: pg_stat_statements.c:107
read
#define read(a, b, c)
Definition: win32.h:13
hash_seq_term
void hash_seq_term(HASH_SEQ_STATUS *status)
Definition: dynahash.c:1465
track_options
static const struct config_enum_entry track_options[]
Definition: pg_stat_statements.c:261
pgBufferUsage
BufferUsage pgBufferUsage
Definition: instrument.c:20
PG_STAT_STATEMENTS_COLS_V1_2
#define PG_STAT_STATEMENTS_COLS_V1_2
Definition: pg_stat_statements.c:1334
pgss_save
static bool pgss_save
Definition: pg_stat_statements.c:272
qtext_fetch
static char * qtext_fetch(Size query_offset, int query_len, char *buffer, Size buffer_size)
Definition: pg_stat_statements.c:2005
PG_FUNCTION_INFO_V1
PG_FUNCTION_INFO_V1(pg_stat_statements_reset)
T_Param
Definition: nodes.h:153
FieldSelect::fieldnum
AttrNumber fieldnum
Definition: primnodes.h:763
ftruncate
#define ftruncate(a, b)
Definition: win32_port.h:60