parse_merge.c

Go to the documentation of this file.

/*-------------------------------------------------------------------------
 *
 * parse_merge.c
 *    handle merge-statement in parser
 *
 * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *    src/backend/parser/parse_merge.c
 *
 *-------------------------------------------------------------------------
 */
 
#include "postgres.h"
 
#include "access/sysattr.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "parser/analyze.h"
#include "parser/parse_collate.h"
#include "parser/parsetree.h"
#include "parser/parser.h"
#include "parser/parse_clause.h"
#include "parser/parse_cte.h"
#include "parser/parse_expr.h"
#include "parser/parse_merge.h"
#include "parser/parse_relation.h"
#include "parser/parse_target.h"
#include "utils/rel.h"
#include "utils/relcache.h"
 
static void setNamespaceForMergeWhen(ParseState *pstate,
                                     MergeWhenClause *mergeWhenClause,
                                     Index targetRTI,
                                     Index sourceRTI);
static void setNamespaceVisibilityForRTE(List *namespace, RangeTblEntry *rte,
                                         bool rel_visible,
                                         bool cols_visible);
 
/*
 * Make appropriate changes to the namespace visibility while transforming
 * individual action's quals and targetlist expressions. In particular, for
 * INSERT actions we must only see the source relation (since INSERT action is
 * invoked for NOT MATCHED tuples and hence there is no target tuple to deal
 * with). On the other hand, UPDATE and DELETE actions can see both source and
 * target relations.
 *
 * Also, since the internal join node can hide the source and target
 * relations, we must explicitly make the respective relation as visible so
 * that columns can be referenced unqualified from these relations.
 */
static void
setNamespaceForMergeWhen(ParseState *pstate, MergeWhenClause *mergeWhenClause,
                         Index targetRTI, Index sourceRTI)
{
    RangeTblEntry *targetRelRTE,
               *sourceRelRTE;
 
    targetRelRTE = rt_fetch(targetRTI, pstate->p_rtable);
    sourceRelRTE = rt_fetch(sourceRTI, pstate->p_rtable);
 
    if (mergeWhenClause->matched)
    {
        Assert(mergeWhenClause->commandType == CMD_UPDATE ||
               mergeWhenClause->commandType == CMD_DELETE ||
               mergeWhenClause->commandType == CMD_NOTHING);
 
        /* MATCHED actions can see both target and source relations. */
        setNamespaceVisibilityForRTE(pstate->p_namespace,
                                     targetRelRTE, true, true);
        setNamespaceVisibilityForRTE(pstate->p_namespace,
                                     sourceRelRTE, true, true);
    }
    else
    {
        /*
         * NOT MATCHED actions can't see target relation, but they can see
         * source relation.
         */
        Assert(mergeWhenClause->commandType == CMD_INSERT ||
               mergeWhenClause->commandType == CMD_NOTHING);
        setNamespaceVisibilityForRTE(pstate->p_namespace,
                                     targetRelRTE, false, false);
        setNamespaceVisibilityForRTE(pstate->p_namespace,
                                     sourceRelRTE, true, true);
    }
}
 
/*
 * transformMergeStmt -
 *    transforms a MERGE statement
 */
Query *
transformMergeStmt(ParseState *pstate, MergeStmt *stmt)
{
    Query      *qry = makeNode(Query);
    ListCell   *l;
    AclMode     targetPerms = ACL_NO_RIGHTS;
    bool        is_terminal[2];
    Index       sourceRTI;
    List       *mergeActionList;
    Node       *joinExpr;
    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[0] = false;
    is_terminal[1] = false;
    foreach(l, stmt->mergeWhenClauses)
    {
        MergeWhenClause *mergeWhenClause = (MergeWhenClause *) lfirst(l);
        int         when_type = (mergeWhenClause->matched ? 0 : 1);
 
        /*
         * Collect action types so we can check target permissions
         */
        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:
                break;
            default:
                elog(ERROR, "unknown action in MERGE WHEN clause");
        }
 
        /*
         * Check for unreachable WHEN clauses
         */
        if (is_terminal[when_type])
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("unreachable WHEN clause specified after unconditional WHEN clause")));
        if (mergeWhenClause->condition == NULL)
            is_terminal[when_type] = 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.
     */
    qry->resultRelation = setTargetTable(pstate, stmt->relation,
                                         stmt->relation->inh,
                                         false, targetPerms);
 
    /*
     * MERGE is unsupported in various cases
     */
    if (pstate->p_target_relation->rd_rel->relkind != RELKIND_RELATION &&
        pstate->p_target_relation->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
        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)));
    if (pstate->p_target_relation->rd_rules != NULL &&
        pstate->p_target_relation->rd_rules->numLocks > 0)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot execute MERGE on relation \"%s\"",
                        RelationGetRelationName(pstate->p_target_relation)),
                 errdetail("MERGE is not supported for relations with rules.")));
 
    /* 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);
    joinExpr = 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
     * quals we use are the join conditions to the merge target.  The join
     * will be constructed fully by transform_MERGE_to_join.
     */
    qry->jointree = makeFromExpr(pstate->p_joinlist, joinExpr);
 
    /*
     * 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->matched = mergeWhenClause->matched;
 
        /* Use an outer join if any INSERT actions exist in the command. */
        if (action->commandType == CMD_INSERT)
            qry->mergeUseOuterJoin = true;
 
        /*
         * 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;
 
    /* RETURNING could potentially be added in the future, but not in SQL std */
    qry->returningList = NULL;
 
    qry->hasTargetSRFs = false;
    qry->hasSubLinks = pstate->p_hasSubLinks;
 
    assign_query_collations(pstate, qry);
 
    return qry;
}
 
static void
setNamespaceVisibilityForRTE(List *namespace, RangeTblEntry *rte,
                             bool rel_visible,
                             bool cols_visible)
{
    ListCell   *lc;
 
    foreach(lc, namespace)
    {
        ParseNamespaceItem *nsitem = (ParseNamespaceItem *) lfirst(lc);
 
        if (nsitem->p_rte == rte)
        {
            nsitem->p_rel_visible = rel_visible;
            nsitem->p_cols_visible = cols_visible;
            break;
        }
    }
}