mirror of https://github.com/citusdata/citus.git
Copy & paste code from Postgres source
All the code in this commit is direct copy & paste from Postgres
source code.
We can classify the copy&paste code into two:
- Copy paste from CTE inline patch from postgres
(https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=608b167f9f9c4553c35bb1ec0eab9ddae643989b)
These include the functions inline_cte(), inline_cte_walker(),
contain_dml(), contain_dml_walker().
It also include the code in function PostgreSQLCTEInlineCondition().
We prefer to extract that code into a seperate function, because
(a) we'll re-use the logic later (b) we added one check for PG_11
Finally, the struct "inline_cte_walker_context" is also copied from
the same Postgres commit.
- Copy paste from the other parts of the Postgres code
In order to implement CTE inlining in Postgres 12, the hackers
modified the query_tree_walker()/range_table_walker() with the
18c0da88a5
Since Citus needs to support the same logic in PG 11, we copy & pasted
that functions (and related flags) with the names pg_12_query_tree_walker()
and pg_12_range_table_walker()
pull/3161/head
Onder Kalaci
Jelte Fennema
parent
1cfebf9f41
commit
1856ab6cdd
|
|
@ -0,0 +1,366 @@
|
||||||
|
/*-------------------------------------------------------------------------
|
||||||
|
*
|
||||||
|
* cte_inline.c
|
||||||
|
* For multi-shard queries, Citus can only recursively plan CTEs. Instead,
|
||||||
|
* with the functions defined in this file, the certain CTEs can be inlined
|
||||||
|
* as subqueries in the query tree. In that case, more optimal distributed
|
||||||
|
* planning, the query pushdown planning, kicks in and the CTEs can actually
|
||||||
|
* be pushed down as long as it is safe to pushdown as a subquery.
|
||||||
|
*
|
||||||
|
* Most of the logic in this function is inspired (and some is copy & pasted)
|
||||||
|
* from PostgreSQL 12's CTE inlining feature.
|
||||||
|
*
|
||||||
|
* Copyright (c) Citus Data, Inc.
|
||||||
|
*-------------------------------------------------------------------------
|
||||||
|
*/
|
||||||
|
#include "postgres.h"
|
||||||
|
|
||||||
|
#include "nodes/nodeFuncs.h"
|
||||||
|
#if PG_VERSION_NUM >= 120000
|
||||||
|
#include "optimizer/optimizer.h"
|
||||||
|
#else
|
||||||
|
#include "optimizer/cost.h"
|
||||||
|
#include "optimizer/clauses.h"
|
||||||
|
#endif
|
||||||
|
#include "rewrite/rewriteManip.h"
|
||||||
|
|
||||||
|
#if PG_VERSION_NUM < 120000
|
||||||
|
|
||||||
|
/* copy & paste from PG 12 */
|
||||||
|
#define PG_12_QTW_EXAMINE_RTES_BEFORE 0x10
|
||||||
|
#define PG_12_QTW_EXAMINE_RTES_AFTER 0x20
|
||||||
|
bool pg_12_query_tree_walker(Query *query,
|
||||||
|
bool (*walker)(),
|
||||||
|
void *context,
|
||||||
|
int flags);
|
||||||
|
bool pg_12_range_table_walker(List *rtable,
|
||||||
|
bool (*walker)(),
|
||||||
|
void *context,
|
||||||
|
int flags);
|
||||||
|
#endif
|
||||||
|
|
||||||
|
typedef struct inline_cte_walker_context
|
||||||
|
{
|
||||||
|
const char *ctename; /* name and relative level of target CTE */
|
||||||
|
int levelsup;
|
||||||
|
int refcount; /* number of remaining references */
|
||||||
|
Query *ctequery; /* query to substitute */
|
||||||
|
} inline_cte_walker_context;
|
||||||
|
|
||||||
|
/* copy & paste from Postgres source, moved into a function for readability */
|
||||||
|
static bool PostgreSQLCTEInlineCondition(CommonTableExpr *cte, CmdType cmdType);
|
||||||
|
|
||||||
|
/* the following utility functions are copy & paste from PostgreSQL code */
|
||||||
|
static void inline_cte(Query *mainQuery, CommonTableExpr *cte);
|
||||||
|
static bool inline_cte_walker(Node *node, inline_cte_walker_context *context);
|
||||||
|
static bool contain_dml(Node *node);
|
||||||
|
static bool contain_dml_walker(Node *node, void *context);
|
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
* PostgreSQLCTEInlineCondition returns true if the CTE is considered
|
||||||
|
* safe to inline by Postgres.
|
||||||
|
*/
|
||||||
|
static bool
|
||||||
|
PostgreSQLCTEInlineCondition(CommonTableExpr *cte, CmdType cmdType)
|
||||||
|
{
|
||||||
|
/*
|
||||||
|
* Consider inlining the CTE (creating RTE_SUBQUERY RTE(s)) instead of
|
||||||
|
* implementing it as a separately-planned CTE.
|
||||||
|
*
|
||||||
|
* We cannot inline if any of these conditions hold:
|
||||||
|
*
|
||||||
|
* 1. The user said not to (the CTEMaterializeAlways option).
|
||||||
|
*
|
||||||
|
* 2. The CTE is recursive.
|
||||||
|
*
|
||||||
|
* 3. The CTE has side-effects; this includes either not being a plain
|
||||||
|
* SELECT, or containing volatile functions. Inlining might change
|
||||||
|
* the side-effects, which would be bad.
|
||||||
|
*
|
||||||
|
* Otherwise, we have an option whether to inline or not. That should
|
||||||
|
* always be a win if there's just a single reference, but if the CTE
|
||||||
|
* is multiply-referenced then it's unclear: inlining adds duplicate
|
||||||
|
* computations, but the ability to absorb restrictions from the outer
|
||||||
|
* query level could outweigh that. We do not have nearly enough
|
||||||
|
* information at this point to tell whether that's true, so we let
|
||||||
|
* the user express a preference. Our default behavior is to inline
|
||||||
|
* only singly-referenced CTEs, but a CTE marked CTEMaterializeNever
|
||||||
|
* will be inlined even if multiply referenced.
|
||||||
|
*/
|
||||||
|
if (
|
||||||
|
#if PG_VERSION_NUM >= 120000
|
||||||
|
(cte->ctematerialized == CTEMaterializeNever ||
|
||||||
|
(cte->ctematerialized == CTEMaterializeDefault &&
|
||||||
|
cte->cterefcount == 1)) &&
|
||||||
|
#else
|
||||||
|
|
||||||
|
/*
|
||||||
|
* If referenced only once inlining would probably perform
|
||||||
|
* better, so for pg < 12, try inlining
|
||||||
|
*/
|
||||||
|
cte->cterefcount == 1 &&
|
||||||
|
#endif
|
||||||
|
!cte->cterecursive &&
|
||||||
|
cmdType == CMD_SELECT &&
|
||||||
|
!contain_dml(cte->ctequery) &&
|
||||||
|
!contain_volatile_functions(cte->ctequery))
|
||||||
|
{
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/* *INDENT-OFF* */
|
||||||
|
/*
|
||||||
|
* inline_cte: convert RTE_CTE references to given CTE into RTE_SUBQUERYs
|
||||||
|
*/
|
||||||
|
static void
|
||||||
|
inline_cte(Query *mainQuery, CommonTableExpr *cte)
|
||||||
|
{
|
||||||
|
struct inline_cte_walker_context context;
|
||||||
|
|
||||||
|
context.ctename = cte->ctename;
|
||||||
|
/* Start at levelsup = -1 because we'll immediately increment it */
|
||||||
|
context.levelsup = -1;
|
||||||
|
context.refcount = cte->cterefcount;
|
||||||
|
context.ctequery = castNode(Query, cte->ctequery);
|
||||||
|
|
||||||
|
(void) inline_cte_walker((Node *) mainQuery, &context);
|
||||||
|
|
||||||
|
/* Assert we replaced all references */
|
||||||
|
Assert(context.refcount == 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
* See PostgreSQL's source code at src/backend/optimizer/plan/subselect.c.
|
||||||
|
*/
|
||||||
|
static bool
|
||||||
|
inline_cte_walker(Node *node, inline_cte_walker_context *context)
|
||||||
|
{
|
||||||
|
if (node == NULL)
|
||||||
|
return false;
|
||||||
|
if (IsA(node, Query))
|
||||||
|
{
|
||||||
|
Query *query = (Query *) node;
|
||||||
|
|
||||||
|
context->levelsup++;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Visit the query's RTE nodes after their contents; otherwise
|
||||||
|
* query_tree_walker would descend into the newly inlined CTE query,
|
||||||
|
* which we don't want.
|
||||||
|
*/
|
||||||
|
#if PG_VERSION_NUM < 120000
|
||||||
|
(void) pg_12_query_tree_walker(query, inline_cte_walker, context,
|
||||||
|
PG_12_QTW_EXAMINE_RTES_AFTER);
|
||||||
|
#else
|
||||||
|
(void) query_tree_walker(query, inline_cte_walker, context,
|
||||||
|
QTW_EXAMINE_RTES_AFTER);
|
||||||
|
#endif
|
||||||
|
context->levelsup--;
|
||||||
|
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
else if (IsA(node, RangeTblEntry))
|
||||||
|
{
|
||||||
|
RangeTblEntry *rte = (RangeTblEntry *) node;
|
||||||
|
|
||||||
|
if (rte->rtekind == RTE_CTE &&
|
||||||
|
strcmp(rte->ctename, context->ctename) == 0 &&
|
||||||
|
rte->ctelevelsup == context->levelsup)
|
||||||
|
{
|
||||||
|
/*
|
||||||
|
* Found a reference to replace. Generate a copy of the CTE query
|
||||||
|
* with appropriate level adjustment for outer references (e.g.,
|
||||||
|
* to other CTEs).
|
||||||
|
*/
|
||||||
|
Query *newquery = copyObject(context->ctequery);
|
||||||
|
|
||||||
|
if (context->levelsup > 0)
|
||||||
|
IncrementVarSublevelsUp((Node *) newquery, context->levelsup, 1);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Convert the RTE_CTE RTE into a RTE_SUBQUERY.
|
||||||
|
*
|
||||||
|
* Historically, a FOR UPDATE clause has been treated as extending
|
||||||
|
* into views and subqueries, but not into CTEs. We preserve this
|
||||||
|
* distinction by not trying to push rowmarks into the new
|
||||||
|
* subquery.
|
||||||
|
*/
|
||||||
|
rte->rtekind = RTE_SUBQUERY;
|
||||||
|
rte->subquery = newquery;
|
||||||
|
rte->security_barrier = false;
|
||||||
|
|
||||||
|
/* Zero out CTE-specific fields */
|
||||||
|
rte->ctename = NULL;
|
||||||
|
rte->ctelevelsup = 0;
|
||||||
|
rte->self_reference = false;
|
||||||
|
rte->coltypes = NIL;
|
||||||
|
rte->coltypmods = NIL;
|
||||||
|
rte->colcollations = NIL;
|
||||||
|
|
||||||
|
/* Count the number of replacements we've done */
|
||||||
|
context->refcount--;
|
||||||
|
}
|
||||||
|
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
return expression_tree_walker(node, inline_cte_walker, context);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
* contain_dml: is any subquery not a plain SELECT?
|
||||||
|
*
|
||||||
|
* We reject SELECT FOR UPDATE/SHARE as well as INSERT etc.
|
||||||
|
*/
|
||||||
|
static bool
|
||||||
|
contain_dml(Node *node)
|
||||||
|
{
|
||||||
|
return contain_dml_walker(node, NULL);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static bool
|
||||||
|
contain_dml_walker(Node *node, void *context)
|
||||||
|
{
|
||||||
|
if (node == NULL)
|
||||||
|
return false;
|
||||||
|
if (IsA(node, Query))
|
||||||
|
{
|
||||||
|
Query *query = (Query *) node;
|
||||||
|
|
||||||
|
if (query->commandType != CMD_SELECT ||
|
||||||
|
query->rowMarks != NIL)
|
||||||
|
return true;
|
||||||
|
|
||||||
|
return query_tree_walker(query, contain_dml_walker, context, 0);
|
||||||
|
}
|
||||||
|
return expression_tree_walker(node, contain_dml_walker, context);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#if PG_VERSION_NUM < 120000
|
||||||
|
/*
|
||||||
|
* pg_12_query_tree_walker is copied from Postgres 12's source
|
||||||
|
* code. The only difference between query_tree_walker the new
|
||||||
|
* two flags added in range_table_walker: QTW_EXAMINE_RTES_AFTER
|
||||||
|
* and QTW_EXAMINE_RTES_BEFORE.
|
||||||
|
*/
|
||||||
|
bool
|
||||||
|
pg_12_query_tree_walker(Query *query,
|
||||||
|
bool (*walker) (),
|
||||||
|
void *context,
|
||||||
|
int flags)
|
||||||
|
{
|
||||||
|
Assert(query != NULL && IsA(query, Query));
|
||||||
|
|
||||||
|
if (walker((Node *) query->targetList, context))
|
||||||
|
return true;
|
||||||
|
if (walker((Node *) query->withCheckOptions, context))
|
||||||
|
return true;
|
||||||
|
if (walker((Node *) query->onConflict, context))
|
||||||
|
return true;
|
||||||
|
if (walker((Node *) query->returningList, context))
|
||||||
|
return true;
|
||||||
|
if (walker((Node *) query->jointree, context))
|
||||||
|
return true;
|
||||||
|
if (walker(query->setOperations, context))
|
||||||
|
return true;
|
||||||
|
if (walker(query->havingQual, context))
|
||||||
|
return true;
|
||||||
|
if (walker(query->limitOffset, context))
|
||||||
|
return true;
|
||||||
|
if (walker(query->limitCount, context))
|
||||||
|
return true;
|
||||||
|
if (!(flags & QTW_IGNORE_CTE_SUBQUERIES))
|
||||||
|
{
|
||||||
|
if (walker((Node *) query->cteList, context))
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
if (!(flags & QTW_IGNORE_RANGE_TABLE))
|
||||||
|
{
|
||||||
|
if (pg_12_range_table_walker(query->rtable, walker, context, flags))
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* pg_12_range_table_walker is copied from Postgres 12's source
|
||||||
|
* code. The only difference between range_table_walker the new
|
||||||
|
* two flags added in range_table_walker: QTW_EXAMINE_RTES_AFTER
|
||||||
|
* and QTW_EXAMINE_RTES_BEFORE.
|
||||||
|
*/
|
||||||
|
bool
|
||||||
|
pg_12_range_table_walker(List *rtable,
|
||||||
|
bool (*walker) (),
|
||||||
|
void *context,
|
||||||
|
int flags)
|
||||||
|
{
|
||||||
|
ListCell *rt;
|
||||||
|
|
||||||
|
foreach(rt, rtable)
|
||||||
|
{
|
||||||
|
RangeTblEntry *rte = (RangeTblEntry *) lfirst(rt);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Walkers might need to examine the RTE node itself either before or
|
||||||
|
* after visiting its contents (or, conceivably, both). Note that if
|
||||||
|
* you specify neither flag, the walker won't visit the RTE at all.
|
||||||
|
*/
|
||||||
|
if (flags & PG_12_QTW_EXAMINE_RTES_BEFORE)
|
||||||
|
if (walker(rte, context))
|
||||||
|
return true;
|
||||||
|
|
||||||
|
switch (rte->rtekind)
|
||||||
|
{
|
||||||
|
case RTE_RELATION:
|
||||||
|
if (walker(rte->tablesample, context))
|
||||||
|
return true;
|
||||||
|
break;
|
||||||
|
case RTE_CTE:
|
||||||
|
case RTE_NAMEDTUPLESTORE:
|
||||||
|
/* nothing to do */
|
||||||
|
break;
|
||||||
|
case RTE_SUBQUERY:
|
||||||
|
if (!(flags & QTW_IGNORE_RT_SUBQUERIES))
|
||||||
|
if (walker(rte->subquery, context))
|
||||||
|
return true;
|
||||||
|
break;
|
||||||
|
case RTE_JOIN:
|
||||||
|
if (!(flags & QTW_IGNORE_JOINALIASES))
|
||||||
|
if (walker(rte->joinaliasvars, context))
|
||||||
|
return true;
|
||||||
|
break;
|
||||||
|
case RTE_FUNCTION:
|
||||||
|
if (walker(rte->functions, context))
|
||||||
|
return true;
|
||||||
|
break;
|
||||||
|
case RTE_TABLEFUNC:
|
||||||
|
if (walker(rte->tablefunc, context))
|
||||||
|
return true;
|
||||||
|
break;
|
||||||
|
case RTE_VALUES:
|
||||||
|
if (walker(rte->values_lists, context))
|
||||||
|
return true;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (walker(rte->securityQuals, context))
|
||||||
|
return true;
|
||||||
|
|
||||||
|
if (flags & PG_12_QTW_EXAMINE_RTES_AFTER)
|
||||||
|
if (walker(rte, context))
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* *INDENT-ON* */
|
||||||
Loading…
Reference in New Issue