From b1484a3f1910bfd0e254afe40085dfc3351bda8c Mon Sep 17 00:00:00 2001 From: Alexander Korotkov Date: Sat, 30 Mar 2024 22:39:03 +0200 Subject: [PATCH] Let table AM insertion methods control index insertion Previously, the executor did index insert unconditionally after calling table AM interface methods tuple_insert() and multi_insert(). This commit introduces the new parameter insert_indexes for these two methods. Setting '*insert_indexes' to true saves the current logic. Setting it to false indicates that table AM cares about index inserts itself and doesn't want the caller to do that. Discussion: https://postgr.es/m/CAPpHfdurb9ycV8udYqM%3Do0sPS66PJ4RCBM1g-bBpvzUfogY0EA%40mail.gmail.com Reviewed-by: Pavel Borisov, Matthias van de Meent, Mark Dilger --- src/backend/access/heap/heapam.c | 4 +++- src/backend/access/heap/heapam_handler.c | 4 +++- src/backend/access/table/tableam.c | 6 ++++-- src/backend/catalog/indexing.c | 4 +++- src/backend/commands/copyfrom.c | 13 ++++++++---- src/backend/commands/createas.c | 4 +++- src/backend/commands/matview.c | 4 +++- src/backend/commands/tablecmds.c | 6 +++++- src/backend/executor/execReplication.c | 6 ++++-- src/backend/executor/nodeModifyTable.c | 6 ++++-- src/include/access/heapam.h | 2 +- src/include/access/tableam.h | 25 +++++++++++++++++------- 12 files changed, 60 insertions(+), 24 deletions(-) diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c index 2f6527df0d..b661d9811e 100644 --- a/src/backend/access/heap/heapam.c +++ b/src/backend/access/heap/heapam.c @@ -2088,7 +2088,8 @@ heap_multi_insert_pages(HeapTuple *heaptuples, int done, int ntuples, Size saveF */ void heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples, - CommandId cid, int options, BulkInsertState bistate) + CommandId cid, int options, BulkInsertState bistate, + bool *insert_indexes) { TransactionId xid = GetCurrentTransactionId(); HeapTuple *heaptuples; @@ -2437,6 +2438,7 @@ heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples, slots[i]->tts_tid = heaptuples[i]->t_self; pgstat_count_heap_insert(relation, ntuples); + *insert_indexes = true; } /* diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c index 26b3be9779..41a4bb0981 100644 --- a/src/backend/access/heap/heapam_handler.c +++ b/src/backend/access/heap/heapam_handler.c @@ -245,7 +245,7 @@ heapam_tuple_satisfies_snapshot(Relation rel, TupleTableSlot *slot, static TupleTableSlot * heapam_tuple_insert(Relation relation, TupleTableSlot *slot, CommandId cid, - int options, BulkInsertState bistate) + int options, BulkInsertState bistate, bool *insert_indexes) { bool shouldFree = true; HeapTuple tuple = ExecFetchSlotHeapTuple(slot, true, &shouldFree); @@ -261,6 +261,8 @@ heapam_tuple_insert(Relation relation, TupleTableSlot *slot, CommandId cid, if (shouldFree) pfree(tuple); + *insert_indexes = true; + return slot; } diff --git a/src/backend/access/table/tableam.c b/src/backend/access/table/tableam.c index 8d3675be95..805d222ceb 100644 --- a/src/backend/access/table/tableam.c +++ b/src/backend/access/table/tableam.c @@ -273,9 +273,11 @@ table_tuple_get_latest_tid(TableScanDesc scan, ItemPointer tid) * default command ID and not allowing access to the speedup options. */ void -simple_table_tuple_insert(Relation rel, TupleTableSlot *slot) +simple_table_tuple_insert(Relation rel, TupleTableSlot *slot, + bool *insert_indexes) { - table_tuple_insert(rel, slot, GetCurrentCommandId(true), 0, NULL); + table_tuple_insert(rel, slot, GetCurrentCommandId(true), 0, NULL, + insert_indexes); } /* diff --git a/src/backend/catalog/indexing.c b/src/backend/catalog/indexing.c index d0d1abda58..4d404f22f8 100644 --- a/src/backend/catalog/indexing.c +++ b/src/backend/catalog/indexing.c @@ -273,12 +273,14 @@ void CatalogTuplesMultiInsertWithInfo(Relation heapRel, TupleTableSlot **slot, int ntuples, CatalogIndexState indstate) { + bool insertIndexes; + /* Nothing to do */ if (ntuples <= 0) return; heap_multi_insert(heapRel, slot, ntuples, - GetCurrentCommandId(true), 0, NULL); + GetCurrentCommandId(true), 0, NULL, &insertIndexes); /* * There is no equivalent to heap_multi_insert for the catalog indexes, so diff --git a/src/backend/commands/copyfrom.c b/src/backend/commands/copyfrom.c index 8908a440e1..b673636977 100644 --- a/src/backend/commands/copyfrom.c +++ b/src/backend/commands/copyfrom.c @@ -397,6 +397,7 @@ CopyMultiInsertBufferFlush(CopyMultiInsertInfo *miinfo, bool line_buf_valid = cstate->line_buf_valid; uint64 save_cur_lineno = cstate->cur_lineno; MemoryContext oldcontext; + bool insertIndexes; Assert(buffer->bistate != NULL); @@ -416,7 +417,8 @@ CopyMultiInsertBufferFlush(CopyMultiInsertInfo *miinfo, nused, mycid, ti_options, - buffer->bistate); + buffer->bistate, + &insertIndexes); MemoryContextSwitchTo(oldcontext); for (i = 0; i < nused; i++) @@ -425,7 +427,7 @@ CopyMultiInsertBufferFlush(CopyMultiInsertInfo *miinfo, * If there are any indexes, update them for all the inserted * tuples, and run AFTER ROW INSERT triggers. */ - if (resultRelInfo->ri_NumIndices > 0) + if (insertIndexes && resultRelInfo->ri_NumIndices > 0) { List *recheckIndexes; @@ -1265,11 +1267,14 @@ CopyFrom(CopyFromState cstate) } else { + bool insertIndexes; + /* OK, store the tuple and create index entries for it */ table_tuple_insert(resultRelInfo->ri_RelationDesc, - myslot, mycid, ti_options, bistate); + myslot, mycid, ti_options, bistate, + &insertIndexes); - if (resultRelInfo->ri_NumIndices > 0) + if (insertIndexes && resultRelInfo->ri_NumIndices > 0) recheckIndexes = ExecInsertIndexTuples(resultRelInfo, myslot, estate, diff --git a/src/backend/commands/createas.c b/src/backend/commands/createas.c index 62050f4dc5..afd3dace07 100644 --- a/src/backend/commands/createas.c +++ b/src/backend/commands/createas.c @@ -578,6 +578,7 @@ static bool intorel_receive(TupleTableSlot *slot, DestReceiver *self) { DR_intorel *myState = (DR_intorel *) self; + bool insertIndexes; /* Nothing to insert if WITH NO DATA is specified. */ if (!myState->into->skipData) @@ -594,7 +595,8 @@ intorel_receive(TupleTableSlot *slot, DestReceiver *self) slot, myState->output_cid, myState->ti_options, - myState->bistate); + myState->bistate, + &insertIndexes); } /* We know this is a newly created relation, so there are no indexes */ diff --git a/src/backend/commands/matview.c b/src/backend/commands/matview.c index 6d09b75556..9ec13d0984 100644 --- a/src/backend/commands/matview.c +++ b/src/backend/commands/matview.c @@ -476,6 +476,7 @@ static bool transientrel_receive(TupleTableSlot *slot, DestReceiver *self) { DR_transientrel *myState = (DR_transientrel *) self; + bool insertIndexes; /* * Note that the input slot might not be of the type of the target @@ -490,7 +491,8 @@ transientrel_receive(TupleTableSlot *slot, DestReceiver *self) slot, myState->output_cid, myState->ti_options, - myState->bistate); + myState->bistate, + &insertIndexes); /* We know this is a newly created relation, so there are no indexes */ diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c index 3fcb9cd078..a28f405e27 100644 --- a/src/backend/commands/tablecmds.c +++ b/src/backend/commands/tablecmds.c @@ -6360,8 +6360,12 @@ ATRewriteTable(AlteredTableInfo *tab, Oid OIDNewHeap, LOCKMODE lockmode) /* Write the tuple out to the new relation */ if (newrel) + { + bool insertIndexes; + table_tuple_insert(newrel, insertslot, mycid, - ti_options, bistate); + ti_options, bistate, &insertIndexes); + } ResetExprContext(econtext); diff --git a/src/backend/executor/execReplication.c b/src/backend/executor/execReplication.c index 0cad843fb6..db685473fc 100644 --- a/src/backend/executor/execReplication.c +++ b/src/backend/executor/execReplication.c @@ -509,6 +509,7 @@ ExecSimpleRelationInsert(ResultRelInfo *resultRelInfo, if (!skip_tuple) { List *recheckIndexes = NIL; + bool insertIndexes; /* Compute stored generated columns */ if (rel->rd_att->constr && @@ -523,9 +524,10 @@ ExecSimpleRelationInsert(ResultRelInfo *resultRelInfo, ExecPartitionCheck(resultRelInfo, slot, estate, true); /* OK, store the tuple and create index entries for it */ - simple_table_tuple_insert(resultRelInfo->ri_RelationDesc, slot); + simple_table_tuple_insert(resultRelInfo->ri_RelationDesc, slot, + &insertIndexes); - if (resultRelInfo->ri_NumIndices > 0) + if (insertIndexes && resultRelInfo->ri_NumIndices > 0) recheckIndexes = ExecInsertIndexTuples(resultRelInfo, slot, estate, false, false, NULL, NIL, false); diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index 325d380b0a..df63844b35 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -1135,13 +1135,15 @@ ExecInsert(ModifyTableContext *context, } else { + bool insertIndexes; + /* insert the tuple normally */ slot = table_tuple_insert(resultRelationDesc, slot, estate->es_output_cid, - 0, NULL); + 0, NULL, &insertIndexes); /* insert index entries for tuple */ - if (resultRelInfo->ri_NumIndices > 0) + if (insertIndexes && resultRelInfo->ri_NumIndices > 0) recheckIndexes = ExecInsertIndexTuples(resultRelInfo, slot, estate, false, false, NULL, NIL, diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h index 91fbc95034..32a3fbce96 100644 --- a/src/include/access/heapam.h +++ b/src/include/access/heapam.h @@ -282,7 +282,7 @@ extern void heap_insert(Relation relation, HeapTuple tup, CommandId cid, int options, BulkInsertState bistate); extern void heap_multi_insert(Relation relation, struct TupleTableSlot **slots, int ntuples, CommandId cid, int options, - BulkInsertState bistate); + BulkInsertState bistate, bool *insert_indexes); extern TM_Result heap_delete(Relation relation, ItemPointer tid, CommandId cid, Snapshot crosscheck, int options, struct TM_FailureData *tmfd, bool changingPart, diff --git a/src/include/access/tableam.h b/src/include/access/tableam.h index cf68ec48eb..cf76fc29d4 100644 --- a/src/include/access/tableam.h +++ b/src/include/access/tableam.h @@ -512,7 +512,8 @@ typedef struct TableAmRoutine /* see table_tuple_insert() for reference about parameters */ TupleTableSlot *(*tuple_insert) (Relation rel, TupleTableSlot *slot, CommandId cid, int options, - struct BulkInsertStateData *bistate); + struct BulkInsertStateData *bistate, + bool *insert_indexes); /* see table_tuple_insert_speculative() for reference about parameters */ void (*tuple_insert_speculative) (Relation rel, @@ -530,7 +531,8 @@ typedef struct TableAmRoutine /* see table_multi_insert() for reference about parameters */ void (*multi_insert) (Relation rel, TupleTableSlot **slots, int nslots, - CommandId cid, int options, struct BulkInsertStateData *bistate); + CommandId cid, int options, struct BulkInsertStateData *bistate, + bool *insert_indexes); /* see table_tuple_delete() for reference about parameters */ TM_Result (*tuple_delete) (Relation rel, @@ -1384,6 +1386,12 @@ table_index_delete_tuples(Relation rel, TM_IndexDeleteOp *delstate) * behavior) is also just passed through to RelationGetBufferForTuple. If * `bistate` is provided, table_finish_bulk_insert() needs to be called. * + * The table AM's implementation of tuple_insert should set `*insert_indexes` + * to true if it expects the caller to insert the relevant index tuples + * (as heap table AM does). It should set `*insert_indexes` to false if + * it cares about index inserts itself and doesn't want the caller to do + * index inserts. + * * Returns the slot containing the inserted tuple, which may differ from the * given slot. For instance, the source slot may be VirtualTupleTableSlot, but * the result slot may correspond to the table AM. On return the slot's @@ -1393,10 +1401,11 @@ table_index_delete_tuples(Relation rel, TM_IndexDeleteOp *delstate) */ static inline TupleTableSlot * table_tuple_insert(Relation rel, TupleTableSlot *slot, CommandId cid, - int options, struct BulkInsertStateData *bistate) + int options, struct BulkInsertStateData *bistate, + bool *insert_indexes) { return rel->rd_tableam->tuple_insert(rel, slot, cid, options, - bistate); + bistate, insert_indexes); } /* @@ -1448,10 +1457,11 @@ table_tuple_complete_speculative(Relation rel, TupleTableSlot *slot, */ static inline void table_multi_insert(Relation rel, TupleTableSlot **slots, int nslots, - CommandId cid, int options, struct BulkInsertStateData *bistate) + CommandId cid, int options, struct BulkInsertStateData *bistate, + bool *insert_indexes) { rel->rd_tableam->multi_insert(rel, slots, nslots, - cid, options, bistate); + cid, options, bistate, insert_indexes); } /* @@ -2096,7 +2106,8 @@ table_scan_sample_next_tuple(TableScanDesc scan, * ---------------------------------------------------------------------------- */ -extern void simple_table_tuple_insert(Relation rel, TupleTableSlot *slot); +extern void simple_table_tuple_insert(Relation rel, TupleTableSlot *slot, + bool *insert_indexes); extern void simple_table_tuple_delete(Relation rel, ItemPointer tid, Snapshot snapshot, TupleTableSlot *oldSlot);