rdelaage
/
postgresql
mirror of https://git.postgresql.org/git/postgresql.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
postgresql/src/backend/rewrite/rewriteSearchCycle.c

682 lines
21 KiB
C
Raw Blame History

/*-------------------------------------------------------------------------
*
* rewriteSearchCycle.c
* Support for rewriting SEARCH and CYCLE clauses.
*
* Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* src/backend/rewrite/rewriteSearchCycle.c
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#include "catalog/pg_operator_d.h"
#include "catalog/pg_type_d.h"
#include "nodes/makefuncs.h"
#include "nodes/parsenodes.h"
#include "nodes/pg_list.h"
#include "nodes/primnodes.h"
#include "parser/analyze.h"
#include "parser/parsetree.h"
#include "rewrite/rewriteManip.h"
#include "rewrite/rewriteSearchCycle.h"
#include "utils/fmgroids.h"
/*----------
* Rewrite a CTE with SEARCH or CYCLE clause
*
* Consider a CTE like
*
* WITH RECURSIVE ctename (col1, col2, col3) AS (
* query1
* UNION [ALL]
* SELECT trosl FROM ctename
* )
*
* With a search clause
*
* SEARCH BREADTH FIRST BY col1, col2 SET sqc
*
* the CTE is rewritten to
*
* WITH RECURSIVE ctename (col1, col2, col3, sqc) AS (
* SELECT col1, col2, col3, -- original WITH column list
* ROW(0, col1, col2) -- initial row of search columns
* FROM (query1) "*TLOCRN*" (col1, col2, col3)
* UNION [ALL]
* SELECT col1, col2, col3, -- same as above
* ROW(sqc.depth + 1, col1, col2) -- count depth
* FROM (SELECT trosl, ctename.sqc FROM ctename) "*TROCRN*" (col1, col2, col3, sqc)
* )
*
* (This isn't quite legal SQL: sqc.depth is meant to refer to the first
* column of sqc, which has a row type, but the field names are not defined
* here. Representing this properly in SQL would be more complicated (and the
* SQL standard actually does it in that more complicated way), but the
* internal representation allows us to construct it this way.)
*
* With a search clause
*
* SEARCH DEPTH FIRST BY col1, col2 SET sqc
*
* the CTE is rewritten to
*
* WITH RECURSIVE ctename (col1, col2, col3, sqc) AS (
* SELECT col1, col2, col3, -- original WITH column list
* ARRAY[ROW(col1, col2)] -- initial row of search columns
* FROM (query1) "*TLOCRN*" (col1, col2, col3)
* UNION [ALL]
* SELECT col1, col2, col3, -- same as above
* sqc || ARRAY[ROW(col1, col2)] -- record rows seen
* FROM (SELECT trosl, ctename.sqc FROM ctename) "*TROCRN*" (col1, col2, col3, sqc)
* )
*
* With a cycle clause
*
* CYCLE col1, col2 SET cmc TO 'Y' DEFAULT 'N' USING cpa
*
* (cmc = cycle mark column, cpa = cycle path) the CTE is rewritten to
*
* WITH RECURSIVE ctename (col1, col2, col3, cmc, cpa) AS (
* SELECT col1, col2, col3, -- original WITH column list
* 'N', -- cycle mark default
* ARRAY[ROW(col1, col2)] -- initial row of cycle columns
* FROM (query1) "*TLOCRN*" (col1, col2, col3)
* UNION [ALL]
* SELECT col1, col2, col3, -- same as above
* CASE WHEN ROW(col1, col2) = ANY (ARRAY[cpa]) THEN 'Y' ELSE 'N' END, -- compute cycle mark column
* cpa || ARRAY[ROW(col1, col2)] -- record rows seen
* FROM (SELECT trosl, ctename.cmc, ctename.cpa FROM ctename) "*TROCRN*" (col1, col2, col3, cmc, cpa)
* WHERE cmc <> 'Y'
* )
*
* The expression to compute the cycle mark column in the right-hand query is
* written as
*
* CASE WHEN ROW(col1, col2) IN (SELECT p.* FROM TABLE(cpa) p) THEN cmv ELSE cmd END
*
* in the SQL standard, but in PostgreSQL we can use the scalar-array operator
* expression shown above.
*
* Also, in some of the cases where operators are shown above we actually
* directly produce the underlying function call.
*
* If both a search clause and a cycle clause is specified, then the search
* clause column is added before the cycle clause columns.
*/
/*
* Make a RowExpr from the specified column names, which have to be among the
* output columns of the CTE.
*/
static RowExpr *
make_path_rowexpr(const CommonTableExpr *cte, const List *col_list)
{
RowExpr *rowexpr;
ListCell *lc;
rowexpr = makeNode(RowExpr);
rowexpr->row_typeid = RECORDOID;
rowexpr->row_format = COERCE_IMPLICIT_CAST;
rowexpr->location = -1;
foreach(lc, col_list)
{
char *colname = strVal(lfirst(lc));
for (int i = 0; i < list_length(cte->ctecolnames); i++)
{
char *colname2 = strVal(list_nth(cte->ctecolnames, i));
if (strcmp(colname, colname2) == 0)
{
Var *var;
var = makeVar(1, i + 1,
list_nth_oid(cte->ctecoltypes, i),
list_nth_int(cte->ctecoltypmods, i),
list_nth_oid(cte->ctecolcollations, i),
0);
rowexpr->args = lappend(rowexpr->args, var);
rowexpr->colnames = lappend(rowexpr->colnames, makeString(colname));
break;
}
}
}
return rowexpr;
}
/*
* Wrap a RowExpr in an ArrayExpr, for the initial search depth first or cycle
* row.
*/
static Expr *
make_path_initial_array(RowExpr *rowexpr)
{
ArrayExpr *arr;
arr = makeNode(ArrayExpr);
arr->array_typeid = RECORDARRAYOID;
arr->element_typeid = RECORDOID;
arr->location = -1;
arr->elements = list_make1(rowexpr);
return (Expr *) arr;
}
/*
* Make an array catenation expression like
*
* cpa || ARRAY[ROW(cols)]
*
* where the varattno of cpa is provided as path_varattno.
*/
static Expr *
make_path_cat_expr(RowExpr *rowexpr, AttrNumber path_varattno)
{
ArrayExpr *arr;
FuncExpr *fexpr;
arr = makeNode(ArrayExpr);
arr->array_typeid = RECORDARRAYOID;
arr->element_typeid = RECORDOID;
arr->location = -1;
arr->elements = list_make1(rowexpr);
fexpr = makeFuncExpr(F_ARRAY_CAT, RECORDARRAYOID,
list_make2(makeVar(1, path_varattno, RECORDARRAYOID, -1, 0, 0),
arr),
InvalidOid, InvalidOid, COERCE_EXPLICIT_CALL);
return (Expr *) fexpr;
}
/*
* The real work happens here.
*/
CommonTableExpr *
rewriteSearchAndCycle(CommonTableExpr *cte)
{
Query *ctequery;
SetOperationStmt *sos;
int rti1,
rti2;
RangeTblEntry *rte1,
*rte2,
*newrte;
Query *newq1,
*newq2;
Query *newsubquery;
RangeTblRef *rtr;
Oid search_seq_type = InvalidOid;
AttrNumber sqc_attno = InvalidAttrNumber;
AttrNumber cmc_attno = InvalidAttrNumber;
AttrNumber cpa_attno = InvalidAttrNumber;
TargetEntry *tle;
RowExpr *cycle_col_rowexpr = NULL;
RowExpr *search_col_rowexpr = NULL;
List *ewcl;
int cte_rtindex = -1;
Assert(cte->search_clause || cte->cycle_clause);
cte = copyObject(cte);
ctequery = castNode(Query, cte->ctequery);
/*
* The top level of the CTE's query should be a UNION. Find the two
* subqueries.
*/
Assert(ctequery->setOperations);
sos = castNode(SetOperationStmt, ctequery->setOperations);
Assert(sos->op == SETOP_UNION);
rti1 = castNode(RangeTblRef, sos->larg)->rtindex;
rti2 = castNode(RangeTblRef, sos->rarg)->rtindex;
rte1 = rt_fetch(rti1, ctequery->rtable);
rte2 = rt_fetch(rti2, ctequery->rtable);
Assert(rte1->rtekind == RTE_SUBQUERY);
Assert(rte2->rtekind == RTE_SUBQUERY);
/*
* We'll need this a few times later.
*/
if (cte->search_clause)
{
if (cte->search_clause->search_breadth_first)
search_seq_type = RECORDOID;
else
search_seq_type = RECORDARRAYOID;
}
/*
* Attribute numbers of the added columns in the CTE's column list
*/
if (cte->search_clause)
sqc_attno = list_length(cte->ctecolnames) + 1;
if (cte->cycle_clause)
{
cmc_attno = list_length(cte->ctecolnames) + 1;
cpa_attno = list_length(cte->ctecolnames) + 2;
if (cte->search_clause)
{
cmc_attno++;
cpa_attno++;
}
}
/*
* Make new left subquery
*/
newq1 = makeNode(Query);
newq1->commandType = CMD_SELECT;
newq1->canSetTag = true;
newrte = makeNode(RangeTblEntry);
newrte->rtekind = RTE_SUBQUERY;
newrte->alias = makeAlias("*TLOCRN*", cte->ctecolnames);
newrte->eref = newrte->alias;
newsubquery = copyObject(rte1->subquery);
IncrementVarSublevelsUp((Node *) newsubquery, 1, 1);
newrte->subquery = newsubquery;
newrte->inFromCl = true;
newq1->rtable = list_make1(newrte);
rtr = makeNode(RangeTblRef);
rtr->rtindex = 1;
newq1->jointree = makeFromExpr(list_make1(rtr), NULL);
/*
* Make target list
*/
for (int i = 0; i < list_length(cte->ctecolnames); i++)
{
Var *var;
var = makeVar(1, i + 1,
list_nth_oid(cte->ctecoltypes, i),
list_nth_int(cte->ctecoltypmods, i),
list_nth_oid(cte->ctecolcollations, i),
0);
tle = makeTargetEntry((Expr *) var, i + 1, strVal(list_nth(cte->ctecolnames, i)), false);
tle->resorigtbl = list_nth_node(TargetEntry, rte1->subquery->targetList, i)->resorigtbl;
tle->resorigcol = list_nth_node(TargetEntry, rte1->subquery->targetList, i)->resorigcol;
newq1->targetList = lappend(newq1->targetList, tle);
}
if (cte->search_clause)
{
Expr *texpr;
search_col_rowexpr = make_path_rowexpr(cte, cte->search_clause->search_col_list);
if (cte->search_clause->search_breadth_first)
{
search_col_rowexpr->args = lcons(makeConst(INT8OID, -1, InvalidOid, sizeof(int64),
Int64GetDatum(0), false, FLOAT8PASSBYVAL),
search_col_rowexpr->args);
search_col_rowexpr->colnames = lcons(makeString("*DEPTH*"), search_col_rowexpr->colnames);
texpr = (Expr *) search_col_rowexpr;
}
else
texpr = make_path_initial_array(search_col_rowexpr);
tle = makeTargetEntry(texpr,
list_length(newq1->targetList) + 1,
cte->search_clause->search_seq_column,
false);
newq1->targetList = lappend(newq1->targetList, tle);
}
if (cte->cycle_clause)
{
tle = makeTargetEntry((Expr *) cte->cycle_clause->cycle_mark_default,
list_length(newq1->targetList) + 1,
cte->cycle_clause->cycle_mark_column,
false);
newq1->targetList = lappend(newq1->targetList, tle);
cycle_col_rowexpr = make_path_rowexpr(cte, cte->cycle_clause->cycle_col_list);
tle = makeTargetEntry(make_path_initial_array(cycle_col_rowexpr),
list_length(newq1->targetList) + 1,
cte->cycle_clause->cycle_path_column,
false);
newq1->targetList = lappend(newq1->targetList, tle);
}
rte1->subquery = newq1;
if (cte->search_clause)
{
rte1->eref->colnames = lappend(rte1->eref->colnames, makeString(cte->search_clause->search_seq_column));
}
if (cte->cycle_clause)
{
rte1->eref->colnames = lappend(rte1->eref->colnames, makeString(cte->cycle_clause->cycle_mark_column));
rte1->eref->colnames = lappend(rte1->eref->colnames, makeString(cte->cycle_clause->cycle_path_column));
}
/*
* Make new right subquery
*/
newq2 = makeNode(Query);
newq2->commandType = CMD_SELECT;
newq2->canSetTag = true;
newrte = makeNode(RangeTblEntry);
newrte->rtekind = RTE_SUBQUERY;
ewcl = copyObject(cte->ctecolnames);
if (cte->search_clause)
{
ewcl = lappend(ewcl, makeString(cte->search_clause->search_seq_column));
}
if (cte->cycle_clause)
{
ewcl = lappend(ewcl, makeString(cte->cycle_clause->cycle_mark_column));
ewcl = lappend(ewcl, makeString(cte->cycle_clause->cycle_path_column));
}
newrte->alias = makeAlias("*TROCRN*", ewcl);
newrte->eref = newrte->alias;
/*
* Find the reference to the recursive CTE in the right UNION subquery's
* range table. We expect it to be two levels up from the UNION subquery
* (and must check that to avoid being fooled by sub-WITHs with the same
* CTE name). There will not be more than one such reference, because the
* parser would have rejected that (see checkWellFormedRecursion() in
* parse_cte.c). However, the parser doesn't insist that the reference
* appear in the UNION subquery's topmost range table, so we might fail to
* find it at all. That's an unimplemented case for the moment.
*/
for (int rti = 1; rti <= list_length(rte2->subquery->rtable); rti++)
{
RangeTblEntry *e = rt_fetch(rti, rte2->subquery->rtable);
if (e->rtekind == RTE_CTE &&
strcmp(cte->ctename, e->ctename) == 0 &&
e->ctelevelsup == 2)
{
cte_rtindex = rti;
break;
}
}
if (cte_rtindex <= 0)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("with a SEARCH or CYCLE clause, the recursive reference to WITH query \"%s\" must be at the top level of its right-hand SELECT",
cte->ctename)));
newsubquery = copyObject(rte2->subquery);
IncrementVarSublevelsUp((Node *) newsubquery, 1, 1);
/*
* Add extra columns to target list of subquery of right subquery
*/
if (cte->search_clause)
{
Var *var;
/* ctename.sqc */
var = makeVar(cte_rtindex, sqc_attno,
search_seq_type, -1, InvalidOid, 0);
tle = makeTargetEntry((Expr *) var,
list_length(newsubquery->targetList) + 1,
cte->search_clause->search_seq_column,
false);
newsubquery->targetList = lappend(newsubquery->targetList, tle);
}
if (cte->cycle_clause)
{
Var *var;
/* ctename.cmc */
var = makeVar(cte_rtindex, cmc_attno,
cte->cycle_clause->cycle_mark_type,
cte->cycle_clause->cycle_mark_typmod,
cte->cycle_clause->cycle_mark_collation, 0);
tle = makeTargetEntry((Expr *) var,
list_length(newsubquery->targetList) + 1,
cte->cycle_clause->cycle_mark_column,
false);
newsubquery->targetList = lappend(newsubquery->targetList, tle);
/* ctename.cpa */
var = makeVar(cte_rtindex, cpa_attno,
RECORDARRAYOID, -1, InvalidOid, 0);
tle = makeTargetEntry((Expr *) var,
list_length(newsubquery->targetList) + 1,
cte->cycle_clause->cycle_path_column,
false);
newsubquery->targetList = lappend(newsubquery->targetList, tle);
}
newrte->subquery = newsubquery;
newrte->inFromCl = true;
newq2->rtable = list_make1(newrte);
rtr = makeNode(RangeTblRef);
rtr->rtindex = 1;
if (cte->cycle_clause)
{
Expr *expr;
/*
* Add cmc <> cmv condition
*/
expr = make_opclause(cte->cycle_clause->cycle_mark_neop, BOOLOID, false,
(Expr *) makeVar(1, cmc_attno,
cte->cycle_clause->cycle_mark_type,
cte->cycle_clause->cycle_mark_typmod,
cte->cycle_clause->cycle_mark_collation, 0),
(Expr *) cte->cycle_clause->cycle_mark_value,
InvalidOid,
cte->cycle_clause->cycle_mark_collation);
newq2->jointree = makeFromExpr(list_make1(rtr), (Node *) expr);
}
else
newq2->jointree = makeFromExpr(list_make1(rtr), NULL);
/*
* Make target list
*/
for (int i = 0; i < list_length(cte->ctecolnames); i++)
{
Var *var;
var = makeVar(1, i + 1,
list_nth_oid(cte->ctecoltypes, i),
list_nth_int(cte->ctecoltypmods, i),
list_nth_oid(cte->ctecolcollations, i),
0);
tle = makeTargetEntry((Expr *) var, i + 1, strVal(list_nth(cte->ctecolnames, i)), false);
tle->resorigtbl = list_nth_node(TargetEntry, rte2->subquery->targetList, i)->resorigtbl;
tle->resorigcol = list_nth_node(TargetEntry, rte2->subquery->targetList, i)->resorigcol;
newq2->targetList = lappend(newq2->targetList, tle);
}
if (cte->search_clause)
{
Expr *texpr;
if (cte->search_clause->search_breadth_first)
{
FieldSelect *fs;
FuncExpr *fexpr;
/*
* ROW(sqc.depth + 1, cols)
*/
search_col_rowexpr = copyObject(search_col_rowexpr);
fs = makeNode(FieldSelect);
fs->arg = (Expr *) makeVar(1, sqc_attno, RECORDOID, -1, 0, 0);
fs->fieldnum = 1;
fs->resulttype = INT8OID;
fs->resulttypmod = -1;
fexpr = makeFuncExpr(F_INT8INC, INT8OID, list_make1(fs), InvalidOid, InvalidOid, COERCE_EXPLICIT_CALL);
linitial(search_col_rowexpr->args) = fexpr;
texpr = (Expr *) search_col_rowexpr;
}
else
{
/*
* sqc || ARRAY[ROW(cols)]
*/
texpr = make_path_cat_expr(search_col_rowexpr, sqc_attno);
}
tle = makeTargetEntry(texpr,
list_length(newq2->targetList) + 1,
cte->search_clause->search_seq_column,
false);
newq2->targetList = lappend(newq2->targetList, tle);
}
if (cte->cycle_clause)
{
ScalarArrayOpExpr *saoe;
CaseExpr *caseexpr;
CaseWhen *casewhen;
/*
* CASE WHEN ROW(cols) = ANY (ARRAY[cpa]) THEN cmv ELSE cmd END
*/
saoe = makeNode(ScalarArrayOpExpr);
saoe->location = -1;
saoe->opno = RECORD_EQ_OP;
saoe->useOr = true;
saoe->args = list_make2(cycle_col_rowexpr,
makeVar(1, cpa_attno, RECORDARRAYOID, -1, 0, 0));
caseexpr = makeNode(CaseExpr);
caseexpr->location = -1;
caseexpr->casetype = cte->cycle_clause->cycle_mark_type;
caseexpr->casecollid = cte->cycle_clause->cycle_mark_collation;
casewhen = makeNode(CaseWhen);
casewhen->location = -1;
casewhen->expr = (Expr *) saoe;
casewhen->result = (Expr *) cte->cycle_clause->cycle_mark_value;
caseexpr->args = list_make1(casewhen);
caseexpr->defresult = (Expr *) cte->cycle_clause->cycle_mark_default;
tle = makeTargetEntry((Expr *) caseexpr,
list_length(newq2->targetList) + 1,
cte->cycle_clause->cycle_mark_column,
false);
newq2->targetList = lappend(newq2->targetList, tle);
/*
* cpa || ARRAY[ROW(cols)]
*/
tle = makeTargetEntry(make_path_cat_expr(cycle_col_rowexpr, cpa_attno),
list_length(newq2->targetList) + 1,
cte->cycle_clause->cycle_path_column,
false);
newq2->targetList = lappend(newq2->targetList, tle);
}
rte2->subquery = newq2;
if (cte->search_clause)
{
rte2->eref->colnames = lappend(rte2->eref->colnames, makeString(cte->search_clause->search_seq_column));
}
if (cte->cycle_clause)
{
rte2->eref->colnames = lappend(rte2->eref->colnames, makeString(cte->cycle_clause->cycle_mark_column));
rte2->eref->colnames = lappend(rte2->eref->colnames, makeString(cte->cycle_clause->cycle_path_column));
}
/*
* Add the additional columns to the SetOperationStmt
*/
if (cte->search_clause)
{
sos->colTypes = lappend_oid(sos->colTypes, search_seq_type);
sos->colTypmods = lappend_int(sos->colTypmods, -1);
sos->colCollations = lappend_oid(sos->colCollations, InvalidOid);
if (!sos->all)
sos->groupClauses = lappend(sos->groupClauses,
makeSortGroupClauseForSetOp(search_seq_type, true));
}
if (cte->cycle_clause)
{
sos->colTypes = lappend_oid(sos->colTypes, cte->cycle_clause->cycle_mark_type);
sos->colTypmods = lappend_int(sos->colTypmods, cte->cycle_clause->cycle_mark_typmod);
sos->colCollations = lappend_oid(sos->colCollations, cte->cycle_clause->cycle_mark_collation);
if (!sos->all)
sos->groupClauses = lappend(sos->groupClauses,
makeSortGroupClauseForSetOp(cte->cycle_clause->cycle_mark_type, true));
sos->colTypes = lappend_oid(sos->colTypes, RECORDARRAYOID);
sos->colTypmods = lappend_int(sos->colTypmods, -1);
sos->colCollations = lappend_oid(sos->colCollations, InvalidOid);
if (!sos->all)
sos->groupClauses = lappend(sos->groupClauses,
makeSortGroupClauseForSetOp(RECORDARRAYOID, true));
}
/*
* Add the additional columns to the CTE query's target list
*/
if (cte->search_clause)
{
ctequery->targetList = lappend(ctequery->targetList,
makeTargetEntry((Expr *) makeVar(1, sqc_attno,
search_seq_type, -1, InvalidOid, 0),
list_length(ctequery->targetList) + 1,
cte->search_clause->search_seq_column,
false));
}
if (cte->cycle_clause)
{
ctequery->targetList = lappend(ctequery->targetList,
makeTargetEntry((Expr *) makeVar(1, cmc_attno,
cte->cycle_clause->cycle_mark_type,
cte->cycle_clause->cycle_mark_typmod,
cte->cycle_clause->cycle_mark_collation, 0),
list_length(ctequery->targetList) + 1,
cte->cycle_clause->cycle_mark_column,
false));
ctequery->targetList = lappend(ctequery->targetList,
makeTargetEntry((Expr *) makeVar(1, cpa_attno,
RECORDARRAYOID, -1, InvalidOid, 0),
list_length(ctequery->targetList) + 1,
cte->cycle_clause->cycle_path_column,
false));
}
/*
* Add the additional columns to the CTE's output columns
*/
cte->ctecolnames = ewcl;
if (cte->search_clause)
{
cte->ctecoltypes = lappend_oid(cte->ctecoltypes, search_seq_type);
cte->ctecoltypmods = lappend_int(cte->ctecoltypmods, -1);
cte->ctecolcollations = lappend_oid(cte->ctecolcollations, InvalidOid);
}
if (cte->cycle_clause)
{
cte->ctecoltypes = lappend_oid(cte->ctecoltypes, cte->cycle_clause->cycle_mark_type);
cte->ctecoltypmods = lappend_int(cte->ctecoltypmods, cte->cycle_clause->cycle_mark_typmod);
cte->ctecolcollations = lappend_oid(cte->ctecolcollations, cte->cycle_clause->cycle_mark_collation);
cte->ctecoltypes = lappend_oid(cte->ctecoltypes, RECORDARRAYOID);
cte->ctecoltypmods = lappend_int(cte->ctecoltypmods, -1);
cte->ctecolcollations = lappend_oid(cte->ctecolcollations, InvalidOid);
}
return cte;
}
Reference in New Issue View Git Blame Copy Permalink