2021-04-07 19:06:47 +02:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
|
|
|
* queryjumble.c
|
|
|
|
* Query normalization and fingerprinting.
|
|
|
|
*
|
|
|
|
* 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 fingerprinting queries, selectively
|
|
|
|
* serializing those fields of each query tree's nodes that are judged to be
|
|
|
|
* essential to the query. This is referred to as a query jumble. This is
|
|
|
|
* distinct from a regular serialization in that various extraneous
|
|
|
|
* information is ignored as irrelevant or not essential to the query, such
|
|
|
|
* as the collations of Vars and, most notably, the values of constants.
|
|
|
|
*
|
|
|
|
* This jumble is acquired at the end of parse analysis of each query, and
|
|
|
|
* a 64-bit hash of it is stored into the query's Query.queryId field.
|
|
|
|
* The server then copies this value around, making it available in plan
|
|
|
|
* tree(s) generated from the query. The executor can then use this value
|
|
|
|
* to blame query costs on the proper queryId.
|
|
|
|
*
|
|
|
|
* Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group
|
|
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* IDENTIFICATION
|
|
|
|
* src/backend/utils/misc/queryjumble.c
|
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
#include "postgres.h"
|
|
|
|
|
|
|
|
#include "common/hashfn.h"
|
|
|
|
#include "miscadmin.h"
|
|
|
|
#include "parser/scansup.h"
|
|
|
|
#include "utils/queryjumble.h"
|
|
|
|
|
|
|
|
#define JUMBLE_SIZE 1024 /* query serialization buffer size */
|
|
|
|
|
2021-05-15 20:13:09 +02:00
|
|
|
/* GUC parameters */
|
|
|
|
int compute_query_id = COMPUTE_QUERY_ID_AUTO;
|
|
|
|
|
|
|
|
/* True when compute_query_id is ON, or AUTO and a module requests them */
|
|
|
|
bool query_id_enabled = false;
|
|
|
|
|
2021-04-20 18:22:26 +02:00
|
|
|
static uint64 compute_utility_query_id(const char *str, int query_location, int query_len);
|
2021-04-07 19:06:47 +02:00
|
|
|
static void AppendJumble(JumbleState *jstate,
|
|
|
|
const unsigned char *item, Size size);
|
|
|
|
static void JumbleQueryInternal(JumbleState *jstate, Query *query);
|
|
|
|
static void JumbleRangeTable(JumbleState *jstate, List *rtable);
|
|
|
|
static void JumbleRowMarks(JumbleState *jstate, List *rowMarks);
|
|
|
|
static void JumbleExpr(JumbleState *jstate, Node *node);
|
|
|
|
static void RecordConstLocation(JumbleState *jstate, int location);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Given a possibly multi-statement source string, confine our attention to the
|
|
|
|
* relevant part of the string.
|
|
|
|
*/
|
|
|
|
const char *
|
|
|
|
CleanQuerytext(const char *query, int *location, int *len)
|
|
|
|
{
|
2021-05-12 19:14:10 +02:00
|
|
|
int query_location = *location;
|
|
|
|
int query_len = *len;
|
2021-04-07 19:06:47 +02:00
|
|
|
|
|
|
|
/* First apply starting offset, unless it's -1 (unknown). */
|
|
|
|
if (query_location >= 0)
|
|
|
|
{
|
|
|
|
Assert(query_location <= strlen(query));
|
|
|
|
query += query_location;
|
|
|
|
/* Length of 0 (or -1) means "rest of string" */
|
|
|
|
if (query_len <= 0)
|
|
|
|
query_len = strlen(query);
|
|
|
|
else
|
|
|
|
Assert(query_len <= strlen(query));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* If query location is unknown, distrust query_len as well */
|
|
|
|
query_location = 0;
|
|
|
|
query_len = strlen(query);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Discard leading and trailing whitespace, too. Use scanner_isspace()
|
|
|
|
* not libc's isspace(), because we want to match the lexer's behavior.
|
|
|
|
*/
|
|
|
|
while (query_len > 0 && scanner_isspace(query[0]))
|
|
|
|
query++, query_location++, query_len--;
|
|
|
|
while (query_len > 0 && scanner_isspace(query[query_len - 1]))
|
|
|
|
query_len--;
|
|
|
|
|
|
|
|
*location = query_location;
|
|
|
|
*len = query_len;
|
|
|
|
|
|
|
|
return query;
|
|
|
|
}
|
|
|
|
|
|
|
|
JumbleState *
|
|
|
|
JumbleQuery(Query *query, const char *querytext)
|
|
|
|
{
|
|
|
|
JumbleState *jstate = NULL;
|
2021-05-12 19:14:10 +02:00
|
|
|
|
2021-05-15 20:13:09 +02:00
|
|
|
Assert(IsQueryIdEnabled());
|
|
|
|
|
2021-04-07 19:06:47 +02:00
|
|
|
if (query->utilityStmt)
|
|
|
|
{
|
2021-04-20 18:22:26 +02:00
|
|
|
query->queryId = compute_utility_query_id(querytext,
|
2021-05-12 19:14:10 +02:00
|
|
|
query->stmt_location,
|
|
|
|
query->stmt_len);
|
2021-04-07 19:06:47 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
jstate = (JumbleState *) palloc(sizeof(JumbleState));
|
|
|
|
|
|
|
|
/* Set up workspace for query jumbling */
|
|
|
|
jstate->jumble = (unsigned char *) palloc(JUMBLE_SIZE);
|
|
|
|
jstate->jumble_len = 0;
|
|
|
|
jstate->clocations_buf_size = 32;
|
|
|
|
jstate->clocations = (LocationLen *)
|
|
|
|
palloc(jstate->clocations_buf_size * sizeof(LocationLen));
|
|
|
|
jstate->clocations_count = 0;
|
|
|
|
jstate->highest_extern_param_id = 0;
|
|
|
|
|
|
|
|
/* Compute query ID and mark the Query node with it */
|
|
|
|
JumbleQueryInternal(jstate, query);
|
|
|
|
query->queryId = DatumGetUInt64(hash_any_extended(jstate->jumble,
|
|
|
|
jstate->jumble_len,
|
|
|
|
0));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we are unlucky enough to get a hash of zero, use 1 instead, to
|
|
|
|
* prevent confusion with the utility-statement case.
|
|
|
|
*/
|
|
|
|
if (query->queryId == UINT64CONST(0))
|
|
|
|
query->queryId = UINT64CONST(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
return jstate;
|
|
|
|
}
|
|
|
|
|
2021-05-15 20:13:09 +02:00
|
|
|
/*
|
|
|
|
* Enables query identifier computation.
|
|
|
|
*
|
|
|
|
* Third-party plugins can use this function to inform core that they require
|
|
|
|
* a query identifier to be computed.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
EnableQueryId(void)
|
|
|
|
{
|
|
|
|
if (compute_query_id != COMPUTE_QUERY_ID_OFF)
|
|
|
|
query_id_enabled = true;
|
|
|
|
}
|
|
|
|
|
2021-04-07 19:06:47 +02:00
|
|
|
/*
|
|
|
|
* Compute a query identifier for the given utility query string.
|
|
|
|
*/
|
|
|
|
static uint64
|
2021-04-20 18:22:26 +02:00
|
|
|
compute_utility_query_id(const char *query_text, int query_location, int query_len)
|
2021-04-07 19:06:47 +02:00
|
|
|
{
|
2021-05-12 19:14:10 +02:00
|
|
|
uint64 queryId;
|
Make use of in-core query id added by commit 5fd9dfa5f5
Use the in-core query id computation for pg_stat_activity,
log_line_prefix, and EXPLAIN VERBOSE.
Similar to other fields in pg_stat_activity, only the queryid from the
top level statements are exposed, and if the backends status isn't
active then the queryid from the last executed statements is displayed.
Add a %Q placeholder to include the queryid in log_line_prefix, which
will also only expose top level statements.
For EXPLAIN VERBOSE, if a query identifier has been computed, either by
enabling compute_query_id or using a third-party module, display it.
Bump catalog version.
Discussion: https://postgr.es/m/20210407125726.tkvjdbw76hxnpwfi@nol
Author: Julien Rouhaud
Reviewed-by: Alvaro Herrera, Nitin Jadhav, Zhihong Yu
2021-04-07 20:03:56 +02:00
|
|
|
const char *sql;
|
|
|
|
|
|
|
|
/*
|
2021-05-12 19:14:10 +02:00
|
|
|
* Confine our attention to the relevant part of the string, if the query
|
|
|
|
* is a portion of a multi-statement source string.
|
Make use of in-core query id added by commit 5fd9dfa5f5
Use the in-core query id computation for pg_stat_activity,
log_line_prefix, and EXPLAIN VERBOSE.
Similar to other fields in pg_stat_activity, only the queryid from the
top level statements are exposed, and if the backends status isn't
active then the queryid from the last executed statements is displayed.
Add a %Q placeholder to include the queryid in log_line_prefix, which
will also only expose top level statements.
For EXPLAIN VERBOSE, if a query identifier has been computed, either by
enabling compute_query_id or using a third-party module, display it.
Bump catalog version.
Discussion: https://postgr.es/m/20210407125726.tkvjdbw76hxnpwfi@nol
Author: Julien Rouhaud
Reviewed-by: Alvaro Herrera, Nitin Jadhav, Zhihong Yu
2021-04-07 20:03:56 +02:00
|
|
|
*/
|
|
|
|
sql = CleanQuerytext(query_text, &query_location, &query_len);
|
2021-04-07 19:06:47 +02:00
|
|
|
|
Make use of in-core query id added by commit 5fd9dfa5f5
Use the in-core query id computation for pg_stat_activity,
log_line_prefix, and EXPLAIN VERBOSE.
Similar to other fields in pg_stat_activity, only the queryid from the
top level statements are exposed, and if the backends status isn't
active then the queryid from the last executed statements is displayed.
Add a %Q placeholder to include the queryid in log_line_prefix, which
will also only expose top level statements.
For EXPLAIN VERBOSE, if a query identifier has been computed, either by
enabling compute_query_id or using a third-party module, display it.
Bump catalog version.
Discussion: https://postgr.es/m/20210407125726.tkvjdbw76hxnpwfi@nol
Author: Julien Rouhaud
Reviewed-by: Alvaro Herrera, Nitin Jadhav, Zhihong Yu
2021-04-07 20:03:56 +02:00
|
|
|
queryId = DatumGetUInt64(hash_any_extended((const unsigned char *) sql,
|
2021-04-07 19:06:47 +02:00
|
|
|
query_len, 0));
|
|
|
|
|
|
|
|
/*
|
2021-05-12 19:14:10 +02:00
|
|
|
* If we are unlucky enough to get a hash of zero(invalid), use queryID as
|
|
|
|
* 2 instead, queryID 1 is already in use for normal statements.
|
2021-04-07 19:06:47 +02:00
|
|
|
*/
|
|
|
|
if (queryId == UINT64CONST(0))
|
|
|
|
queryId = UINT64CONST(2);
|
|
|
|
|
|
|
|
return queryId;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* AppendJumble: Append a value that is substantive in a given query to
|
|
|
|
* the current jumble.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
AppendJumble(JumbleState *jstate, const unsigned char *item, Size size)
|
|
|
|
{
|
|
|
|
unsigned char *jumble = jstate->jumble;
|
|
|
|
Size jumble_len = jstate->jumble_len;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Whenever the jumble buffer is full, we hash the current contents and
|
|
|
|
* reset the buffer to contain just that hash value, thus relying on the
|
|
|
|
* hash to summarize everything so far.
|
|
|
|
*/
|
|
|
|
while (size > 0)
|
|
|
|
{
|
|
|
|
Size part_size;
|
|
|
|
|
|
|
|
if (jumble_len >= JUMBLE_SIZE)
|
|
|
|
{
|
|
|
|
uint64 start_hash;
|
|
|
|
|
|
|
|
start_hash = DatumGetUInt64(hash_any_extended(jumble,
|
|
|
|
JUMBLE_SIZE, 0));
|
|
|
|
memcpy(jumble, &start_hash, sizeof(start_hash));
|
|
|
|
jumble_len = sizeof(start_hash);
|
|
|
|
}
|
|
|
|
part_size = Min(size, JUMBLE_SIZE - jumble_len);
|
|
|
|
memcpy(jumble + jumble_len, item, part_size);
|
|
|
|
jumble_len += part_size;
|
|
|
|
item += part_size;
|
|
|
|
size -= part_size;
|
|
|
|
}
|
|
|
|
jstate->jumble_len = jumble_len;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Wrappers around AppendJumble to encapsulate details of serialization
|
|
|
|
* of individual local variable elements.
|
|
|
|
*/
|
|
|
|
#define APP_JUMB(item) \
|
|
|
|
AppendJumble(jstate, (const unsigned char *) &(item), sizeof(item))
|
|
|
|
#define APP_JUMB_STRING(str) \
|
|
|
|
AppendJumble(jstate, (const unsigned char *) (str), strlen(str) + 1)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* JumbleQueryInternal: Selectively serialize the query tree, appending
|
|
|
|
* significant data to the "query jumble" while ignoring nonsignificant data.
|
|
|
|
*
|
|
|
|
* Rule of thumb for what to include is that we should ignore anything not
|
|
|
|
* semantically significant (such as alias names) as well as anything that can
|
|
|
|
* be deduced from child nodes (else we'd just be double-hashing that piece
|
|
|
|
* of information).
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
JumbleQueryInternal(JumbleState *jstate, Query *query)
|
|
|
|
{
|
|
|
|
Assert(IsA(query, Query));
|
|
|
|
Assert(query->utilityStmt == NULL);
|
|
|
|
|
|
|
|
APP_JUMB(query->commandType);
|
|
|
|
/* resultRelation is usually predictable from commandType */
|
|
|
|
JumbleExpr(jstate, (Node *) query->cteList);
|
|
|
|
JumbleRangeTable(jstate, query->rtable);
|
|
|
|
JumbleExpr(jstate, (Node *) query->jointree);
|
|
|
|
JumbleExpr(jstate, (Node *) query->targetList);
|
|
|
|
JumbleExpr(jstate, (Node *) query->onConflict);
|
|
|
|
JumbleExpr(jstate, (Node *) query->returningList);
|
|
|
|
JumbleExpr(jstate, (Node *) query->groupClause);
|
2021-05-03 20:59:30 +02:00
|
|
|
APP_JUMB(query->groupDistinct);
|
2021-04-07 19:06:47 +02:00
|
|
|
JumbleExpr(jstate, (Node *) query->groupingSets);
|
|
|
|
JumbleExpr(jstate, query->havingQual);
|
|
|
|
JumbleExpr(jstate, (Node *) query->windowClause);
|
|
|
|
JumbleExpr(jstate, (Node *) query->distinctClause);
|
|
|
|
JumbleExpr(jstate, (Node *) query->sortClause);
|
|
|
|
JumbleExpr(jstate, query->limitOffset);
|
|
|
|
JumbleExpr(jstate, query->limitCount);
|
2021-05-03 20:59:30 +02:00
|
|
|
APP_JUMB(query->limitOption);
|
2021-04-07 19:06:47 +02:00
|
|
|
JumbleRowMarks(jstate, query->rowMarks);
|
|
|
|
JumbleExpr(jstate, query->setOperations);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Jumble a range table
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
JumbleRangeTable(JumbleState *jstate, List *rtable)
|
|
|
|
{
|
|
|
|
ListCell *lc;
|
|
|
|
|
|
|
|
foreach(lc, rtable)
|
|
|
|
{
|
|
|
|
RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
|
|
|
|
|
|
|
|
APP_JUMB(rte->rtekind);
|
|
|
|
switch (rte->rtekind)
|
|
|
|
{
|
|
|
|
case RTE_RELATION:
|
|
|
|
APP_JUMB(rte->relid);
|
|
|
|
JumbleExpr(jstate, (Node *) rte->tablesample);
|
2021-05-03 20:59:30 +02:00
|
|
|
APP_JUMB(rte->inh);
|
2021-04-07 19:06:47 +02:00
|
|
|
break;
|
|
|
|
case RTE_SUBQUERY:
|
|
|
|
JumbleQueryInternal(jstate, rte->subquery);
|
|
|
|
break;
|
|
|
|
case RTE_JOIN:
|
|
|
|
APP_JUMB(rte->jointype);
|
|
|
|
break;
|
|
|
|
case RTE_FUNCTION:
|
|
|
|
JumbleExpr(jstate, (Node *) rte->functions);
|
|
|
|
break;
|
|
|
|
case RTE_TABLEFUNC:
|
|
|
|
JumbleExpr(jstate, (Node *) rte->tablefunc);
|
|
|
|
break;
|
|
|
|
case RTE_VALUES:
|
|
|
|
JumbleExpr(jstate, (Node *) rte->values_lists);
|
|
|
|
break;
|
|
|
|
case RTE_CTE:
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Depending on the CTE name here isn't ideal, but it's the
|
|
|
|
* only info we have to identify the referenced WITH item.
|
|
|
|
*/
|
|
|
|
APP_JUMB_STRING(rte->ctename);
|
|
|
|
APP_JUMB(rte->ctelevelsup);
|
|
|
|
break;
|
|
|
|
case RTE_NAMEDTUPLESTORE:
|
|
|
|
APP_JUMB_STRING(rte->enrname);
|
|
|
|
break;
|
|
|
|
case RTE_RESULT:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
elog(ERROR, "unrecognized RTE kind: %d", (int) rte->rtekind);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Jumble a rowMarks list
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
JumbleRowMarks(JumbleState *jstate, List *rowMarks)
|
|
|
|
{
|
|
|
|
ListCell *lc;
|
|
|
|
|
|
|
|
foreach(lc, rowMarks)
|
|
|
|
{
|
|
|
|
RowMarkClause *rowmark = lfirst_node(RowMarkClause, lc);
|
|
|
|
|
|
|
|
if (!rowmark->pushedDown)
|
|
|
|
{
|
|
|
|
APP_JUMB(rowmark->rti);
|
|
|
|
APP_JUMB(rowmark->strength);
|
|
|
|
APP_JUMB(rowmark->waitPolicy);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Jumble an expression tree
|
|
|
|
*
|
|
|
|
* In general this function should handle all the same node types that
|
|
|
|
* expression_tree_walker() does, and therefore it's coded to be as parallel
|
|
|
|
* to that function as possible. However, since we are only invoked on
|
|
|
|
* queries immediately post-parse-analysis, we need not handle node types
|
|
|
|
* that only appear in planning.
|
|
|
|
*
|
|
|
|
* Note: the reason we don't simply use expression_tree_walker() is that the
|
|
|
|
* point of that function is to support tree walkers that don't care about
|
|
|
|
* most tree node types, but here we care about all types. We should complain
|
|
|
|
* about any unrecognized node type.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
JumbleExpr(JumbleState *jstate, Node *node)
|
|
|
|
{
|
|
|
|
ListCell *temp;
|
|
|
|
|
|
|
|
if (node == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Guard against stack overflow due to overly complex expressions */
|
|
|
|
check_stack_depth();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We always emit the node's NodeTag, then any additional fields that are
|
|
|
|
* considered significant, and then we recurse to any child nodes.
|
|
|
|
*/
|
|
|
|
APP_JUMB(node->type);
|
|
|
|
|
|
|
|
switch (nodeTag(node))
|
|
|
|
{
|
|
|
|
case T_Var:
|
|
|
|
{
|
|
|
|
Var *var = (Var *) node;
|
|
|
|
|
|
|
|
APP_JUMB(var->varno);
|
|
|
|
APP_JUMB(var->varattno);
|
|
|
|
APP_JUMB(var->varlevelsup);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_Const:
|
|
|
|
{
|
|
|
|
Const *c = (Const *) node;
|
|
|
|
|
|
|
|
/* We jumble only the constant's type, not its value */
|
|
|
|
APP_JUMB(c->consttype);
|
|
|
|
/* Also, record its parse location for query normalization */
|
|
|
|
RecordConstLocation(jstate, c->location);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_Param:
|
|
|
|
{
|
|
|
|
Param *p = (Param *) node;
|
|
|
|
|
|
|
|
APP_JUMB(p->paramkind);
|
|
|
|
APP_JUMB(p->paramid);
|
|
|
|
APP_JUMB(p->paramtype);
|
|
|
|
/* Also, track the highest external Param id */
|
|
|
|
if (p->paramkind == PARAM_EXTERN &&
|
|
|
|
p->paramid > jstate->highest_extern_param_id)
|
|
|
|
jstate->highest_extern_param_id = p->paramid;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_Aggref:
|
|
|
|
{
|
|
|
|
Aggref *expr = (Aggref *) node;
|
|
|
|
|
|
|
|
APP_JUMB(expr->aggfnoid);
|
|
|
|
JumbleExpr(jstate, (Node *) expr->aggdirectargs);
|
|
|
|
JumbleExpr(jstate, (Node *) expr->args);
|
|
|
|
JumbleExpr(jstate, (Node *) expr->aggorder);
|
|
|
|
JumbleExpr(jstate, (Node *) expr->aggdistinct);
|
|
|
|
JumbleExpr(jstate, (Node *) expr->aggfilter);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_GroupingFunc:
|
|
|
|
{
|
|
|
|
GroupingFunc *grpnode = (GroupingFunc *) node;
|
|
|
|
|
|
|
|
JumbleExpr(jstate, (Node *) grpnode->refs);
|
2021-05-03 20:59:30 +02:00
|
|
|
APP_JUMB(grpnode->agglevelsup);
|
2021-04-07 19:06:47 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_WindowFunc:
|
|
|
|
{
|
|
|
|
WindowFunc *expr = (WindowFunc *) node;
|
|
|
|
|
|
|
|
APP_JUMB(expr->winfnoid);
|
|
|
|
APP_JUMB(expr->winref);
|
|
|
|
JumbleExpr(jstate, (Node *) expr->args);
|
|
|
|
JumbleExpr(jstate, (Node *) expr->aggfilter);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_SubscriptingRef:
|
|
|
|
{
|
|
|
|
SubscriptingRef *sbsref = (SubscriptingRef *) node;
|
|
|
|
|
|
|
|
JumbleExpr(jstate, (Node *) sbsref->refupperindexpr);
|
|
|
|
JumbleExpr(jstate, (Node *) sbsref->reflowerindexpr);
|
|
|
|
JumbleExpr(jstate, (Node *) sbsref->refexpr);
|
|
|
|
JumbleExpr(jstate, (Node *) sbsref->refassgnexpr);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_FuncExpr:
|
|
|
|
{
|
|
|
|
FuncExpr *expr = (FuncExpr *) node;
|
|
|
|
|
|
|
|
APP_JUMB(expr->funcid);
|
|
|
|
JumbleExpr(jstate, (Node *) expr->args);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_NamedArgExpr:
|
|
|
|
{
|
|
|
|
NamedArgExpr *nae = (NamedArgExpr *) node;
|
|
|
|
|
|
|
|
APP_JUMB(nae->argnumber);
|
|
|
|
JumbleExpr(jstate, (Node *) nae->arg);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_OpExpr:
|
|
|
|
case T_DistinctExpr: /* struct-equivalent to OpExpr */
|
|
|
|
case T_NullIfExpr: /* struct-equivalent to OpExpr */
|
|
|
|
{
|
|
|
|
OpExpr *expr = (OpExpr *) node;
|
|
|
|
|
|
|
|
APP_JUMB(expr->opno);
|
|
|
|
JumbleExpr(jstate, (Node *) expr->args);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_ScalarArrayOpExpr:
|
|
|
|
{
|
|
|
|
ScalarArrayOpExpr *expr = (ScalarArrayOpExpr *) node;
|
|
|
|
|
|
|
|
APP_JUMB(expr->opno);
|
|
|
|
APP_JUMB(expr->useOr);
|
|
|
|
JumbleExpr(jstate, (Node *) expr->args);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_BoolExpr:
|
|
|
|
{
|
|
|
|
BoolExpr *expr = (BoolExpr *) node;
|
|
|
|
|
|
|
|
APP_JUMB(expr->boolop);
|
|
|
|
JumbleExpr(jstate, (Node *) expr->args);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_SubLink:
|
|
|
|
{
|
|
|
|
SubLink *sublink = (SubLink *) node;
|
|
|
|
|
|
|
|
APP_JUMB(sublink->subLinkType);
|
|
|
|
APP_JUMB(sublink->subLinkId);
|
|
|
|
JumbleExpr(jstate, (Node *) sublink->testexpr);
|
|
|
|
JumbleQueryInternal(jstate, castNode(Query, sublink->subselect));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_FieldSelect:
|
|
|
|
{
|
|
|
|
FieldSelect *fs = (FieldSelect *) node;
|
|
|
|
|
|
|
|
APP_JUMB(fs->fieldnum);
|
|
|
|
JumbleExpr(jstate, (Node *) fs->arg);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_FieldStore:
|
|
|
|
{
|
|
|
|
FieldStore *fstore = (FieldStore *) node;
|
|
|
|
|
|
|
|
JumbleExpr(jstate, (Node *) fstore->arg);
|
|
|
|
JumbleExpr(jstate, (Node *) fstore->newvals);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_RelabelType:
|
|
|
|
{
|
|
|
|
RelabelType *rt = (RelabelType *) node;
|
|
|
|
|
|
|
|
APP_JUMB(rt->resulttype);
|
|
|
|
JumbleExpr(jstate, (Node *) rt->arg);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_CoerceViaIO:
|
|
|
|
{
|
|
|
|
CoerceViaIO *cio = (CoerceViaIO *) node;
|
|
|
|
|
|
|
|
APP_JUMB(cio->resulttype);
|
|
|
|
JumbleExpr(jstate, (Node *) cio->arg);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_ArrayCoerceExpr:
|
|
|
|
{
|
|
|
|
ArrayCoerceExpr *acexpr = (ArrayCoerceExpr *) node;
|
|
|
|
|
|
|
|
APP_JUMB(acexpr->resulttype);
|
|
|
|
JumbleExpr(jstate, (Node *) acexpr->arg);
|
|
|
|
JumbleExpr(jstate, (Node *) acexpr->elemexpr);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_ConvertRowtypeExpr:
|
|
|
|
{
|
|
|
|
ConvertRowtypeExpr *crexpr = (ConvertRowtypeExpr *) node;
|
|
|
|
|
|
|
|
APP_JUMB(crexpr->resulttype);
|
|
|
|
JumbleExpr(jstate, (Node *) crexpr->arg);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_CollateExpr:
|
|
|
|
{
|
|
|
|
CollateExpr *ce = (CollateExpr *) node;
|
|
|
|
|
|
|
|
APP_JUMB(ce->collOid);
|
|
|
|
JumbleExpr(jstate, (Node *) ce->arg);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_CaseExpr:
|
|
|
|
{
|
|
|
|
CaseExpr *caseexpr = (CaseExpr *) node;
|
|
|
|
|
|
|
|
JumbleExpr(jstate, (Node *) caseexpr->arg);
|
|
|
|
foreach(temp, caseexpr->args)
|
|
|
|
{
|
|
|
|
CaseWhen *when = lfirst_node(CaseWhen, temp);
|
|
|
|
|
|
|
|
JumbleExpr(jstate, (Node *) when->expr);
|
|
|
|
JumbleExpr(jstate, (Node *) when->result);
|
|
|
|
}
|
|
|
|
JumbleExpr(jstate, (Node *) caseexpr->defresult);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_CaseTestExpr:
|
|
|
|
{
|
|
|
|
CaseTestExpr *ct = (CaseTestExpr *) node;
|
|
|
|
|
|
|
|
APP_JUMB(ct->typeId);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_ArrayExpr:
|
|
|
|
JumbleExpr(jstate, (Node *) ((ArrayExpr *) node)->elements);
|
|
|
|
break;
|
|
|
|
case T_RowExpr:
|
|
|
|
JumbleExpr(jstate, (Node *) ((RowExpr *) node)->args);
|
|
|
|
break;
|
|
|
|
case T_RowCompareExpr:
|
|
|
|
{
|
|
|
|
RowCompareExpr *rcexpr = (RowCompareExpr *) node;
|
|
|
|
|
|
|
|
APP_JUMB(rcexpr->rctype);
|
|
|
|
JumbleExpr(jstate, (Node *) rcexpr->largs);
|
|
|
|
JumbleExpr(jstate, (Node *) rcexpr->rargs);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_CoalesceExpr:
|
|
|
|
JumbleExpr(jstate, (Node *) ((CoalesceExpr *) node)->args);
|
|
|
|
break;
|
|
|
|
case T_MinMaxExpr:
|
|
|
|
{
|
|
|
|
MinMaxExpr *mmexpr = (MinMaxExpr *) node;
|
|
|
|
|
|
|
|
APP_JUMB(mmexpr->op);
|
|
|
|
JumbleExpr(jstate, (Node *) mmexpr->args);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_SQLValueFunction:
|
|
|
|
{
|
|
|
|
SQLValueFunction *svf = (SQLValueFunction *) node;
|
|
|
|
|
|
|
|
APP_JUMB(svf->op);
|
|
|
|
/* type is fully determined by op */
|
|
|
|
APP_JUMB(svf->typmod);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_XmlExpr:
|
|
|
|
{
|
|
|
|
XmlExpr *xexpr = (XmlExpr *) node;
|
|
|
|
|
|
|
|
APP_JUMB(xexpr->op);
|
|
|
|
JumbleExpr(jstate, (Node *) xexpr->named_args);
|
|
|
|
JumbleExpr(jstate, (Node *) xexpr->args);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_NullTest:
|
|
|
|
{
|
|
|
|
NullTest *nt = (NullTest *) node;
|
|
|
|
|
|
|
|
APP_JUMB(nt->nulltesttype);
|
|
|
|
JumbleExpr(jstate, (Node *) nt->arg);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_BooleanTest:
|
|
|
|
{
|
|
|
|
BooleanTest *bt = (BooleanTest *) node;
|
|
|
|
|
|
|
|
APP_JUMB(bt->booltesttype);
|
|
|
|
JumbleExpr(jstate, (Node *) bt->arg);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_CoerceToDomain:
|
|
|
|
{
|
|
|
|
CoerceToDomain *cd = (CoerceToDomain *) node;
|
|
|
|
|
|
|
|
APP_JUMB(cd->resulttype);
|
|
|
|
JumbleExpr(jstate, (Node *) cd->arg);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_CoerceToDomainValue:
|
|
|
|
{
|
|
|
|
CoerceToDomainValue *cdv = (CoerceToDomainValue *) node;
|
|
|
|
|
|
|
|
APP_JUMB(cdv->typeId);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_SetToDefault:
|
|
|
|
{
|
|
|
|
SetToDefault *sd = (SetToDefault *) node;
|
|
|
|
|
|
|
|
APP_JUMB(sd->typeId);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_CurrentOfExpr:
|
|
|
|
{
|
|
|
|
CurrentOfExpr *ce = (CurrentOfExpr *) node;
|
|
|
|
|
|
|
|
APP_JUMB(ce->cvarno);
|
|
|
|
if (ce->cursor_name)
|
|
|
|
APP_JUMB_STRING(ce->cursor_name);
|
|
|
|
APP_JUMB(ce->cursor_param);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_NextValueExpr:
|
|
|
|
{
|
|
|
|
NextValueExpr *nve = (NextValueExpr *) node;
|
|
|
|
|
|
|
|
APP_JUMB(nve->seqid);
|
|
|
|
APP_JUMB(nve->typeId);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_InferenceElem:
|
|
|
|
{
|
|
|
|
InferenceElem *ie = (InferenceElem *) node;
|
|
|
|
|
|
|
|
APP_JUMB(ie->infercollid);
|
|
|
|
APP_JUMB(ie->inferopclass);
|
|
|
|
JumbleExpr(jstate, ie->expr);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_TargetEntry:
|
|
|
|
{
|
|
|
|
TargetEntry *tle = (TargetEntry *) node;
|
|
|
|
|
|
|
|
APP_JUMB(tle->resno);
|
|
|
|
APP_JUMB(tle->ressortgroupref);
|
|
|
|
JumbleExpr(jstate, (Node *) tle->expr);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_RangeTblRef:
|
|
|
|
{
|
|
|
|
RangeTblRef *rtr = (RangeTblRef *) node;
|
|
|
|
|
|
|
|
APP_JUMB(rtr->rtindex);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_JoinExpr:
|
|
|
|
{
|
|
|
|
JoinExpr *join = (JoinExpr *) node;
|
|
|
|
|
|
|
|
APP_JUMB(join->jointype);
|
|
|
|
APP_JUMB(join->isNatural);
|
|
|
|
APP_JUMB(join->rtindex);
|
|
|
|
JumbleExpr(jstate, join->larg);
|
|
|
|
JumbleExpr(jstate, join->rarg);
|
|
|
|
JumbleExpr(jstate, join->quals);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_FromExpr:
|
|
|
|
{
|
|
|
|
FromExpr *from = (FromExpr *) node;
|
|
|
|
|
|
|
|
JumbleExpr(jstate, (Node *) from->fromlist);
|
|
|
|
JumbleExpr(jstate, from->quals);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_OnConflictExpr:
|
|
|
|
{
|
|
|
|
OnConflictExpr *conf = (OnConflictExpr *) node;
|
|
|
|
|
|
|
|
APP_JUMB(conf->action);
|
|
|
|
JumbleExpr(jstate, (Node *) conf->arbiterElems);
|
|
|
|
JumbleExpr(jstate, conf->arbiterWhere);
|
|
|
|
JumbleExpr(jstate, (Node *) conf->onConflictSet);
|
|
|
|
JumbleExpr(jstate, conf->onConflictWhere);
|
|
|
|
APP_JUMB(conf->constraint);
|
|
|
|
APP_JUMB(conf->exclRelIndex);
|
|
|
|
JumbleExpr(jstate, (Node *) conf->exclRelTlist);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_List:
|
|
|
|
foreach(temp, (List *) node)
|
|
|
|
{
|
|
|
|
JumbleExpr(jstate, (Node *) lfirst(temp));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_IntList:
|
|
|
|
foreach(temp, (List *) node)
|
|
|
|
{
|
|
|
|
APP_JUMB(lfirst_int(temp));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_SortGroupClause:
|
|
|
|
{
|
|
|
|
SortGroupClause *sgc = (SortGroupClause *) node;
|
|
|
|
|
|
|
|
APP_JUMB(sgc->tleSortGroupRef);
|
|
|
|
APP_JUMB(sgc->eqop);
|
|
|
|
APP_JUMB(sgc->sortop);
|
|
|
|
APP_JUMB(sgc->nulls_first);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_GroupingSet:
|
|
|
|
{
|
|
|
|
GroupingSet *gsnode = (GroupingSet *) node;
|
|
|
|
|
|
|
|
JumbleExpr(jstate, (Node *) gsnode->content);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_WindowClause:
|
|
|
|
{
|
|
|
|
WindowClause *wc = (WindowClause *) node;
|
|
|
|
|
|
|
|
APP_JUMB(wc->winref);
|
|
|
|
APP_JUMB(wc->frameOptions);
|
|
|
|
JumbleExpr(jstate, (Node *) wc->partitionClause);
|
|
|
|
JumbleExpr(jstate, (Node *) wc->orderClause);
|
|
|
|
JumbleExpr(jstate, wc->startOffset);
|
|
|
|
JumbleExpr(jstate, wc->endOffset);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_CommonTableExpr:
|
|
|
|
{
|
|
|
|
CommonTableExpr *cte = (CommonTableExpr *) node;
|
|
|
|
|
|
|
|
/* we store the string name because RTE_CTE RTEs need it */
|
|
|
|
APP_JUMB_STRING(cte->ctename);
|
|
|
|
APP_JUMB(cte->ctematerialized);
|
|
|
|
JumbleQueryInternal(jstate, castNode(Query, cte->ctequery));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_SetOperationStmt:
|
|
|
|
{
|
|
|
|
SetOperationStmt *setop = (SetOperationStmt *) node;
|
|
|
|
|
|
|
|
APP_JUMB(setop->op);
|
|
|
|
APP_JUMB(setop->all);
|
|
|
|
JumbleExpr(jstate, setop->larg);
|
|
|
|
JumbleExpr(jstate, setop->rarg);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_RangeTblFunction:
|
|
|
|
{
|
|
|
|
RangeTblFunction *rtfunc = (RangeTblFunction *) node;
|
|
|
|
|
|
|
|
JumbleExpr(jstate, rtfunc->funcexpr);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_TableFunc:
|
|
|
|
{
|
|
|
|
TableFunc *tablefunc = (TableFunc *) node;
|
|
|
|
|
|
|
|
JumbleExpr(jstate, tablefunc->docexpr);
|
|
|
|
JumbleExpr(jstate, tablefunc->rowexpr);
|
|
|
|
JumbleExpr(jstate, (Node *) tablefunc->colexprs);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_TableSampleClause:
|
|
|
|
{
|
|
|
|
TableSampleClause *tsc = (TableSampleClause *) node;
|
|
|
|
|
|
|
|
APP_JUMB(tsc->tsmhandler);
|
|
|
|
JumbleExpr(jstate, (Node *) tsc->args);
|
|
|
|
JumbleExpr(jstate, (Node *) tsc->repeatable);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* Only a warning, since we can stumble along anyway */
|
|
|
|
elog(WARNING, "unrecognized node type: %d",
|
|
|
|
(int) nodeTag(node));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Record location of constant within query string of query tree
|
|
|
|
* that is currently being walked.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
RecordConstLocation(JumbleState *jstate, int location)
|
|
|
|
{
|
|
|
|
/* -1 indicates unknown or undefined location */
|
|
|
|
if (location >= 0)
|
|
|
|
{
|
|
|
|
/* enlarge array if needed */
|
|
|
|
if (jstate->clocations_count >= jstate->clocations_buf_size)
|
|
|
|
{
|
|
|
|
jstate->clocations_buf_size *= 2;
|
|
|
|
jstate->clocations = (LocationLen *)
|
|
|
|
repalloc(jstate->clocations,
|
|
|
|
jstate->clocations_buf_size *
|
|
|
|
sizeof(LocationLen));
|
|
|
|
}
|
|
|
|
jstate->clocations[jstate->clocations_count].location = location;
|
|
|
|
/* initialize lengths to -1 to simplify third-party module usage */
|
|
|
|
jstate->clocations[jstate->clocations_count].length = -1;
|
|
|
|
jstate->clocations_count++;
|
|
|
|
}
|
|
|
|
}
|