diff --git a/contrib/pg_stat_statements/pg_stat_statements.c b/contrib/pg_stat_statements/pg_stat_statements.c new file mode 100644 index 434aa71..8bc9cc5 *** a/contrib/pg_stat_statements/pg_stat_statements.c --- b/contrib/pg_stat_statements/pg_stat_statements.c *************** *** 10,15 **** --- 10,34 ---- * an entry, one must hold the lock shared or exclusive (so the entry doesn't * disappear!) and also take the entry's mutex spinlock. * + * As of Postgres 9.2, this module normalizes query strings. Normalization is a + * process whereby similar queries, typically differing only in their constants + * (though the exact rules are somewhat more subtle than that) are recognized as + * equivalent, and are tracked as a single entry. This is particularly useful + * for non-prepared queries. + * + * Normalization is implemented by selectively serializing fields of each query + * tree's nodes, which are judged to be essential to the nature of the query. + * This is referred to as a query jumble. This is distinct from a straight + * serialization of the query tree in that constants are canonicalized, and + * various extraneous information is ignored as irrelevant, such as the + * collation of Vars. Once this jumble is acquired, a 64-bit hash is taken, + * which is copied back into the query tree at the post-analysis stage. + * Postgres then naively copies this value around, making it later available + * from within the corresponding plan tree. The executor can then use this value + * to blame query costs on a known query_id. + * + * Within the executor hook, the module stores the cost of the queries + * execution, based on a query_id provided by the core system. * * Copyright (c) 2008-2012, PostgreSQL Global Development Group * *************** *** 22,38 **** --- 41,67 ---- #include + /* + * XXX: include scanner.h first, to prevent code from gram.h complaining about + * lack of a core-parser type definition. + */ + #include "parser/scanner.h" + #include "access/hash.h" #include "executor/instrument.h" #include "funcapi.h" #include "mb/pg_wchar.h" #include "miscadmin.h" + #include "parser/analyze.h" + #include "parser/gram.h" + #include "parser/parsetree.h" #include "pgstat.h" #include "storage/fd.h" #include "storage/ipc.h" #include "storage/spin.h" #include "tcop/utility.h" #include "utils/builtins.h" + #include "utils/memutils.h" PG_MODULE_MAGIC; *************** PG_MODULE_MAGIC; *** 41,54 **** #define PGSS_DUMP_FILE "global/pg_stat_statements.stat" /* This constant defines the magic number in the stats file header */ ! static const uint32 PGSS_FILE_HEADER = 0x20100108; /* 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 USAGE_DECREASE_FACTOR (0.99) /* decreased every entry_dealloc */ #define USAGE_DEALLOC_PERCENT 5 /* free this % of entries at once */ ! /* * Hashtable key that defines the identity of a hashtable entry. The * hash comparators do not assume that the query string is null-terminated; --- 70,88 ---- #define PGSS_DUMP_FILE "global/pg_stat_statements.stat" /* This constant defines the magic number in the stats file header */ ! static const uint32 PGSS_FILE_HEADER = 0x20120103; /* 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 USAGE_DECREASE_FACTOR (0.99) /* decreased every entry_dealloc */ #define USAGE_DEALLOC_PERCENT 5 /* free this % of entries at once */ ! #define JUMBLE_SIZE 1024 /* query serialization buffer size */ ! /* Magic values for jumble */ ! #define MAG_HASH_BUF 0xFA /* buffer is a hash of query tree */ ! #define MAG_STR_BUF 0xEB /* buffer is query string itself */ ! #define MAG_RETURN_LIST 0xAE /* returning list node follows */ ! #define MAG_LIMIT_OFFSET 0xBA /* limit/offset node follows */ /* * Hashtable key that defines the identity of a hashtable entry. The * hash comparators do not assume that the query string is null-terminated; *************** typedef struct pgssHashKey *** 63,70 **** Oid userid; /* user OID */ Oid dbid; /* database OID */ int encoding; /* query encoding */ ! int query_len; /* # of valid bytes in query string */ ! const char *query_ptr; /* query string proper */ } pgssHashKey; /* --- 97,103 ---- Oid userid; /* user OID */ Oid dbid; /* database OID */ int encoding; /* query encoding */ ! uint64 query_id; /* query identifier */ } pgssHashKey; /* *************** typedef struct pgssEntry *** 95,100 **** --- 128,134 ---- { pgssHashKey key; /* hash key of entry - MUST BE FIRST */ Counters counters; /* the statistics for this query */ + int query_len; /* # of valid bytes in query string */ slock_t mutex; /* protects the counters only */ char query[1]; /* VARIABLE LENGTH ARRAY - MUST BE LAST */ /* Note: the allocated length of query[] is actually pgss->query_size */ *************** typedef struct pgssSharedState *** 109,115 **** --- 143,167 ---- int query_size; /* max query length in bytes */ } pgssSharedState; + /* + * Last seen constant positions for a statement + */ + typedef struct pgssQueryConEntry + { + pgssHashKey key; /* hash key of entry - MUST BE FIRST */ + int n_elems; /* length of offsets array */ + Size offsets[1]; /* VARIABLE LENGTH ARRAY - MUST BE LAST */ + /* Note: the allocated length of offsets is actually n_elems */ + } pgssQueryConEntry; /*---- Local variables ----*/ + /* Jumble of current query tree */ + static unsigned char *last_jumble = NULL; + /* Buffer that represents position of normalized characters */ + static Size *last_offsets = NULL; + /* Current Length of last_offsets buffer */ + static Size last_offset_buf_size = 10; + /* Current number of actual offsets stored in last_offsets */ + static Size last_offset_num = 0; /* Current nesting depth of ExecutorRun calls */ static int nested_level = 0; *************** static ExecutorRun_hook_type prev_Execut *** 121,131 **** --- 173,192 ---- static ExecutorFinish_hook_type prev_ExecutorFinish = NULL; static ExecutorEnd_hook_type prev_ExecutorEnd = NULL; static ProcessUtility_hook_type prev_ProcessUtility = NULL; + static parse_analyze_hook_type prev_parse_analyze_hook = NULL; + static parse_analyze_varparams_hook_type prev_parse_analyze_varparams_hook = NULL; /* Links to shared memory state */ static pgssSharedState *pgss = NULL; static HTAB *pgss_hash = NULL; + /* + * Maintain a stack of the rangetable of the query tree that we're currently + * walking, so subqueries can reference parent rangetables. The stack is pushed + * and popped as each Query struct is walked into or out of. + */ + static List* pgss_rangetbl_stack = NIL; + /*---- GUC variables ----*/ typedef enum *************** static int pgss_max; /* max # statemen *** 147,152 **** --- 208,214 ---- static int pgss_track; /* tracking level */ static bool pgss_track_utility; /* whether to track utility commands */ static bool pgss_save; /* whether to save stats across shutdown */ + static bool pgss_string_key; /* whether to always only hash query str */ #define pgss_enabled() \ *************** PG_FUNCTION_INFO_V1(pg_stat_statements); *** 166,171 **** --- 228,250 ---- static void pgss_shmem_startup(void); static void pgss_shmem_shutdown(int code, Datum arg); + static int comp_offset(const void *a, const void *b); + static Query *pgss_parse_analyze(Node *parseTree, const char *sourceText, + Oid *paramTypes, int numParams); + static Query *pgss_parse_analyze_varparams(Node *parseTree, const char *sourceText, + Oid **paramTypes, int *numParams); + static void pgss_process_post_analysis_tree(Query* post_analysis_tree, + const char* sourceText); + static uint32 get_constant_length(const char* query_str_const); + static uint64 JumbleQuery(Query *post_analysis_tree); + static void AppendJumb(unsigned char* item, unsigned char jumble[], Size size, Size *i); + static void PerformJumble(const Query *tree, Size size, Size *i); + static void QualsNode(const OpExpr *node, Size size, Size *i, List *rtable); + static void LeafNode(const Node *arg, Size size, Size *i, List *rtable); + static void LimitOffsetNode(const Node *node, Size size, Size *i, List *rtable); + static void JoinExprNode(JoinExpr *node, Size size, Size *i, List *rtable); + static void JoinExprNodeChild(const Node *node, Size size, Size *i, List *rtable); + static void RecordConstLocation(int location); static void pgss_ExecutorStart(QueryDesc *queryDesc, int eflags); static void pgss_ExecutorRun(QueryDesc *queryDesc, ScanDirection direction, *************** static void pgss_ProcessUtility(Node *pa *** 177,188 **** DestReceiver *dest, char *completionTag); static uint32 pgss_hash_fn(const void *key, Size keysize); static int pgss_match_fn(const void *key1, const void *key2, Size keysize); ! static void pgss_store(const char *query, double total_time, uint64 rows, ! const BufferUsage *bufusage); static Size pgss_memsize(void); ! static pgssEntry *entry_alloc(pgssHashKey *key); static void entry_dealloc(void); static void entry_reset(void); /* --- 256,272 ---- DestReceiver *dest, char *completionTag); static uint32 pgss_hash_fn(const void *key, Size keysize); static int pgss_match_fn(const void *key1, const void *key2, Size keysize); ! static uint64 pgss_hash_string(const char* str); ! static void pgss_store(const char *query, uint64 query_id, ! double total_time, uint64 rows, ! const BufferUsage *bufusage, bool empty_entry, bool normalize); static Size pgss_memsize(void); ! static pgssEntry *entry_alloc(pgssHashKey *key, const char* query, int new_query_len); static void entry_dealloc(void); static void entry_reset(void); + static int n_dups(Size offs[], Size n); + static Size* dedup_toks(Size offs[], Size n, + Size new_size); /* *************** static void entry_reset(void); *** 191,196 **** --- 275,281 ---- void _PG_init(void) { + MemoryContext cur_context; /* * 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 *************** _PG_init(void) *** 252,257 **** --- 337,357 ---- NULL, NULL); + /* + * Support legacy pg_stat_statements behavior, for compatibility with + * versions shipped with Postgres 8.4, 9.0 and 9.1 + */ + DefineCustomBoolVariable("pg_stat_statements.string_key", + "Differentiate queries based on query string alone.", + NULL, + &pgss_string_key, + false, + PGC_POSTMASTER, + 0, + NULL, + NULL, + NULL); + EmitWarningsOnPlaceholders("pg_stat_statements"); /* *************** _PG_init(void) *** 263,268 **** --- 363,383 ---- RequestAddinLWLocks(1); /* + * Allocate a buffer to store selective serialization of the query tree + * for the purposes of query normalization. + * + * State that persists for the lifetime of the backend should be allocated + * in TopMemoryContext + */ + cur_context = MemoryContextSwitchTo(TopMemoryContext); + + last_jumble = palloc(JUMBLE_SIZE); + /* Allocate space for bookkeeping information for query str normalization */ + last_offsets = palloc(last_offset_buf_size * sizeof(Size)); + + MemoryContextSwitchTo(cur_context); + + /* * Install hooks. */ prev_shmem_startup_hook = shmem_startup_hook; *************** _PG_init(void) *** 277,282 **** --- 392,401 ---- ExecutorEnd_hook = pgss_ExecutorEnd; prev_ProcessUtility = ProcessUtility_hook; ProcessUtility_hook = pgss_ProcessUtility; + prev_parse_analyze_hook = parse_analyze_hook; + parse_analyze_hook = pgss_parse_analyze; + prev_parse_analyze_varparams_hook = parse_analyze_varparams_hook; + parse_analyze_varparams_hook = pgss_parse_analyze_varparams; } /* *************** _PG_fini(void) *** 292,297 **** --- 411,421 ---- ExecutorFinish_hook = prev_ExecutorFinish; ExecutorEnd_hook = prev_ExecutorEnd; ProcessUtility_hook = prev_ProcessUtility; + parse_analyze_hook = prev_parse_analyze_hook; + parse_analyze_varparams_hook = prev_parse_analyze_varparams_hook; + + pfree(last_jumble); + pfree(last_offsets); } /* *************** pgss_shmem_startup(void) *** 395,421 **** if (!PG_VALID_BE_ENCODING(temp.key.encoding)) goto error; /* Previous incarnation might have had a larger query_size */ ! if (temp.key.query_len >= buffer_size) { ! buffer = (char *) repalloc(buffer, temp.key.query_len + 1); ! buffer_size = temp.key.query_len + 1; } ! if (fread(buffer, 1, temp.key.query_len, file) != temp.key.query_len) goto error; ! buffer[temp.key.query_len] = '\0'; /* Clip to available length if needed */ ! if (temp.key.query_len >= query_size) ! temp.key.query_len = pg_encoding_mbcliplen(temp.key.encoding, buffer, ! temp.key.query_len, query_size - 1); - temp.key.query_ptr = buffer; /* make the hashtable entry (discards old entries if too many) */ ! entry = entry_alloc(&temp.key); /* copy in the actual stats */ entry->counters = temp.counters; --- 519,546 ---- if (!PG_VALID_BE_ENCODING(temp.key.encoding)) goto error; + /* Previous incarnation might have had a larger query_size */ ! if (temp.query_len >= buffer_size) { ! buffer = (char *) repalloc(buffer, temp.query_len + 1); ! buffer_size = temp.query_len + 1; } ! if (fread(buffer, 1, temp.query_len, file) != temp.query_len) goto error; ! buffer[temp.query_len] = '\0'; ! /* Clip to available length if needed */ ! if (temp.query_len >= query_size) ! temp.query_len = pg_encoding_mbcliplen(temp.key.encoding, buffer, ! temp.query_len, query_size - 1); /* make the hashtable entry (discards old entries if too many) */ ! entry = entry_alloc(&temp.key, buffer, temp.query_len); /* copy in the actual stats */ entry->counters = temp.counters; *************** pgss_shmem_shutdown(int code, Datum arg) *** 477,483 **** hash_seq_init(&hash_seq, pgss_hash); while ((entry = hash_seq_search(&hash_seq)) != NULL) { ! int len = entry->key.query_len; if (fwrite(entry, offsetof(pgssEntry, mutex), 1, file) != 1 || fwrite(entry->query, 1, len, file) != len) --- 602,608 ---- hash_seq_init(&hash_seq, pgss_hash); while ((entry = hash_seq_search(&hash_seq)) != NULL) { ! int len = entry->query_len; if (fwrite(entry, offsetof(pgssEntry, mutex), 1, file) != 1 || fwrite(entry->query, 1, len, file) != len) *************** error: *** 503,508 **** --- 628,1702 ---- } /* + * comp_offset: Comparator for qsorting Size values. + */ + static int + comp_offset(const void *a, const void *b) + { + Size l = *((Size*) a); + Size r = *((Size*) b); + if (l < r) + return -1; + else if (l > r) + return +1; + else + return 0; + } + + static Query * + pgss_parse_analyze(Node *parseTree, const char *sourceText, + Oid *paramTypes, int numParams) + { + Query *post_analysis_tree; + + if (prev_parse_analyze_hook) + post_analysis_tree = (*prev_parse_analyze_hook) (parseTree, sourceText, + paramTypes, numParams); + else + post_analysis_tree = standard_parse_analyze(parseTree, sourceText, + paramTypes, numParams); + + if (!post_analysis_tree->utilityStmt) + pgss_process_post_analysis_tree(post_analysis_tree, sourceText); + + return post_analysis_tree; + } + + static Query * + pgss_parse_analyze_varparams(Node *parseTree, const char *sourceText, + Oid **paramTypes, int *numParams) + { + Query *post_analysis_tree; + + if (prev_parse_analyze_hook) + post_analysis_tree = (*prev_parse_analyze_varparams_hook) (parseTree, + sourceText, paramTypes, numParams); + else + post_analysis_tree = standard_parse_analyze_varparams(parseTree, + sourceText, paramTypes, numParams); + + if (!post_analysis_tree->utilityStmt) + pgss_process_post_analysis_tree(post_analysis_tree, sourceText); + + return post_analysis_tree; + } + + /* + * pgss_process_post_analysis_tree: Record query_id, which is based on the query + * tree, within the tree itself, for later retrieval in the exeuctor hook. The + * core system will copy the value to the tree's corresponding plannedstmt. + */ + static void + pgss_process_post_analysis_tree(Query* post_analysis_tree, + const char* sourceText) + { + BufferUsage bufusage; + + post_analysis_tree->query_id = JumbleQuery(post_analysis_tree); + + memset(&bufusage, 0, sizeof(bufusage)); + pgss_store(sourceText, post_analysis_tree->query_id, 0, 0, &bufusage, + true, true); + + /* Trim last_offsets */ + if (last_offset_buf_size > 10) + { + last_offset_buf_size = 10; + last_offsets = repalloc(last_offsets, + last_offset_buf_size * + sizeof(Size)); + } + } + + /* + * Given query_str_const, which points to the first character of a constant + * within a null-terminated SQL query string, determine the total length of the + * constant. + * + * The constant may use any available constant syntax, including but not limited + * to float literals, bit-strings, single quoted strings and dollar-quoted + * strings. This is accomplished by using the public API for the core scanner, + * with a few workarounds for quirks of their representation, such as the fact + * that constants preceded by a minus symbol have a position at the minus + * symbol, and yet are separately tokenized. This is effectively the inverse of + * what the later parsing step would have done to the Const node's position - + * compensate for the inclusion of the minus symbol. + * + * It is the caller's job to ensure that the string points to the first + * character of a valid constant, and that it includes the constant in its + * entirety. Since in practice the string has already been validated, and the + * initial position that the caller provides will have originated from within + * the authoritative parser, this should not be a problem. + */ + static uint32 + get_constant_length(const char* query_str_const) + { + core_yyscan_t init_scan; + core_yy_extra_type ext_type; + core_YYSTYPE type; + uint32 len; + YYLTYPE pos; + int token; + int orig_tok_len; + + if (query_str_const[0] == '-') + /* Negative constant */ + return 1 + get_constant_length(&query_str_const[1]); + + init_scan = scanner_init(query_str_const, + &ext_type, + ScanKeywords, + NumScanKeywords); + + token = core_yylex(&type, &pos, + init_scan); + + orig_tok_len = strlen(ext_type.scanbuf); + switch(token) + { + case NULL_P: + case SCONST: + case BCONST: + case XCONST: + case TRUE_P: + case FALSE_P: + case FCONST: + case ICONST: + case TYPECAST: + default: + len = orig_tok_len; + break; + /* XXX: "select integer '1'" must normalize to "select ?" + * This is due to the position given within Const nodes. + * + * This is rather fragile, as I must enumerate all such types that there + * may be leading tokens for here: + */ + case DECIMAL_P: + case BOOLEAN_P: + case NAME_P: + case TEXT_P: + case XML_P: + case TIMESTAMP: + case TIME: + case INTERVAL: + case INTEGER: + case BIGINT: + case NUMERIC: + case IDENT: + for(;;) + { + int lat_tok = core_yylex(&type, &pos, + init_scan); + if (token == IDENT && lat_tok != SCONST) + { + len = orig_tok_len; + break; + } + /* String to follow */ + if (lat_tok == SCONST) + { + len = strlen(ext_type.scanbuf); + break; + } + } + break; + } + scanner_finish(init_scan); + Assert(len > 0); + return len; + } + + /* + * JumbleQuery: Selectively serialize query tree, and return a hash representing + * that serialization - it's query_id. + * + * Note that this doesn't necessarily uniquely identify the query across + * different databases and encodings. + */ + static uint64 + JumbleQuery(Query *post_analysis_tree) + { + /* State for this run of PerformJumble */ + Size i = 0; + last_offset_num = 0; + memset(last_jumble, 0, JUMBLE_SIZE); + last_jumble[++i] = MAG_HASH_BUF; + PerformJumble(post_analysis_tree, JUMBLE_SIZE, &i); + /* Reset rangetbl state */ + list_free(pgss_rangetbl_stack); + pgss_rangetbl_stack = NIL; + + /* Sort offsets for later query string canonicalization */ + qsort(last_offsets, last_offset_num, sizeof(Size), comp_offset); + return hash_any64((const unsigned char* ) last_jumble, i); + } + + /* + * AppendJumb: Append a value that is substantive to a given query to jumble, + * while incrementing the iterator, i. + */ + static void + AppendJumb(unsigned char* item, unsigned char jumble[], Size size, Size *i) + { + Assert(item != NULL); + Assert(jumble != NULL); + Assert(i != NULL); + + /* + * Copy the entire item to the buffer, or as much of it as possible to fill + * the buffer to capacity. + */ + memcpy(jumble + *i, item, Min(*i > JUMBLE_SIZE? 0:JUMBLE_SIZE - *i, size)); + + /* + * Continually hash the query tree's jumble. + * + * Was JUMBLE_SIZE exceeded? If so, hash the jumble and append that to the + * start of the jumble buffer, and then continue to append the fraction of + * "item" that we might not have been able to fit at the end of the buffer + * in the last iteration. Since the value of i has been set to 0, there is + * no need to memset the buffer in advance of this new iteration, but + * effectively we are completely discarding the prior iteration's jumble + * except for this hashed value. + */ + if (*i > JUMBLE_SIZE) + { + uint64 start_hash = hash_any64((const unsigned char* ) last_jumble, JUMBLE_SIZE); + int hash_l = sizeof(start_hash); + int part_left_l = Max(0, ((int) size - ((int) *i - JUMBLE_SIZE))); + + Assert(part_left_l >= 0 && part_left_l <= size); + + memcpy(jumble, &start_hash, hash_l); + memcpy(jumble + hash_l, item + (size - part_left_l), part_left_l); + *i = hash_l + part_left_l; + } + else + { + *i += size; + } + } + + /* + * Wrapper around AppendJumb to encapsulate details of serialization + * of individual local variable elements. + */ + #define APP_JUMB(item) \ + AppendJumb((unsigned char*)&item, last_jumble, sizeof(item), i) + + /* + * Space in the jumble buffer is limited - we can compact enum representations + * that will obviously never really need more than a single byte to store all + * possible enumerations. + * + * It would be pretty questionable to attempt this with an enum that has + * explicit integer values corresponding to constants, such as the huge enum + * "Node" that we use to dynamically identify nodes, and it would be downright + * incorrect to do so with one with negative values explicitly assigned to + * constants. This is intended to be used with enums with perhaps less than a + * dozen possible values, that are never likely to far exceed that. + */ + #define COMPACT_ENUM(val) \ + (unsigned char) val; + /* + * PerformJumble: Serialize the query tree "parse" and canonicalize + * constants, while simply skipping over others that are not essential to the + * query, such that it is usefully normalized, excluding things from the tree + * that are not essential to the query itself. + * + * The last_jumble buffer, which this function writes to, can be hashed to + * uniquely identify a query that may use different constants in successive + * calls. + */ + static void + PerformJumble(const Query *tree, Size size, Size *i) + { + ListCell *l; + /* table join tree (FROM and WHERE clauses) */ + FromExpr *jt = (FromExpr *) tree->jointree; + /* # of result tuples to skip (int8 expr) */ + FuncExpr *off = (FuncExpr *) tree->limitOffset; + /* # of result tuples to skip (int8 expr) */ + FuncExpr *limcount = (FuncExpr *) tree->limitCount; + + if (pgss_rangetbl_stack && + !IsA(pgss_rangetbl_stack, List)) + pgss_rangetbl_stack = NIL; + + if (tree->rtable != NIL) + { + pgss_rangetbl_stack = lappend(pgss_rangetbl_stack, tree->rtable); + } + else + { + /* Add dummy Range table entry to maintain stack */ + RangeTblEntry *rte = makeNode(RangeTblEntry); + List *dummy = lappend(NIL, rte); + pgss_rangetbl_stack = lappend(pgss_rangetbl_stack, dummy); + } + + + APP_JUMB(tree->resultRelation); + + if (tree->intoClause) + { + unsigned char OnCommit; + unsigned char skipData; + IntoClause *ic = tree->intoClause; + RangeVar *rel = ic->rel; + + OnCommit = COMPACT_ENUM(ic->onCommit); + skipData = COMPACT_ENUM(ic->skipData); + APP_JUMB(OnCommit); + APP_JUMB(skipData); + if (rel) + { + APP_JUMB(rel->relpersistence); + /* Bypass macro abstraction to supply size directly. + * + * Serialize schemaname, relname themselves - this makes us + * somewhat consistent with the behavior of utility statements like "create + * table", which seems appropriate. + */ + if (rel->schemaname) + AppendJumb((unsigned char *)rel->schemaname, last_jumble, + strlen(rel->schemaname), i); + if (rel->relname) + AppendJumb((unsigned char *)rel->relname, last_jumble, + strlen(rel->relname), i); + } + } + + /* WITH list (of CommonTableExpr's) */ + foreach(l, tree->cteList) + { + CommonTableExpr *cte = (CommonTableExpr *) lfirst(l); + Query *cteq = (Query*) cte->ctequery; + if (cteq) + PerformJumble(cteq, size, i); + } + if (jt) + { + if (jt->quals) + { + if (IsA(jt->quals, OpExpr)) + { + QualsNode((OpExpr*) jt->quals, size, i, tree->rtable); + } + else + { + LeafNode((Node*) jt->quals, size, i, tree->rtable); + } + } + /* table join tree */ + foreach(l, jt->fromlist) + { + Node* fr = lfirst(l); + if (IsA(fr, JoinExpr)) + { + JoinExprNode((JoinExpr*) fr, size, i, tree->rtable); + } + else if (IsA(fr, RangeTblRef)) + { + unsigned char rtekind; + RangeTblRef *rtf = (RangeTblRef *) fr; + RangeTblEntry *rte = rt_fetch(rtf->rtindex, tree->rtable); + APP_JUMB(rte->relid); + rtekind = COMPACT_ENUM(rte->rtekind); + APP_JUMB(rtekind); + /* Subselection in where clause */ + if (rte->subquery) + PerformJumble(rte->subquery, size, i); + + /* Function call in where clause */ + if (rte->funcexpr) + LeafNode((Node*) rte->funcexpr, size, i, tree->rtable); + } + else + { + ereport(WARNING, + (errcode(ERRCODE_INTERNAL_ERROR), + errmsg("unexpected, unrecognised fromlist node type: %d", + (int) nodeTag(fr)))); + } + } + } + /* + * target list (of TargetEntry) + * columns returned by query + */ + foreach(l, tree->targetList) + { + TargetEntry *tg = (TargetEntry *) lfirst(l); + Node *e = (Node*) tg->expr; + if (tg->ressortgroupref) + /* nonzero if referenced by a sort/group - for ORDER BY */ + APP_JUMB(tg->ressortgroupref); + APP_JUMB(tg->resno); /* column number for select */ + /* + * Handle the various types of nodes in + * the select list of this query + */ + LeafNode(e, size, i, tree->rtable); + } + /* return-values list (of TargetEntry) */ + foreach(l, tree->returningList) + { + TargetEntry *rt = (TargetEntry *) lfirst(l); + Expr *e = (Expr*) rt->expr; + unsigned char magic = MAG_RETURN_LIST; + APP_JUMB(magic); + /* + * Handle the various types of nodes in + * the select list of this query + */ + LeafNode((Node*) e, size, i, tree->rtable); + } + /* a list of SortGroupClause's */ + foreach(l, tree->groupClause) + { + SortGroupClause *gc = (SortGroupClause *) lfirst(l); + APP_JUMB(gc->tleSortGroupRef); + APP_JUMB(gc->nulls_first); + } + + if (tree->havingQual) + { + if (IsA(tree->havingQual, OpExpr)) + { + OpExpr *na = (OpExpr *) tree->havingQual; + QualsNode(na, size, i, tree->rtable); + } + else + { + Node *n = (Node*) tree->havingQual; + LeafNode(n, size, i, tree->rtable); + } + } + + foreach(l, tree->windowClause) + { + WindowClause *wc = (WindowClause *) lfirst(l); + ListCell *il; + APP_JUMB(wc->frameOptions); + foreach(il, wc->partitionClause) /* PARTITION BY list */ + { + Node *n = (Node *) lfirst(il); + LeafNode(n, size, i, tree->rtable); + } + foreach(il, wc->orderClause) /* ORDER BY list */ + { + Node *n = (Node *) lfirst(il); + LeafNode(n, size, i, tree->rtable); + } + } + + foreach(l, tree->distinctClause) + { + SortGroupClause *dc = (SortGroupClause *) lfirst(l); + APP_JUMB(dc->tleSortGroupRef); + APP_JUMB(dc->nulls_first); + } + + /* Don't look at tree->sortClause, + * because the value ressortgroupref is already + * serialized when we iterate through targetList + */ + + if (off) + LimitOffsetNode((Node*) off, size, i, tree->rtable); + + if (limcount) + LimitOffsetNode((Node*) limcount, size, i, tree->rtable); + + if (tree->setOperations) + { + /* + * set-operation tree if this is top + * level of a UNION/INTERSECT/EXCEPT query + */ + unsigned char op; + SetOperationStmt *topop = (SetOperationStmt *) tree->setOperations; + op = COMPACT_ENUM(topop->op); + APP_JUMB(op); + APP_JUMB(topop->all); + + /* leaf selects are RTE subselections */ + foreach(l, tree->rtable) + { + RangeTblEntry *r = (RangeTblEntry *) lfirst(l); + if (r->subquery) + PerformJumble(r->subquery, size, i); + } + } + pgss_rangetbl_stack = list_delete_ptr(pgss_rangetbl_stack, + list_nth(pgss_rangetbl_stack, pgss_rangetbl_stack->length - 1)); + } + + /* + * Perform selective serialization of "Quals" nodes when + * they're IsA(*, OpExpr) + */ + static void + QualsNode(const OpExpr *node, Size size, Size *i, List *rtable) + { + ListCell *l; + APP_JUMB(node->xpr); + APP_JUMB(node->opno); + foreach(l, node->args) + { + Node *arg = (Node *) lfirst(l); + LeafNode(arg, size, i, rtable); + } + } + + /* + * LeafNode: Selectively serialize a selection of parser/prim nodes that are + * frequently, though certainly not necesssarily leaf nodes, such as Vars + * (columns), constants and function calls + */ + static void + LeafNode(const Node *arg, Size size, Size *i, List *rtable) + { + ListCell *l; + /* Use the node's NodeTag as a magic number */ + APP_JUMB(arg->type); + + if (IsA(arg, Const)) + { + /* + * If implicit casts are used, such as when inserting an integer into a + * text column, then that will be a distinct query from directly + * inserting a string literal, so that literal value will be a FuncExpr + * to cast, and control won't reach here for that node. This behavior is + * considered correct. + */ + Const *c = (Const *) arg; + + /* + * Datatype of the constant is a + * differentiator + */ + APP_JUMB(c->consttype); + RecordConstLocation(c->location); + } + else if(IsA(arg, CoerceToDomain)) + { + CoerceToDomain *cd = (CoerceToDomain*) arg; + /* + * Datatype of the constant is a + * differentiator + */ + APP_JUMB(cd->resulttype); + LeafNode((Node*) cd->arg, size, i, rtable); + } + else if (IsA(arg, Var)) + { + Var *v = (Var *) arg; + RangeTblEntry *rte; + ListCell *lc; + + /* + * We need to get the details of the rangetable, but rtable may not + * refer to the relevant one if we're in a subselection. + */ + if (v->varlevelsup == 0) + { + rte = rt_fetch(v->varno, rtable); + } + else + { + List *rtable_upper = list_nth(pgss_rangetbl_stack, + (list_length(pgss_rangetbl_stack) - 1) - v->varlevelsup); + rte = rt_fetch(v->varno, rtable_upper); + } + APP_JUMB(rte->relid); + + foreach(lc, rte->values_lists) + { + List *sublist = (List *) lfirst(lc); + ListCell *lc2; + + foreach(lc2, sublist) + { + Node *col = (Node *) lfirst(lc2); + LeafNode(col, size, i, rtable); + } + } + APP_JUMB(v->varattno); + } + else if (IsA(arg, CurrentOfExpr)) + { + CurrentOfExpr *CoE = (CurrentOfExpr*) arg; + APP_JUMB(CoE->cvarno); + APP_JUMB(CoE->cursor_param); + } + else if (IsA(arg, CollateExpr)) + { + CollateExpr *Ce = (CollateExpr*) arg; + APP_JUMB(Ce->collOid); + } + else if (IsA(arg, FieldSelect)) + { + FieldSelect *Fs = (FieldSelect*) arg; + APP_JUMB(Fs->resulttype); + LeafNode((Node*) Fs->arg, size, i, rtable); + } + else if (IsA(arg, NamedArgExpr)) + { + NamedArgExpr *Nae = (NamedArgExpr*) arg; + APP_JUMB(Nae->argnumber); + LeafNode((Node*) Nae->arg, size, i, rtable); + } + else if (IsA(arg, Param)) + { + Param *p = ((Param *) arg); + APP_JUMB(p->paramkind); + APP_JUMB(p->paramid); + } + else if (IsA(arg, RelabelType)) + { + RelabelType *rt = (RelabelType*) arg; + APP_JUMB(rt->resulttype); + LeafNode((Node*) rt->arg, size, i, rtable); + } + else if (IsA(arg, WindowFunc)) + { + WindowFunc *wf = (WindowFunc *) arg; + APP_JUMB(wf->winfnoid); + foreach(l, wf->args) + { + Node *arg = (Node *) lfirst(l); + LeafNode(arg, size, i, rtable); + } + } + else if (IsA(arg, FuncExpr)) + { + FuncExpr *f = (FuncExpr *) arg; + APP_JUMB(f->funcid); + foreach(l, f->args) + { + Node *arg = (Node *) lfirst(l); + LeafNode(arg, size, i, rtable); + } + } + else if (IsA(arg, OpExpr) || IsA(arg, DistinctExpr)) + { + QualsNode((OpExpr*) arg, size, i, rtable); + } + else if (IsA(arg, CoerceViaIO)) + { + CoerceViaIO *Cio = (CoerceViaIO*) arg; + APP_JUMB(Cio->coerceformat); + APP_JUMB(Cio->resulttype); + LeafNode((Node*) Cio->arg, size, i, rtable); + } + else if (IsA(arg, Aggref)) + { + Aggref *a = (Aggref *) arg; + APP_JUMB(a->aggfnoid); + foreach(l, a->args) + { + Node *arg = (Node *) lfirst(l); + LeafNode(arg, size, i, rtable); + } + } + else if (IsA(arg, SubLink)) + { + SubLink *s = (SubLink*) arg; + APP_JUMB(s->subLinkType); + /* Serialize select-list subselect recursively */ + if (s->subselect) + PerformJumble((Query*) s->subselect, size, i); + + if (s->testexpr) + LeafNode((Node*) s->testexpr, size, i, rtable); + foreach(l, s->operName) + { + Node *arg = (Node *) lfirst(l); + LeafNode(arg, size, i, rtable); + } + } + else if (IsA(arg, TargetEntry)) + { + TargetEntry *rt = (TargetEntry *) arg; + Node *e = (Node*) rt->expr; + APP_JUMB(rt->resorigtbl); + APP_JUMB(rt->ressortgroupref); + LeafNode(e, size, i, rtable); + } + else if (IsA(arg, BoolExpr)) + { + BoolExpr *be = (BoolExpr *) arg; + APP_JUMB(be->boolop); + foreach(l, be->args) + { + Node *arg = (Node *) lfirst(l); + LeafNode(arg, size, i, rtable); + } + } + else if (IsA(arg, NullTest)) + { + NullTest *nt = (NullTest *) arg; + Node *arg = (Node *) nt->arg; + unsigned char nulltesttype = COMPACT_ENUM(nt->nulltesttype); + APP_JUMB(nulltesttype); /* IS NULL, IS NOT NULL */ + APP_JUMB(nt->argisrow); /* is input a composite type ? */ + LeafNode(arg, size, i, rtable); + } + else if (IsA(arg, ArrayExpr)) + { + ArrayExpr *ae = (ArrayExpr *) arg; + APP_JUMB(ae->array_typeid); /* type of expression result */ + APP_JUMB(ae->element_typeid); /* common type of array elements */ + foreach(l, ae->elements) + { + Node *arg = (Node *) lfirst(l); + LeafNode(arg, size, i, rtable); + } + } + else if (IsA(arg, CaseExpr)) + { + CaseExpr *ce = (CaseExpr*) arg; + Assert(ce->casetype != InvalidOid); + APP_JUMB(ce->casetype); + foreach(l, ce->args) + { + Node *arg = (Node *) lfirst(l); + LeafNode(arg, size, i, rtable); + } + if (ce->arg) + LeafNode((Node*) ce->arg, size, i, rtable); + + if (ce->defresult) + { + /* Default result (ELSE clause). + * + * May be NULL, because no else clause + * was actually specified, and thus the value is + * equivalent to SQL ELSE NULL + */ + LeafNode((Node*) ce->defresult, size, i, rtable); + } + } + else if (IsA(arg, CaseTestExpr)) + { + CaseTestExpr *ct = (CaseTestExpr*) arg; + APP_JUMB(ct->typeId); + } + else if (IsA(arg, CaseWhen)) + { + CaseWhen *cw = (CaseWhen*) arg; + Node *res = (Node*) cw->result; + Node *exp = (Node*) cw->expr; + if (res) + LeafNode(res, size, i, rtable); + if (exp) + LeafNode(exp, size, i, rtable); + } + else if (IsA(arg, MinMaxExpr)) + { + MinMaxExpr *cw = (MinMaxExpr*) arg; + APP_JUMB(cw->minmaxtype); + APP_JUMB(cw->op); + foreach(l, cw->args) + { + Node *arg = (Node *) lfirst(l); + LeafNode(arg, size, i, rtable); + } + } + else if (IsA(arg, ScalarArrayOpExpr)) + { + ScalarArrayOpExpr *sa = (ScalarArrayOpExpr*) arg; + APP_JUMB(sa->opfuncid); + APP_JUMB(sa->useOr); + foreach(l, sa->args) + { + Node *arg = (Node *) lfirst(l); + LeafNode(arg, size, i, rtable); + } + } + else if (IsA(arg, CoalesceExpr)) + { + CoalesceExpr *ca = (CoalesceExpr*) arg; + foreach(l, ca->args) + { + Node *arg = (Node *) lfirst(l); + LeafNode(arg, size, i, rtable); + } + } + else if (IsA(arg, ArrayCoerceExpr)) + { + ArrayCoerceExpr *ac = (ArrayCoerceExpr *) arg; + LeafNode((Node*) ac->arg, size, i, rtable); + } + else if (IsA(arg, WindowClause)) + { + WindowClause *wc = (WindowClause*) arg; + foreach(l, wc->partitionClause) + { + Node *arg = (Node *) lfirst(l); + LeafNode(arg, size, i, rtable); + } + foreach(l, wc->orderClause) + { + Node *arg = (Node *) lfirst(l); + LeafNode(arg, size, i, rtable); + } + } + else if (IsA(arg, SortGroupClause)) + { + SortGroupClause *sgc = (SortGroupClause*) arg; + APP_JUMB(sgc->tleSortGroupRef); + APP_JUMB(sgc->nulls_first); + } + else if (IsA(arg, Integer) || + IsA(arg, Float) || + IsA(arg, String) || + IsA(arg, BitString) || + IsA(arg, Null) + ) + { + /* It is not necessary to serialize Value nodes - they are seen when + * aliases are used, which are ignored. + */ + return; + } + else if (IsA(arg, BooleanTest)) + { + BooleanTest *bt = (BooleanTest *) arg; + APP_JUMB(bt->booltesttype); + LeafNode((Node*) bt->arg, size, i, rtable); + } + else if (IsA(arg, ArrayRef)) + { + ArrayRef *ar = (ArrayRef*) arg; + APP_JUMB(ar->refarraytype); + foreach(l, ar->refupperindexpr) + { + Node *arg = (Node *) lfirst(l); + LeafNode(arg, size, i, rtable); + } + foreach(l, ar->reflowerindexpr) + { + Node *arg = (Node *) lfirst(l); + LeafNode(arg, size, i, rtable); + } + if (ar->refexpr) + LeafNode((Node*) ar->refexpr, size, i, rtable); + if (ar->refassgnexpr) + LeafNode((Node*) ar->refassgnexpr, size, i, rtable); + } + else if (IsA(arg, NullIfExpr)) + { + /* NullIfExpr is just a typedef for OpExpr */ + QualsNode((OpExpr*) arg, size, i, rtable); + } + else if (IsA(arg, RowExpr)) + { + RowExpr *re = (RowExpr*) arg; + APP_JUMB(re->row_format); + foreach(l, re->args) + { + Node *arg = (Node *) lfirst(l); + LeafNode(arg, size, i, rtable); + } + + } + else if (IsA(arg, XmlExpr)) + { + XmlExpr *xml = (XmlExpr*) arg; + APP_JUMB(xml->op); + foreach(l, xml->args) + { + Node *arg = (Node *) lfirst(l); + LeafNode(arg, size, i, rtable); + } + /* non-XML expressions for xml_attributes */ + foreach(l, xml->named_args) + { + Node *arg = (Node *) lfirst(l); + LeafNode(arg, size, i, rtable); + } + /* parallel list of Value strings */ + foreach(l, xml->arg_names) + { + Node *arg = (Node *) lfirst(l); + LeafNode(arg, size, i, rtable); + } + } + else if (IsA(arg, RowCompareExpr)) + { + RowCompareExpr *rc = (RowCompareExpr*) arg; + foreach(l, rc->largs) + { + Node *arg = (Node *) lfirst(l); + LeafNode(arg, size, i, rtable); + } + foreach(l, rc->rargs) + { + Node *arg = (Node *) lfirst(l); + LeafNode(arg, size, i, rtable); + } + } + else if (IsA(arg, SetToDefault)) + { + SetToDefault *sd = (SetToDefault*) arg; + APP_JUMB(sd->typeId); + APP_JUMB(sd->typeMod); + } + else if (IsA(arg, ConvertRowtypeExpr)) + { + ConvertRowtypeExpr* Cr = (ConvertRowtypeExpr*) arg; + APP_JUMB(Cr->convertformat); + APP_JUMB(Cr->resulttype); + LeafNode((Node*) Cr->arg, size, i, rtable); + } + else if (IsA(arg, FieldStore)) + { + FieldStore* Fs = (FieldStore*) arg; + LeafNode((Node*) Fs->arg, size, i, rtable); + foreach(l, Fs->newvals) + { + Node *arg = (Node *) lfirst(l); + LeafNode(arg, size, i, rtable); + } + } + else + { + ereport(WARNING, + (errcode(ERRCODE_INTERNAL_ERROR), + errmsg("unexpected, unrecognised LeafNode node type: %d", + (int) nodeTag(arg)))); + } + } + + /* + * Perform selective serialization of limit or offset nodes + */ + static void + LimitOffsetNode(const Node *node, Size size, Size *i, List *rtable) + { + ListCell *l; + unsigned char magic = MAG_LIMIT_OFFSET; + APP_JUMB(magic); + + if (IsA(node, FuncExpr)) + { + + foreach(l, ((FuncExpr*) node)->args) + { + Node *arg = (Node *) lfirst(l); + LeafNode(arg, size, i, rtable); + } + } + else + { + /* Fall back on leaf node representation */ + LeafNode(node, size, i, rtable); + } + } + + /* + * JoinExprNode: Perform selective serialization of JoinExpr nodes + */ + static void + JoinExprNode(JoinExpr *node, Size size, Size *i, List *rtable) + { + Node *larg = node->larg; /* left subtree */ + Node *rarg = node->rarg; /* right subtree */ + ListCell *l; + + Assert( IsA(node, JoinExpr)); + + APP_JUMB(node->jointype); + APP_JUMB(node->isNatural); + + if (node->quals) + { + if ( IsA(node, OpExpr)) + { + QualsNode((OpExpr*) node->quals, size, i, rtable); + } + else + { + LeafNode((Node*) node->quals, size, i, rtable); + } + + } + foreach(l, node->usingClause) /* USING clause, if any (list of String) */ + { + Node *arg = (Node *) lfirst(l); + LeafNode(arg, size, i, rtable); + } + if (larg) + JoinExprNodeChild(larg, size, i, rtable); + if (rarg) + JoinExprNodeChild(rarg, size, i, rtable); + } + + /* + * JoinExprNodeChild: Serialize children of the JoinExpr node + */ + static void + JoinExprNodeChild(const Node *node, Size size, Size *i, List *rtable) + { + if (IsA(node, RangeTblRef)) + { + RangeTblRef *rt = (RangeTblRef*) node; + RangeTblEntry *rte = rt_fetch(rt->rtindex, rtable); + ListCell *l; + + APP_JUMB(rte->relid); + APP_JUMB(rte->jointype); + + if (rte->subquery) + PerformJumble((Query*) rte->subquery, size, i); + + foreach(l, rte->joinaliasvars) + { + Node *arg = (Node *) lfirst(l); + LeafNode(arg, size, i, rtable); + } + } + else if (IsA(node, JoinExpr)) + { + JoinExprNode((JoinExpr*) node, size, i, rtable); + } + else + { + LeafNode(node, size, i, rtable); + } + } + + /* + * Record location of constant within query string of query tree that is + * currently being walked. + */ + static void + RecordConstLocation(int location) + { + /* -1 indicates unknown or undefined location */ + if (location > -1) + { + if (last_offset_num < pgss->query_size / 2) + { + if (last_offset_num >= last_offset_buf_size) + { + last_offset_buf_size *= 2; + last_offsets = repalloc(last_offsets, + last_offset_buf_size * + sizeof(Size)); + + } + last_offsets[last_offset_num] = location; + last_offset_num++; + } + } + } + + /* * ExecutorStart hook: start up tracking if needed */ static void *************** pgss_ExecutorEnd(QueryDesc *queryDesc) *** 585,590 **** --- 1779,1789 ---- { if (queryDesc->totaltime && pgss_enabled()) { + uint64 queryId; + if (pgss_string_key) + queryId = pgss_hash_string(queryDesc->sourceText); + else + queryId = queryDesc->plannedstmt->queryId; /* * Make sure stats accumulation is done. (Note: it's okay if several * levels of hook all do this.) *************** pgss_ExecutorEnd(QueryDesc *queryDesc) *** 592,600 **** InstrEndLoop(queryDesc->totaltime); pgss_store(queryDesc->sourceText, ! queryDesc->totaltime->total, ! queryDesc->estate->es_processed, ! &queryDesc->totaltime->bufusage); } if (prev_ExecutorEnd) --- 1791,1803 ---- InstrEndLoop(queryDesc->totaltime); pgss_store(queryDesc->sourceText, ! queryId, ! queryDesc->totaltime->total, ! queryDesc->estate->es_processed, ! &queryDesc->totaltime->bufusage, ! false, ! false); ! } if (prev_ExecutorEnd) *************** pgss_ProcessUtility(Node *parsetree, con *** 616,621 **** --- 1819,1825 ---- instr_time start; instr_time duration; uint64 rows = 0; + uint64 query_id; BufferUsage bufusage; bufusage = pgBufferUsage; *************** pgss_ProcessUtility(Node *parsetree, con *** 665,672 **** bufusage.temp_blks_written = pgBufferUsage.temp_blks_written - bufusage.temp_blks_written; ! pgss_store(queryString, INSTR_TIME_GET_DOUBLE(duration), rows, ! &bufusage); } else { --- 1869,1879 ---- bufusage.temp_blks_written = pgBufferUsage.temp_blks_written - bufusage.temp_blks_written; ! query_id = pgss_hash_string(queryString); ! ! /* In the case of utility statements, hash the query string directly */ ! pgss_store(queryString, query_id, ! INSTR_TIME_GET_DOUBLE(duration), rows, &bufusage, false, false); } else { *************** pgss_hash_fn(const void *key, Size keysi *** 690,697 **** /* we don't bother to include encoding in the hash */ return hash_uint32((uint32) k->userid) ^ hash_uint32((uint32) k->dbid) ^ ! DatumGetUInt32(hash_any((const unsigned char *) k->query_ptr, ! k->query_len)); } /* --- 1897,1904 ---- /* we don't bother to include encoding in the hash */ return hash_uint32((uint32) k->userid) ^ hash_uint32((uint32) k->dbid) ^ ! DatumGetUInt32(hash_any((const unsigned char* ) &k->query_id, ! sizeof(k->query_id)) ); } /* *************** pgss_match_fn(const void *key1, const vo *** 706,727 **** if (k1->userid == k2->userid && k1->dbid == k2->dbid && k1->encoding == k2->encoding && ! k1->query_len == k2->query_len && ! memcmp(k1->query_ptr, k2->query_ptr, k1->query_len) == 0) return 0; else return 1; } /* * Store some statistics for a statement. */ static void ! pgss_store(const char *query, double total_time, uint64 rows, ! const BufferUsage *bufusage) { pgssHashKey key; double usage; pgssEntry *entry; Assert(query != NULL); --- 1913,1958 ---- if (k1->userid == k2->userid && k1->dbid == k2->dbid && k1->encoding == k2->encoding && ! k1->query_id == k2->query_id) return 0; else return 1; } /* + * Given an arbitrarily long query string, produce a hash for the purposes of + * identifying the query, without canonicalizing constants. Used when hashing + * utility statements, or for legacy compatibility mode. + */ + static uint64 + pgss_hash_string(const char* str) + { + /* For additional protection against collisions, including magic value */ + uint64 Magic = MAG_STR_BUF; + uint64 result; + Size size = sizeof(Magic) + strlen(str); + unsigned char* p = palloc(size); + memcpy(p, &Magic, sizeof(Magic)); + memcpy(p + sizeof(Magic), str, strlen(str)); + result = hash_any64((const unsigned char *) p, size); + pfree(p); + return result; + } + + /* * Store some statistics for a statement. */ static void ! pgss_store(const char *query, uint64 query_id, ! double total_time, uint64 rows, ! const BufferUsage *bufusage, ! bool empty_entry, ! bool normalize) { pgssHashKey key; double usage; + int new_query_len = strlen(query); + char *norm_query = NULL; pgssEntry *entry; Assert(query != NULL); *************** pgss_store(const char *query, double tot *** 734,747 **** key.userid = GetUserId(); key.dbid = MyDatabaseId; key.encoding = GetDatabaseEncoding(); ! key.query_len = strlen(query); ! if (key.query_len >= pgss->query_size) ! key.query_len = pg_encoding_mbcliplen(key.encoding, query, ! key.query_len, pgss->query_size - 1); - key.query_ptr = query; - usage = USAGE_EXEC(duration); /* Lookup the hash table entry with shared lock. */ --- 1965,1980 ---- key.userid = GetUserId(); key.dbid = MyDatabaseId; key.encoding = GetDatabaseEncoding(); ! key.query_id = query_id; ! ! if (new_query_len >= pgss->query_size) ! /* We don't have to worry about this later, because canonicalization ! * cannot possibly result in a longer query string ! */ ! new_query_len = pg_encoding_mbcliplen(key.encoding, query, ! new_query_len, pgss->query_size - 1); usage = USAGE_EXEC(duration); /* Lookup the hash table entry with shared lock. */ *************** pgss_store(const char *query, double tot *** 750,759 **** entry = (pgssEntry *) hash_search(pgss_hash, &key, HASH_FIND, NULL); if (!entry) { ! /* Must acquire exclusive lock to add a new entry. */ ! LWLockRelease(pgss->lock); ! LWLockAcquire(pgss->lock, LW_EXCLUSIVE); ! entry = entry_alloc(&key); } /* Grab the spinlock while updating the counters. */ --- 1983,2103 ---- entry = (pgssEntry *) hash_search(pgss_hash, &key, HASH_FIND, NULL); if (!entry) { ! Size *offs = NULL; ! int qry_n_dups; ! int off_n = 0; ! ! offs = last_offsets; ! off_n = last_offset_num; ! ! if ((qry_n_dups = n_dups(offs, off_n)) > 0) ! { ! /* Assuming that we cannot have walked some part of the tree twice ! * seems rather fragile, and besides, there isn't much we can do to ! * ensure that this does not happen with targetLists that contain ! * duplicate entries, as with queries like "values(1,2), (3,4)". ! */ ! Size *offs_new; ! offs_new = dedup_toks(offs, off_n, off_n - qry_n_dups); ! offs = offs_new; ! off_n = off_n - qry_n_dups; ! } ! ! /* ! * It is necessary to generate a normalized version of the query ! * string that will be used to represent it. It's important that ! * the user be presented with a stable representation of the query. ! * ! * Note that the representation seen by the user will only have ! * non-differentiating Const tokens swapped with '?' characters, and ! * this does not for example take account of the fact that alias names ! * could vary between successive calls of what is regarded as the same ! * query. ! */ ! if (off_n > 0 && normalize) ! { ! int i, ! off = 0, /* Offset from start for cur tok */ ! tok_len = 0, /* length (in bytes) of that tok */ ! quer_it = 0, /* Original query iterator */ ! n_quer_it = 0, /* Normalized query iterator */ ! len_to_wrt = 0, /* Length (in bytes) to write */ ! last_off = 0, /* Offset from start for last iter tok */ ! last_tok_len = 0, /* length (in bytes) of that tok */ ! length_delta = 0; /* Finished str is n bytes shorter so far */ ! ! norm_query = palloc0(new_query_len + 1); ! for(i = 0; i < off_n; i++) ! { ! off = offs[i]; ! tok_len = get_constant_length(&query[off]); ! len_to_wrt = off - last_off; ! len_to_wrt -= last_tok_len; ! length_delta += tok_len - 1; ! Assert(tok_len > 0); ! Assert(len_to_wrt >= 0); ! /* ! * Each iteration copies everything prior to the current ! * offset/token to be replaced, except bytes copied in ! * previous iterations ! */ ! if (off - length_delta + tok_len > new_query_len) ! { ! /* We could just be oversized due to a large constant ! * literal. Try and copy bytes prior to the literal that may ! * have been missed. ! */ ! if (off - length_delta < new_query_len) ! { ! memcpy(norm_query + n_quer_it, query + quer_it, ! Min(len_to_wrt, new_query_len - n_quer_it)); ! n_quer_it += len_to_wrt; ! quer_it += len_to_wrt + tok_len; ! ! /* ! * See if there is room left for a '?', and copy one ! * over if there is. ! */ ! if (n_quer_it < new_query_len) ! norm_query[n_quer_it++] = '?'; ! } ! /* ! * Even though we'd have exceeded buffer size with last ! * constant if constants weren't canonicalized, they are, so ! * there could be additional constants that will fit in that ! * buffer, once they're actually represented as '?' ! */ ! continue; ! } ! memcpy(norm_query + n_quer_it, query + quer_it, len_to_wrt); ! ! n_quer_it += len_to_wrt; ! norm_query[n_quer_it++] = '?'; ! quer_it += len_to_wrt + tok_len; ! last_off = off; ! last_tok_len = tok_len; ! } ! /* Copy end of query string (piece past last constant) if there's room */ ! memcpy(norm_query + n_quer_it, query + (off + tok_len), ! Min( strlen(query) - (off + tok_len), ! new_query_len - n_quer_it ) ); ! /* ! * Must acquire exclusive lock to add a new entry. ! * Leave that until as late as possible. ! */ ! LWLockRelease(pgss->lock); ! LWLockAcquire(pgss->lock, LW_EXCLUSIVE); ! ! entry = entry_alloc(&key, norm_query, strlen(norm_query)); ! } ! else ! { ! /* Acquire exclusive lock as required by entry_alloc() */ ! LWLockRelease(pgss->lock); ! LWLockAcquire(pgss->lock, LW_EXCLUSIVE); ! ! entry = entry_alloc(&key, query, new_query_len); ! } } /* Grab the spinlock while updating the counters. */ *************** pgss_store(const char *query, double tot *** 761,767 **** volatile pgssEntry *e = (volatile pgssEntry *) entry; SpinLockAcquire(&e->mutex); ! e->counters.calls += 1; e->counters.total_time += total_time; e->counters.rows += rows; e->counters.shared_blks_hit += bufusage->shared_blks_hit; --- 2105,2113 ---- volatile pgssEntry *e = (volatile pgssEntry *) entry; SpinLockAcquire(&e->mutex); ! if (!empty_entry) ! e->counters.calls += 1; ! e->counters.total_time += total_time; e->counters.rows += rows; e->counters.shared_blks_hit += bufusage->shared_blks_hit; *************** pgss_store(const char *query, double tot *** 775,782 **** e->counters.usage += usage; SpinLockRelease(&e->mutex); } - LWLockRelease(pgss->lock); } /* --- 2121,2129 ---- e->counters.usage += usage; SpinLockRelease(&e->mutex); } LWLockRelease(pgss->lock); + if (norm_query) + pfree(norm_query); } /* *************** pg_stat_statements(PG_FUNCTION_ARGS) *** 863,869 **** qstr = (char *) pg_do_encoding_conversion((unsigned char *) entry->query, ! entry->key.query_len, entry->key.encoding, GetDatabaseEncoding()); values[i++] = CStringGetTextDatum(qstr); --- 2210,2216 ---- qstr = (char *) pg_do_encoding_conversion((unsigned char *) entry->query, ! entry->query_len, entry->key.encoding, GetDatabaseEncoding()); values[i++] = CStringGetTextDatum(qstr); *************** pg_stat_statements(PG_FUNCTION_ARGS) *** 881,886 **** --- 2228,2236 ---- tmp = e->counters; SpinLockRelease(&e->mutex); } + /* Skip record of unexecuted query */ + if (tmp.calls == 0) + continue; values[i++] = Int64GetDatumFast(tmp.calls); values[i++] = Float8GetDatumFast(tmp.total_time); *************** pgss_memsize(void) *** 933,946 **** * have made the entry while we waited to get exclusive lock. */ static pgssEntry * ! entry_alloc(pgssHashKey *key) { pgssEntry *entry; bool found; - /* Caller must have clipped query properly */ - Assert(key->query_len < pgss->query_size); - /* Make space if needed */ while (hash_get_num_entries(pgss_hash) >= pgss_max) entry_dealloc(); --- 2283,2293 ---- * have made the entry while we waited to get exclusive lock. */ static pgssEntry * ! entry_alloc(pgssHashKey *key, const char* query, int new_query_len) { pgssEntry *entry; bool found; /* Make space if needed */ while (hash_get_num_entries(pgss_hash) >= pgss_max) entry_dealloc(); *************** entry_alloc(pgssHashKey *key) *** 952,968 **** { /* New entry, initialize it */ ! /* dynahash tried to copy the key for us, but must fix query_ptr */ ! entry->key.query_ptr = entry->query; /* reset the statistics */ memset(&entry->counters, 0, sizeof(Counters)); entry->counters.usage = USAGE_INIT; /* re-initialize the mutex each time ... we assume no one using it */ SpinLockInit(&entry->mutex); /* ... and don't forget the query text */ ! memcpy(entry->query, key->query_ptr, key->query_len); ! entry->query[key->query_len] = '\0'; } return entry; } --- 2299,2318 ---- { /* New entry, initialize it */ ! entry->query_len = new_query_len; ! Assert(entry->query_len > 0); /* reset the statistics */ memset(&entry->counters, 0, sizeof(Counters)); entry->counters.usage = USAGE_INIT; /* re-initialize the mutex each time ... we assume no one using it */ SpinLockInit(&entry->mutex); /* ... and don't forget the query text */ ! memcpy(entry->query, query, entry->query_len); ! Assert(new_query_len <= pgss->query_size); ! entry->query[entry->query_len] = '\0'; } + /* Caller must have clipped query properly */ + Assert(entry->query_len < pgss->query_size); return entry; } *************** entry_reset(void) *** 1040,1042 **** --- 2390,2437 ---- LWLockRelease(pgss->lock); } + + /* + * Returns a value indicating the number of duplicates. + * + * Assumes that the array has already been sorted. + */ + static int + n_dups(Size offs[], Size n) + { + int i, n_fdups = 0; + + for(i = 1; i < n; i++) + if (offs[i - 1] == offs[i]) + n_fdups++; + + return n_fdups; + } + + /* + * Function removes duplicate values, returning new array. + * + * new_size specifies the size of the new, duplicate-free array, which must be + * known ahead of time. + * + * Assumes that the array has already been sorted. + */ + static Size* + dedup_toks(Size offs[], Size n, Size new_size) + { + int i, j = 0; + Size *new_offsets; + + new_offsets = (Size*) palloc(sizeof(Size) * new_size); + new_offsets[j++] = offs[0]; + + for(i = 1; i < n; i++) + { + if (offs[i - 1] == offs[i]) + continue; + new_offsets[j++] = offs[i]; + } + Assert(j == new_size); + + return new_offsets; + } diff --git a/src/backend/access/hash/hashfunc.c b/src/backend/access/hash/hashfunc.c new file mode 100644 index 0e4cf8e..5497deb *** a/src/backend/access/hash/hashfunc.c --- b/src/backend/access/hash/hashfunc.c *************** hashvarlena(PG_FUNCTION_ARGS) *** 291,308 **** * k : the key (the unaligned variable-length array of bytes) * len : the length of the key, counting by bytes * ! * Returns a uint32 value. Every bit of the key affects every bit of ! * the return value. Every 1-bit and 2-bit delta achieves avalanche. ! * About 6*len+35 instructions. The best hash table sizes are powers ! * of 2. There is no need to do mod a prime (mod is sooo slow!). ! * If you need less than 32 bits, use a bitmask. * ! * Note: we could easily change this function to return a 64-bit hash value ! * by using the final values of both b and c. b is perhaps a little less ! * well mixed than c, however. */ Datum ! hash_any(register const unsigned char *k, register int keylen) { register uint32 a, b, --- 291,305 ---- * k : the key (the unaligned variable-length array of bytes) * len : the length of the key, counting by bytes * ! * Returns a uint32 or a uint64 value, depending on the width_32 argument. * ! * Every bit of the key affects every bit of the return value. Every 1-bit and ! * 2-bit delta achieves avalanche. About 6*len+35 instructions. The best hash ! * table sizes are powers of 2. There is no need to do mod a prime (mod is sooo ! * slow!). If you need less than 32 bits, use a bitmask. */ Datum ! hash_any_var_width(register const unsigned char *k, register int keylen, bool width_32) { register uint32 a, b, *************** hash_any(register const unsigned char *k *** 496,502 **** final(a, b, c); /* report the result */ ! return UInt32GetDatum(c); } /* --- 493,503 ---- final(a, b, c); /* report the result */ ! if (width_32) ! return UInt32GetDatum(c); ! else ! return (uint64) b | ! (((uint64) c) << (sizeof(uint64) / 2) * BITS_PER_BYTE); } /* diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c new file mode 100644 index cc3168d..385c13a *** a/src/backend/nodes/copyfuncs.c --- b/src/backend/nodes/copyfuncs.c *************** *** 62,67 **** --- 62,70 ---- #define COPY_LOCATION_FIELD(fldname) \ (newnode->fldname = from->fldname) + /* Copy a query_id field (for Copy, this is same as scalar case) */ + #define COPY_QUERYID_FIELD(fldname) \ + (newnode->fldname = from->fldname) /* **************************************************************** * plannodes.h copy functions *************** _copyPlannedStmt(const PlannedStmt *from *** 92,97 **** --- 95,101 ---- COPY_NODE_FIELD(relationOids); COPY_NODE_FIELD(invalItems); COPY_SCALAR_FIELD(nParamExec); + COPY_QUERYID_FIELD(queryId); return newnode; } *************** _copyQuery(const Query *from) *** 2415,2420 **** --- 2419,2425 ---- COPY_SCALAR_FIELD(commandType); COPY_SCALAR_FIELD(querySource); + COPY_SCALAR_FIELD(query_id); COPY_SCALAR_FIELD(canSetTag); COPY_NODE_FIELD(utilityStmt); COPY_SCALAR_FIELD(resultRelation); diff --git a/src/backend/nodes/equalfuncs.c b/src/backend/nodes/equalfuncs.c new file mode 100644 index 2295195..ce75da3 *** a/src/backend/nodes/equalfuncs.c --- b/src/backend/nodes/equalfuncs.c *************** *** 83,88 **** --- 83,91 ---- #define COMPARE_LOCATION_FIELD(fldname) \ ((void) 0) + /* Compare a query_id field (this is a no-op, per note above) */ + #define COMPARE_QUERYID_FIELD(fldname) \ + ((void) 0) /* * Stuff from primnodes.h *************** _equalQuery(const Query *a, const Query *** 897,902 **** --- 900,906 ---- { COMPARE_SCALAR_FIELD(commandType); COMPARE_SCALAR_FIELD(querySource); + COMPARE_QUERYID_FIELD(query_id); COMPARE_SCALAR_FIELD(canSetTag); COMPARE_NODE_FIELD(utilityStmt); COMPARE_SCALAR_FIELD(resultRelation); diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c new file mode 100644 index 829f6d4..1b5cfaf *** a/src/backend/nodes/outfuncs.c --- b/src/backend/nodes/outfuncs.c *************** *** 46,51 **** --- 46,55 ---- #define WRITE_UINT_FIELD(fldname) \ appendStringInfo(str, " :" CppAsString(fldname) " %u", node->fldname) + /* Write a location/query id field (anything written as ":fldname %lu") */ + #define WRITE_ULINT_FIELD(fldname) \ + appendStringInfo(str, " :" CppAsString(fldname) " %lu", node->fldname) + /* Write an OID field (don't hard-wire assumption that OID is same as uint) */ #define WRITE_OID_FIELD(fldname) \ appendStringInfo(str, " :" CppAsString(fldname) " %u", node->fldname) *************** *** 81,86 **** --- 85,94 ---- #define WRITE_LOCATION_FIELD(fldname) \ appendStringInfo(str, " :" CppAsString(fldname) " %d", node->fldname) + /* Write a query id field */ + #define WRITE_QUERYID_FIELD(fldname) \ + ((void) 0) + /* Write a Node field */ #define WRITE_NODE_FIELD(fldname) \ (appendStringInfo(str, " :" CppAsString(fldname) " "), \ *************** _outPlannedStmt(StringInfo str, const Pl *** 255,260 **** --- 263,269 ---- WRITE_NODE_FIELD(relationOids); WRITE_NODE_FIELD(invalItems); WRITE_INT_FIELD(nParamExec); + WRITE_QUERYID_FIELD(queryId); } /* *************** _outQuery(StringInfo str, const Query *n *** 2159,2164 **** --- 2168,2174 ---- WRITE_ENUM_FIELD(commandType, CmdType); WRITE_ENUM_FIELD(querySource, QuerySource); + WRITE_QUERYID_FIELD(query_id); WRITE_BOOL_FIELD(canSetTag); /* diff --git a/src/backend/nodes/readfuncs.c b/src/backend/nodes/readfuncs.c new file mode 100644 index b9258ad..d2e65ef *** a/src/backend/nodes/readfuncs.c --- b/src/backend/nodes/readfuncs.c *************** *** 68,73 **** --- 68,79 ---- token = pg_strtok(&length); /* get field value */ \ local_node->fldname = atoui(token) + /* Read an unsigned integer field (anything written as ":fldname %lu") */ + #define READ_ULINT_FIELD(fldname) \ + token = pg_strtok(&length); /* skip :fldname */ \ + token = pg_strtok(&length); /* get field value */ \ + local_node->fldname = atoul(token) + /* Read an OID field (don't hard-wire assumption that OID is same as uint) */ #define READ_OID_FIELD(fldname) \ token = pg_strtok(&length); /* skip :fldname */ \ *************** *** 110,115 **** --- 116,124 ---- token = pg_strtok(&length); /* get field value */ \ local_node->fldname = -1 /* set field to "unknown" */ + /* NOOP */ + #define READ_QUERYID_FIELD(fldname) \ + ((void) 0) /* Read a Node field */ #define READ_NODE_FIELD(fldname) \ token = pg_strtok(&length); /* skip :fldname */ \ *************** *** 133,138 **** --- 142,149 ---- */ #define atoui(x) ((unsigned int) strtoul((x), NULL, 10)) + #define atoul(x) ((unsigned long) strtoul((x), NULL, 10)) + #define atooid(x) ((Oid) strtoul((x), NULL, 10)) #define strtobool(x) ((*(x) == 't') ? true : false) *************** _readQuery(void) *** 195,200 **** --- 206,212 ---- READ_ENUM_FIELD(commandType, CmdType); READ_ENUM_FIELD(querySource, QuerySource); + READ_QUERYID_FIELD(query_id); READ_BOOL_FIELD(canSetTag); READ_NODE_FIELD(utilityStmt); READ_INT_FIELD(resultRelation); diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c new file mode 100644 index 2e8ea5a..ae011ae *** a/src/backend/optimizer/plan/planner.c --- b/src/backend/optimizer/plan/planner.c *************** standard_planner(Query *parse, int curso *** 240,245 **** --- 240,246 ---- result->relationOids = glob->relationOids; result->invalItems = glob->invalItems; result->nParamExec = list_length(glob->paramlist); + result->queryId = parse->query_id; return result; } diff --git a/src/backend/parser/analyze.c b/src/backend/parser/analyze.c new file mode 100644 index be6e93e..fc43bed *** a/src/backend/parser/analyze.c --- b/src/backend/parser/analyze.c *************** static Query *transformExplainStmt(Parse *** 65,73 **** static void transformLockingClause(ParseState *pstate, Query *qry, LockingClause *lc, bool pushedDown); /* ! * parse_analyze * Analyze a raw parse tree and transform it to Query form. * * Optionally, information about $n parameter types can be supplied. --- 65,89 ---- static void transformLockingClause(ParseState *pstate, Query *qry, LockingClause *lc, bool pushedDown); + /* Hooks for plugins to get control of parse analysis */ + parse_analyze_hook_type parse_analyze_hook = NULL; + parse_analyze_varparams_hook_type parse_analyze_varparams_hook = NULL; + + + Query * + parse_analyze(Node *parseTree, const char *sourceText, + Oid *paramTypes, int numParams) + { + if (parse_analyze_hook) + return (*parse_analyze_hook) (parseTree, sourceText, + paramTypes, numParams); + else + return standard_parse_analyze(parseTree, sourceText, + paramTypes, numParams); + } /* ! * standard_parse_analyze * Analyze a raw parse tree and transform it to Query form. * * Optionally, information about $n parameter types can be supplied. *************** static void transformLockingClause(Parse *** 78,84 **** * a dummy CMD_UTILITY Query node. */ Query * ! parse_analyze(Node *parseTree, const char *sourceText, Oid *paramTypes, int numParams) { ParseState *pstate = make_parsestate(NULL); --- 94,100 ---- * a dummy CMD_UTILITY Query node. */ Query * ! standard_parse_analyze(Node *parseTree, const char *sourceText, Oid *paramTypes, int numParams) { ParseState *pstate = make_parsestate(NULL); *************** parse_analyze(Node *parseTree, const cha *** 98,112 **** return query; } /* ! * parse_analyze_varparams * * This variant is used when it's okay to deduce information about $n * symbol datatypes from context. The passed-in paramTypes[] array can * be modified or enlarged (via repalloc). */ Query * ! parse_analyze_varparams(Node *parseTree, const char *sourceText, Oid **paramTypes, int *numParams) { ParseState *pstate = make_parsestate(NULL); --- 114,140 ---- return query; } + Query * + parse_analyze_varparams(Node *parseTree, const char *sourceText, + Oid **paramTypes, int *numParams) + { + if (parse_analyze_varparams_hook) + return (*parse_analyze_varparams_hook) (parseTree, sourceText, + paramTypes, numParams); + else + return standard_parse_analyze_varparams(parseTree, sourceText, + paramTypes, numParams); + } + /* ! * standard_parse_analyze_varparams * * This variant is used when it's okay to deduce information about $n * symbol datatypes from context. The passed-in paramTypes[] array can * be modified or enlarged (via repalloc). */ Query * ! standard_parse_analyze_varparams(Node *parseTree, const char *sourceText, Oid **paramTypes, int *numParams) { ParseState *pstate = make_parsestate(NULL); *************** transformSelectStmt(ParseState *pstate, *** 877,882 **** --- 905,911 ---- ListCell *l; qry->commandType = CMD_SELECT; + qry->query_id = 0; /* process the WITH clause independently of all else */ if (stmt->withClause) diff --git a/src/include/access/hash.h b/src/include/access/hash.h new file mode 100644 index a3d0f98..464d772 *** a/src/include/access/hash.h --- b/src/include/access/hash.h *************** typedef HashMetaPageData *HashMetaPage; *** 239,244 **** --- 239,246 ---- */ #define HASHPROC 1 + #define hash_any(k, keylen) (hash_any_var_width(k, keylen, true)) + #define hash_any64(k, keylen) (hash_any_var_width(k, keylen, false)) /* public routines */ *************** extern Datum hashint2vector(PG_FUNCTION_ *** 278,284 **** extern Datum hashname(PG_FUNCTION_ARGS); extern Datum hashtext(PG_FUNCTION_ARGS); extern Datum hashvarlena(PG_FUNCTION_ARGS); ! extern Datum hash_any(register const unsigned char *k, register int keylen); extern Datum hash_uint32(uint32 k); /* private routines */ --- 280,286 ---- extern Datum hashname(PG_FUNCTION_ARGS); extern Datum hashtext(PG_FUNCTION_ARGS); extern Datum hashvarlena(PG_FUNCTION_ARGS); ! extern Datum hash_any_var_width(register const unsigned char *k, register int keylen, bool width_32); extern Datum hash_uint32(uint32 k); /* private routines */ diff --git a/src/include/nodes/parsenodes.h b/src/include/nodes/parsenodes.h new file mode 100644 index 1d33ceb..d4133f2 *** a/src/include/nodes/parsenodes.h --- b/src/include/nodes/parsenodes.h *************** typedef struct Query *** 103,108 **** --- 103,111 ---- QuerySource querySource; /* where did I come from? */ + uint64 query_id; /* query identifier that can be set by plugins. + * Will be copied to resulting PlannedStmt. */ + bool canSetTag; /* do I set the command result tag? */ Node *utilityStmt; /* non-null if this is DECLARE CURSOR or a diff --git a/src/include/nodes/plannodes.h b/src/include/nodes/plannodes.h new file mode 100644 index 7d90b91..f520085 *** a/src/include/nodes/plannodes.h --- b/src/include/nodes/plannodes.h *************** typedef struct PlannedStmt *** 67,72 **** --- 67,74 ---- List *invalItems; /* other dependencies, as PlanInvalItems */ int nParamExec; /* number of PARAM_EXEC Params used */ + + uint64 queryId; /* query identifier carried from query tree */ } PlannedStmt; /* macro for fetching the Plan associated with a SubPlan node */ diff --git a/src/include/parser/analyze.h b/src/include/parser/analyze.h new file mode 100644 index b8987db..2bad10f *** a/src/include/parser/analyze.h --- b/src/include/parser/analyze.h *************** *** 16,26 **** --- 16,38 ---- #include "parser/parse_node.h" + /* Hook for plugins to get control in parse_analyze() */ + typedef Query* (*parse_analyze_hook_type) (Node *parseTree, const char *sourceText, + Oid *paramTypes, int numParams); + extern PGDLLIMPORT parse_analyze_hook_type parse_analyze_hook; + /* Hook for plugins to get control in parse_analyze_varparams() */ + typedef Query* (*parse_analyze_varparams_hook_type) (Node *parseTree, const char *sourceText, + Oid **paramTypes, int *numParams); + extern PGDLLIMPORT parse_analyze_varparams_hook_type parse_analyze_varparams_hook; extern Query *parse_analyze(Node *parseTree, const char *sourceText, Oid *paramTypes, int numParams); + extern Query *standard_parse_analyze(Node *parseTree, const char *sourceText, + Oid *paramTypes, int numParams); extern Query *parse_analyze_varparams(Node *parseTree, const char *sourceText, Oid **paramTypes, int *numParams); + extern Query *standard_parse_analyze_varparams(Node *parseTree, const char *sourceText, + Oid **paramTypes, int *numParams); extern Query *parse_sub_analyze(Node *parseTree, ParseState *parentParseState, CommonTableExpr *parentCTE,