/*------------------------------------------------------------------------- * * pg_stat_statements . c * Track statement planning and execution times as well as resource * usage across a whole database cluster . * * Execution costs are totaled for each distinct source query , and kept in * a shared hashtable . ( We track only as many distinct queries as will fit * in the designated amount of shared memory . ) * * Starting in Postgres 9 . 2 , this module normalized query entries . As of * Postgres 14 , the normalization is done by the core if compute_query_id is * enabled , or optionally by third - party modules . * * To facilitate presenting entries to users , we create " representative " query * strings in which constants are replaced with parameter symbols ( $ n ) , to * make it clearer what a normalized entry can represent . To save on shared * memory , and to avoid having to truncate oversized query strings , we store * these strings in a temporary external query - texts file . Offsets into this * file are kept in shared memory . * * Note about locking issues : to create or delete an entry in the shared * hashtable , one must hold pgss - > lock exclusively . Modifying any field * in an entry except the counters requires the same . To look up an entry , * one must hold the lock shared . To read or update the counters within * an entry , one must hold the lock shared or exclusive ( so the entry doesn ' t * disappear ! ) and also take the entry ' s mutex spinlock . * The shared state variable pgss - > extent ( the next free spot in the external * query - text file ) should be accessed only while holding either the * pgss - > mutex spinlock , or exclusive lock on pgss - > lock . We use the mutex to * allow reserving file space while holding only shared lock on pgss - > lock . * Rewriting the entire external query - text file , eg for garbage collection , * requires holding pgss - > lock exclusively ; this allows individual entries * in the file to be read or written while holding only shared lock . * * * Copyright ( c ) 2008 - 2025 , PostgreSQL Global Development Group * * IDENTIFICATION * contrib / pg_stat_statements / pg_stat_statements . c * * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #include "postgres.h" #include <math.h>#include <sys/stat.h>#include <unistd.h>#include "access/parallel.h" #include "catalog/pg_authid.h" #include "common/int.h" #include "executor/instrument.h" #include "funcapi.h" #include "jit/jit.h" #include "mb/pg_wchar.h" #include "miscadmin.h" #include "nodes/queryjumble.h" #include "optimizer/planner.h" #include "parser/analyze.h" #include "parser/scanner.h" #include "pgstat.h" #include "storage/fd.h" #include "storage/ipc.h" #include "storage/lwlock.h" #include "storage/shmem.h" #include "storage/spin.h" #include "tcop/utility.h" #include "utils/acl.h" #include "utils/builtins.h" #include "utils/memutils.h" #include "utils/timestamp.h" "pg_stat_statements" ,/* Location of permanent stats file (valid when database is shut down) */ #define PGSS_DUMP_FILE PGSTAT_STAT_PERMANENT_DIRECTORY "/pg_stat_statements.stat" /* * Location of external query text file . #define PGSS_TEXT_FILE PG_STAT_TMP_DIR "/pgss_query_texts.stat" /* Magic number identifying the stats file format */ static const uint32 PGSS_FILE_HEADER = 0 x20220408;/* PostgreSQL major version number, changes in which invalidate all entries */ static const uint32 PGSS_PG_MAJOR_VERSION = PG_VERSION_NUM / 100 ;/* XXX: Should USAGE_EXEC reflect execution time and/or buffer usage? */ #define USAGE_EXEC(duration) (1 .0 )#define USAGE_INIT (1 .0 ) /* including initial planning */ #define ASSUMED_MEDIAN_INIT (10 .0 ) /* initial assumed median usage */ #define ASSUMED_LENGTH_INIT 1024 /* initial assumed mean query length */ #define USAGE_DECREASE_FACTOR (0 .99 ) /* decreased every entry_dealloc */ #define STICKY_DECREASE_FACTOR (0 .50 ) /* factor for sticky entries */ #define USAGE_DEALLOC_PERCENT 5 /* free this % of entries at once */ #define IS_STICKY(c) ((c.calls[PGSS_PLAN] + c.calls[PGSS_EXEC]) == 0 )/* * Extension version number , for supporting older extension versions ' objects typedef enum pgssVersion0 ,typedef enum pgssStoreKind1 ,/* * PGSS_PLAN and PGSS_EXEC must be respectively 0 and 1 as they ' re used to * reference the underlying values in the arrays in the Counters struct , * and this order is required in pg_stat_statements_internal ( ) . 0 ,#define PGSS_NUMKIND (PGSS_EXEC + 1 )/* * Hashtable key that defines the identity of a hashtable entry . We separate * queries by user and by database even if they are otherwise identical . * * If you add a new key to this struct , make sure to teach pgss_store ( ) to * zero the padding bytes . Otherwise , things will break , because pgss_hash is * created using HASH_BLOBS , and thus tag_hash is used to hash this . typedef struct pgssHashKey/* user OID */ /* database OID */ /* query identifier */ bool toplevel; /* query executed at top level */ /* * The actual stats counters kept within pgssEntry . typedef struct Counters/* # of times planned/executed */ double total_time[PGSS_NUMKIND]; /* total planning/execution time, double min_time[PGSS_NUMKIND]; /* minimum planning/execution time in double max_time[PGSS_NUMKIND]; /* maximum planning/execution time in double mean_time[PGSS_NUMKIND]; /* mean planning/execution time in double sum_var_time[PGSS_NUMKIND]; /* sum of variances in /* total # of retrieved or affected rows */ /* # of shared buffer hits */ /* # of shared disk blocks read */ /* # of shared disk blocks dirtied */ /* # of shared disk blocks written */ /* # of local buffer hits */ /* # of local disk blocks read */ /* # of local disk blocks dirtied */ /* # of local disk blocks written */ /* # of temp blocks read */ /* # of temp blocks written */ double shared_blk_read_time; /* time spent reading shared blocks, double shared_blk_write_time; /* time spent writing shared blocks, double local_blk_read_time; /* time spent reading local blocks, in double local_blk_write_time; /* time spent writing local blocks, in double temp_blk_read_time; /* time spent reading temp blocks, in msec */ double temp_blk_write_time; /* time spent writing temp blocks, in double usage; /* usage factor */ /* # of WAL records generated */ /* # of WAL full page images generated */ /* total amount of WAL generated in bytes */ /* # of times the WAL buffers became full */ /* total number of JIT functions emitted */ double jit_generation_time; /* total time to generate jit code */ /* number of times inlining time has been double jit_deform_time; /* total time to deform tuples in jit code */ /* number of times deform time has been > double jit_inlining_time; /* total time to inline jit code */ /* number of times optimization time double jit_optimization_time; /* total time to optimize jit code */ /* number of times emission time has been double jit_emission_time; /* total time to emit jit code */ /* # of parallel workers planned /* # of parallel workers actually /* * Global statistics for pg_stat_statements typedef struct pgssGlobalStats/* # of times entries were deallocated */ /* timestamp with all stats reset */ /* * Statistics per statement * * Note : in event of a failure in garbage collection of the query text file , * we reset query_offset to zero and query_len to - 1 . This will be seen as * an invalid state by qtext_fetch ( ) . typedef struct pgssEntry/* hash key of entry - MUST BE FIRST */ /* the statistics for this query */ /* query text offset in external file */ int query_len; /* # of valid bytes in query string, or -1 */ int encoding; /* query text encoding */ /* timestamp of entry allocation */ /* timestamp of last min/max values reset */ /* protects the counters only */ /* * Global shared state typedef struct pgssSharedState/* protects hashtable search/modification */ double cur_median_usage; /* current median usage in hashtable */ /* current mean entry text length */ /* protects following fields only: */ /* current extent of query file */ int n_writers; /* number of active writers to query file */ int gc_count; /* query file garbage collection cycle count */ /* global statistics for pgss */ /*---- Local variables ----*/ /* Current nesting depth of planner/ExecutorRun/ProcessUtility calls */ static int nesting_level = 0 ;/* Saved hook values */ static shmem_request_hook_type prev_shmem_request_hook = NULL;static shmem_startup_hook_type prev_shmem_startup_hook = NULL;static post_parse_analyze_hook_type prev_post_parse_analyze_hook = NULL;static planner_hook_type prev_planner_hook = NULL;static ExecutorStart_hook_type prev_ExecutorStart = NULL;static ExecutorRun_hook_type prev_ExecutorRun = NULL;static ExecutorFinish_hook_type prev_ExecutorFinish = NULL;static ExecutorEnd_hook_type prev_ExecutorEnd = NULL;static ProcessUtility_hook_type prev_ProcessUtility = NULL;/* Links to shared memory state */ static pgssSharedState *pgss = NULL;static HTAB *pgss_hash = NULL;/*---- GUC variables ----*/ typedef enum /* track no statements */ /* only top level statements */ /* all statements, including nested ones */ static const struct config_enum_entry track_options[] ="none" , PGSS_TRACK_NONE, false },"top" , PGSS_TRACK_TOP, false },"all" , PGSS_TRACK_ALL, false },0 , false }static int pgss_max = 5000 ; /* max # statements to track */ static int pgss_track = PGSS_TRACK_TOP; /* tracking level */ static bool pgss_track_utility = true ; /* whether to track utility commands */ static bool pgss_track_planning = false ; /* whether to track planning static bool pgss_save = true ; /* whether to save stats across shutdown */ #define pgss_enabled(level) \0 )))#define record_gc_qtexts() \do { \while (0 )/*---- Function declarations ----*/ static void pgss_shmem_request(void );static void pgss_shmem_startup(void );static void pgss_shmem_shutdown(int code, Datum arg);static void pgss_post_parse_analyze(ParseState *pstate, Query *query,static PlannedStmt *pgss_planner(Query *parse,const char *query_string,int cursorOptions,static void pgss_ExecutorStart(QueryDesc *queryDesc, int eflags);static void pgss_ExecutorRun(QueryDesc *queryDesc,static void pgss_ExecutorFinish(QueryDesc *queryDesc);static void pgss_ExecutorEnd(QueryDesc *queryDesc);static void pgss_ProcessUtility(PlannedStmt *pstmt, const char *queryString,bool readOnlyTree,static void pgss_store(const char *query, int64 queryId,int query_location, int query_len,double total_time, uint64 rows,const BufferUsage *bufusage,const WalUsage *walusage,const struct JitInstrumentation *jitusage,int parallel_workers_to_launch,int parallel_workers_launched);static void pg_stat_statements_internal(FunctionCallInfo fcinfo,bool showtext);static Size pgss_memsize(void );static pgssEntry *entry_alloc(pgssHashKey *key, Size query_offset, int query_len,int encoding, bool sticky);static void entry_dealloc(void );static bool qtext_store(const char *query, int query_len,int *gc_count);static char *qtext_load_file(Size *buffer_size);static char *qtext_fetch(Size query_offset, int query_len,char *buffer, Size buffer_size);static bool need_gc_qtexts(void );static void gc_qtexts(void );static TimestampTz entry_reset(Oid userid, Oid dbid, int64 queryid, bool minmax_only);static char *generate_normalized_query(JumbleState *jstate, const char *query,int query_loc, int *query_len_p);static void fill_in_constant_lengths(JumbleState *jstate, const char *query,int query_loc);static int comp_location(const void *a, const void *b);/* * Module load callback void void )/* * In order to create our shared memory area , we have to be loaded via * shared_preload_libraries . If not , fall out without hooking into any of * the main system . ( We don ' t throw error here because it seems useful to * allow the pg_stat_statements functions to be created even when the * module isn ' t active . The functions must protect themselves against * being called then , however . ) if (!process_shared_preload_libraries_in_progress)return ;/* * Inform the postmaster that we want to enable query_id calculation if * compute_query_id is set to auto . /* * Define ( or redefine ) custom GUC variables . "pg_stat_statements.max" ,"Sets the maximum number of statements tracked by pg_stat_statements." ,5000 ,100 ,2 ,0 ,"pg_stat_statements.track" ,"Selects which statements are tracked by pg_stat_statements." ,0 ,"pg_stat_statements.track_utility" ,"Selects whether utility commands are tracked by pg_stat_statements." ,true ,0 ,"pg_stat_statements.track_planning" ,"Selects whether planning duration is tracked by pg_stat_statements." ,false ,0 ,"pg_stat_statements.save" ,"Save pg_stat_statements statistics across server shutdowns." ,true ,0 ,"pg_stat_statements" );/* * Install hooks . /* * shmem_request hook : request additional shared resources . We ' ll allocate or * attach to the shared resources in pgss_shmem_startup ( ) . static void void )if (prev_shmem_request_hook)"pg_stat_statements" , 1 );/* * shmem_startup hook : allocate or attach to shared memory , * then load any pre - existing statistics from file . * Also create and load the query - texts file , which is expected to exist * ( even if empty ) while the module is enabled . static void void )bool found;int buffer_size;char *buffer = NULL;if (prev_shmem_startup_hook)/* reset in case this is a restart within the postmaster */ /* * Create or attach to the shared memory state , including hash table "pg_stat_statements" ,sizeof (pgssSharedState),if (!found)/* First time through ... */ "pg_stat_statements" ))->lock;0 ;0 ;0 ;0 ;sizeof (pgssHashKey);sizeof (pgssEntry);"pg_stat_statements hash" ,/* * If we ' re in the postmaster ( or a standalone backend . . . ) , set up a shmem * exit hook to dump the statistics to disk . if (!IsUnderPostmaster)0 );/* * Done if some other process already completed our initialization . if (found)return ;/* * Note : we don ' t bother with locks here , because there should be no other * processes running when this code is reached . /* Unlink query text file possibly left over from crash */ /* Allocate new query text temp file */ if (qfile == NULL)goto write_error;/* * If we were told not to load old statistics , we ' re done . ( Note we do * not try to unlink any old dump file in this case . This seems a bit * questionable but it ' s the historical behavior . ) if (!pgss_save)return ;/* * Attempt to load old statistics from the dump file . if (file == NULL)if (errno != ENOENT)goto read_error;/* No existing persisted stats file, so we're done */ return ;2048 ;char *) palloc(buffer_size);if (fread(&header, sizeof (uint32), 1 , file) != 1 ||sizeof (uint32), 1 , file) != 1 ||sizeof (int32), 1 , file) != 1 )goto read_error;if (header != PGSS_FILE_HEADER ||goto data_error;for (i = 0 ; i < num; i++)if (fread(&temp, sizeof (pgssEntry), 1 , file) != 1 )goto read_error;/* Encoding is the only field we can easily sanity-check */ if (!PG_VALID_BE_ENCODING(temp.encoding))goto data_error;/* Resize buffer as needed */ if (temp.query_len >= buffer_size)2 , temp.query_len + 1 );if (fread(buffer, 1 , temp.query_len + 1 , file) != temp.query_len + 1 )goto read_error;/* Should have a trailing null, but let's make sure */ '\0' ;/* Skip loading "sticky" entries */ if (IS_STICKY(temp.counters))continue ;/* Store the query text */ if (fwrite(buffer, 1 , temp.query_len + 1 , qfile) != temp.query_len + 1 )goto write_error;1 ;/* make the hashtable entry (discards old entries if too many) */ false );/* copy in the actual stats */ /* Read global statistics for pg_stat_statements */ if (fread(&pgss->stats, sizeof (pgssGlobalStats), 1 , file) != 1 )goto read_error;/* * Remove the persisted stats file so it ' s not included in * backups / replication standbys , etc . A new file will be written on next * shutdown . * * Note : it ' s okay if the PGSS_TEXT_FILE is included in a basebackup , * because we remove that file on startup ; it acts inversely to * PGSS_DUMP_FILE , in that it is only supposed to be around when the * server is running , whereas PGSS_DUMP_FILE is only supposed to be around * when the server is not running . Leaving the file creates no danger of * a newly restored database having a spurious record of execution costs , * which is what we ' re really concerned about here . return ;"could not read file \" %s\": %m" ,goto fail;"ignoring invalid data in file \" %s\"" ,goto fail;"could not write file \" %s\": %m" ,if (buffer)if (file)if (qfile)/* If possible, throw away the bogus file; ignore any error */ /* * Don ' t unlink PGSS_TEXT_FILE here ; it should always be around while the * server is running with pg_stat_statements enabled /* * shmem_shutdown hook : Dump statistics into file . * * Note : we don ' t bother with acquiring lock , because there should be no * other processes running when this is called . static void int code, Datum arg)char *qbuffer = NULL;0 ;/* Don't try to dump during a crash. */ if (code)return ;/* Safety check ... shouldn't get here unless shmem is set up. */ if (!pgss || !pgss_hash)return ;/* Don't dump if told not to. */ if (!pgss_save)return ;".tmp" , PG_BINARY_W);if (file == NULL)goto error;if (fwrite(&PGSS_FILE_HEADER, sizeof (uint32), 1 , file) != 1 )goto error;if (fwrite(&PGSS_PG_MAJOR_VERSION, sizeof (uint32), 1 , file) != 1 )goto error;if (fwrite(&num_entries, sizeof (int32), 1 , file) != 1 )goto error;if (qbuffer == NULL)goto error;/* * When serializing to disk , we store query texts immediately after their * entry data . Any orphaned query texts are thereby excluded . while ((entry = hash_seq_search(&hash_seq)) != NULL)int len = entry->query_len;char *qstr = qtext_fetch(entry->query_offset, len,if (qstr == NULL)continue ; /* Ignore any entries with bogus texts */ if (fwrite(entry, sizeof (pgssEntry), 1 , file) != 1 ||1 , len + 1 , file) != len + 1 )/* note: we assume hash_seq_term won't change errno */ goto error;/* Dump global statistics for pg_stat_statements */ if (fwrite(&pgss->stats, sizeof (pgssGlobalStats), 1 , file) != 1 )goto error;if (FreeFile(file))goto error;/* * Rename file into place , so we atomically replace any old one . void ) durable_rename(PGSS_DUMP_FILE ".tmp" , PGSS_DUMP_FILE, LOG);/* Unlink query-texts file; it's not needed while shutdown */ return ;"could not write file \" %s\": %m" ,".tmp" )));if (qbuffer)if (file)".tmp" );/* * Post - parse - analysis hook : mark query with a queryId static void if (prev_post_parse_analyze_hook)/* Safety check... */ if (!pgss || !pgss_hash || !pgss_enabled(nesting_level))return ;/* * If it ' s EXECUTE , clear the queryId so that stats will accumulate for * the underlying PREPARE . But don ' t do this if we ' re not tracking * utility statements , to avoid messing up another extension that might be * tracking them . if (query->utilityStmt)if (pgss_track_utility && IsA(query->utilityStmt, ExecuteStmt))0 );return ;/* * If query jumbling were able to identify any ignorable constants , we * immediately create a hash table entry for the query , so that we can * record the normalized form of the query string . If there were no such * constants , the normalized string would be the same as the query text * anyway , so there ' s no need for an early entry . if (jstate && jstate->clocations_count > 0 )0 ,0 ,0 ,0 );/* * Planner hook : forward to regular planner , but measure planning time * if needed . static PlannedStmt *const char *query_string,int cursorOptions,/* * We can ' t process the query if no query_string is provided , as * pgss_store needs it . We also ignore query without queryid , as it would * be treated as a utility statement , which may not be the case . if (pgss_enabled(nesting_level)0 ))/* We need to track buffer usage as the planner can access them. */ /* * Similarly the planner could write some WAL records in some cases * ( e . g . setting a hint bit with those being WAL - logged ) if (prev_planner_hook)else /* calc differences of buffer counters. */ 0 , sizeof (BufferUsage));/* calc differences of WAL counters. */ 0 , sizeof (WalUsage));0 ,0 ,0 );else /* * Even though we ' re not tracking plan time for this statement , we * must still increment the nesting level , to ensure that functions * evaluated during planning are not seen as top - level calls . if (prev_planner_hook)else return result;/* * ExecutorStart hook : start up tracking if needed static void int eflags)if (prev_ExecutorStart)else /* * If query has queryId zero , don ' t track it . This prevents double * counting of optimizable statements that are directly contained in * utility statements . if (pgss_enabled(nesting_level) && queryDesc->plannedstmt->queryId != INT64CONST(0 ))/* * Set up to track total elapsed time in ExecutorRun . Make sure the * space is allocated in the per - query context so it will go away at * ExecutorEnd . if (queryDesc->totaltime == NULL)1 , INSTRUMENT_ALL, false );/* * ExecutorRun hook : all we need do is track nesting depth static void if (prev_ExecutorRun)else /* * ExecutorFinish hook : all we need do is track nesting depth static void if (prev_ExecutorFinish)else /* * ExecutorEnd hook : store results if needed static void if (queryId != INT64CONST(0 ) && queryDesc->totaltime &&/* * Make sure stats accumulation is done . ( Note : it ' s okay if several * levels of hook all do this . ) 1000 .0 , /* convert to msec */ if (prev_ExecutorEnd)else /* * ProcessUtility hook static void const char *queryString,bool readOnlyTree,int saved_stmt_location = pstmt->stmt_location;int saved_stmt_len = pstmt->stmt_len;bool enabled = pgss_track_utility && pgss_enabled(nesting_level);/* * Force utility statements to get queryId zero . We do this even in cases * where the statement contains an optimizable statement for which a * queryId could be derived ( such as EXPLAIN or DECLARE CURSOR ) . For such * cases , runtime control will first go through ProcessUtility and then * the executor , and we don ' t want the executor hooks to do anything , * since we are already measuring the statement ' s costs at the utility * level . * * Note that this is only done if pg_stat_statements is enabled and * configured to track utility statements , in the unlikely possibility * that user configured another extension to handle utility statements * only . if (enabled)0 );/* * If it ' s an EXECUTE statement , we don ' t track it and don ' t increment the * nesting level . This allows the cycles to be charged to the underlying * PREPARE instead ( by the Executor hooks ) , which is much more useful . * * We also don ' t track execution of PREPARE . If we did , we would get one * hash table entry for the PREPARE ( with hash calculated from the query * string ) , and then a different one with the same query string ( but hash * calculated from the query tree ) would be used to accumulate costs of * ensuing EXECUTEs . This would be confusing . Since PREPARE doesn ' t * actually run the planner ( only parse + rewrite ) , its costs are generally * pretty negligible and it seems okay to just ignore it . if (enabled &&if (prev_ProcessUtility)else /* * CAUTION : do not access the * pstmt data structure again below here . * If it was a ROLLBACK or similar , that data structure may have been * freed . We must copy everything we still need into local variables , * which we did above . * * For the same reason , we can ' t risk restoring pstmt - > queryId to its * former value , which ' d otherwise be a good idea . /* * Track the total number of rows retrieved or affected by the utility * statements of COPY , FETCH , CREATE TABLE AS , CREATE MATERIALIZED * VIEW , REFRESH MATERIALIZED VIEW and SELECT INTO . 0 ;/* calc differences of buffer counters. */ 0 , sizeof (BufferUsage));/* calc differences of WAL counters. */ 0 , sizeof (WalUsage));0 ,0 );else /* * Even though we ' re not tracking execution time for this statement , * we must still increment the nesting level , to ensure that functions * evaluated within it are not seen as top - level calls . But don ' t do * so for EXECUTE ; that way , when control reaches pgss_planner or * pgss_ExecutorStart , we will treat the costs as top - level if * appropriate . Likewise , don ' t bump for PREPARE , so that parse * analysis will treat the statement as top - level if appropriate . * * To be absolutely certain we don ' t mess up the nesting level , * evaluate the bump_level condition just once . bool bump_level =if (bump_level)if (prev_ProcessUtility)else if (bump_level)/* * Store some statistics for a statement . * * If jstate is not NULL then we ' re trying to create an entry for which * we have no statistics as yet ; we just want to record the normalized * query string . total_time , rows , bufusage and walusage are ignored in this * case . * * If kind is PGSS_PLAN or PGSS_EXEC , its value is used as the array position * for the arrays in the Counters field . static void const char *query, int64 queryId,int query_location, int query_len,double total_time, uint64 rows,const BufferUsage *bufusage,const WalUsage *walusage,const struct JitInstrumentation *jitusage,int parallel_workers_to_launch,int parallel_workers_launched)char *norm_query = NULL;int encoding = GetDatabaseEncoding();/* Safety check... */ if (!pgss || !pgss_hash)return ;/* * Nothing to do if compute_query_id isn ' t enabled and no other module * computed a query identifier . if (queryId == INT64CONST(0 ))return ;/* * Confine our attention to the relevant part of the string , if the query * is a portion of a multi - statement source string , and update query * location and length if needed . /* Set up key for hashtable search */ /* clear padding */ 0 , sizeof (pgssHashKey));0 );/* Lookup the hash table entry with shared lock. */ /* Create new entry, if not present */ if (!entry)int gc_count;bool stored;bool do_gc;/* * Create a new , normalized query string if caller asked . We don ' t * need to hold the lock while doing this work . ( Note : in any case , * it ' s possible that someone else creates a duplicate hashtable entry * in the interval where we don ' t hold the lock below . That case is * handled by entry_alloc . ) if (jstate)/* Append new query text to file with only shared lock held */ /* * Determine whether we need to garbage collect external query texts * while the shared lock is still held . This micro - optimization * avoids taking the time to decide this while holding exclusive lock . /* Need exclusive lock to make a new hashtable entry - promote */ /* * A garbage collection may have occurred while we weren ' t holding the * lock . In the unlikely event that this happens , the query text we * stored above will have been garbage collected , so write it again . * This should be infrequent enough that doing it while holding * exclusive lock isn ' t a performance problem . if (!stored || pgss->gc_count != gc_count)/* If we failed to write to the text file, give up */ if (!stored)goto done;/* OK to create a new hashtable entry */ /* If needed, perform garbage collection while exclusive lock held */ if (do_gc)/* Increment the counts, except when jstate is not NULL */ if (!jstate)/* * Grab the spinlock while updating the counters ( see comment about * locking rules at the head of the file ) /* "Unstick" entry if it was previously sticky */ if (IS_STICKY(entry->counters))1 ;if (entry->counters.calls[kind] == 1 )else /* * Welford ' s method for accurately computing variance . See * < http : //www.johndcook.com/blog/standard_deviation/> double old_mean = entry->counters.mean_time[kind];/* * Calculate min and max time . min = 0 and max = 0 means that the * min / max statistics were reset if (entry->counters.min_time[kind] == 0 0 )else if (entry->counters.min_time[kind] > total_time)if (entry->counters.max_time[kind] < total_time)_read_time);k_write_time);ead_time);write_time);d_time);ite_time);if (jitusage)counter);if (INSTR_TIME_GET_MILLISEC(jitusage->deform_counter));if (INSTR_TIME_GET_MILLISEC(jitusage->inlining_counter))ter);if (INSTR_TIME_GET_MILLISEC(jitusage->optimization_counter))ion_counter);if (INSTR_TIME_GET_MILLISEC(jitusage->emission_counter))ter);/* parallel worker counters */ /* We postpone this clean-up until we're out of the lock */ if (norm_query)/* * Reset statement statistics corresponding to userid , dbid , and queryid . 0 );1 );2 );false );bool minmax_only;0 );1 );2 );3 );/* * Reset statement statistics . 0 , 0 , 0 , false );/* Number of output arguments (columns) for various API versions */ #define PG_STAT_STATEMENTS_COLS_V1_0 14 #define PG_STAT_STATEMENTS_COLS_V1_1 18 #define PG_STAT_STATEMENTS_COLS_V1_2 19 #define PG_STAT_STATEMENTS_COLS_V1_3 23 #define PG_STAT_STATEMENTS_COLS_V1_8 32 #define PG_STAT_STATEMENTS_COLS_V1_9 33 #define PG_STAT_STATEMENTS_COLS_V1_10 43 #define PG_STAT_STATEMENTS_COLS_V1_11 49 #define PG_STAT_STATEMENTS_COLS_V1_12 52 #define PG_STAT_STATEMENTS_COLS 52 /* maximum of above */ /* * Retrieve statement statistics . * * The SQL API of this function has changed multiple times , and will likely * do so again in future . To support the case where a newer version of this * loadable module is being used with an old SQL declaration of the function , * we continue to support the older API versions . For 1 . 2 and later , the * expected API version is identified by embedding it in the C name of the * function . Unfortunately we weren ' t bright enough to do that for 1 . 1 . bool showtext = PG_GETARG_BOOL(0 );return (Datum) 0 ;bool showtext = PG_GETARG_BOOL(0 );return (Datum) 0 ;bool showtext = PG_GETARG_BOOL(0 );return (Datum) 0 ;bool showtext = PG_GETARG_BOOL(0 );return (Datum) 0 ;bool showtext = PG_GETARG_BOOL(0 );return (Datum) 0 ;bool showtext = PG_GETARG_BOOL(0 );return (Datum) 0 ;bool showtext = PG_GETARG_BOOL(0 );return (Datum) 0 ;/* * Legacy entry point for pg_stat_statements ( ) API versions 1 . 0 and 1 . 1 . * This can be removed someday , perhaps . /* If it's really API 1.1, we'll figure that out below */ true );return (Datum) 0 ;/* Common code for all versions of pg_stat_statements() */ static void bool showtext)bool is_allowed_role = false ;char *qbuffer = NULL;0 ;0 ;int gc_count = 0 ;/* * Superusers or roles with the privileges of pg_read_all_stats members * are allowed /* hash table must exist already */ if (!pgss || !pgss_hash)"pg_stat_statements must be loaded via \" shared_preload_libraries\"" )));0 );/* * Check we have the expected number of output arguments . Aside from * being a good safety check , we need a kluge here to detect API version * 1 . 1 , which was wedged into the code in an ill - considered way . switch (rsinfo->setDesc->natts)case PG_STAT_STATEMENTS_COLS_V1_0:if (api_version != PGSS_V1_0)"incorrect number of output arguments" );break ;case PG_STAT_STATEMENTS_COLS_V1_1:/* pg_stat_statements() should have told us 1.0 */ if (api_version != PGSS_V1_0)"incorrect number of output arguments" );break ;case PG_STAT_STATEMENTS_COLS_V1_2:if (api_version != PGSS_V1_2)"incorrect number of output arguments" );break ;case PG_STAT_STATEMENTS_COLS_V1_3:if (api_version != PGSS_V1_3)"incorrect number of output arguments" );break ;case PG_STAT_STATEMENTS_COLS_V1_8:if (api_version != PGSS_V1_8)"incorrect number of output arguments" );break ;case PG_STAT_STATEMENTS_COLS_V1_9:if (api_version != PGSS_V1_9)"incorrect number of output arguments" );break ;case PG_STAT_STATEMENTS_COLS_V1_10:if (api_version != PGSS_V1_10)"incorrect number of output arguments" );break ;case PG_STAT_STATEMENTS_COLS_V1_11:if (api_version != PGSS_V1_11)"incorrect number of output arguments" );break ;case PG_STAT_STATEMENTS_COLS_V1_12:if (api_version != PGSS_V1_12)"incorrect number of output arguments" );break ;default :"incorrect number of output arguments" );/* * We ' d like to load the query text file ( if needed ) while not holding any * lock on pgss - > lock . In the worst case we ' ll have to do this again * after we have the lock , but it ' s unlikely enough to make this a win * despite occasional duplicated work . We need to reload if anybody * writes to the file ( either a retail qtext_store ( ) , or a garbage * collection ) between this point and where we ' ve gotten shared lock . If * a qtext_store is actually in progress when we look , we might as well * skip the speculative load entirely . if (showtext)int n_writers;/* Take the mutex so we can examine variables */ /* No point in loading file now if there are active writers */ if (n_writers == 0 )/* * Get shared lock , load or reload the query text file if we must , and * iterate over the hashtable entries . * * With a large hash table , we might be holding the lock rather longer * than one could wish . However , this only blocks creation of new hash * table entries , and the larger the hash table the less likely that is to * be needed . So we can hope this is okay . Perhaps someday we ' ll decide * we need to partition the hash table to limit the time spent holding any * one lock . if (showtext)/* * Here it is safe to examine extent and gc_count without taking the * mutex . Note that although other processes might change * pgss - > extent just after we look at it , the strings they then write * into the file cannot yet be referenced in the hashtable , so we * don ' t care whether we see them or not . * * If qtext_load_file fails , we just press on ; we ' ll return NULL for * every query text . if (qbuffer == NULL ||if (qbuffer)while ((entry = hash_seq_search(&hash_seq)) != NULL)bool nulls[PG_STAT_STATEMENTS_COLS];int i = 0 ;double stddev;0 , sizeof (values));0 , sizeof (nulls));if (api_version >= PGSS_V1_9)if (is_allowed_role || entry->key.userid == userid)if (api_version >= PGSS_V1_2)if (showtext)char *qstr = qtext_fetch(entry->query_offset,if (qstr)char *enc;if (enc != qstr)else /* Just return a null if we fail to find the text */ true ;else /* Query text not requested */ true ;else /* Don't show queryid */ if (api_version >= PGSS_V1_2)true ;/* * Don ' t show query text , but hint as to the reason for not doing * so if it was requested if (showtext)"<insufficient privilege>" );else true ;/* copy counters to a local variable to keep locking time short */ /* * The spinlock is not required when reading these two as they are * always updated when holding pgss - > lock exclusively . /* Skip entry if unexecuted (ie, it's a pending "sticky" entry) */ if (IS_STICKY(tmp))continue ;/* Note that we rely on PGSS_PLAN being 0 and PGSS_EXEC being 1. */ for (int kind = 0 ; kind < PGSS_NUMKIND; kind++)if (kind == PGSS_EXEC || api_version >= PGSS_V1_8)if ((kind == PGSS_EXEC && api_version >= PGSS_V1_3) ||/* * Note we are calculating the population variance here , not * the sample variance , as we have data for the whole * population , so Bessel ' s correction is not used , and we * don ' t divide by tmp . calls - 1 . if (tmp.calls[kind] > 1 )else 0 .0 ;if (api_version >= PGSS_V1_1)if (api_version >= PGSS_V1_1)if (api_version >= PGSS_V1_1)if (api_version >= PGSS_V1_11)if (api_version >= PGSS_V1_10)if (api_version >= PGSS_V1_8)char buf[256 ];sizeof buf, UINT64_FORMAT, tmp.wal_bytes);/* Convert to numeric. */ 0 ),1 ));if (api_version >= PGSS_V1_12)if (api_version >= PGSS_V1_10)if (api_version >= PGSS_V1_11)if (api_version >= PGSS_V1_12)if (api_version >= PGSS_V1_11)1 /* fail if you forget to update this assert */ )); if (qbuffer)/* Number of output arguments (columns) for pg_stat_statements_info */ #define PG_STAT_STATEMENTS_INFO_COLS 2 /* * Return statistics of pg_stat_statements . 0 };bool nulls[PG_STAT_STATEMENTS_INFO_COLS] = {0 };if (!pgss || !pgss_hash)"pg_stat_statements must be loaded via \" shared_preload_libraries\"" )));/* Build a tuple descriptor for our result type */ if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)"return type must be a row type" );/* Read global statistics for pg_stat_statements */ 0 ] = Int64GetDatum(stats.dealloc);1 ] = TimestampTzGetDatum(stats.stats_reset);/* * Estimate shared memory space needed . static Sizevoid )sizeof (pgssSharedState));sizeof (pgssEntry)));return size;/* * Allocate a new hashtable entry . * caller must hold an exclusive lock on pgss - > lock * * " query " need not be null - terminated ; we rely on query_len instead * * If " sticky " is true , make the new entry artificially sticky so that it will * probably still be there when the query finishes execution . We do this by * giving it a median usage value rather than the normal value . ( Strictly * speaking , query strings are normalized on a best effort basis , though it * would be difficult to demonstrate this even under artificial conditions . ) * * Note : despite needing exclusive lock , it ' s not an error for the target * entry to already exist . This is because pgss_store releases and * reacquires lock after failing to find a match ; so someone else could * have made the entry while we waited to get exclusive lock . static pgssEntry *int query_len, int encoding,bool sticky)bool found;/* Make space if needed */ while (hash_get_num_entries(pgss_hash) >= pgss_max)/* Find or create an entry with desired hash code */ if (!found)/* New entry, initialize it */ /* reset the statistics */ 0 , sizeof (Counters));/* set the appropriate initial usage count */ /* re-initialize the mutex each time ... we assume no one using it */ /* ... and don't forget the query text metadata */ 0 );return entry;/* * qsort comparator for sorting into increasing usage order static int const void *lhs, const void *rhs)double l_usage = (*(pgssEntry *const *) lhs)->counters.usage;double r_usage = (*(pgssEntry *const *) rhs)->counters.usage;if (l_usage < r_usage)return -1 ;else if (l_usage > r_usage)return +1 ;else return 0 ;/* * Deallocate least - used entries . * * Caller must hold an exclusive lock on pgss - > lock . static void void )int nvictims;int i;int nvalidtexts;/* * Sort entries by usage and deallocate USAGE_DEALLOC_PERCENT of them . * While we ' re scanning the table , apply the decay factor to the usage * values , and update the mean query length . * * Note that the mean query length is almost immediately obsolete , since * we compute it before not after discarding the least - used entries . * Hopefully , that doesn ' t affect the mean too much ; it doesn ' t seem worth * making two passes to get a more current result . Likewise , the new * cur_median_usage includes the entries we ' re about to zap . sizeof (pgssEntry *));0 ;0 ;0 ;while ((entry = hash_seq_search(&hash_seq)) != NULL)/* "Sticky" entries get a different usage decay rate. */ if (IS_STICKY(entry->counters))else /* In the mean length computation, ignore dropped texts. */ if (entry->query_len >= 0 )1 ;/* Sort into increasing order by usage */ sizeof (pgssEntry *), entry_cmp);/* Record the (approximate) median usage */ if (i > 0 )2 ]->counters.usage;/* Record the mean query length */ if (nvalidtexts > 0 )else /* Now zap an appropriate fraction of lowest-usage entries */ 10 , i * USAGE_DEALLOC_PERCENT / 100 );for (i = 0 ; i < nvictims; i++)/* Increment the number of times entries are deallocated */ 1 ;/* * Given a query string ( not necessarily null - terminated ) , allocate a new * entry in the external query text file and store the string there . * * If successful , returns true , and stores the new entry ' s offset in the file * into * query_offset . Also , if gc_count isn ' t NULL , * gc_count is set to the * number of garbage collections that have occurred so far . * * On failure , returns false . * * At least a shared lock on pgss - > lock must be held by the caller , so as * to prevent a concurrent garbage collection . Share - lock - holding callers * should pass a gc_count pointer to obtain the number of garbage collections , * so that they can recheck the count after obtaining exclusive lock to * detect whether a garbage collection occurred ( and removed this entry ) . static bool const char *query, int query_len,int *gc_count)int fd;/* * We use a spinlock to protect extent / n_writers / gc_count , so that * multiple processes may execute this function concurrently . 1 ;if (gc_count)/* * Don ' t allow the file to grow larger than what qtext_load_file can * ( theoretically ) handle . This has been seen to be reachable on 32 - bit * platforms . if (unlikely(query_len >= MaxAllocHugeSize - off))/* not quite right, but it'll do */ 1 ;goto error;/* Now write the data into the successfully-reserved part of the file */ if (fd < 0 )goto error;if (pg_pwrite(fd, query, query_len, off) != query_len)goto error;if (pg_pwrite(fd, "\0" , 1 , off + query_len) != 1 )goto error;/* Mark our write complete */ return true ;"could not write file \" %s\": %m" ,if (fd >= 0 )/* Mark our write complete */ return false ;/* * Read the external query text file into a palloc ' d buffer . * * Returns NULL ( without throwing an error ) if unable to read , eg * file not there or insufficient memory . * * On success , the buffer size is also returned into * buffer_size . * * This can be called without any lock on pgss - > lock , but in that case * the caller is responsible for verifying that the result is sane . static char *char *buf;int fd;struct stat stat;if (fd < 0 )if (errno != ENOENT)"could not read file \" %s\": %m" ,return NULL;/* Get file length */ if (fstat(fd, &stat))"could not stat file \" %s\": %m" ,return NULL;/* Allocate buffer; beware that off_t might be wider than size_t */ if (stat.st_size <= MaxAllocHugeSize)char *) palloc_extended(stat.st_size, MCXT_ALLOC_HUGE | MCXT_ALLOC_NO_OOM);else if (buf == NULL)"out of memory" ),"Could not allocate enough memory to read file \" %s\"." ,return NULL;/* * OK , slurp in the file . Windows fails if we try to read more than * INT_MAX bytes at once , and other platforms might not like that either , * so read a very large file in 1 GB segments . 0 ;while (nread < stat.st_size)int toread = Min(1024 * 1024 * 1024 , stat.st_size - nread);/* * If we get a short read and errno doesn ' t get set , the reason is * probably that garbage collection truncated the file since we did * the fstat ( ) , so we don ' t log a complaint - - - but we don ' t return * the data , either , since it ' s most likely corrupt due to concurrent * writes from garbage collection . 0 ;if (read(fd, buf + nread, toread) != toread)if (errno)"could not read file \" %s\": %m" ,return NULL;if (CloseTransientFile(fd) != 0 )"could not close file \" %s\": %m" , PGSS_TEXT_FILE)));return buf;/* * Locate a query text in the file image previously read by qtext_load_file ( ) . * * We validate the given offset / length , and return NULL if bogus . Otherwise , * the result points to a null - terminated string within the buffer . static char *int query_len,char *buffer, Size buffer_size)/* File read failed? */ if (buffer == NULL)return NULL;/* Bogus offset/length? */ if (query_len < 0 ||return NULL;/* As a further sanity check, make sure there's a trailing null */ if (buffer[query_offset + query_len] != '\0' )return NULL;/* Looks OK */ return buffer + query_offset;/* * Do we need to garbage - collect the external query text file ? * * Caller should hold at least a shared lock on pgss - > lock . static bool void )/* Read shared extent pointer */ /* * Don ' t proceed if file does not exceed 512 bytes per possible entry . * * Here and in the next test , 32 - bit machines have overflow hazards if * pgss_max and / or mean_query_len are large . Force the multiplications * and comparisons to be done in uint64 arithmetic to forestall trouble . if ((uint64) extent < (uint64) 512 * pgss_max)return false ;/* * Don ' t proceed if file is less than about 50 % bloat . Nothing can or * should be done in the event of unusually large query texts accounting * for file ' s large size . We go to the trouble of maintaining the mean * query length in order to prevent garbage collection from thrashing * uselessly . if ((uint64) extent < (uint64) pgss->mean_query_len * pgss_max * 2 )return false ;return true ;/* * Garbage - collect orphaned query texts in external file . * * This won ' t be called often in the typical case , since it ' s likely that * there won ' t be too much churn , and besides , a similar compaction process * occurs when serializing to disk at shutdown or as part of resetting . * Despite this , it seems prudent to plan for the edge case where the file * becomes unreasonably large , with no other method of compaction likely to * occur in the foreseeable future . * * The caller must hold an exclusive lock on pgss - > lock . * * At the first sign of trouble we unlink the query text file to get a clean * slate ( although existing statistics are retained ) , rather than risk * thrashing by allowing the same problem case to recur indefinitely . static void void )char *qbuffer;int nentries;/* * When called from pgss_store , some other session might have proceeded * with garbage collection in the no - lock - held interim of lock strength * escalation . Check once more that this is actually necessary . if (!need_gc_qtexts())return ;/* * Load the old texts file . If we fail ( out of memory , for instance ) , * invalidate query texts . Hopefully this is rare . It might seem better * to leave things alone on an OOM failure , but the problem is that the * file is only going to get bigger ; hoping for a future non - OOM result is * risky and can easily lead to complete denial of service . if (qbuffer == NULL)goto gc_fail;/* * We overwrite the query texts file in place , so as to reduce the risk of * an out - of - disk - space failure . Since the file is guaranteed not to get * larger , this should always work on traditional filesystems ; though we * could still lose on copy - on - write filesystems . if (qfile == NULL)"could not write file \" %s\": %m" ,goto gc_fail;0 ;0 ;while ((entry = hash_seq_search(&hash_seq)) != NULL)int query_len = entry->query_len;char *qry = qtext_fetch(entry->query_offset,if (qry == NULL)/* Trouble ... drop the text */ 0 ;1 ;/* entry will not be counted in mean query length computation */ continue ;if (fwrite(qry, 1 , query_len + 1 , qfile) != query_len + 1 )"could not write file \" %s\": %m" ,goto gc_fail;1 ;/* * Truncate away any now - unused space . If this fails for some odd reason , * we log it , but there ' s no need to fail . if (ftruncate(fileno(qfile), extent) != 0 )"could not truncate file \" %s\": %m" ,if (FreeFile(qfile))"could not write file \" %s\": %m" ,goto gc_fail;"pgss gc of queries file shrunk size from %zu to %zu" ,/* Reset the shared extent pointer */ /* * Also update the mean query length , to be sure that need_gc_qtexts ( ) * won ' t still think we have a problem . if (nentries > 0 )else /* * OK , count a garbage collection cycle . ( Note : even though we have * exclusive lock on pgss - > lock , we must take pgss - > mutex for this , since * other processes may examine gc_count while holding only the mutex . * Also , we have to advance the count * after * we ' ve rewritten the file , * else other processes might not realize they read a stale file . ) return ;/* clean up resources */ if (qfile)if (qbuffer)/* * Since the contents of the external file are now uncertain , mark all * hashtable entries as having invalid texts . while ((entry = hash_seq_search(&hash_seq)) != NULL)0 ;1 ;/* * Destroy the query text file and create a new , empty one void ) unlink(PGSS_TEXT_FILE);if (qfile == NULL)"could not recreate file \" %s\": %m" ,else /* Reset the shared extent pointer */ 0 ;/* Reset mean_query_len to match the new state */ /* * Bump the GC count even though we failed . * * This is needed to make concurrent readers of file without any lock on * pgss - > lock notice existence of new version of file . Once readers * subsequently observe a change in GC count with pgss - > lock held , that * forces a safe reopen of file . Writers also require that we bump here , * of course . ( As required by locking protocol , readers and writers don ' t * trust earlier file contents until gc_count is found unchanged after * pgss - > lock acquired in shared or exclusive mode respectively . ) #define SINGLE_ENTRY_RESET(e) \if (e) { \if (minmax_only) { \/* When requested reset only min/max statistics of an entry */ \ for (int kind = 0 ; kind < PGSS_NUMKIND; kind++) \0 ; \0 ; \else \/* Remove the key otherwise */ \ /* * Reset entries corresponding to parameters passed . static TimestampTzbool minmax_only)long num_entries;long num_remove = 0 ;if (!pgss || !pgss_hash)"pg_stat_statements must be loaded via \" shared_preload_libraries\"" )));if (userid != 0 && dbid != 0 && queryid != INT64CONST(0 ))/* If all the parameters are available, use the fast path. */ 0 , sizeof (pgssHashKey));/* * Reset the entry if it exists , starting with the non - top - level * entry . false ;/* Also reset the top-level entry if it exists. */ true ;else if (userid != 0 || dbid != 0 || queryid != INT64CONST(0 ))/* Reset entries corresponding to valid parameters. */ while ((entry = hash_seq_search(&hash_seq)) != NULL)if ((!userid || entry->key.userid == userid) &&else /* Reset all entries. */ while ((entry = hash_seq_search(&hash_seq)) != NULL)/* All entries are removed? */ if (num_entries != num_remove)goto release_lock;/* * Reset global statistics for pg_stat_statements since all entries are * removed . 0 ;/* * Write new empty query file , perhaps even creating a new one to recover * if the file was missing . if (qfile == NULL)"could not create file \" %s\": %m" ,goto done;/* If ftruncate fails, log it, but it's not a fatal problem */ if (ftruncate(fileno(qfile), 0 ) != 0 )"could not truncate file \" %s\": %m" ,0 ;/* This counts as a query text garbage collection for our purposes */ return stats_reset;/* * Generate a normalized version of the query string that will be used to * represent all similar queries . * * Note that the normalized representation may well vary depending on * just which " equivalent " query is used to create the hashtable entry . * We assume this is OK . * * If query_loc > 0 , then " query " has been advanced by that much compared to * the original string start , so we need to translate the provided locations * to compensate . ( This lets us avoid re - scanning statements before the one * of interest , so it ' s worth doing . ) * * * query_len_p contains the input string length , and is updated with * the result string length on exit . The resulting string might be longer * or shorter depending on what happens with replacement of constants . * * Returns a palloc ' d string . static char *const char *query,int query_loc, int *query_len_p)char *norm_query;int query_len = *query_len_p;int norm_query_buflen, /* Space allowed for norm_query */ /* Length (in bytes) to write */ 0 , /* Source query byte location */ 0 , /* Normalized query byte location */ 0 , /* Offset from start for previous tok */ 0 ; /* Length (in bytes) of that tok */ int num_constants_replaced = 0 ;/* * Get constants ' lengths ( core system only gives us locations ) . Note * this also ensures the items are sorted by location . /* * Allow for $ n symbols to be longer than the constants they replace . * Constants must take at least one byte in text form , while a $ n symbol * certainly isn ' t more than 11 bytes , even if n reaches INT_MAX . We * could refine that limit based on the max value of n for the current * query , but it hardly seems worth any extra effort to do so . 10 ;/* Allocate result buffer */ 1 );for (int i = 0 ; i < jstate->clocations_count; i++)int off, /* Offset from start for cur tok */ /* Length (in bytes) of that tok */ /* * If we have an external param at this location , but no lists are * being squashed across the query , then we skip here ; this will make * us print the characters found in the original query that represent * the parameter in the next iteration ( or after the loop is done ) , * which is a bit odd but seems to work okay in most cases . if (jstate->clocations[i].extern_param && !jstate->has_squashed_lists)continue ;/* Adjust recorded location if we're dealing with partial string */ if (tok_len < 0 )continue ; /* ignore any duplicates */ /* Copy next chunk (what precedes the next constant) */ 0 );/* * And insert a param symbol in place of the constant token ; and , if * we have a squashable list , insert a placeholder comment starting * from the list ' s second value . "$%d%s" ,1 + jstate->highest_extern_param_id," /*, ... */" : ""); /* move forward */ /* * We ' ve copied up until the last ignorable constant . Copy over the * remaining bytes of the original query string . 0 );'\0' ;return norm_query;/* * Given a valid SQL string and an array of constant - location records , * fill in the textual lengths of those constants . * * The constants may use any allowed constant syntax , such as float literals , * bit - strings , single - quoted strings and dollar - quoted strings . This is * accomplished by using the public API for the core scanner . * * It is the caller ' s job to ensure that the string is a valid SQL statement * with constants at the indicated locations . Since in practice the string * has already been parsed , and the locations that the caller provides will * have originated from within the authoritative parser , this should not be * a problem . * * Multiple constants can have the same location . We reset lengths of those * past the first to - 1 so that they can later be ignored . * * If query_loc > 0 , then " query " has been advanced by that much compared to * the original string start , so we need to translate the provided locations * to compensate . ( This lets us avoid re - scanning statements before the one * of interest , so it ' s worth doing . ) * * N . B . There is an assumption that a ' - ' character at a Const location begins * a negative numeric constant . This precludes there ever being another * reason for a constant to start with a ' - ' . static void const char *query,int query_loc)/* * Sort the records by location so that we can process them in order while * scanning the query text . if (jstate->clocations_count > 1 )sizeof (LocationLen), comp_location);/* initialize the flex scanner --- should match raw_parser() */ /* we don't want to re-emit any escape string warnings */ false ;/* Search for each constant, in sequence */ for (int i = 0 ; i < jstate->clocations_count; i++)int loc;int tok;/* Ignore constants after the first one in the same location */ if (i > 0 && locs[i].location == locs[i - 1 ].location)1 ;continue ;if (locs[i].squashed)continue ; /* squashable list, ignore */ /* Adjust recorded location if we're dealing with partial string */ 0 );/* * We have a valid location for a constant that ' s not a dupe . Lex * tokens until we find the desired constant . for (;;)/* We should not hit end-of-string, but if we do, behave sanely */ if (tok == 0 )break ; /* out of inner for-loop */ /* * We should find the token position exactly , but if we somehow * run past it , work with that . if (yylloc >= loc)if (query[loc] == '-' )/* * It ' s a negative value - this is the one and only case * where we replace more than a single token . * * Do not compensate for the core system ' s special - case * adjustment of location to that of the leading ' - ' * operator in the event of a negative constant . It is * also useful for our purposes to start from the minus * symbol . In this way , queries like " select * from foo * where bar = 1 " and " select * from foo where bar = - 2 " * will have identical normalized query strings . if (tok == 0 )break ; /* out of inner for-loop */ /* * We now rely on the assumption that flex has placed a zero * byte after the text of the current token in scanbuf . break ; /* out of inner for-loop */ /* If we hit end-of-string, give up, leaving remaining lengths -1 */ if (tok == 0 )break ;/* * comp_location : comparator for qsorting LocationLen structs by location static int const void *a, const void *b)int l = ((const LocationLen *) a)->location;int r = ((const LocationLen *) b)->location;return pg_cmp_s32(l, r);
Messung V0.5 in Prozent C=91 H=87 G=88
¤ Dauer der Verarbeitung: 0.122 Sekunden
(vorverarbeitet am 2026-08-08)
¤ *© Formatika GbR, Deutschland
