parse_merge.h File Reference

#include "parser/parse_node.h"

Include dependency graph for parse_merge.h:

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

Go to the source code of this file.

Functions
Query *	transformMergeStmt (ParseState *pstate, MergeStmt *stmt)

Function Documentation

transformMergeStmt()

Query * transformMergeStmt ( ParseState *  pstate, MergeStmt *  stmt  )

extern

Definition at line 107 of file parse_merge.c.

{
    Query      *qry = makeNode(Query);
    ListCell   *l;
    AclMode     targetPerms = ACL_NO_RIGHTS;
    bool        is_terminal[NUM_MERGE_MATCH_KINDS];
    Index       sourceRTI;
    List       *mergeActionList;
    ParseNamespaceItem *nsitem;
 
    /* There can't be any outer WITH to worry about */
    Assert(pstate->p_ctenamespace == NIL);
 
    qry->commandType = CMD_MERGE;
    qry->hasRecursive = false;
 
    /* process the WITH clause independently of all else */
    if (stmt->withClause)
    {
        if (stmt->withClause->recursive)
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("WITH RECURSIVE is not supported for MERGE statement")));
 
        qry->cteList = transformWithClause(pstate, stmt->withClause);
        qry->hasModifyingCTE = pstate->p_hasModifyingCTE;
    }
 
    /*
     * Check WHEN clauses for permissions and sanity
     */
    is_terminal[MERGE_WHEN_MATCHED] = false;
    is_terminal[MERGE_WHEN_NOT_MATCHED_BY_SOURCE] = false;
    is_terminal[MERGE_WHEN_NOT_MATCHED_BY_TARGET] = false;
    foreach(l, stmt->mergeWhenClauses)
    {
        MergeWhenClause *mergeWhenClause = (MergeWhenClause *) lfirst(l);
 
        /*
         * Collect permissions to check, according to action types. We require
         * SELECT privileges for DO NOTHING because it'd be irregular to have
         * a target relation with zero privileges checked, in case DO NOTHING
         * is the only action.  There's no damage from that: any meaningful
         * MERGE command requires at least some access to the table anyway.
         */
        switch (mergeWhenClause->commandType)
        {
            case CMD_INSERT:
                targetPerms |= ACL_INSERT;
                break;
            case CMD_UPDATE:
                targetPerms |= ACL_UPDATE;
                break;
            case CMD_DELETE:
                targetPerms |= ACL_DELETE;
                break;
            case CMD_NOTHING:
                targetPerms |= ACL_SELECT;
                break;
            default:
                elog(ERROR, "unknown action in MERGE WHEN clause");
        }
 
        /*
         * Check for unreachable WHEN clauses
         */
        if (is_terminal[mergeWhenClause->matchKind])
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("unreachable WHEN clause specified after unconditional WHEN clause")));
        if (mergeWhenClause->condition == NULL)
            is_terminal[mergeWhenClause->matchKind] = true;
    }
 
    /*
     * Set up the MERGE target table.  The target table is added to the
     * namespace below and to joinlist in transform_MERGE_to_join, so don't do
     * it here.
     *
     * Initially mergeTargetRelation is the same as resultRelation, so data is
     * read from the table being updated.  However, that might be changed by
     * the rewriter, if the target is a trigger-updatable view, to allow
     * target data to be read from the expanded view query while updating the
     * original view relation.
     */
    qry->resultRelation = setTargetTable(pstate, stmt->relation,
                                         stmt->relation->inh,
                                         false, targetPerms);
    qry->mergeTargetRelation = qry->resultRelation;
 
    /* The target relation must be a table or a view */
    if (pstate->p_target_relation->rd_rel->relkind != RELKIND_RELATION &&
        pstate->p_target_relation->rd_rel->relkind != RELKIND_PARTITIONED_TABLE &&
        pstate->p_target_relation->rd_rel->relkind != RELKIND_VIEW)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot execute MERGE on relation \"%s\"",
                        RelationGetRelationName(pstate->p_target_relation)),
                 errdetail_relkind_not_supported(pstate->p_target_relation->rd_rel->relkind)));
 
    /* Now transform the source relation to produce the source RTE. */
    transformFromClause(pstate,
                        list_make1(stmt->sourceRelation));
    sourceRTI = list_length(pstate->p_rtable);
    nsitem = GetNSItemByRangeTablePosn(pstate, sourceRTI, 0);
 
    /*
     * Check that the target table doesn't conflict with the source table.
     * This would typically be a checkNameSpaceConflicts call, but we want a
     * more specific error message.
     */
    if (strcmp(pstate->p_target_nsitem->p_names->aliasname,
               nsitem->p_names->aliasname) == 0)
        ereport(ERROR,
                errcode(ERRCODE_DUPLICATE_ALIAS),
                errmsg("name \"%s\" specified more than once",
                       pstate->p_target_nsitem->p_names->aliasname),
                errdetail("The name is used both as MERGE target table and data source."));
 
    /*
     * There's no need for a targetlist here; it'll be set up by
     * preprocess_targetlist later.
     */
    qry->targetList = NIL;
    qry->rtable = pstate->p_rtable;
    qry->rteperminfos = pstate->p_rteperminfos;
 
    /*
     * Transform the join condition.  This includes references to the target
     * side, so add that to the namespace.
     */
    addNSItemToQuery(pstate, pstate->p_target_nsitem, false, true, true);
    qry->mergeJoinCondition = transformExpr(pstate, stmt->joinCondition,
                                            EXPR_KIND_JOIN_ON);
 
    /*
     * Create the temporary query's jointree using the joinlist we built using
     * just the source relation; the target relation is not included. The join
     * will be constructed fully by transform_MERGE_to_join.
     */
    qry->jointree = makeFromExpr(pstate->p_joinlist, NULL);
 
    /* Transform the RETURNING list, if any */
    transformReturningClause(pstate, qry, stmt->returningClause,
                             EXPR_KIND_MERGE_RETURNING);
 
    /*
     * We now have a good query shape, so now look at the WHEN conditions and
     * action targetlists.
     *
     * Overall, the MERGE Query's targetlist is NIL.
     *
     * Each individual action has its own targetlist that needs separate
     * transformation. These transforms don't do anything to the overall
     * targetlist, since that is only used for resjunk columns.
     *
     * We can reference any column in Target or Source, which is OK because
     * both of those already have RTEs. There is nothing like the EXCLUDED
     * pseudo-relation for INSERT ON CONFLICT.
     */
    mergeActionList = NIL;
    foreach(l, stmt->mergeWhenClauses)
    {
        MergeWhenClause *mergeWhenClause = lfirst_node(MergeWhenClause, l);
        MergeAction *action;
 
        action = makeNode(MergeAction);
        action->commandType = mergeWhenClause->commandType;
        action->matchKind = mergeWhenClause->matchKind;
 
        /*
         * Set namespace for the specific action. This must be done before
         * analyzing the WHEN quals and the action targetlist.
         */
        setNamespaceForMergeWhen(pstate, mergeWhenClause,
                                 qry->resultRelation,
                                 sourceRTI);
 
        /*
         * Transform the WHEN condition.
         *
         * Note that these quals are NOT added to the join quals; instead they
         * are evaluated separately during execution to decide which of the
         * WHEN MATCHED or WHEN NOT MATCHED actions to execute.
         */
        action->qual = transformWhereClause(pstate, mergeWhenClause->condition,
                                            EXPR_KIND_MERGE_WHEN, "WHEN");
 
        /*
         * Transform target lists for each INSERT and UPDATE action stmt
         */
        switch (action->commandType)
        {
            case CMD_INSERT:
                {
                    List       *exprList = NIL;
                    ListCell   *lc;
                    RTEPermissionInfo *perminfo;
                    ListCell   *icols;
                    ListCell   *attnos;
                    List       *icolumns;
                    List       *attrnos;
 
                    pstate->p_is_insert = true;
 
                    icolumns = checkInsertTargets(pstate,
                                                  mergeWhenClause->targetList,
                                                  &attrnos);
                    Assert(list_length(icolumns) == list_length(attrnos));
 
                    action->override = mergeWhenClause->override;
 
                    /*
                     * Handle INSERT much like in transformInsertStmt
                     */
                    if (mergeWhenClause->values == NIL)
                    {
                        /*
                         * We have INSERT ... DEFAULT VALUES.  We can handle
                         * this case by emitting an empty targetlist --- all
                         * columns will be defaulted when the planner expands
                         * the targetlist.
                         */
                        exprList = NIL;
                    }
                    else
                    {
                        /*
                         * Process INSERT ... VALUES with a single VALUES
                         * sublist.  We treat this case separately for
                         * efficiency.  The sublist is just computed directly
                         * as the Query's targetlist, with no VALUES RTE.  So
                         * it works just like a SELECT without any FROM.
                         */
 
                        /*
                         * Do basic expression transformation (same as a ROW()
                         * expr, but allow SetToDefault at top level)
                         */
                        exprList = transformExpressionList(pstate,
                                                           mergeWhenClause->values,
                                                           EXPR_KIND_VALUES_SINGLE,
                                                           true);
 
                        /* Prepare row for assignment to target table */
                        exprList = transformInsertRow(pstate, exprList,
                                                      mergeWhenClause->targetList,
                                                      icolumns, attrnos,
                                                      false);
                    }
 
                    /*
                     * Generate action's target list using the computed list
                     * of expressions. Also, mark all the target columns as
                     * needing insert permissions.
                     */
                    perminfo = pstate->p_target_nsitem->p_perminfo;
                    forthree(lc, exprList, icols, icolumns, attnos, attrnos)
                    {
                        Expr       *expr = (Expr *) lfirst(lc);
                        ResTarget  *col = lfirst_node(ResTarget, icols);
                        AttrNumber  attr_num = (AttrNumber) lfirst_int(attnos);
                        TargetEntry *tle;
 
                        tle = makeTargetEntry(expr,
                                              attr_num,
                                              col->name,
                                              false);
                        action->targetList = lappend(action->targetList, tle);
 
                        perminfo->insertedCols =
                            bms_add_member(perminfo->insertedCols,
                                           attr_num - FirstLowInvalidHeapAttributeNumber);
                    }
                }
                break;
            case CMD_UPDATE:
                {
                    pstate->p_is_insert = false;
                    action->targetList =
                        transformUpdateTargetList(pstate,
                                                  mergeWhenClause->targetList);
                }
                break;
            case CMD_DELETE:
                break;
 
            case CMD_NOTHING:
                action->targetList = NIL;
                break;
            default:
                elog(ERROR, "unknown action in MERGE WHEN clause");
        }
 
        mergeActionList = lappend(mergeActionList, action);
    }
 
    qry->mergeActionList = mergeActionList;
 
    qry->hasTargetSRFs = false;
    qry->hasSubLinks = pstate->p_hasSubLinks;
 
    assign_query_collations(pstate, qry);
 
    return qry;
}

References ACL_DELETE, ACL_INSERT, ACL_NO_RIGHTS, ACL_SELECT, ACL_UPDATE, addNSItemToQuery(), Alias::aliasname, Assert, assign_query_collations(), bms_add_member(), checkInsertTargets(), CMD_DELETE, CMD_INSERT, CMD_MERGE, CMD_NOTHING, CMD_UPDATE, Query::commandType, Query::cteList, elog, ereport, errcode(), errdetail(), errdetail_relkind_not_supported(), errmsg(), ERROR, EXPR_KIND_JOIN_ON, EXPR_KIND_MERGE_RETURNING, EXPR_KIND_MERGE_WHEN, EXPR_KIND_VALUES_SINGLE, fb(), FirstLowInvalidHeapAttributeNumber, forthree, GetNSItemByRangeTablePosn(), Query::jointree, lappend(), lfirst, lfirst_int, lfirst_node, list_length(), list_make1, makeFromExpr(), makeNode, makeTargetEntry(), MERGE_WHEN_MATCHED, MERGE_WHEN_NOT_MATCHED_BY_SOURCE, MERGE_WHEN_NOT_MATCHED_BY_TARGET, Query::mergeActionList, Query::mergeJoinCondition, NIL, NUM_MERGE_MATCH_KINDS, ParseState::p_ctenamespace, ParseState::p_hasModifyingCTE, ParseState::p_hasSubLinks, ParseState::p_is_insert, ParseState::p_joinlist, ParseNamespaceItem::p_names, ParseNamespaceItem::p_perminfo, ParseState::p_rtable, ParseState::p_rteperminfos, ParseState::p_target_nsitem, ParseState::p_target_relation, RelationData::rd_rel, RelationGetRelationName, Query::rtable, setNamespaceForMergeWhen(), setTargetTable(), stmt, Query::targetList, transformExpr(), transformExpressionList(), transformFromClause(), transformInsertRow(), transformReturningClause(), transformUpdateTargetList(), transformWhereClause(), and transformWithClause().

Referenced by transformStmt().