database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-07-02 09:02:37 +03:00
Code Activity

Revert "Modified files for MERGE"

Browse Source 
This reverts commit 354f13855e.
This commit is contained in:
Simon Riggs
2018-04-02 21:34:15 +01:00
parent 354f13855e
commit 7cf8a5c302
82 changed files with 165 additions and 2570 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
src/backend/access/heap/heapam.c
View File

@ -3245,7 +3245,6 @@ l1:
result == HeapTupleUpdated ||
result == HeapTupleBeingUpdated);
Assert(!(tp.t_data->t_infomask & HEAP_XMAX_INVALID));
hufd->result = result;
hufd->ctid = tp.t_data->t_ctid;
hufd->xmax = HeapTupleHeaderGetUpdateXid(tp.t_data);
if (result == HeapTupleSelfUpdated)
@ -3508,7 +3507,7 @@ simple_heap_delete(Relation relation, ItemPointer tid)
HTSU_Result
heap_update(Relation relation, ItemPointer otid, HeapTuple newtup,
CommandId cid, Snapshot crosscheck, bool wait,
HeapUpdateFailureData *hufd)
HeapUpdateFailureData *hufd, LockTupleMode *lockmode)
{
HTSU_Result result;
TransactionId xid = GetCurrentTransactionId();
@ -3548,10 +3547,8 @@ heap_update(Relation relation, ItemPointer otid, HeapTuple newtup,
infomask2_old_tuple,
infomask_new_tuple,
infomask2_new_tuple;
LockTupleMode lockmode;
Assert(ItemPointerIsValid(otid));
Assert(hufd != NULL);
/*
* Forbid this during a parallel operation, lest it allocate a combocid.
@ -3667,7 +3664,7 @@ heap_update(Relation relation, ItemPointer otid, HeapTuple newtup,
*/
if (!bms_overlap(modified_attrs, key_attrs))
{
lockmode = hufd->lockmode = LockTupleNoKeyExclusive;
*lockmode = LockTupleNoKeyExclusive;
mxact_status = MultiXactStatusNoKeyUpdate;
key_intact = true;
@ -3684,7 +3681,7 @@ heap_update(Relation relation, ItemPointer otid, HeapTuple newtup,
}
else
{
lockmode = hufd->lockmode = LockTupleExclusive;
*lockmode = LockTupleExclusive;
mxact_status = MultiXactStatusUpdate;
key_intact = false;
}
@ -3762,12 +3759,12 @@ l2:
int remain;
if (DoesMultiXactIdConflict((MultiXactId) xwait, infomask,
lockmode))
*lockmode))
{
LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
/* acquire tuple lock, if necessary */
heap_acquire_tuplock(relation, &(oldtup.t_self), lockmode,
heap_acquire_tuplock(relation, &(oldtup.t_self), *lockmode,
LockWaitBlock, &have_tuple_lock);
/* wait for multixact */
@ -3851,7 +3848,7 @@ l2:
* lock.
*/
LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
heap_acquire_tuplock(relation, &(oldtup.t_self), lockmode,
heap_acquire_tuplock(relation, &(oldtup.t_self), *lockmode,
LockWaitBlock, &have_tuple_lock);
XactLockTableWait(xwait, relation, &oldtup.t_self,
XLTW_Update);
@ -3890,7 +3887,6 @@ l2:
result == HeapTupleUpdated ||
result == HeapTupleBeingUpdated);
Assert(!(oldtup.t_data->t_infomask & HEAP_XMAX_INVALID));
hufd->result = result;
hufd->ctid = oldtup.t_data->t_ctid;
hufd->xmax = HeapTupleHeaderGetUpdateXid(oldtup.t_data);
if (result == HeapTupleSelfUpdated)
@ -3899,7 +3895,7 @@ l2:
hufd->cmax = InvalidCommandId;
UnlockReleaseBuffer(buffer);
if (have_tuple_lock)
UnlockTupleTuplock(relation, &(oldtup.t_self), lockmode);
UnlockTupleTuplock(relation, &(oldtup.t_self), *lockmode);
if (vmbuffer != InvalidBuffer)
ReleaseBuffer(vmbuffer);
bms_free(hot_attrs);
@ -3937,7 +3933,7 @@ l2:
compute_new_xmax_infomask(HeapTupleHeaderGetRawXmax(oldtup.t_data),
oldtup.t_data->t_infomask,
oldtup.t_data->t_infomask2,
xid, lockmode, true,
xid, *lockmode, true,
&xmax_old_tuple, &infomask_old_tuple,
&infomask2_old_tuple);
@ -4054,7 +4050,7 @@ l2:
compute_new_xmax_infomask(HeapTupleHeaderGetRawXmax(oldtup.t_data),
oldtup.t_data->t_infomask,
oldtup.t_data->t_infomask2,
xid, lockmode, false,
xid, *lockmode, false,
&xmax_lock_old_tuple, &infomask_lock_old_tuple,
&infomask2_lock_old_tuple);
@ -4366,7 +4362,7 @@ l2:
* Release the lmgr tuple lock, if we had it.
*/
if (have_tuple_lock)
UnlockTupleTuplock(relation, &(oldtup.t_self), lockmode);
UnlockTupleTuplock(relation, &(oldtup.t_self), *lockmode);
pgstat_count_heap_update(relation, use_hot_update);
@ -4590,11 +4586,12 @@ simple_heap_update(Relation relation, ItemPointer otid, HeapTuple tup)
{
HTSU_Result result;
HeapUpdateFailureData hufd;
LockTupleMode lockmode;
result = heap_update(relation, otid, tup,
GetCurrentCommandId(true), InvalidSnapshot,
true /* wait for commit */ ,
&hufd);
&hufd, &lockmode);
switch (result)
{
case HeapTupleSelfUpdated:
@ -5180,7 +5177,6 @@ failed:
Assert(result == HeapTupleSelfUpdated || result == HeapTupleUpdated ||
result == HeapTupleWouldBlock);
Assert(!(tuple->t_data->t_infomask & HEAP_XMAX_INVALID));
hufd->result = result;
hufd->ctid = tuple->t_data->t_ctid;
hufd->xmax = HeapTupleHeaderGetUpdateXid(tuple->t_data);
if (result == HeapTupleSelfUpdated)

6
src/backend/catalog/sql_features.txt
View File

@ -229,9 +229,9 @@ F311 Schema definition statement 02 CREATE TABLE for persistent base tables YES
F311 Schema definition statement 03 CREATE VIEW YES
F311 Schema definition statement 04 CREATE VIEW: WITH CHECK OPTION YES
F311 Schema definition statement 05 GRANT statement YES
F312 MERGE statement YES also consider INSERT ... ON CONFLICT DO UPDATE
F313 Enhanced MERGE statement YES
F314 MERGE statement with DELETE branch YES
F312 MERGE statement NO consider INSERT ... ON CONFLICT DO UPDATE
F313 Enhanced MERGE statement NO
F314 MERGE statement with DELETE branch NO
F321 User authorization YES
F341 Usage tables NO no ROUTINE_*_USAGE tables
F361 Subprogram support YES

33
src/backend/commands/explain.c
View File

@ -946,9 +946,6 @@ ExplainNode(PlanState *planstate, List *ancestors,
case CMD_DELETE:
pname = operation = "Delete";
break;
case CMD_MERGE:
pname = operation = "Merge";
break;
default:
pname = "???";
break;
@ -3010,10 +3007,6 @@ show_modifytable_info(ModifyTableState *mtstate, List *ancestors,
operation = "Delete";
foperation = "Foreign Delete";
break;
case CMD_MERGE:
operation = "Merge";
foperation = "Foreign Merge";
break;
default:
operation = "???";
foperation = "Foreign ???";
@ -3136,32 +3129,6 @@ show_modifytable_info(ModifyTableState *mtstate, List *ancestors,
other_path, 0, es);
}
}
else if (node->operation == CMD_MERGE)
{
/* EXPLAIN ANALYZE display of actual outcome for each tuple proposed */
if (es->analyze && mtstate->ps.instrument)
{
double total;
double insert_path;
double update_path;
double delete_path;
double skipped_path;
InstrEndLoop(mtstate->mt_plans[0]->instrument);
/* count the number of source rows */
total = mtstate->mt_plans[0]->instrument->ntuples;
insert_path = mtstate->ps.instrument->nfiltered1;
update_path = mtstate->ps.instrument->nfiltered2;
delete_path = mtstate->ps.instrument->nfiltered3;
skipped_path = total - insert_path - update_path - delete_path;
ExplainPropertyFloat("Tuples Inserted", NULL, insert_path, 0, es);
ExplainPropertyFloat("Tuples Updated", NULL, update_path, 0, es);
ExplainPropertyFloat("Tuples Deleted", NULL, delete_path, 0, es);
ExplainPropertyFloat("Tuples Skipped", NULL, skipped_path, 0, es);
}
}
if (labeltargets)
ExplainCloseGroup("Target Tables", "Target Tables", false, es);

1
src/backend/commands/prepare.c
View File

@ -151,7 +151,6 @@ PrepareQuery(PrepareStmt *stmt, const char *queryString,
case CMD_INSERT:
case CMD_UPDATE:
case CMD_DELETE:
case CMD_MERGE:
/* OK */
break;
default:

156
src/backend/commands/trigger.c
View File

@ -85,8 +85,7 @@ static HeapTuple GetTupleForTrigger(EState *estate,
ResultRelInfo *relinfo,
ItemPointer tid,
LockTupleMode lockmode,
TupleTableSlot **newSlot,
HeapUpdateFailureData *hufdp);
TupleTableSlot **newSlot);
static bool TriggerEnabled(EState *estate, ResultRelInfo *relinfo,
Trigger *trigger, TriggerEvent event,
Bitmapset *modifiedCols,
@ -2730,8 +2729,7 @@ bool
ExecBRDeleteTriggers(EState *estate, EPQState *epqstate,
ResultRelInfo *relinfo,
ItemPointer tupleid,
HeapTuple fdw_trigtuple,
HeapUpdateFailureData *hufdp)
HeapTuple fdw_trigtuple)
{
TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
bool result = true;
@ -2745,7 +2743,7 @@ ExecBRDeleteTriggers(EState *estate, EPQState *epqstate,
if (fdw_trigtuple == NULL)
{
trigtuple = GetTupleForTrigger(estate, epqstate, relinfo, tupleid,
LockTupleExclusive, &newSlot, hufdp);
LockTupleExclusive, &newSlot);
if (trigtuple == NULL)
return false;
}
@ -2816,7 +2814,6 @@ ExecARDeleteTriggers(EState *estate, ResultRelInfo *relinfo,
relinfo,
tupleid,
LockTupleExclusive,
NULL,
NULL);
else
trigtuple = fdw_trigtuple;
@ -2954,8 +2951,7 @@ ExecBRUpdateTriggers(EState *estate, EPQState *epqstate,
ResultRelInfo *relinfo,
ItemPointer tupleid,
HeapTuple fdw_trigtuple,
TupleTableSlot *slot,
HeapUpdateFailureData *hufdp)
TupleTableSlot *slot)
{
TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
HeapTuple slottuple = ExecMaterializeSlot(slot);
@ -2976,7 +2972,7 @@ ExecBRUpdateTriggers(EState *estate, EPQState *epqstate,
{
/* get a copy of the on-disk tuple we are planning to update */
trigtuple = GetTupleForTrigger(estate, epqstate, relinfo, tupleid,
lockmode, &newSlot, hufdp);
lockmode, &newSlot);
if (trigtuple == NULL)
return NULL; /* cancel the update action */
}
@ -3096,7 +3092,6 @@ ExecARUpdateTriggers(EState *estate, ResultRelInfo *relinfo,
relinfo,
tupleid,
LockTupleExclusive,
NULL,
NULL);
else
trigtuple = fdw_trigtuple;
@ -3245,8 +3240,7 @@ GetTupleForTrigger(EState *estate,
ResultRelInfo *relinfo,
ItemPointer tid,
LockTupleMode lockmode,
TupleTableSlot **newSlot,
HeapUpdateFailureData *hufdp)
TupleTableSlot **newSlot)
{
Relation relation = relinfo->ri_RelationDesc;
HeapTupleData tuple;
@ -3272,11 +3266,6 @@ ltrmark:;
estate->es_output_cid,
lockmode, LockWaitBlock,
false, &buffer, &hufd);
/* Let the caller know about failure reason, if any. */
if (hufdp)
*hufdp = hufd;
switch (test)
{
case HeapTupleSelfUpdated:
@ -3313,17 +3302,10 @@ ltrmark:;
/* it was updated, so look at the updated version */
TupleTableSlot *epqslot;
/*
* If we're running MERGE then we must install the
* new tuple in the slot of the underlying join query and
* not the result relation itself. If the join does not
* yield any tuple, the caller will take the necessary
* action.
*/
epqslot = EvalPlanQual(estate,
epqstate,
relation,
GetEPQRangeTableIndex(relinfo),
relinfo->ri_RangeTableIndex,
lockmode,
&hufd.ctid,
hufd.xmax);
@ -3846,14 +3828,8 @@ struct AfterTriggersTableData
bool before_trig_done; /* did we already queue BS triggers? */
bool after_trig_done; /* did we already queue AS triggers? */
AfterTriggerEventList after_trig_events; /* if so, saved list pointer */
/* "old" transition table for UPDATE, if any */
Tuplestorestate *old_upd_tuplestore;
/* "new" transition table for UPDATE, if any */
Tuplestorestate *new_upd_tuplestore;
/* "old" transition table for DELETE, if any */
Tuplestorestate *old_del_tuplestore;
/* "new" transition table INSERT, if any */
Tuplestorestate *new_ins_tuplestore;
Tuplestorestate *old_tuplestore; /* "old" transition table, if any */
Tuplestorestate *new_tuplestore; /* "new" transition table, if any */
};
static AfterTriggersData afterTriggers;
@ -4320,19 +4296,13 @@ AfterTriggerExecute(AfterTriggerEvent event,
{
if (LocTriggerData.tg_trigger->tgoldtable)
{
if (TRIGGER_FIRED_BY_UPDATE(evtshared->ats_event))
LocTriggerData.tg_oldtable = evtshared->ats_table->old_upd_tuplestore;
else
LocTriggerData.tg_oldtable = evtshared->ats_table->old_del_tuplestore;
LocTriggerData.tg_oldtable = evtshared->ats_table->old_tuplestore;
evtshared->ats_table->closed = true;
}
if (LocTriggerData.tg_trigger->tgnewtable)
{
if (TRIGGER_FIRED_BY_INSERT(evtshared->ats_event))
LocTriggerData.tg_newtable = evtshared->ats_table->new_ins_tuplestore;
else
LocTriggerData.tg_newtable = evtshared->ats_table->new_upd_tuplestore;
LocTriggerData.tg_newtable = evtshared->ats_table->new_tuplestore;
evtshared->ats_table->closed = true;
}
}
@ -4667,10 +4637,8 @@ TransitionCaptureState *
MakeTransitionCaptureState(TriggerDesc *trigdesc, Oid relid, CmdType cmdType)
{
TransitionCaptureState *state;
bool need_old_upd,
need_new_upd,
need_old_del,
need_new_ins;
bool need_old,
need_new;
AfterTriggersTableData *table;
MemoryContext oldcxt;
ResourceOwner saveResourceOwner;
@ -4682,31 +4650,23 @@ MakeTransitionCaptureState(TriggerDesc *trigdesc, Oid relid, CmdType cmdType)
switch (cmdType)
{
case CMD_INSERT:
need_old_upd = need_old_del = need_new_upd = false;
need_new_ins = trigdesc->trig_insert_new_table;
need_old = false;
need_new = trigdesc->trig_insert_new_table;
break;
case CMD_UPDATE:
need_old_upd = trigdesc->trig_update_old_table;
need_new_upd = trigdesc->trig_update_new_table;
need_old_del = need_new_ins = false;
need_old = trigdesc->trig_update_old_table;
need_new = trigdesc->trig_update_new_table;
break;
case CMD_DELETE:
need_old_del = trigdesc->trig_delete_old_table;
need_old_upd = need_new_upd = need_new_ins = false;
break;
case CMD_MERGE:
need_old_upd = trigdesc->trig_update_old_table;
need_new_upd = trigdesc->trig_update_new_table;
need_old_del = trigdesc->trig_delete_old_table;
need_new_ins = trigdesc->trig_insert_new_table;
need_old = trigdesc->trig_delete_old_table;
need_new = false;
break;
default:
elog(ERROR, "unexpected CmdType: %d", (int) cmdType);
/* keep compiler quiet */
need_old_upd = need_new_upd = need_old_del = need_new_ins = false;
need_old = need_new = false; /* keep compiler quiet */
break;
}
if (!need_old_upd && !need_new_upd && !need_new_ins && !need_old_del)
if (!need_old && !need_new)
return NULL;
/* Check state, like AfterTriggerSaveEvent. */
@ -4736,14 +4696,10 @@ MakeTransitionCaptureState(TriggerDesc *trigdesc, Oid relid, CmdType cmdType)
saveResourceOwner = CurrentResourceOwner;
CurrentResourceOwner = CurTransactionResourceOwner;
if (need_old_upd && table->old_upd_tuplestore == NULL)
table->old_upd_tuplestore = tuplestore_begin_heap(false, false, work_mem);
if (need_new_upd && table->new_upd_tuplestore == NULL)
table->new_upd_tuplestore = tuplestore_begin_heap(false, false, work_mem);
if (need_old_del && table->old_del_tuplestore == NULL)
table->old_del_tuplestore = tuplestore_begin_heap(false, false, work_mem);
if (need_new_ins && table->new_ins_tuplestore == NULL)
table->new_ins_tuplestore = tuplestore_begin_heap(false, false, work_mem);
if (need_old && table->old_tuplestore == NULL)
table->old_tuplestore = tuplestore_begin_heap(false, false, work_mem);
if (need_new && table->new_tuplestore == NULL)
table->new_tuplestore = tuplestore_begin_heap(false, false, work_mem);
CurrentResourceOwner = saveResourceOwner;
MemoryContextSwitchTo(oldcxt);
@ -4932,20 +4888,12 @@ AfterTriggerFreeQuery(AfterTriggersQueryData *qs)
{
AfterTriggersTableData *table = (AfterTriggersTableData *) lfirst(lc);
ts = table->old_upd_tuplestore;
table->old_upd_tuplestore = NULL;
ts = table->old_tuplestore;
table->old_tuplestore = NULL;
if (ts)
tuplestore_end(ts);
ts = table->new_upd_tuplestore;
table->new_upd_tuplestore = NULL;
if (ts)
tuplestore_end(ts);
ts = table->old_del_tuplestore;
table->old_del_tuplestore = NULL;
if (ts)
tuplestore_end(ts);
ts = table->new_ins_tuplestore;
table->new_ins_tuplestore = NULL;
ts = table->new_tuplestore;
table->new_tuplestore = NULL;
if (ts)
tuplestore_end(ts);
}
@ -5796,28 +5744,12 @@ AfterTriggerSaveEvent(EState *estate, ResultRelInfo *relinfo,
newtup == NULL));
if (oldtup != NULL &&
(event == TRIGGER_EVENT_DELETE && delete_old_table))
((event == TRIGGER_EVENT_DELETE && delete_old_table) ||
(event == TRIGGER_EVENT_UPDATE && update_old_table)))
{
Tuplestorestate *old_tuplestore;
old_tuplestore = transition_capture->tcs_private->old_del_tuplestore;
if (map != NULL)
{
HeapTuple converted = do_convert_tuple(oldtup, map);
tuplestore_puttuple(old_tuplestore, converted);
pfree(converted);
}
else
tuplestore_puttuple(old_tuplestore, oldtup);
}
if (oldtup != NULL &&
(event == TRIGGER_EVENT_UPDATE && update_old_table))
{
Tuplestorestate *old_tuplestore;
old_tuplestore = transition_capture->tcs_private->old_upd_tuplestore;
old_tuplestore = transition_capture->tcs_private->old_tuplestore;
if (map != NULL)
{
@ -5830,30 +5762,12 @@ AfterTriggerSaveEvent(EState *estate, ResultRelInfo *relinfo,
tuplestore_puttuple(old_tuplestore, oldtup);
}
if (newtup != NULL &&
(event == TRIGGER_EVENT_INSERT && insert_new_table))
((event == TRIGGER_EVENT_INSERT && insert_new_table) ||
(event == TRIGGER_EVENT_UPDATE && update_new_table)))
{
Tuplestorestate *new_tuplestore;
new_tuplestore = transition_capture->tcs_private->new_ins_tuplestore;
if (original_insert_tuple != NULL)
tuplestore_puttuple(new_tuplestore, original_insert_tuple);
else if (map != NULL)
{
HeapTuple converted = do_convert_tuple(newtup, map);
tuplestore_puttuple(new_tuplestore, converted);
pfree(converted);
}
else
tuplestore_puttuple(new_tuplestore, newtup);
}
if (newtup != NULL &&
(event == TRIGGER_EVENT_UPDATE && update_new_table))
{
Tuplestorestate *new_tuplestore;
new_tuplestore = transition_capture->tcs_private->new_upd_tuplestore;
new_tuplestore = transition_capture->tcs_private->new_tuplestore;
if (original_insert_tuple != NULL)
tuplestore_puttuple(new_tuplestore, original_insert_tuple);

2
src/backend/executor/Makefile
View File

@ -22,7 +22,7 @@ OBJS = execAmi.o execCurrent.o execExpr.o execExprInterp.o \
nodeCustom.o nodeFunctionscan.o nodeGather.o \
nodeHash.o nodeHashjoin.o nodeIndexscan.o nodeIndexonlyscan.o \
nodeLimit.o nodeLockRows.o nodeGatherMerge.o \
nodeMaterial.o nodeMergeAppend.o nodeMergejoin.o nodeMerge.o nodeModifyTable.o \
nodeMaterial.o nodeMergeAppend.o nodeMergejoin.o nodeModifyTable.o \
nodeNestloop.o nodeProjectSet.o nodeRecursiveunion.o nodeResult.o \
nodeSamplescan.o nodeSeqscan.o nodeSetOp.o nodeSort.o nodeUnique.o \
nodeValuesscan.o \

10
src/backend/executor/README
View File

@ -37,16 +37,6 @@ the plan tree returns the computed tuples to be updated, plus a "junk"
one. For DELETE, the plan tree need only deliver a CTID column, and the
ModifyTable node visits each of those rows and marks the row deleted.
MERGE runs one generic plan that returns candidate target rows. Each row
consists of a super-row that contains all the columns needed by any of the
individual actions, plus a CTID and a TABLEOID junk columns. The CTID column is
required to know if a matching target row was found or not and the TABLEOID
column is needed to find the underlying target partition, in case when the
target table is a partition table. If the CTID column is set we attempt to
activate WHEN MATCHED actions, or if it is NULL then we will attempt to
activate WHEN NOT MATCHED actions. Once we know which action is activated we
form the final result row and apply only those changes.
XXX a great deal more documentation needs to be written here...

17
src/backend/executor/execMain.c
View File

@ -233,7 +233,6 @@ standard_ExecutorStart(QueryDesc *queryDesc, int eflags)
case CMD_INSERT:
case CMD_DELETE:
case CMD_UPDATE:
case CMD_MERGE:
estate->es_output_cid = GetCurrentCommandId(true);
break;
@ -1358,9 +1357,6 @@ InitResultRelInfo(ResultRelInfo *resultRelInfo,
resultRelInfo->ri_onConflictArbiterIndexes = NIL;
resultRelInfo->ri_onConflict = NULL;
resultRelInfo->ri_mergeTargetRTI = 0;
resultRelInfo->ri_mergeState = (MergeState *) palloc0(sizeof (MergeState));
/*
* Partition constraint, which also includes the partition constraint of
* all the ancestors that are partitions. Note that it will be checked
@ -2209,19 +2205,6 @@ ExecWithCheckOptions(WCOKind kind, ResultRelInfo *resultRelInfo,
errmsg("new row violates row-level security policy for table \"%s\"",
wco->relname)));
break;
case WCO_RLS_MERGE_UPDATE_CHECK:
case WCO_RLS_MERGE_DELETE_CHECK:
if (wco->polname != NULL)
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
errmsg("target row violates row-level security policy \"%s\" (USING expression) for table \"%s\"",
wco->polname, wco->relname)));
else
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
errmsg("target row violates row-level security policy (USING expression) for table \"%s\"",
wco->relname)));
break;
case WCO_RLS_CONFLICT_CHECK:
if (wco->polname != NULL)
ereport(ERROR,

116
src/backend/executor/execPartition.c
View File

@ -67,8 +67,6 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate, Relation rel)
ResultRelInfo *update_rri = NULL;
int num_update_rri = 0,
update_rri_index = 0;
bool is_update = false;
bool is_merge = false;
PartitionTupleRouting *proute;
int nparts;
ModifyTable *node = mtstate ? (ModifyTable *) mtstate->ps.plan : NULL;
@ -91,22 +89,13 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate, Relation rel)
/* Set up details specific to the type of tuple routing we are doing. */
if (node && node->operation == CMD_UPDATE)
is_update = true;
else if (node && node->operation == CMD_MERGE)
is_merge = true;
if (is_update)
{
update_rri = mtstate->resultRelInfo;
num_update_rri = list_length(node->plans);
proute->subplan_partition_offsets =
palloc(num_update_rri * sizeof(int));
proute->num_subplan_partition_offsets = num_update_rri;
}
if (is_update || is_merge)
{
/*
* We need an additional tuple slot for storing transient tuples that
* are converted to the root table descriptor.
@ -310,25 +299,6 @@ ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
return result;
}
/*
* Given OID of the partition leaf, return the index of the leaf in the
* partition hierarchy.
*/
int
ExecFindPartitionByOid(PartitionTupleRouting *proute, Oid partoid)
{
int i;
for (i = 0; i < proute->num_partitions; i++)
{
if (proute->partition_oids[i] == partoid)
break;
}
Assert(i < proute->num_partitions);
return i;
}
/*
* ExecInitPartitionInfo
* Initialize ResultRelInfo and other information for a partition if not
@ -367,8 +337,6 @@ ExecInitPartitionInfo(ModifyTableState *mtstate,
rootrel,
estate->es_instrument);
leaf_part_rri->ri_PartitionLeafIndex = partidx;
/*
* Verify result relation is a valid target for an INSERT. An UPDATE of a
* partition-key becomes a DELETE+INSERT operation, so this check is still
@ -657,90 +625,6 @@ ExecInitPartitionInfo(ModifyTableState *mtstate,
Assert(proute->partitions[partidx] == NULL);
proute->partitions[partidx] = leaf_part_rri;
/*
* Initialize information about this partition that's needed to handle
* MERGE.
*/
if (node && node->operation == CMD_MERGE)
{
TupleDesc partrelDesc = RelationGetDescr(partrel);
TupleConversionMap *map = proute->parent_child_tupconv_maps[partidx];
int firstVarno = mtstate->resultRelInfo[0].ri_RangeTableIndex;
Relation firstResultRel = mtstate->resultRelInfo[0].ri_RelationDesc;
/*
* If the root parent and partition have the same tuple
* descriptor, just reuse the original MERGE state for partition.
*/
if (map == NULL)
{
leaf_part_rri->ri_mergeState = resultRelInfo->ri_mergeState;
}
else
{
/* Convert expressions contain partition's attnos. */
List *conv_tl, *conv_qual;
ListCell *l;
List *matchedActionStates = NIL;
List *notMatchedActionStates = NIL;
foreach (l, node->mergeActionList)
{
MergeAction *action = lfirst_node(MergeAction, l);
MergeActionState *action_state = makeNode(MergeActionState);
TupleDesc tupDesc;
ExprContext *econtext;
action_state->matched = action->matched;
action_state->commandType = action->commandType;
conv_qual = (List *) action->qual;
conv_qual = map_partition_varattnos(conv_qual,
firstVarno, partrel,
firstResultRel, NULL);
action_state->whenqual = ExecInitQual(conv_qual, &mtstate->ps);
conv_tl = (List *) action->targetList;
conv_tl = map_partition_varattnos(conv_tl,
firstVarno, partrel,
firstResultRel, NULL);
conv_tl = adjust_partition_tlist( conv_tl, map);
tupDesc = ExecTypeFromTL(conv_tl, partrelDesc->tdhasoid);
action_state->tupDesc = tupDesc;
/* build action projection state */
econtext = mtstate->ps.ps_ExprContext;
action_state->proj =
ExecBuildProjectionInfo(conv_tl, econtext,
mtstate->mt_mergeproj,
&mtstate->ps,
partrelDesc);
if (action_state->matched)
matchedActionStates =
lappend(matchedActionStates, action_state);
else
notMatchedActionStates =
lappend(notMatchedActionStates, action_state);
}
leaf_part_rri->ri_mergeState->matchedActionStates =
matchedActionStates;
leaf_part_rri->ri_mergeState->notMatchedActionStates =
notMatchedActionStates;
}
/*
* get_partition_dispatch_recurse() and expand_partitioned_rtentry()
* fetch the leaf OIDs in the same order. So we can safely derive the
* index of the merge target relation corresponding to this partition
* by simply adding partidx + 1 to the root's merge target relation.
*/
leaf_part_rri->ri_mergeTargetRTI = node->mergeTargetRelation +
partidx + 1;
}
MemoryContextSwitchTo(oldContext);
return leaf_part_rri;

4
src/backend/executor/execReplication.c
View File

@ -454,7 +454,7 @@ ExecSimpleRelationUpdate(EState *estate, EPQState *epqstate,
{
slot = ExecBRUpdateTriggers(estate, epqstate, resultRelInfo,
&searchslot->tts_tuple->t_self,
NULL, slot, NULL);
NULL, slot);
if (slot == NULL) /* "do nothing" */
skip_tuple = true;
@ -515,7 +515,7 @@ ExecSimpleRelationDelete(EState *estate, EPQState *epqstate,
{
skip_tuple = !ExecBRDeleteTriggers(estate, epqstate, resultRelInfo,
&searchslot->tts_tuple->t_self,
NULL, NULL);
NULL);
}
if (!skip_tuple)

384
src/backend/executor/nodeModifyTable.c
View File

@ -42,7 +42,6 @@
#include "commands/trigger.h"
#include "executor/execPartition.h"
#include "executor/executor.h"
#include "executor/nodeMerge.h"
#include "executor/nodeModifyTable.h"
#include "foreign/fdwapi.h"
#include "miscadmin.h"
@ -63,17 +62,17 @@ static bool ExecOnConflictUpdate(ModifyTableState *mtstate,
EState *estate,
bool canSetTag,
TupleTableSlot **returning);
static TupleTableSlot *ExecPrepareTupleRouting(ModifyTableState *mtstate,
EState *estate,
PartitionTupleRouting *proute,
ResultRelInfo *targetRelInfo,
TupleTableSlot *slot);
static ResultRelInfo *getTargetResultRelInfo(ModifyTableState *node);
static void ExecSetupChildParentMapForTcs(ModifyTableState *mtstate);
static void ExecSetupChildParentMapForSubplan(ModifyTableState *mtstate);
static TupleConversionMap *tupconv_map_for_subplan(ModifyTableState *node,
int whichplan);
/* flags for mt_merge_subcommands */
#define MERGE_INSERT 0x01
#define MERGE_UPDATE 0x02
#define MERGE_DELETE 0x04
/*
* Verify that the tuples to be produced by INSERT or UPDATE match the
* target relation's rowtype
@ -260,12 +259,11 @@ ExecCheckTIDVisible(EState *estate,
* Returns RETURNING result if any, otherwise NULL.
* ----------------------------------------------------------------
*/
extern TupleTableSlot *
static TupleTableSlot *
ExecInsert(ModifyTableState *mtstate,
TupleTableSlot *slot,
TupleTableSlot *planSlot,
EState *estate,
MergeActionState *actionState,
bool canSetTag)
{
HeapTuple tuple;
@ -392,17 +390,9 @@ ExecInsert(ModifyTableState *mtstate,
* partition, we should instead check UPDATE policies, because we are
* executing policies defined on the target table, and not those
* defined on the child partitions.
*
* If we're running MERGE, we refer to the action that we're executing
* to know if we're doing an INSERT or UPDATE to a partition table.
*/
if (mtstate->operation == CMD_UPDATE)
wco_kind = WCO_RLS_UPDATE_CHECK;
else if (mtstate->operation == CMD_MERGE)
wco_kind = (actionState->commandType == CMD_UPDATE) ?
WCO_RLS_UPDATE_CHECK : WCO_RLS_INSERT_CHECK;
else
wco_kind = WCO_RLS_INSERT_CHECK;
wco_kind = (mtstate->operation == CMD_UPDATE) ?
WCO_RLS_UPDATE_CHECK : WCO_RLS_INSERT_CHECK;
/*
* ExecWithCheckOptions() will skip any WCOs which are not of the kind
@ -627,19 +617,10 @@ ExecInsert(ModifyTableState *mtstate,
* passed to foreign table triggers; it is NULL when the foreign
* table has no relevant triggers.
*
* MERGE passes actionState of the action it's currently executing;
* regular DELETE passes NULL. This is used by ExecDelete to know if it's
* being called from MERGE or regular DELETE operation.
*
* If the DELETE fails because the tuple is concurrently updated/deleted
* by this or some other transaction, hufdp is filled with the reason as
* well as other important information. Currently only MERGE needs this
* information.
*
* Returns RETURNING result if any, otherwise NULL.
* ----------------------------------------------------------------
*/
TupleTableSlot *
static TupleTableSlot *
ExecDelete(ModifyTableState *mtstate,
ItemPointer tupleid,
HeapTuple oldtuple,
@ -648,8 +629,6 @@ ExecDelete(ModifyTableState *mtstate,
EState *estate,
bool *tupleDeleted,
bool processReturning,
HeapUpdateFailureData *hufdp,
MergeActionState *actionState,
bool canSetTag)
{
ResultRelInfo *resultRelInfo;
@ -662,14 +641,6 @@ ExecDelete(ModifyTableState *mtstate,
if (tupleDeleted)
*tupleDeleted = false;
/*
* Initialize hufdp. Since the caller is only interested in the failure
* status, initialize with the state that is used to indicate successful
* operation.
*/
if (hufdp)
hufdp->result = HeapTupleMayBeUpdated;
/*
* get information on the (current) result relation
*/
@ -683,7 +654,7 @@ ExecDelete(ModifyTableState *mtstate,
bool dodelete;
dodelete = ExecBRDeleteTriggers(estate, epqstate, resultRelInfo,
tupleid, oldtuple, hufdp);
tupleid, oldtuple);
if (!dodelete) /* "do nothing" */
return NULL;
@ -750,15 +721,6 @@ ldelete:;
estate->es_crosscheck_snapshot,
true /* wait for commit */ ,
&hufd);
/*
* Copy the necessary information, if the caller has asked for it. We
* must do this irrespective of whether the tuple was updated or
* deleted.
*/
if (hufdp)
*hufdp = hufd;
switch (result)
{
case HeapTupleSelfUpdated:
@ -793,11 +755,7 @@ ldelete:;
errmsg("tuple to be updated was already modified by an operation triggered by the current command"),
errhint("Consider using an AFTER trigger instead of a BEFORE trigger to propagate changes to other rows.")));
/*
* Else, already deleted by self; nothing to do but inform
* MERGE about it anyways so that it can take necessary
* action.
*/
/* Else, already deleted by self; nothing to do */
return NULL;
case HeapTupleMayBeUpdated:
@ -808,24 +766,14 @@ ldelete:;
ereport(ERROR,
(errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
errmsg("could not serialize access due to concurrent update")));
if (!ItemPointerEquals(tupleid, &hufd.ctid))
{
TupleTableSlot *epqslot;
/*
* If we're executing MERGE, then the onus of running
* EvalPlanQual() and handling its outcome lies with the
* caller.
*/
if (actionState != NULL)
return NULL;
/* Normal DELETE path. */
epqslot = EvalPlanQual(estate,
epqstate,
resultRelationDesc,
GetEPQRangeTableIndex(resultRelInfo),
resultRelInfo->ri_RangeTableIndex,
LockTupleExclusive,
&hufd.ctid,
hufd.xmax);
@ -835,12 +783,7 @@ ldelete:;
goto ldelete;
}
}
/*
* tuple already deleted; nothing to do. But MERGE might want
* to handle it differently. We've already filled-in hufdp
* with sufficient information for MERGE to look at.
*/
/* tuple already deleted; nothing to do */
return NULL;
default:
@ -968,21 +911,10 @@ ldelete:;
* foreign table triggers; it is NULL when the foreign table has
* no relevant triggers.
*
* MERGE passes actionState of the action it's currently executing;
* regular UPDATE passes NULL. This is used by ExecUpdate to know if it's
* being called from MERGE or regular UPDATE operation. ExecUpdate may
* pass this information to ExecInsert if it ends up running DELETE+INSERT
* for partition key updates.
*
* If the UPDATE fails because the tuple is concurrently updated/deleted
* by this or some other transaction, hufdp is filled with the reason as
* well as other important information. Currently only MERGE needs this
* information.
*
* Returns RETURNING result if any, otherwise NULL.
* ----------------------------------------------------------------
*/
extern TupleTableSlot *
static TupleTableSlot *
ExecUpdate(ModifyTableState *mtstate,
ItemPointer tupleid,
HeapTuple oldtuple,
@ -990,9 +922,6 @@ ExecUpdate(ModifyTableState *mtstate,
TupleTableSlot *planSlot,
EPQState *epqstate,
EState *estate,
bool *tuple_updated,
HeapUpdateFailureData *hufdp,
MergeActionState *actionState,
bool canSetTag)
{
HeapTuple tuple;
@ -1009,17 +938,6 @@ ExecUpdate(ModifyTableState *mtstate,
if (IsBootstrapProcessingMode())
elog(ERROR, "cannot UPDATE during bootstrap");
if (tuple_updated)
*tuple_updated = false;
/*
* Initialize hufdp. Since the caller is only interested in the failure
* status, initialize with the state that is used to indicate successful
* operation.
*/
if (hufdp)
hufdp->result = HeapTupleMayBeUpdated;
/*
* get the heap tuple out of the tuple table slot, making sure we have a
* writable copy
@ -1037,7 +955,7 @@ ExecUpdate(ModifyTableState *mtstate,
resultRelInfo->ri_TrigDesc->trig_update_before_row)
{
slot = ExecBRUpdateTriggers(estate, epqstate, resultRelInfo,
tupleid, oldtuple, slot, hufdp);
tupleid, oldtuple, slot);
if (slot == NULL) /* "do nothing" */
return NULL;
@ -1083,6 +1001,7 @@ ExecUpdate(ModifyTableState *mtstate,
}
else
{
LockTupleMode lockmode;
bool partition_constraint_failed;
/*
@ -1160,9 +1079,8 @@ lreplace:;
* Row movement, part 1. Delete the tuple, but skip RETURNING
* processing. We want to return rows from INSERT.
*/
ExecDelete(mtstate, tupleid, oldtuple, planSlot, epqstate,
estate, &tuple_deleted, false, hufdp, NULL,
false);
ExecDelete(mtstate, tupleid, oldtuple, planSlot, epqstate, estate,
&tuple_deleted, false, false);
/*
* For some reason if DELETE didn't happen (e.g. trigger prevented
@ -1198,36 +1116,16 @@ lreplace:;
saved_tcs_map = mtstate->mt_transition_capture->tcs_map;
/*
* We should convert the tuple into root's tuple descriptor, since
* ExecInsert() starts the search from root. To do that, we need to
* retrieve the tuple conversion map for this resultRelInfo.
*
* If we're running MERGE then resultRelInfo is per-partition
* resultRelInfo as initialized in ExecInitPartitionInfo(). Note
* that we don't expand inheritance for the resultRelation in case
* of MERGE and hence there is just one subplan. Whereas for
* regular UPDATE, resultRelInfo is one of the per-subplan
* resultRelInfos. In either case the position of this partition in
* tracked in ri_PartitionLeafIndex;
*
* Retrieve the map either by looking at the resultRelInfo's
* position in mtstate->resultRelInfo[] (for UPDATE) or by simply
* using the ri_PartitionLeafIndex value (for MERGE).
* resultRelInfo is one of the per-subplan resultRelInfos. So we
* should convert the tuple into root's tuple descriptor, since
* ExecInsert() starts the search from root. The tuple conversion
* map list is in the order of mtstate->resultRelInfo[], so to
* retrieve the one for this resultRel, we need to know the
* position of the resultRel in mtstate->resultRelInfo[].
*/
if (mtstate->operation == CMD_MERGE)
{
map_index = resultRelInfo->ri_PartitionLeafIndex;
Assert(mtstate->rootResultRelInfo == NULL);
tupconv_map = TupConvMapForLeaf(proute,
mtstate->resultRelInfo,
map_index);
}
else
{
map_index = resultRelInfo - mtstate->resultRelInfo;
Assert(map_index >= 0 && map_index < mtstate->mt_nplans);
tupconv_map = tupconv_map_for_subplan(mtstate, map_index);
}
map_index = resultRelInfo - mtstate->resultRelInfo;
Assert(map_index >= 0 && map_index < mtstate->mt_nplans);
tupconv_map = tupconv_map_for_subplan(mtstate, map_index);
tuple = ConvertPartitionTupleSlot(tupconv_map,
tuple,
proute->root_tuple_slot,
@ -1237,16 +1135,12 @@ lreplace:;
* Prepare for tuple routing, making it look like we're inserting
* into the root.
*/
Assert(mtstate->rootResultRelInfo != NULL);
slot = ExecPrepareTupleRouting(mtstate, estate, proute,
getTargetResultRelInfo(mtstate),
slot);
mtstate->rootResultRelInfo, slot);
ret_slot = ExecInsert(mtstate, slot, planSlot,
estate, actionState, canSetTag);
/* Update is successful. */
if (tuple_updated)
*tuple_updated = true;
estate, canSetTag);
/* Revert ExecPrepareTupleRouting's node change. */
estate->es_result_relation_info = resultRelInfo;
@ -1284,16 +1178,7 @@ lreplace:;
estate->es_output_cid,
estate->es_crosscheck_snapshot,
true /* wait for commit */ ,
&hufd);
/*
* Copy the necessary information, if the caller has asked for it. We
* must do this irrespective of whether the tuple was updated or
* deleted.
*/
if (hufdp)
*hufdp = hufd;
&hufd, &lockmode);
switch (result)
{
case HeapTupleSelfUpdated:
@ -1338,42 +1223,26 @@ lreplace:;
ereport(ERROR,
(errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
errmsg("could not serialize access due to concurrent update")));
if (!ItemPointerEquals(tupleid, &hufd.ctid))
{
TupleTableSlot *epqslot;
/*
* If we're executing MERGE, then the onus of running
* EvalPlanQual() and handling its outcome lies with the
* caller.
*/
if (actionState != NULL)
return NULL;
/* Regular UPDATE path. */
epqslot = EvalPlanQual(estate,
epqstate,
resultRelationDesc,
GetEPQRangeTableIndex(resultRelInfo),
hufd.lockmode,
resultRelInfo->ri_RangeTableIndex,
lockmode,
&hufd.ctid,
hufd.xmax);
if (!TupIsNull(epqslot))
{
*tupleid = hufd.ctid;
/* Normal UPDATE path */
slot = ExecFilterJunk(resultRelInfo->ri_junkFilter, epqslot);
tuple = ExecMaterializeSlot(slot);
goto lreplace;
}
}
/*
* tuple already deleted; nothing to do. But MERGE might want
* to handle it differently. We've already filled-in hufdp
* with sufficient information for MERGE to look at.
*/
/* tuple already deleted; nothing to do */
return NULL;
default:
@ -1402,9 +1271,6 @@ lreplace:;
estate, false, NULL, NIL);
}
if (tuple_updated)
*tuple_updated = true;
if (canSetTag)
(estate->es_processed)++;
@ -1499,9 +1365,9 @@ ExecOnConflictUpdate(ModifyTableState *mtstate,
* there's no historical behavior to break.
*
* It is the user's responsibility to prevent this situation from
* occurring. These problems are why SQL Standard similarly
* specifies that for SQL MERGE, an exception must be raised in
* the event of an attempt to update the same row twice.
* occurring. These problems are why SQL-2003 similarly specifies
* that for SQL MERGE, an exception must be raised in the event of
* an attempt to update the same row twice.
*/
if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetXmin(tuple.t_data)))
ereport(ERROR,
@ -1623,7 +1489,7 @@ ExecOnConflictUpdate(ModifyTableState *mtstate,
*returning = ExecUpdate(mtstate, &tuple.t_self, NULL,
mtstate->mt_conflproj, planSlot,
&mtstate->mt_epqstate, mtstate->ps.state,
NULL, NULL, NULL, canSetTag);
canSetTag);
ReleaseBuffer(buffer);
return true;
@ -1661,14 +1527,6 @@ fireBSTriggers(ModifyTableState *node)
case CMD_DELETE:
ExecBSDeleteTriggers(node->ps.state, resultRelInfo);
break;
case CMD_MERGE:
if (node->mt_merge_subcommands & MERGE_INSERT)
ExecBSInsertTriggers(node->ps.state, resultRelInfo);
if (node->mt_merge_subcommands & MERGE_UPDATE)
ExecBSUpdateTriggers(node->ps.state, resultRelInfo);
if (node->mt_merge_subcommands & MERGE_DELETE)
ExecBSDeleteTriggers(node->ps.state, resultRelInfo);
break;
default:
elog(ERROR, "unknown operation");
break;
@ -1724,17 +1582,6 @@ fireASTriggers(ModifyTableState *node)
ExecASDeleteTriggers(node->ps.state, resultRelInfo,
node->mt_transition_capture);
break;
case CMD_MERGE:
if (node->mt_merge_subcommands & MERGE_DELETE)
ExecASDeleteTriggers(node->ps.state, resultRelInfo,
node->mt_transition_capture);
if (node->mt_merge_subcommands & MERGE_UPDATE)
ExecASUpdateTriggers(node->ps.state, resultRelInfo,
node->mt_transition_capture);
if (node->mt_merge_subcommands & MERGE_INSERT)
ExecASInsertTriggers(node->ps.state, resultRelInfo,
node->mt_transition_capture);
break;
default:
elog(ERROR, "unknown operation");
break;
@ -1797,7 +1644,7 @@ ExecSetupTransitionCaptureState(ModifyTableState *mtstate, EState *estate)
*
* Returns a slot holding the tuple of the partition rowtype.
*/
TupleTableSlot *
static TupleTableSlot *
ExecPrepareTupleRouting(ModifyTableState *mtstate,
EState *estate,
PartitionTupleRouting *proute,
@ -2120,7 +1967,6 @@ ExecModifyTable(PlanState *pstate)
{
/* advance to next subplan if any */
node->mt_whichplan++;
if (node->mt_whichplan < node->mt_nplans)
{
resultRelInfo++;
@ -2169,12 +2015,6 @@ ExecModifyTable(PlanState *pstate)
EvalPlanQualSetSlot(&node->mt_epqstate, planSlot);
slot = planSlot;
if (operation == CMD_MERGE)
{
ExecMerge(node, estate, slot, junkfilter, resultRelInfo);
continue;
}
tupleid = NULL;
oldtuple = NULL;
if (junkfilter != NULL)
@ -2256,20 +2096,19 @@ ExecModifyTable(PlanState *pstate)
slot = ExecPrepareTupleRouting(node, estate, proute,
resultRelInfo, slot);
slot = ExecInsert(node, slot, planSlot,
estate, NULL, node->canSetTag);
estate, node->canSetTag);
/* Revert ExecPrepareTupleRouting's state change. */
if (proute)
estate->es_result_relation_info = resultRelInfo;
break;
case CMD_UPDATE:
slot = ExecUpdate(node, tupleid, oldtuple, slot, planSlot,
&node->mt_epqstate, estate,
NULL, NULL, NULL, node->canSetTag);
&node->mt_epqstate, estate, node->canSetTag);
break;
case CMD_DELETE:
slot = ExecDelete(node, tupleid, oldtuple, planSlot,
&node->mt_epqstate, estate,
NULL, true, NULL, NULL, node->canSetTag);
NULL, true, node->canSetTag);
break;
default:
elog(ERROR, "unknown operation");
@ -2359,16 +2198,6 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
saved_resultRelInfo = estate->es_result_relation_info;
resultRelInfo = mtstate->resultRelInfo;
/*
* mergeTargetRelation must be set if we're running MERGE and mustn't be
* set if we're not.
*/
Assert(operation != CMD_MERGE || node->mergeTargetRelation > 0);
Assert(operation == CMD_MERGE || node->mergeTargetRelation == 0);
resultRelInfo->ri_mergeTargetRTI = node->mergeTargetRelation;
i = 0;
foreach(l, node->plans)
{
@ -2447,8 +2276,7 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
* partition key.
*/
if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
(operation == CMD_INSERT || operation == CMD_MERGE ||
update_tuple_routing_needed))
(operation == CMD_INSERT || update_tuple_routing_needed))
mtstate->mt_partition_tuple_routing =
ExecSetupPartitionTupleRouting(mtstate, rel);
@ -2459,15 +2287,6 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
if (!(eflags & EXEC_FLAG_EXPLAIN_ONLY))
ExecSetupTransitionCaptureState(mtstate, estate);
/*
* If we are doing MERGE then setup child-parent mapping. This will be
* required in case we end up doing a partition-key update, triggering a
* tuple routing.
*/
if (mtstate->operation == CMD_MERGE &&
mtstate->mt_partition_tuple_routing != NULL)
ExecSetupChildParentMapForLeaf(mtstate->mt_partition_tuple_routing);
/*
* Construct mapping from each of the per-subplan partition attnos to the
* root attno. This is required when during update row movement the tuple
@ -2659,106 +2478,6 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
}
}
resultRelInfo = mtstate->resultRelInfo;
if (node->mergeActionList)
{
ListCell *l;
ExprContext *econtext;
List *mergeMatchedActionStates = NIL;
List *mergeNotMatchedActionStates = NIL;
TupleDesc relationDesc = resultRelInfo->ri_RelationDesc->rd_att;
mtstate->mt_merge_subcommands = 0;
if (mtstate->ps.ps_ExprContext == NULL)
ExecAssignExprContext(estate, &mtstate->ps);
econtext = mtstate->ps.ps_ExprContext;
/* initialize slot for the existing tuple */
Assert(mtstate->mt_existing == NULL);
mtstate->mt_existing =
ExecInitExtraTupleSlot(mtstate->ps.state,
mtstate->mt_partition_tuple_routing ?
NULL : relationDesc);
/* initialize slot for merge actions */
Assert(mtstate->mt_mergeproj == NULL);
mtstate->mt_mergeproj =
ExecInitExtraTupleSlot(mtstate->ps.state,
mtstate->mt_partition_tuple_routing ?
NULL : relationDesc);
/*
* Create a MergeActionState for each action on the mergeActionList
* and add it to either a list of matched actions or not-matched
* actions.
*/
foreach(l, node->mergeActionList)
{
MergeAction *action = (MergeAction *) lfirst(l);
MergeActionState *action_state = makeNode(MergeActionState);
TupleDesc tupDesc;
action_state->matched = action->matched;
action_state->commandType = action->commandType;
action_state->whenqual = ExecInitQual((List *) action->qual,
&mtstate->ps);
/* create target slot for this action's projection */
tupDesc = ExecTypeFromTL((List *) action->targetList,
resultRelInfo->ri_RelationDesc->rd_rel->relhasoids);
action_state->tupDesc = tupDesc;
/* build action projection state */
action_state->proj =
ExecBuildProjectionInfo(action->targetList, econtext,
mtstate->mt_mergeproj, &mtstate->ps,
resultRelInfo->ri_RelationDesc->rd_att);
/*
* We create two lists - one for WHEN MATCHED actions and one
* for WHEN NOT MATCHED actions - and stick the
* MergeActionState into the appropriate list.
*/
if (action_state->matched)
mergeMatchedActionStates =
lappend(mergeMatchedActionStates, action_state);
else
mergeNotMatchedActionStates =
lappend(mergeNotMatchedActionStates, action_state);
switch (action->commandType)
{
case CMD_INSERT:
ExecCheckPlanOutput(resultRelInfo->ri_RelationDesc,
action->targetList);
mtstate->mt_merge_subcommands |= MERGE_INSERT;
break;
case CMD_UPDATE:
ExecCheckPlanOutput(resultRelInfo->ri_RelationDesc,
action->targetList);
mtstate->mt_merge_subcommands |= MERGE_UPDATE;
break;
case CMD_DELETE:
mtstate->mt_merge_subcommands |= MERGE_DELETE;
break;
case CMD_NOTHING:
break;
default:
elog(ERROR, "unknown operation");
break;
}
resultRelInfo->ri_mergeState->matchedActionStates =
mergeMatchedActionStates;
resultRelInfo->ri_mergeState->notMatchedActionStates =
mergeNotMatchedActionStates;
}
}
/* select first subplan */
mtstate->mt_whichplan = 0;
subplan = (Plan *) linitial(node->plans);
@ -2772,7 +2491,7 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
* --- no need to look first. Typically, this will be a 'ctid' or
* 'wholerow' attribute, but in the case of a foreign data wrapper it
* might be a set of junk attributes sufficient to identify the remote
* row. We follow this logic for MERGE, so it always has a junk attributes.
* row.
*
* If there are multiple result relations, each one needs its own junk
* filter. Note multiple rels are only possible for UPDATE/DELETE, so we
@ -2800,7 +2519,6 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
break;
case CMD_UPDATE:
case CMD_DELETE:
case CMD_MERGE:
junk_filter_needed = true;
break;
default:
@ -2816,7 +2534,6 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
JunkFilter *j;
subplan = mtstate->mt_plans[i]->plan;
if (operation == CMD_INSERT || operation == CMD_UPDATE)
ExecCheckPlanOutput(resultRelInfo->ri_RelationDesc,
subplan->targetlist);
@ -2825,9 +2542,7 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
resultRelInfo->ri_RelationDesc->rd_att->tdhasoid,
ExecInitExtraTupleSlot(estate, NULL));
if (operation == CMD_UPDATE ||
operation == CMD_DELETE ||
operation == CMD_MERGE)
if (operation == CMD_UPDATE || operation == CMD_DELETE)
{
/* For UPDATE/DELETE, find the appropriate junk attr now */
char relkind;
@ -2840,15 +2555,6 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
j->jf_junkAttNo = ExecFindJunkAttribute(j, "ctid");
if (!AttributeNumberIsValid(j->jf_junkAttNo))
elog(ERROR, "could not find junk ctid column");
if (operation == CMD_MERGE &&
relkind == RELKIND_PARTITIONED_TABLE)
{
j->jf_otherJunkAttNo = ExecFindJunkAttribute(j, "tableoid");
if (!AttributeNumberIsValid(j->jf_otherJunkAttNo))
elog(ERROR, "could not find junk tableoid column");
}
}
else if (relkind == RELKIND_FOREIGN_TABLE)
{

3
src/backend/executor/spi.c
View File

@ -2420,9 +2420,6 @@ _SPI_pquery(QueryDesc *queryDesc, bool fire_triggers, uint64 tcount)
else
res = SPI_OK_UPDATE;
break;
case CMD_MERGE:
res = SPI_OK_MERGE;
break;
default:
return SPI_ERROR_OPUNKNOWN;
}

40
src/backend/nodes/copyfuncs.c
View File

@ -207,7 +207,6 @@ _copyModifyTable(const ModifyTable *from)
COPY_NODE_FIELD(partitioned_rels);
COPY_SCALAR_FIELD(partColsUpdated);
COPY_NODE_FIELD(resultRelations);
COPY_SCALAR_FIELD(mergeTargetRelation);
COPY_SCALAR_FIELD(resultRelIndex);
COPY_SCALAR_FIELD(rootResultRelIndex);
COPY_NODE_FIELD(plans);
@ -223,8 +222,6 @@ _copyModifyTable(const ModifyTable *from)
COPY_NODE_FIELD(onConflictWhere);
COPY_SCALAR_FIELD(exclRelRTI);
COPY_NODE_FIELD(exclRelTlist);
COPY_NODE_FIELD(mergeSourceTargetList);
COPY_NODE_FIELD(mergeActionList);
return newnode;
}
@ -2980,9 +2977,6 @@ _copyQuery(const Query *from)
COPY_NODE_FIELD(setOperations);
COPY_NODE_FIELD(constraintDeps);
COPY_NODE_FIELD(withCheckOptions);
COPY_SCALAR_FIELD(mergeTarget_relation);
COPY_NODE_FIELD(mergeSourceTargetList);
COPY_NODE_FIELD(mergeActionList);
COPY_LOCATION_FIELD(stmt_location);
COPY_LOCATION_FIELD(stmt_len);
@ -3046,34 +3040,6 @@ _copyUpdateStmt(const UpdateStmt *from)
return newnode;
}
static MergeStmt *
_copyMergeStmt(const MergeStmt *from)
{
MergeStmt *newnode = makeNode(MergeStmt);
COPY_NODE_FIELD(relation);
COPY_NODE_FIELD(source_relation);
COPY_NODE_FIELD(join_condition);
COPY_NODE_FIELD(mergeActionList);
return newnode;
}
static MergeAction *
_copyMergeAction(const MergeAction *from)
{
MergeAction *newnode = makeNode(MergeAction);
COPY_SCALAR_FIELD(matched);
COPY_SCALAR_FIELD(commandType);
COPY_NODE_FIELD(condition);
COPY_NODE_FIELD(qual);
COPY_NODE_FIELD(stmt);
COPY_NODE_FIELD(targetList);
return newnode;
}
static SelectStmt *
_copySelectStmt(const SelectStmt *from)
{
@ -5136,12 +5102,6 @@ copyObjectImpl(const void *from)
case T_UpdateStmt:
retval = _copyUpdateStmt(from);
break;
case T_MergeStmt:
retval = _copyMergeStmt(from);
break;
case T_MergeAction:
retval = _copyMergeAction(from);
break;
case T_SelectStmt:
retval = _copySelectStmt(from);
break;

32
src/backend/nodes/equalfuncs.c
View File

@ -987,8 +987,6 @@ _equalQuery(const Query *a, const Query *b)
COMPARE_NODE_FIELD(setOperations);
COMPARE_NODE_FIELD(constraintDeps);
COMPARE_NODE_FIELD(withCheckOptions);
COMPARE_NODE_FIELD(mergeSourceTargetList);
COMPARE_NODE_FIELD(mergeActionList);
COMPARE_LOCATION_FIELD(stmt_location);
COMPARE_LOCATION_FIELD(stmt_len);
@ -1044,30 +1042,6 @@ _equalUpdateStmt(const UpdateStmt *a, const UpdateStmt *b)
return true;
}
static bool
_equalMergeStmt(const MergeStmt *a, const MergeStmt *b)
{
COMPARE_NODE_FIELD(relation);
COMPARE_NODE_FIELD(source_relation);
COMPARE_NODE_FIELD(join_condition);
COMPARE_NODE_FIELD(mergeActionList);
return true;
}
static bool
_equalMergeAction(const MergeAction *a, const MergeAction *b)
{
COMPARE_SCALAR_FIELD(matched);
COMPARE_SCALAR_FIELD(commandType);
COMPARE_NODE_FIELD(condition);
COMPARE_NODE_FIELD(qual);
COMPARE_NODE_FIELD(stmt);
COMPARE_NODE_FIELD(targetList);
return true;
}
static bool
_equalSelectStmt(const SelectStmt *a, const SelectStmt *b)
{
@ -3259,12 +3233,6 @@ equal(const void *a, const void *b)
case T_UpdateStmt:
retval = _equalUpdateStmt(a, b);
break;
case T_MergeStmt:
retval = _equalMergeStmt(a, b);
break;
case T_MergeAction:
retval = _equalMergeAction(a, b);
break;
case T_SelectStmt:
retval = _equalSelectStmt(a, b);
break;

48
src/backend/nodes/nodeFuncs.c
View File

@ -2146,16 +2146,6 @@ expression_tree_walker(Node *node,
return true;
}
break;
case T_MergeAction:
{
MergeAction *action = (MergeAction *) node;
if (walker(action->targetList, context))
return true;
if (walker(action->qual, context))
return true;
}
break;
case T_JoinExpr:
{
JoinExpr *join = (JoinExpr *) node;
@ -2265,10 +2255,6 @@ query_tree_walker(Query *query,
return true;
if (walker((Node *) query->onConflict, context))
return true;
if (walker((Node *) query->mergeSourceTargetList, context))
return true;
if (walker((Node *) query->mergeActionList, context))
return true;
if (walker((Node *) query->returningList, context))
return true;
if (walker((Node *) query->jointree, context))
@ -2946,18 +2932,6 @@ expression_tree_mutator(Node *node,
return (Node *) newnode;
}
break;
case T_MergeAction:
{
MergeAction *action = (MergeAction *) node;
MergeAction *newnode;
FLATCOPY(newnode, action, MergeAction);
MUTATE(newnode->qual, action->qual, Node *);
MUTATE(newnode->targetList, action->targetList, List *);
return (Node *) newnode;
}
break;
case T_JoinExpr:
{
JoinExpr *join = (JoinExpr *) node;
@ -3109,8 +3083,6 @@ query_tree_mutator(Query *query,
MUTATE(query->targetList, query->targetList, List *);
MUTATE(query->withCheckOptions, query->withCheckOptions, List *);
MUTATE(query->onConflict, query->onConflict, OnConflictExpr *);
MUTATE(query->mergeSourceTargetList, query->mergeSourceTargetList, List *);
MUTATE(query->mergeActionList, query->mergeActionList, List *);
MUTATE(query->returningList, query->returningList, List *);
MUTATE(query->jointree, query->jointree, FromExpr *);
MUTATE(query->setOperations, query->setOperations, Node *);
@ -3252,9 +3224,9 @@ query_or_expression_tree_mutator(Node *node,
* boundaries: we descend to everything that's possibly interesting.
*
* Currently, the node type coverage here extends only to DML statements
* (SELECT/INSERT/UPDATE/DELETE/MERGE) and nodes that can appear in them,
* because this is used mainly during analysis of CTEs, and only DML
* statements can appear in CTEs.
* (SELECT/INSERT/UPDATE/DELETE) and nodes that can appear in them, because
* this is used mainly during analysis of CTEs, and only DML statements can
* appear in CTEs.
*/
bool
raw_expression_tree_walker(Node *node,
@ -3434,20 +3406,6 @@ raw_expression_tree_walker(Node *node,
return true;
}
break;
case T_MergeStmt:
{
MergeStmt *stmt = (MergeStmt *) node;
if (walker(stmt->relation, context))
return true;
if (walker(stmt->source_relation, context))
return true;
if (walker(stmt->join_condition, context))
return true;
if (walker(stmt->mergeActionList, context))
return true;
}
break;
case T_SelectStmt:
{
SelectStmt *stmt = (SelectStmt *) node;

25
src/backend/nodes/outfuncs.c
View File

@ -375,7 +375,6 @@ _outModifyTable(StringInfo str, const ModifyTable *node)
WRITE_NODE_FIELD(partitioned_rels);
WRITE_BOOL_FIELD(partColsUpdated);
WRITE_NODE_FIELD(resultRelations);
WRITE_INT_FIELD(mergeTargetRelation);
WRITE_INT_FIELD(resultRelIndex);
WRITE_INT_FIELD(rootResultRelIndex);
WRITE_NODE_FIELD(plans);
@ -391,21 +390,6 @@ _outModifyTable(StringInfo str, const ModifyTable *node)
WRITE_NODE_FIELD(onConflictWhere);
WRITE_UINT_FIELD(exclRelRTI);
WRITE_NODE_FIELD(exclRelTlist);
WRITE_NODE_FIELD(mergeSourceTargetList);
WRITE_NODE_FIELD(mergeActionList);
}
static void
_outMergeAction(StringInfo str, const MergeAction *node)
{
WRITE_NODE_TYPE("MERGEACTION");
WRITE_BOOL_FIELD(matched);
WRITE_ENUM_FIELD(commandType, CmdType);
WRITE_NODE_FIELD(condition);
WRITE_NODE_FIELD(qual);
/* We don't dump the stmt node */
WRITE_NODE_FIELD(targetList);
}
static void
@ -2130,7 +2114,6 @@ _outModifyTablePath(StringInfo str, const ModifyTablePath *node)
WRITE_NODE_FIELD(partitioned_rels);
WRITE_BOOL_FIELD(partColsUpdated);
WRITE_NODE_FIELD(resultRelations);
WRITE_INT_FIELD(mergeTargetRelation);
WRITE_NODE_FIELD(subpaths);
WRITE_NODE_FIELD(subroots);
WRITE_NODE_FIELD(withCheckOptionLists);
@ -2138,8 +2121,6 @@ _outModifyTablePath(StringInfo str, const ModifyTablePath *node)
WRITE_NODE_FIELD(rowMarks);
WRITE_NODE_FIELD(onconflict);
WRITE_INT_FIELD(epqParam);
WRITE_NODE_FIELD(mergeSourceTargetList);
WRITE_NODE_FIELD(mergeActionList);
}
static void
@ -2961,9 +2942,6 @@ _outQuery(StringInfo str, const Query *node)
WRITE_NODE_FIELD(setOperations);
WRITE_NODE_FIELD(constraintDeps);
/* withCheckOptions intentionally omitted, see comment in parsenodes.h */
WRITE_INT_FIELD(mergeTarget_relation);
WRITE_NODE_FIELD(mergeSourceTargetList);
WRITE_NODE_FIELD(mergeActionList);
WRITE_LOCATION_FIELD(stmt_location);
WRITE_LOCATION_FIELD(stmt_len);
}
@ -3679,9 +3657,6 @@ outNode(StringInfo str, const void *obj)
case T_ModifyTable:
_outModifyTable(str, obj);
break;
case T_MergeAction:
_outMergeAction(str, obj);
break;
case T_Append:
_outAppend(str, obj);
break;

6
src/backend/nodes/readfuncs.c
View File

@ -270,9 +270,6 @@ _readQuery(void)
READ_NODE_FIELD(setOperations);
READ_NODE_FIELD(constraintDeps);
/* withCheckOptions intentionally omitted, see comment in parsenodes.h */
READ_INT_FIELD(mergeTarget_relation);
READ_NODE_FIELD(mergeSourceTargetList);
READ_NODE_FIELD(mergeActionList);
READ_LOCATION_FIELD(stmt_location);
READ_LOCATION_FIELD(stmt_len);
@ -1579,7 +1576,6 @@ _readModifyTable(void)
READ_NODE_FIELD(partitioned_rels);
READ_BOOL_FIELD(partColsUpdated);
READ_NODE_FIELD(resultRelations);
READ_INT_FIELD(mergeTargetRelation);
READ_INT_FIELD(resultRelIndex);
READ_INT_FIELD(rootResultRelIndex);
READ_NODE_FIELD(plans);
@ -1595,8 +1591,6 @@ _readModifyTable(void)
READ_NODE_FIELD(onConflictWhere);
READ_UINT_FIELD(exclRelRTI);
READ_NODE_FIELD(exclRelTlist);
READ_NODE_FIELD(mergeSourceTargetList);
READ_NODE_FIELD(mergeActionList);
READ_DONE();
}

22
src/backend/optimizer/plan/createplan.c
View File

@ -288,13 +288,9 @@ static ModifyTable *make_modifytable(PlannerInfo *root,
CmdType operation, bool canSetTag,
Index nominalRelation, List *partitioned_rels,
bool partColsUpdated,
List *resultRelations,
Index mergeTargetRelation,
List *subplans,
List *resultRelations, List *subplans,
List *withCheckOptionLists, List *returningLists,
List *rowMarks, OnConflictExpr *onconflict,
List *mergeSourceTargetList,
List *mergeActionList, int epqParam);
List *rowMarks, OnConflictExpr *onconflict, int epqParam);
static GatherMerge *create_gather_merge_plan(PlannerInfo *root,
GatherMergePath *best_path);
@ -2450,14 +2446,11 @@ create_modifytable_plan(PlannerInfo *root, ModifyTablePath *best_path)
best_path->partitioned_rels,
best_path->partColsUpdated,
best_path->resultRelations,
best_path->mergeTargetRelation,
subplans,
best_path->withCheckOptionLists,
best_path->returningLists,
best_path->rowMarks,
best_path->onconflict,
best_path->mergeSourceTargetList,
best_path->mergeActionList,
best_path->epqParam);
copy_generic_path_info(&plan->plan, &best_path->path);
@ -6524,13 +6517,9 @@ make_modifytable(PlannerInfo *root,
CmdType operation, bool canSetTag,
Index nominalRelation, List *partitioned_rels,
bool partColsUpdated,
List *resultRelations,
Index mergeTargetRelation,
List *subplans,
List *resultRelations, List *subplans,
List *withCheckOptionLists, List *returningLists,
List *rowMarks, OnConflictExpr *onconflict,
List *mergeSourceTargetList,
List *mergeActionList, int epqParam)
List *rowMarks, OnConflictExpr *onconflict, int epqParam)
{
ModifyTable *node = makeNode(ModifyTable);
List *fdw_private_list;
@ -6556,7 +6545,6 @@ make_modifytable(PlannerInfo *root,
node->partitioned_rels = partitioned_rels;
node->partColsUpdated = partColsUpdated;
node->resultRelations = resultRelations;
node->mergeTargetRelation = mergeTargetRelation;
node->resultRelIndex = -1; /* will be set correctly in setrefs.c */
node->rootResultRelIndex = -1; /* will be set correctly in setrefs.c */
node->plans = subplans;
@ -6589,8 +6577,6 @@ make_modifytable(PlannerInfo *root,
node->withCheckOptionLists = withCheckOptionLists;
node->returningLists = returningLists;
node->rowMarks = rowMarks;
node->mergeSourceTargetList = mergeSourceTargetList;
node->mergeActionList = mergeActionList;
node->epqParam = epqParam;
/*

29
src/backend/optimizer/plan/planner.c
View File

@ -794,24 +794,6 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
/* exclRelTlist contains only Vars, so no preprocessing needed */
}
foreach(l, parse->mergeActionList)
{
MergeAction *action = (MergeAction *) lfirst(l);
action->targetList = (List *)
preprocess_expression(root,
(Node *) action->targetList,
EXPRKIND_TARGET);
action->qual =
preprocess_expression(root,
(Node *) action->qual,
EXPRKIND_QUAL);
}
parse->mergeSourceTargetList = (List *)
preprocess_expression(root, (Node *) parse->mergeSourceTargetList,
EXPRKIND_TARGET);
root->append_rel_list = (List *)
preprocess_expression(root, (Node *) root->append_rel_list,
EXPRKIND_APPINFO);
@ -1553,7 +1535,6 @@ inheritance_planner(PlannerInfo *root)
subroot->parse->returningList);
Assert(!parse->onConflict);
Assert(parse->mergeActionList == NIL);
}
/* Result path must go into outer query's FINAL upperrel */
@ -1612,15 +1593,12 @@ inheritance_planner(PlannerInfo *root)
partitioned_rels,
partColsUpdated,
resultRelations,
0,
subpaths,
subroots,
withCheckOptionLists,
returningLists,
rowMarks,
NULL,
NULL,
NULL,
SS_assign_special_param(root)));
}
@ -2151,8 +2129,8 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
}
/*
* If this is an INSERT/UPDATE/DELETE/MERGE, and we're not being
* called from inheritance_planner, add the ModifyTable node.
* If this is an INSERT/UPDATE/DELETE, and we're not being called from
* inheritance_planner, add the ModifyTable node.
*/
if (parse->commandType != CMD_SELECT && !inheritance_update)
{
@ -2192,15 +2170,12 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
NIL,
false,
list_make1_int(parse->resultRelation),
parse->mergeTarget_relation,
list_make1(path),
list_make1(root),
withCheckOptionLists,
returningLists,
rowMarks,
parse->onConflict,
parse->mergeSourceTargetList,
parse->mergeActionList,
SS_assign_special_param(root));
}

54
src/backend/optimizer/plan/setrefs.c
View File

@ -851,60 +851,6 @@ set_plan_refs(PlannerInfo *root, Plan *plan, int rtoffset)
fix_scan_list(root, splan->exclRelTlist, rtoffset);
}
/*
* The MERGE produces the target rows by performing a right
* join between the target relation and the source relation
* (which could be a plain relation or a subquery). The INSERT
* and UPDATE actions of the MERGE requires access to the
* columns from the source relation. We arrange things so that
* the source relation attributes are available as INNER_VAR
* and the target relation attributes are available from the
* scan tuple.
*/
if (splan->mergeActionList != NIL)
{
/*
* mergeSourceTargetList is already setup correctly to
* include all Vars coming from the source relation. So we
* fix the targetList of individual action nodes by
* ensuring that the source relation Vars are referenced
* as INNER_VAR. Note that for this to work correctly,
* during execution, the ecxt_innertuple must be set to
* the tuple obtained from the source relation.
*
* We leave the Vars from the result relation (i.e. the
* target relation) unchanged i.e. those Vars would be
* picked from the scan slot. So during execution, we must
* ensure that ecxt_scantuple is setup correctly to refer
* to the tuple from the target relation.
*/
indexed_tlist *itlist;
itlist = build_tlist_index(splan->mergeSourceTargetList);
splan->mergeTargetRelation += rtoffset;
foreach(l, splan->mergeActionList)
{
MergeAction *action = (MergeAction *) lfirst(l);
/* Fix targetList of each action. */
action->targetList = fix_join_expr(root,
action->targetList,
NULL, itlist,
linitial_int(splan->resultRelations),
rtoffset);
/* Fix quals too. */
action->qual = (Node *) fix_join_expr(root,
(List *) action->qual,
NULL, itlist,
linitial_int(splan->resultRelations),
rtoffset);
}
}
splan->nominalRelation += rtoffset;
splan->exclRelRTI += rtoffset;

41
src/backend/optimizer/prep/preptlist.c
View File

@ -118,46 +118,6 @@ preprocess_targetlist(PlannerInfo *root)
tlist = expand_targetlist(tlist, command_type,
result_relation, target_relation);
if (command_type == CMD_MERGE)
{
ListCell *l;
/*
* For MERGE, add any junk column(s) needed to allow the executor to
* identify the rows to be updated or deleted, with different
* handling for partitioned tables.
*/
rewriteTargetListMerge(parse, target_relation);
/*
* For MERGE command, handle targetlist of each MergeAction separately.
* Give the same treatment to MergeAction->targetList as we would have
* given to a regular INSERT/UPDATE/DELETE.
*/
foreach(l, parse->mergeActionList)
{
MergeAction *action = (MergeAction *) lfirst(l);
switch (action->commandType)
{
case CMD_INSERT:
case CMD_UPDATE:
action->targetList = expand_targetlist(action->targetList,
action->commandType,
result_relation,
target_relation);
break;
case CMD_DELETE:
break;
case CMD_NOTHING:
break;
default:
elog(ERROR, "unknown action in MERGE WHEN clause");
}
}
}
/*
* Add necessary junk columns for rowmarked rels. These values are needed
* for locking of rels selected FOR UPDATE/SHARE, and to do EvalPlanQual
@ -388,7 +348,6 @@ expand_targetlist(List *tlist, int command_type,
true /* byval */ );
}
break;
case CMD_MERGE:
case CMD_UPDATE:
if (!att_tup->attisdropped)
{

11
src/backend/optimizer/util/pathnode.c
View File

@ -3284,21 +3284,17 @@ create_lockrows_path(PlannerInfo *root, RelOptInfo *rel,
* 'rowMarks' is a list of PlanRowMarks (non-locking only)
* 'onconflict' is the ON CONFLICT clause, or NULL
* 'epqParam' is the ID of Param for EvalPlanQual re-eval
* 'mergeActionList' is a list of MERGE actions
*/
ModifyTablePath *
create_modifytable_path(PlannerInfo *root, RelOptInfo *rel,
CmdType operation, bool canSetTag,
Index nominalRelation, List *partitioned_rels,
bool partColsUpdated,
List *resultRelations,
Index mergeTargetRelation,
List *subpaths,
List *resultRelations, List *subpaths,
List *subroots,
List *withCheckOptionLists, List *returningLists,
List *rowMarks, OnConflictExpr *onconflict,
List *mergeSourceTargetList,
List *mergeActionList, int epqParam)
int epqParam)
{
ModifyTablePath *pathnode = makeNode(ModifyTablePath);
double total_size;
@ -3363,7 +3359,6 @@ create_modifytable_path(PlannerInfo *root, RelOptInfo *rel,
pathnode->partitioned_rels = list_copy(partitioned_rels);
pathnode->partColsUpdated = partColsUpdated;
pathnode->resultRelations = resultRelations;
pathnode->mergeTargetRelation = mergeTargetRelation;
pathnode->subpaths = subpaths;
pathnode->subroots = subroots;
pathnode->withCheckOptionLists = withCheckOptionLists;
@ -3371,8 +3366,6 @@ create_modifytable_path(PlannerInfo *root, RelOptInfo *rel,
pathnode->rowMarks = rowMarks;
pathnode->onconflict = onconflict;
pathnode->epqParam = epqParam;
pathnode->mergeSourceTargetList = mergeSourceTargetList;
pathnode->mergeActionList = mergeActionList;
return pathnode;
}

4
src/backend/optimizer/util/plancat.c
View File

@ -1835,10 +1835,6 @@ has_row_triggers(PlannerInfo *root, Index rti, CmdType event)
trigDesc->trig_delete_before_row))
result = true;
break;
/* There is no separate event for MERGE, only INSERT/UPDATE/DELETE */
case CMD_MERGE:
result = false;
break;
default:
elog(ERROR, "unrecognized CmdType: %d", (int) event);
break;

2
src/backend/parser/Makefile
View File

@ -14,7 +14,7 @@ override CPPFLAGS := -I. -I$(srcdir) $(CPPFLAGS)
OBJS= analyze.o gram.o scan.o parser.o \
parse_agg.o parse_clause.o parse_coerce.o parse_collate.o parse_cte.o \
parse_enr.o parse_expr.o parse_func.o parse_merge.o parse_node.o parse_oper.o \
parse_enr.o parse_expr.o parse_func.o parse_node.o parse_oper.o \
parse_param.o parse_relation.o parse_target.o parse_type.o \
parse_utilcmd.o scansup.o

18
src/backend/parser/analyze.c
View File

@ -38,7 +38,6 @@
#include "parser/parse_cte.h"
#include "parser/parse_expr.h"
#include "parser/parse_func.h"
#include "parser/parse_merge.h"
#include "parser/parse_oper.h"
#include "parser/parse_param.h"
#include "parser/parse_relation.h"
@ -54,6 +53,9 @@ post_parse_analyze_hook_type post_parse_analyze_hook = NULL;
static Query *transformOptionalSelectInto(ParseState *pstate, Node *parseTree);
static Query *transformDeleteStmt(ParseState *pstate, DeleteStmt *stmt);
static Query *transformInsertStmt(ParseState *pstate, InsertStmt *stmt);
static List *transformInsertRow(ParseState *pstate, List *exprlist,
List *stmtcols, List *icolumns, List *attrnos,
bool strip_indirection);
static OnConflictExpr *transformOnConflictClause(ParseState *pstate,
OnConflictClause *onConflictClause);
static int count_rowexpr_columns(ParseState *pstate, Node *expr);
@ -66,6 +68,8 @@ static void determineRecursiveColTypes(ParseState *pstate,
Node *larg, List *nrtargetlist);
static Query *transformUpdateStmt(ParseState *pstate, UpdateStmt *stmt);
static List *transformReturningList(ParseState *pstate, List *returningList);
static List *transformUpdateTargetList(ParseState *pstate,
List *targetList);
static Query *transformDeclareCursorStmt(ParseState *pstate,
DeclareCursorStmt *stmt);
static Query *transformExplainStmt(ParseState *pstate,
@ -263,7 +267,6 @@ transformStmt(ParseState *pstate, Node *parseTree)
case T_InsertStmt:
case T_UpdateStmt:
case T_DeleteStmt:
case T_MergeStmt:
(void) test_raw_expression_coverage(parseTree, NULL);
break;
default:
@ -288,10 +291,6 @@ transformStmt(ParseState *pstate, Node *parseTree)
result = transformUpdateStmt(pstate, (UpdateStmt *) parseTree);
break;
case T_MergeStmt:
result = transformMergeStmt(pstate, (MergeStmt *) parseTree);
break;
case T_SelectStmt:
{
SelectStmt *n = (SelectStmt *) parseTree;
@ -367,7 +366,6 @@ analyze_requires_snapshot(RawStmt *parseTree)
case T_InsertStmt:
case T_DeleteStmt:
case T_UpdateStmt:
case T_MergeStmt:
case T_SelectStmt:
result = true;
break;
@ -898,7 +896,7 @@ transformInsertStmt(ParseState *pstate, InsertStmt *stmt)
* attrnos: integer column numbers (must be same length as icolumns)
* strip_indirection: if true, remove any field/array assignment nodes
*/
List *
static List *
transformInsertRow(ParseState *pstate, List *exprlist,
List *stmtcols, List *icolumns, List *attrnos,
bool strip_indirection)
@ -2262,9 +2260,9 @@ transformUpdateStmt(ParseState *pstate, UpdateStmt *stmt)
/*
* transformUpdateTargetList -
* handle SET clause in UPDATE/MERGE/INSERT ... ON CONFLICT UPDATE
* handle SET clause in UPDATE/INSERT ... ON CONFLICT UPDATE
*/
List *
static List *
transformUpdateTargetList(ParseState *pstate, List *origTlist)
{
List *tlist = NIL;

158
src/backend/parser/gram.y
View File

@ -282,7 +282,6 @@ static Node *makeRecursiveViewSelect(char *relname, List *aliases, Node *query);
CreateMatViewStmt RefreshMatViewStmt CreateAmStmt
CreatePublicationStmt AlterPublicationStmt
CreateSubscriptionStmt AlterSubscriptionStmt DropSubscriptionStmt
MergeStmt
%type <node> select_no_parens select_with_parens select_clause
simple_select values_clause
@ -585,10 +584,6 @@ static Node *makeRecursiveViewSelect(char *relname, List *aliases, Node *query);
%type <list> hash_partbound partbound_datum_list range_datum_list
%type <defelt> hash_partbound_elem
%type <node> merge_when_clause opt_and_condition
%type <list> merge_when_list
%type <node> merge_update merge_delete merge_insert
/*
* Non-keyword token types. These are hard-wired into the "flex" lexer.
* They must be listed first so that their numeric codes do not depend on
@ -656,8 +651,7 @@ static Node *makeRecursiveViewSelect(char *relname, List *aliases, Node *query);
LEADING LEAKPROOF LEAST LEFT LEVEL LIKE LIMIT LISTEN LOAD LOCAL
LOCALTIME LOCALTIMESTAMP LOCATION LOCK_P LOCKED LOGGED
MAPPING MATCH MATCHED MATERIALIZED MAXVALUE MERGE METHOD
MINUTE_P MINVALUE MODE MONTH_P MOVE
MAPPING MATCH MATERIALIZED MAXVALUE METHOD MINUTE_P MINVALUE MODE MONTH_P MOVE
NAME_P NAMES NATIONAL NATURAL NCHAR NEW NEXT NO NONE
NOT NOTHING NOTIFY NOTNULL NOWAIT NULL_P NULLIF
@ -926,7 +920,6 @@ stmt :
| RefreshMatViewStmt
| LoadStmt
| LockStmt
| MergeStmt
| NotifyStmt
| PrepareStmt
| ReassignOwnedStmt
@ -10667,7 +10660,6 @@ ExplainableStmt:
| InsertStmt
| UpdateStmt
| DeleteStmt
| MergeStmt
| DeclareCursorStmt
| CreateAsStmt
| CreateMatViewStmt
@ -10730,7 +10722,6 @@ PreparableStmt:
| InsertStmt
| UpdateStmt
| DeleteStmt /* by default all are $$=$1 */
| MergeStmt
;
/*****************************************************************************
@ -11097,151 +11088,6 @@ set_target_list:
;
/*****************************************************************************
*
* QUERY:
* MERGE STATEMENTS
*
*****************************************************************************/
MergeStmt:
MERGE INTO relation_expr_opt_alias
USING table_ref
ON a_expr
merge_when_list
{
MergeStmt *m = makeNode(MergeStmt);
m->relation = $3;
m->source_relation = $5;
m->join_condition = $7;
m->mergeActionList = $8;
$$ = (Node *)m;
}
;
merge_when_list:
merge_when_clause { $$ = list_make1($1); }
| merge_when_list merge_when_clause { $$ = lappend($1,$2); }
;
merge_when_clause:
WHEN MATCHED opt_and_condition THEN merge_update
{
MergeAction *m = makeNode(MergeAction);
m->matched = true;
m->commandType = CMD_UPDATE;
m->condition = $3;
m->stmt = $5;
$$ = (Node *)m;
}
| WHEN MATCHED opt_and_condition THEN merge_delete
{
MergeAction *m = makeNode(MergeAction);
m->matched = true;
m->commandType = CMD_DELETE;
m->condition = $3;
m->stmt = $5;
$$ = (Node *)m;
}
| WHEN NOT MATCHED opt_and_condition THEN merge_insert
{
MergeAction *m = makeNode(MergeAction);
m->matched = false;
m->commandType = CMD_INSERT;
m->condition = $4;
m->stmt = $6;
$$ = (Node *)m;
}
| WHEN NOT MATCHED opt_and_condition THEN DO NOTHING
{
MergeAction *m = makeNode(MergeAction);
m->matched = false;
m->commandType = CMD_NOTHING;
m->condition = $4;
m->stmt = NULL;
$$ = (Node *)m;
}
;
opt_and_condition:
AND a_expr { $$ = $2; }
| { $$ = NULL; }
;
merge_delete:
DELETE_P
{
DeleteStmt *n = makeNode(DeleteStmt);
$$ = (Node *)n;
}
;
merge_update:
UPDATE SET set_clause_list
{
UpdateStmt *n = makeNode(UpdateStmt);
n->targetList = $3;
$$ = (Node *)n;
}
;
merge_insert:
INSERT values_clause
{
InsertStmt *n = makeNode(InsertStmt);
n->cols = NIL;
n->selectStmt = $2;
$$ = (Node *)n;
}
| INSERT OVERRIDING override_kind VALUE_P values_clause
{
InsertStmt *n = makeNode(InsertStmt);
n->cols = NIL;
n->override = $3;
n->selectStmt = $5;
$$ = (Node *)n;
}
| INSERT '(' insert_column_list ')' values_clause
{
InsertStmt *n = makeNode(InsertStmt);
n->cols = $3;
n->selectStmt = $5;
$$ = (Node *)n;
}
| INSERT '(' insert_column_list ')' OVERRIDING override_kind VALUE_P values_clause
{
InsertStmt *n = makeNode(InsertStmt);
n->cols = $3;
n->override = $6;
n->selectStmt = $8;
$$ = (Node *)n;
}
| INSERT DEFAULT VALUES
{
InsertStmt *n = makeNode(InsertStmt);
n->cols = NIL;
n->selectStmt = NULL;
$$ = (Node *)n;
}
;
/*****************************************************************************
*
* QUERY:
@ -15242,10 +15088,8 @@ unreserved_keyword:
| LOGGED
| MAPPING
| MATCH
| MATCHED
| MATERIALIZED
| MAXVALUE
| MERGE
| METHOD
| MINUTE_P
| MINVALUE

10
src/backend/parser/parse_agg.c
View File

@ -455,13 +455,6 @@ check_agglevels_and_constraints(ParseState *pstate, Node *expr)
case EXPR_KIND_VALUES_SINGLE:
errkind = true;
break;
case EXPR_KIND_MERGE_WHEN_AND:
if (isAgg)
err = _("aggregate functions are not allowed in WHEN AND conditions");
else
err = _("grouping operations are not allowed in WHEN AND conditions");
break;
case EXPR_KIND_CHECK_CONSTRAINT:
case EXPR_KIND_DOMAIN_CHECK:
if (isAgg)
@ -880,9 +873,6 @@ transformWindowFuncCall(ParseState *pstate, WindowFunc *wfunc,
case EXPR_KIND_VALUES_SINGLE:
errkind = true;
break;
case EXPR_KIND_MERGE_WHEN_AND:
err = _("window functions are not allowed in WHEN AND conditions");
break;
case EXPR_KIND_CHECK_CONSTRAINT:
case EXPR_KIND_DOMAIN_CHECK:
err = _("window functions are not allowed in check constraints");

45
src/backend/parser/parse_clause.c
View File

@ -76,6 +76,9 @@ static RangeTblEntry *transformRangeTableFunc(ParseState *pstate,
RangeTableFunc *t);
static TableSampleClause *transformRangeTableSample(ParseState *pstate,
RangeTableSample *rts);
static Node *transformFromClauseItem(ParseState *pstate, Node *n,
RangeTblEntry **top_rte, int *top_rti,
List **namespace);
static Node *buildMergedJoinVar(ParseState *pstate, JoinType jointype,
Var *l_colvar, Var *r_colvar);
static ParseNamespaceItem *makeNamespaceItem(RangeTblEntry *rte,
@ -136,7 +139,6 @@ transformFromClause(ParseState *pstate, List *frmList)
n = transformFromClauseItem(pstate, n,
&rte,
&rtindex,
NULL, NULL,
&namespace);
checkNameSpaceConflicts(pstate, pstate->p_namespace, namespace);
@ -1094,20 +1096,13 @@ getRTEForSpecialRelationTypes(ParseState *pstate, RangeVar *rv)
*
* *top_rti: receives the rangetable index of top_rte. (Ditto.)
*
* *right_rte: receives the RTE corresponding to the right side of the
* jointree. Only MERGE really needs to know about this and only MERGE passes a
* non-NULL pointer.
*
* *right_rti: receives the rangetable index of the right_rte.
*
* *namespace: receives a List of ParseNamespaceItems for the RTEs exposed
* as table/column names by this item. (The lateral_only flags in these items
* are indeterminate and should be explicitly set by the caller before use.)
*/
Node *
static Node *
transformFromClauseItem(ParseState *pstate, Node *n,
RangeTblEntry **top_rte, int *top_rti,
RangeTblEntry **right_rte, int *right_rti,
List **namespace)
{
if (IsA(n, RangeVar))
@ -1199,7 +1194,7 @@ transformFromClauseItem(ParseState *pstate, Node *n,
/* Recursively transform the contained relation */
rel = transformFromClauseItem(pstate, rts->relation,
top_rte, top_rti, NULL, NULL, namespace);
top_rte, top_rti, namespace);
/* Currently, grammar could only return a RangeVar as contained rel */
rtr = castNode(RangeTblRef, rel);
rte = rt_fetch(rtr->rtindex, pstate->p_rtable);
@ -1227,7 +1222,6 @@ transformFromClauseItem(ParseState *pstate, Node *n,
List *l_namespace,
*r_namespace,
*my_namespace,
*save_namespace,
*l_colnames,
*r_colnames,
*res_colnames,
@ -1246,7 +1240,6 @@ transformFromClauseItem(ParseState *pstate, Node *n,
j->larg = transformFromClauseItem(pstate, j->larg,
&l_rte,
&l_rtindex,
NULL, NULL,
&l_namespace);
/*
@ -1270,34 +1263,12 @@ transformFromClauseItem(ParseState *pstate, Node *n,
sv_namespace_length = list_length(pstate->p_namespace);
pstate->p_namespace = list_concat(pstate->p_namespace, l_namespace);
/*
* If we are running MERGE, don't make the other RTEs visible while
* parsing the source relation. It mustn't see them.
*
* Currently, only MERGE passes non-NULL value for right_rte, so we
* can safely deduce if we're running MERGE or not by just looking at
* the right_rte. If that ever changes, we should look at other means
* to find that.
*/
if (right_rte)
{
save_namespace = pstate->p_namespace;
pstate->p_namespace = NIL;
}
/* And now we can process the RHS */
j->rarg = transformFromClauseItem(pstate, j->rarg,
&r_rte,
&r_rtindex,
NULL, NULL,
&r_namespace);
/*
* And now restore the namespace again so that join-quals can see it.
*/
if (right_rte)
pstate->p_namespace = save_namespace;
/* Remove the left-side RTEs from the namespace list again */
pstate->p_namespace = list_truncate(pstate->p_namespace,
sv_namespace_length);
@ -1324,12 +1295,6 @@ transformFromClauseItem(ParseState *pstate, Node *n,
expandRTE(r_rte, r_rtindex, 0, -1, false,
&r_colnames, &r_colvars);
if (right_rte)
*right_rte = r_rte;
if (right_rti)
*right_rti = r_rtindex;
/*
* Natural join does not explicitly specify columns; must generate
* columns to join. Need to run through the list of columns from each

1
src/backend/parser/parse_collate.c
View File

@ -485,7 +485,6 @@ assign_collations_walker(Node *node, assign_collations_context *context)
case T_FromExpr:
case T_OnConflictExpr:
case T_SortGroupClause:
case T_MergeAction:
(void) expression_tree_walker(node,
assign_collations_walker,
(void *) &loccontext);

3
src/backend/parser/parse_expr.c
View File

@ -1818,7 +1818,6 @@ transformSubLink(ParseState *pstate, SubLink *sublink)
case EXPR_KIND_RETURNING:
case EXPR_KIND_VALUES:
case EXPR_KIND_VALUES_SINGLE:
case EXPR_KIND_MERGE_WHEN_AND:
/* okay */
break;
case EXPR_KIND_CHECK_CONSTRAINT:
@ -3476,8 +3475,6 @@ ParseExprKindName(ParseExprKind exprKind)
return "PARTITION BY";
case EXPR_KIND_CALL_ARGUMENT:
return "CALL";
case EXPR_KIND_MERGE_WHEN_AND:
return "MERGE WHEN AND";
/*
* There is intentionally no default: case here, so that the

3
src/backend/parser/parse_func.c
View File

@ -2277,9 +2277,6 @@ check_srf_call_placement(ParseState *pstate, Node *last_srf, int location)
/* okay, since we process this like a SELECT tlist */
pstate->p_hasTargetSRFs = true;
break;
case EXPR_KIND_MERGE_WHEN_AND:
err = _("set-returning functions are not allowed in WHEN AND conditions");
break;
case EXPR_KIND_CHECK_CONSTRAINT:
case EXPR_KIND_DOMAIN_CHECK:
err = _("set-returning functions are not allowed in check constraints");

10
src/backend/parser/parse_relation.c
View File

@ -728,16 +728,6 @@ scanRTEForColumn(ParseState *pstate, RangeTblEntry *rte, const char *colname,
colname),
parser_errposition(pstate, location)));
/* In MERGE WHEN AND condition, no system column is allowed except tableOid or OID */
if (pstate->p_expr_kind == EXPR_KIND_MERGE_WHEN_AND &&
attnum < InvalidAttrNumber &&
!(attnum == TableOidAttributeNumber || attnum == ObjectIdAttributeNumber))
ereport(ERROR,
(errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
errmsg("system column \"%s\" reference in WHEN AND condition is invalid",
colname),
parser_errposition(pstate, location)));
if (attnum != InvalidAttrNumber)
{
/* now check to see if column actually is defined */

117
src/backend/rewrite/rewriteHandler.c
View File

@ -1377,57 +1377,6 @@ rewriteTargetListUD(Query *parsetree, RangeTblEntry *target_rte,
}
}
void
rewriteTargetListMerge(Query *parsetree, Relation target_relation)
{
Var *var = NULL;
const char *attrname;
TargetEntry *tle;
Assert(target_relation->rd_rel->relkind == RELKIND_RELATION ||
target_relation->rd_rel->relkind == RELKIND_MATVIEW ||
target_relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
/*
* Emit CTID so that executor can find the row to update or delete.
*/
var = makeVar(parsetree->mergeTarget_relation,
SelfItemPointerAttributeNumber,
TIDOID,
-1,
InvalidOid,
0);
attrname = "ctid";
tle = makeTargetEntry((Expr *) var,
list_length(parsetree->targetList) + 1,
pstrdup(attrname),
true);
parsetree->targetList = lappend(parsetree->targetList, tle);
/*
* If we are dealing with partitioned table, then emit TABLEOID so that
* executor can find the partition the row belongs to.
*/
if (target_relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
{
var = makeVar(parsetree->mergeTarget_relation,
TableOidAttributeNumber,
OIDOID,
-1,
InvalidOid,
0);
attrname = "tableoid";
tle = makeTargetEntry((Expr *) var,
list_length(parsetree->targetList) + 1,
pstrdup(attrname),
true);
parsetree->targetList = lappend(parsetree->targetList, tle);
}
}
/*
* matchLocks -
@ -3382,7 +3331,6 @@ RewriteQuery(Query *parsetree, List *rewrite_events)
}
else if (event == CMD_UPDATE)
{
Assert(parsetree->override == OVERRIDING_NOT_SET);
parsetree->targetList =
rewriteTargetListIU(parsetree->targetList,
parsetree->commandType,
@ -3390,50 +3338,6 @@ RewriteQuery(Query *parsetree, List *rewrite_events)
rt_entry_relation,
parsetree->resultRelation, NULL);
}
else if (event == CMD_MERGE)
{
Assert(parsetree->override == OVERRIDING_NOT_SET);
/*
* Rewrite each action targetlist separately
*/
foreach(lc1, parsetree->mergeActionList)
{
MergeAction *action = (MergeAction *) lfirst(lc1);
switch (action->commandType)
{
case CMD_NOTHING:
case CMD_DELETE: /* Nothing to do here */
break;
case CMD_UPDATE:
action->targetList =
rewriteTargetListIU(action->targetList,
action->commandType,
parsetree->override,
rt_entry_relation,
parsetree->resultRelation,
NULL);
break;
case CMD_INSERT:
{
InsertStmt *istmt = (InsertStmt *) action->stmt;
action->targetList =
rewriteTargetListIU(action->targetList,
action->commandType,
istmt->override,
rt_entry_relation,
parsetree->resultRelation,
NULL);
}
break;
default:
elog(ERROR, "unrecognized commandType: %d", action->commandType);
break;
}
}
}
else if (event == CMD_DELETE)
{
/* Nothing to do here */
@ -3447,20 +3351,13 @@ RewriteQuery(Query *parsetree, List *rewrite_events)
locks = matchLocks(event, rt_entry_relation->rd_rules,
result_relation, parsetree, &hasUpdate);
/*
* XXX MERGE doesn't support write rules because they would violate
* the SQL Standard spec and would be unclear how they should work.
*/
if (event == CMD_MERGE)
product_queries = NIL;
else
product_queries = fireRules(parsetree,
result_relation,
event,
locks,
&instead,
&returning,
&qual_product);
product_queries = fireRules(parsetree,
result_relation,
event,
locks,
&instead,
&returning,
&qual_product);
/*
* If there were no INSTEAD rules, and the target relation is a view

97
src/backend/rewrite/rowsecurity.c
View File

@ -379,95 +379,6 @@ get_row_security_policies(Query *root, RangeTblEntry *rte, int rt_index,
}
}
/*
* FOR MERGE, we fetch policies for UPDATE, DELETE and INSERT (and ALL)
* and set them up so that we can enforce the appropriate policy depending
* on the final action we take.
*
* We don't fetch the SELECT policies since they are correctly applied to
* the root->mergeTarget_relation. The target rows are selected after
* joining the mergeTarget_relation and the source relation and hence it's
* enough to apply SELECT policies to the mergeTarget_relation.
*
* We don't push the UPDATE/DELETE USING quals to the RTE because we don't
* really want to apply them while scanning the relation since we don't
* know whether we will be doing a UPDATE or a DELETE at the end. We apply
* the respective policy once we decide the final action on the target
* tuple.
*
* XXX We are setting up USING quals as WITH CHECK. If RLS prohibits
* UPDATE/DELETE on the target row, we shall throw an error instead of
* silently ignoring the row. This is different than how normal
* UPDATE/DELETE works and more in line with INSERT ON CONFLICT DO UPDATE
* handling.
*/
if (commandType == CMD_MERGE)
{
List *merge_permissive_policies;
List *merge_restrictive_policies;
/*
* Fetch the UPDATE policies and set them up to execute on the
* existing target row before doing UPDATE.
*/
get_policies_for_relation(rel, CMD_UPDATE, user_id,
&merge_permissive_policies,
&merge_restrictive_policies);
/*
* WCO_RLS_MERGE_UPDATE_CHECK is used to check UPDATE USING quals on
* the existing target row.
*/
add_with_check_options(rel, rt_index,
WCO_RLS_MERGE_UPDATE_CHECK,
merge_permissive_policies,
merge_restrictive_policies,
withCheckOptions,
hasSubLinks,
true);
/*
* Same with DELETE policies.
*/
get_policies_for_relation(rel, CMD_DELETE, user_id,
&merge_permissive_policies,
&merge_restrictive_policies);
add_with_check_options(rel, rt_index,
WCO_RLS_MERGE_DELETE_CHECK,
merge_permissive_policies,
merge_restrictive_policies,
withCheckOptions,
hasSubLinks,
true);
/*
* No special handling is required for INSERT policies. They will be
* checked and enforced during ExecInsert(). But we must add them to
* withCheckOptions.
*/
get_policies_for_relation(rel, CMD_INSERT, user_id,
&merge_permissive_policies,
&merge_restrictive_policies);
add_with_check_options(rel, rt_index,
WCO_RLS_INSERT_CHECK,
merge_permissive_policies,
merge_restrictive_policies,
withCheckOptions,
hasSubLinks,
false);
/* Enforce the WITH CHECK clauses of the UPDATE policies */
add_with_check_options(rel, rt_index,
WCO_RLS_UPDATE_CHECK,
merge_permissive_policies,
merge_restrictive_policies,
withCheckOptions,
hasSubLinks,
false);
}
heap_close(rel, NoLock);
/*
@ -527,14 +438,6 @@ get_policies_for_relation(Relation relation, CmdType cmd, Oid user_id,
if (policy->polcmd == ACL_DELETE_CHR)
cmd_matches = true;
break;
case CMD_MERGE:
/*
* We do not support a separate policy for MERGE command.
* Instead it derives from the policies defined for other
* commands.
*/
break;
default:
elog(ERROR, "unrecognized policy command type %d",
(int) cmd);

5
src/backend/tcop/pquery.c
View File

@ -193,11 +193,6 @@ ProcessQuery(PlannedStmt *plan,
"DELETE " UINT64_FORMAT,
queryDesc->estate->es_processed);
break;
case CMD_MERGE:
snprintf(completionTag, COMPLETION_TAG_BUFSIZE,
"MERGE " UINT64_FORMAT,
queryDesc->estate->es_processed);
break;
default:
strcpy(completionTag, "???");
break;

16
src/backend/tcop/utility.c
View File

@ -110,7 +110,6 @@ CommandIsReadOnly(PlannedStmt *pstmt)
case CMD_UPDATE:
case CMD_INSERT:
case CMD_DELETE:
case CMD_MERGE:
return false;
case CMD_UTILITY:
/* For now, treat all utility commands as read/write */
@ -1833,8 +1832,6 @@ QueryReturnsTuples(Query *parsetree)
case CMD_SELECT:
/* returns tuples */
return true;
case CMD_MERGE:
return false;
case CMD_INSERT:
case CMD_UPDATE:
case CMD_DELETE:
@ -2079,10 +2076,6 @@ CreateCommandTag(Node *parsetree)
tag = "UPDATE";
break;
case T_MergeStmt:
tag = "MERGE";
break;
case T_SelectStmt:
tag = "SELECT";
break;
@ -2826,9 +2819,6 @@ CreateCommandTag(Node *parsetree)
case CMD_DELETE:
tag = "DELETE";
break;
case CMD_MERGE:
tag = "MERGE";
break;
case CMD_UTILITY:
tag = CreateCommandTag(stmt->utilityStmt);
break;
@ -2889,9 +2879,6 @@ CreateCommandTag(Node *parsetree)
case CMD_DELETE:
tag = "DELETE";
break;
case CMD_MERGE:
tag = "MERGE";
break;
case CMD_UTILITY:
tag = CreateCommandTag(stmt->utilityStmt);
break;
@ -2940,7 +2927,6 @@ GetCommandLogLevel(Node *parsetree)
case T_InsertStmt:
case T_DeleteStmt:
case T_UpdateStmt:
case T_MergeStmt:
lev = LOGSTMT_MOD;
break;
@ -3380,7 +3366,6 @@ GetCommandLogLevel(Node *parsetree)
case CMD_UPDATE:
case CMD_INSERT:
case CMD_DELETE:
case CMD_MERGE:
lev = LOGSTMT_MOD;
break;
@ -3411,7 +3396,6 @@ GetCommandLogLevel(Node *parsetree)
case CMD_UPDATE:
case CMD_INSERT:
case CMD_DELETE:
case CMD_MERGE:
lev = LOGSTMT_MOD;
break;