本节介绍ExecUpdate函数。

ExecUpdate函数

static TupleTableSlot *
ExecUpdate(ModifyTableState *mtstate,
		   ItemPointer tupleid,
		   HeapTuple oldtuple,
		   TupleTableSlot *slot,
		   TupleTableSlot *planSlot,
		   EPQState *epqstate,
		   EState *estate,
		   bool canSetTag);

if (IsBootstrapProcessingMode())
	elog(ERROR, "cannot UPDATE during bootstrap");

ExecMaterializeSlot(slot);


resultRelInfo = estate->es_result_relation_info;
resultRelationDesc = resultRelInfo->ri_RelationDesc;


if (resultRelInfo->ri_TrigDesc &&
	resultRelInfo->ri_TrigDesc->trig_update_before_row)
{
	if (!ExecBRUpdateTriggers(estate, epqstate, resultRelInfo,
						  tupleid, oldtuple, slot))
		return NULL;		
}


if (resultRelInfo->ri_TrigDesc &&
	resultRelInfo->ri_TrigDesc->trig_update_instead_row)
{
	if (!ExecIRUpdateTriggers(estate, resultRelInfo,
						  oldtuple, slot))
		return NULL;		
}

else if (resultRelInfo->ri_FdwRoutine)
{
	
	if (resultRelationDesc->rd_att->constr &&
		resultRelationDesc->rd_att->constr->has_generated_stored)
		ExecComputeStoredGenerated(estate, slot);
	
	
	slot = resultRelInfo->ri_FdwRoutine->ExecForeignUpdate(estate,
								   resultRelInfo,
								   slot,
								   planSlot);
	
	if (slot == NULL)	
		return NULL;
	
	
	slot->tts_tableOid = RelationGetRelid(resultRelationDesc);
}

else
{
	
	slot->tts_tableOid = RelationGetRelid(resultRelationDesc);
	
	
	if (resultRelationDesc->rd_att->constr &&
		resultRelationDesc->rd_att->constr->has_generated_stored)
		ExecComputeStoredGenerated(estate, slot);
	

lreplace:
	
	ExecMaterializeSlot(slot);
	
	
	partition_constraint_failed =
		resultRelInfo->ri_PartitionCheck &&
		!ExecPartitionCheck(resultRelInfo, slot, estate, false);
	
	
	if (!partition_constraint_failed &&
		resultRelInfo->ri_WithCheckOptions != NIL)
	{
		ExecWithCheckOptions(WCO_RLS_UPDATE_CHECK,
					 resultRelInfo, slot, estate);
	}
	
	
	if (partition_constraint_failed)
	{
		PartitionTupleRouting *proute = mtstate->mt_partition_tuple_routing;
		
		
		if (((ModifyTable *) mtstate->ps.plan)->onConflictAction == ONCONFLICT_UPDATE)
			ereport(ERROR,
					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
					 errmsg("invalid ON UPDATE specification"),
					 errdetail("The result tuple would appear in a different partition than the original tuple.")));
		
		
		if (proute == NULL)
			ExecPartitionCheckEmitError(resultRelInfo, slot, estate);
		
		
		ExecDelete(mtstate, tupleid, oldtuple, planSlot, epqstate,
				   estate, false, false  ,
				   true  , &tuple_deleted, &epqslot);
		
		
		if (!tuple_deleted)
		{
			
			if (TupIsNull(epqslot))
				return NULL;
			else
			{
				slot = ExecFilterJunk(resultRelInfo->ri_junkFilter, epqslot);
				goto lreplace;
			}
		}
		
		
		if (mtstate->mt_transition_capture)
			saved_tcs_map = mtstate->mt_transition_capture->tcs_map;
		
		
		map_index = resultRelInfo - mtstate->resultRelInfo;
		Assert(map_index >= 0 && map_index < mtstate->mt_nplans);
		tupconv_map = tupconv_map_for_subplan(mtstate, map_index);
		if (tupconv_map != NULL)
			slot = execute_attr_map_slot(tupconv_map->attrMap,
							 slot,
							 mtstate->mt_root_tuple_slot);
		
		
		Assert(mtstate->rootResultRelInfo != NULL);
		slot = ExecPrepareTupleRouting(mtstate, estate, proute,
						   mtstate->rootResultRelInfo, slot);
		
		
		ret_slot = ExecInsert(mtstate, slot, planSlot,
								  estate, canSetTag);
		
		
		estate->es_result_relation_info = resultRelInfo;
		if (mtstate->mt_transition_capture)
		{
			mtstate->mt_transition_capture->tcs_original_insert_tuple = NULL;
			mtstate->mt_transition_capture->tcs_map = saved_tcs_map;
		}
		
		
		return ret_slot;
	}
	
	
	if (resultRelationDesc->rd_att->constr)
		ExecConstraints(resultRelInfo, slot, estate);
	
	
	result = table_tuple_update(resultRelationDesc, tupleid, slot,
						estate->es_output_cid,
						estate->es_snapshot,
						estate->es_crosscheck_snapshot,
						true  ,
						&tmfd, &lockmode, &update_indexes);
	
	switch (result)
	{
		
		case TM_SelfModified:
			if (tmfd.cmax != estate->es_output_cid)
				ereport(ERROR,
						(errcode(ERRCODE_TRIGGERED_DATA_CHANGE_VIOLATION),
						 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.")));

			
			return NULL;
		
		
		case TM_Ok:
			break;
			
		
		case TM_Updated:
			{
				
				if (IsolationUsesXactSnapshot())
					ereport(ERROR,
							(errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
							 errmsg("could not serialize access due to concurrent update")));
				
				
				inputslot = EvalPlanQualSlot(epqstate, resultRelationDesc,
									 resultRelInfo->ri_RangeTableIndex);

				result = table_tuple_lock(resultRelationDesc, tupleid,
								  estate->es_snapshot,
								  inputslot, estate->es_output_cid,
								  lockmode, LockWaitBlock,
								  TUPLE_LOCK_FLAG_FIND_LAST_VERSION,
								  &tmfd);
				
				switch (result)
				{
					case TM_Ok:
						Assert(tmfd.traversed);
						
						
						epqslot = EvalPlanQual(epqstate,
									   resultRelationDesc,
									   resultRelInfo->ri_RangeTableIndex,
									   inputslot);
						if (TupIsNull(epqslot))
							return NULL;
						
						slot = ExecFilterJunk(resultRelInfo->ri_junkFilter, epqslot);
							goto lreplace;
						
					
					case TM_Deleted:
						return NULL;
						
					
					case TM_SelfModified:
						if (tmfd.cmax != estate->es_output_cid)
							ereport(ERROR,
								(errcode(ERRCODE_TRIGGERED_DATA_CHANGE_VIOLATION),
								 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.")));
						return NULL;
						
					
					default:
						elog(ERROR, "unexpected table_tuple_lock status: %u",
							 result);
						return NULL;
				}
			}
			
			break;
			
		
		case TM_Deleted:
			if (IsolationUsesXactSnapshot())
				ereport(ERROR,
						(errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
						 errmsg("could not serialize access due to concurrent delete")));
			return NULL;
			
		
		default:
			elog(ERROR, "unrecognized table_tuple_update status: %u",
					 result);
			return NULL;
	}
	
	
	if (resultRelInfo->ri_NumIndices > 0 && update_indexes)
		recheckIndexes = ExecInsertIndexTuples(slot, estate, false, NULL, NIL);
}


if (canSetTag)
	(estate->es_processed)++;


ExecARUpdateTriggers(estate, resultRelInfo, tupleid, oldtuple, slot,
				 recheckIndexes,
				 mtstate->operation == CMD_INSERT ?
				 mtstate->mt_oc_transition_capture :
				 mtstate->mt_transition_capture);

list_free(recheckIndexes);


if (resultRelInfo->ri_WithCheckOptions != NIL)
	ExecWithCheckOptions(WCO_VIEW_CHECK, resultRelInfo, slot, estate);


if (resultRelInfo->ri_projectReturning)
	return ExecProcessReturning(resultRelInfo, slot, planSlot);

return NULL;