rewriteSearchCycle.h File Reference

#include "nodes/parsenodes.h"

Include dependency graph for rewriteSearchCycle.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
CommonTableExpr *	rewriteSearchAndCycle (CommonTableExpr *cte)

Function Documentation

rewriteSearchAndCycle()

CommonTableExpr * rewriteSearchAndCycle ( CommonTableExpr *  cte )

extern

Definition at line 203 of file rewriteSearchCycle.c.

{
    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 = NULL;
    newrte->eref = makeAlias("*TLOCRN*", cte->ctecolnames);
    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, true),
                                             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 = NULL;
    newrte->eref = makeAlias("*TROCRN*", ewcl);
 
    /*
     * 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;
}

References FieldSelect::arg, Assert, castNode, CMD_SELECT, COERCE_EXPLICIT_CALL, copyObject, CommonTableExpr::ctename, CommonTableExpr::ctequery, ereport, errcode(), errmsg(), ERROR, fb(), FieldSelect::fieldnum, i, IncrementVarSublevelsUp(), Int64GetDatum(), InvalidAttrNumber, InvalidOid, lappend(), lappend_int(), lappend_oid(), lcons(), linitial, list_length(), list_make1, list_make2, list_nth(), list_nth_int(), list_nth_node, list_nth_oid(), make_opclause(), make_path_cat_expr(), make_path_initial_array(), make_path_rowexpr(), makeAlias(), makeConst(), makeFromExpr(), makeFuncExpr(), makeNode, makeSortGroupClauseForSetOp(), makeString(), makeTargetEntry(), makeVar(), rt_fetch, Query::rtable, RTE_CTE, RTE_SUBQUERY, SETOP_UNION, Query::setOperations, strVal, and Query::targetList.

Referenced by fireRIRrules().