/*-------------------------------------------------------------------------

 *

 * parse_merge.c

 *    handle merge-statement in parser

 *

 * Portions Copyright (c) 1996-2025, 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 "nodes/makefuncs.h"

#include "parser/analyze.h"

#include "parser/parse_clause.h"

#include "parser/parse_collate.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 "parser/parsetree.h"

#include "utils/rel.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 [BY TARGET] 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, unless invoked for NOT MATCHED BY SOURCE.

 *

 * 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->matchKind == MERGE_WHEN_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 if (mergeWhenClause->matchKind == MERGE_WHEN_NOT_MATCHED_BY_SOURCE)

  {

    /*

     * NOT MATCHED BY SOURCE actions can see the target relation, but they

     * can't see the source relation.

     */

    Assert(mergeWhenClause->commandType == CMD_UPDATE ||

         mergeWhenClause->commandType == CMD_DELETE ||

         mergeWhenClause->commandType == CMD_NOTHING);

    setNamespaceVisibilityForRTE(pstate->p_namespace,

                   targetRelRTE, true, true);

    setNamespaceVisibilityForRTE(pstate->p_namespace,

                   sourceRelRTE, false, false);

  }

  else            /* MERGE_WHEN_NOT_MATCHED_BY_TARGET */

  {

    /*

     * NOT MATCHED [BY TARGET] 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[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;

}

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;

    }

  }

}