In the executor, use an array of pointers to access the rangetable.

Instead of doing a lot of list_nth() accesses to es_range_table,
create a flattened pointer array during executor startup and index
into that to get at individual RangeTblEntrys.

This eliminates one source of O(N^2) behavior with lots of partitions.
(I'm not exactly convinced that it's the most important source, but
it's an easy one to fix.)

Amit Langote and David Rowley

Discussion: https://postgr.es/m/468c85d9-540e-66a2-1dde-fec2b741e688@lab.ntt.co.jp

diff --git a/contrib/postgres_fdw/postgres_fdw.c b/contrib/postgres_fdw/postgres_fdw.c
index c02287a55cade1b2635a983ca78ed3cbf2e6225b..b91b7d27de90a5b8c2956ecabc395538f540d562 100644 (file)
--- a/contrib/postgres_fdw/postgres_fdw.c
+++ b/contrib/postgres_fdw/postgres_fdw.c
@@ -1345,7 +1345,7 @@ postgresBeginForeignScan(ForeignScanState *node, int eflags)
        rtindex = fsplan->scan.scanrelid;
    else
        rtindex = bms_next_member(fsplan->fs_relids, -1);
-   rte = rt_fetch(rtindex, estate->es_range_table);
+   rte = exec_rt_fetch(rtindex, estate);
    userid = rte->checkAsUser ? rte->checkAsUser : GetUserId();
 
    /* Get info about foreign table. */
@@ -1731,8 +1731,8 @@ postgresBeginForeignModify(ModifyTableState *mtstate,
                                        FdwModifyPrivateRetrievedAttrs);
 
    /* Find RTE. */
-   rte = rt_fetch(resultRelInfo->ri_RangeTableIndex,
-                  mtstate->ps.state->es_range_table);
+   rte = exec_rt_fetch(resultRelInfo->ri_RangeTableIndex,
+                       mtstate->ps.state);
 
    /* Construct an execution state. */
    fmstate = create_foreign_modify(mtstate->ps.state,
@@ -2036,7 +2036,7 @@ postgresBeginForeignInsert(ModifyTableState *mtstate,
     * correspond to this partition if it is one of the UPDATE subplan target
     * rels; in that case, we can just use the existing RTE as-is.
     */
-   rte = list_nth(estate->es_range_table, resultRelation - 1);
+   rte = exec_rt_fetch(resultRelation, estate);
    if (rte->relid != RelationGetRelid(rel))
    {
        rte = copyObject(rte);
@@ -2396,7 +2396,7 @@ postgresBeginDirectModify(ForeignScanState *node, int eflags)
     * ExecCheckRTEPerms() does.
     */
    rtindex = estate->es_result_relation_info->ri_RangeTableIndex;
-   rte = rt_fetch(rtindex, estate->es_range_table);
+   rte = exec_rt_fetch(rtindex, estate);
    userid = rte->checkAsUser ? rte->checkAsUser : GetUserId();
 
    /* Get info about foreign table. */
@@ -5752,7 +5752,7 @@ conversion_error_callback(void *arg)
            RangeTblEntry *rte;
            Var        *var = (Var *) tle->expr;
 
-           rte = rt_fetch(var->varno, estate->es_range_table);
+           rte = exec_rt_fetch(var->varno, estate);
 
            if (var->varattno == 0)
                is_wholerow = true;

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index df98e4ac626dea9d8786b2302ca0b590703385d8..86b0fb300ff8fb0931cd4958ee5f8cfed9fd4b98 100644 (file)
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -2484,9 +2484,8 @@ CopyFrom(CopyState cstate)
    estate->es_result_relations = resultRelInfo;
    estate->es_num_result_relations = 1;
    estate->es_result_relation_info = resultRelInfo;
-   estate->es_range_table = cstate->range_table;
-   estate->es_relations = (Relation *) palloc0(list_length(cstate->range_table) *
-                                               sizeof(Relation));
+
+   ExecInitRangeTable(estate, cstate->range_table);
 
    /* Set up a tuple slot too */
    myslot = ExecInitExtraTupleSlot(estate, tupDesc);

diff --git a/src/backend/commands/trigger.c b/src/backend/commands/trigger.c
index 136f9f0627549806ad86b6da53d4959c95ea5e45..240e85e39103f2b60dc638631c08f469acd0cce0 100644 (file)
--- a/src/backend/commands/trigger.c
+++ b/src/backend/commands/trigger.c
@@ -75,7 +75,7 @@ static int    MyTriggerDepth = 0;
  * to be changed, however.
  */
 #define GetUpdatedColumns(relinfo, estate) \
-   (rt_fetch((relinfo)->ri_RangeTableIndex, (estate)->es_range_table)->updatedCols)
+   (exec_rt_fetch((relinfo)->ri_RangeTableIndex, estate)->updatedCols)
 
 /* Local function prototypes */
 static void ConvertTriggerToFK(CreateTrigStmt *stmt, Oid funcoid);

diff --git a/src/backend/executor/execExprInterp.c b/src/backend/executor/execExprInterp.c
index c549e3db5d9db98828517eb6c0672680d274222b..1b0946b02f2c46ca39c57b8f8cc424cc6446083e 100644 (file)
--- a/src/backend/executor/execExprInterp.c
+++ b/src/backend/executor/execExprInterp.c
@@ -3934,10 +3934,10 @@ ExecEvalWholeRowVar(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
         * perhaps other places.)
         */
        if (econtext->ecxt_estate &&
-           variable->varno <= list_length(econtext->ecxt_estate->es_range_table))
+           variable->varno <= econtext->ecxt_estate->es_range_table_size)
        {
-           RangeTblEntry *rte = rt_fetch(variable->varno,
-                                         econtext->ecxt_estate->es_range_table);
+           RangeTblEntry *rte = exec_rt_fetch(variable->varno,
+                                              econtext->ecxt_estate);
 
            if (rte->eref)
                ExecTypeSetColNames(output_tupdesc, rte->eref->colnames);

diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index 8cbd75ed7aa36a3610ac6c44d78c69f12f9614f5..71b720eec9e0934a5fb9934a56fcbd4d3fdf7432 100644 (file)
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -109,9 +109,9 @@ static void EvalPlanQualStart(EPQState *epqstate, EState *parentestate,
  * to be changed, however.
  */
 #define GetInsertedColumns(relinfo, estate) \
-   (rt_fetch((relinfo)->ri_RangeTableIndex, (estate)->es_range_table)->insertedCols)
+   (exec_rt_fetch((relinfo)->ri_RangeTableIndex, estate)->insertedCols)
 #define GetUpdatedColumns(relinfo, estate) \
-   (rt_fetch((relinfo)->ri_RangeTableIndex, (estate)->es_range_table)->updatedCols)
+   (exec_rt_fetch((relinfo)->ri_RangeTableIndex, estate)->updatedCols)
 
 /* end of local decls */
 
@@ -823,15 +823,7 @@ InitPlan(QueryDesc *queryDesc, int eflags)
    /*
     * initialize the node's execution state
     */
-   estate->es_range_table = rangeTable;
-
-   /*
-    * Allocate an array to store an open Relation corresponding to each
-    * rangeTable item, and initialize entries to NULL.  Relations are opened
-    * and stored here as needed.
-    */
-   estate->es_relations = (Relation *) palloc0(list_length(rangeTable) *
-                                               sizeof(Relation));
+   ExecInitRangeTable(estate, rangeTable);
 
    estate->es_plannedstmt = plannedstmt;
 
@@ -918,9 +910,9 @@ InitPlan(QueryDesc *queryDesc, int eflags)
                                     resultRelIndex))
                {
                    Relation    resultRelDesc;
+                   Oid         reloid = exec_rt_fetch(resultRelIndex, estate)->relid;
 
-                   resultRelDesc = heap_open(getrelid(resultRelIndex, rangeTable),
-                                             NoLock);
+                   resultRelDesc = heap_open(reloid, NoLock);
                    Assert(CheckRelationLockedByMe(resultRelDesc, RowExclusiveLock, true));
                    heap_close(resultRelDesc, NoLock);
                }
@@ -962,7 +954,7 @@ InitPlan(QueryDesc *queryDesc, int eflags)
            continue;
 
        /* get relation's OID (will produce InvalidOid if subquery) */
-       relid = getrelid(rc->rti, rangeTable);
+       relid = exec_rt_fetch(rc->rti, estate)->relid;
 
        switch (rc->markType)
        {
@@ -1619,8 +1611,8 @@ static void
 ExecEndPlan(PlanState *planstate, EState *estate)
 {
    ResultRelInfo *resultRelInfo;
-   int         num_relations;
-   int         i;
+   Index       num_relations;
+   Index       i;
    ListCell   *l;
 
    /*
@@ -1661,7 +1653,7 @@ ExecEndPlan(PlanState *planstate, EState *estate)
     * close whatever rangetable Relations have been opened.  We did not
     * acquire locks in ExecGetRangeTableRelation, so don't release 'em here.
     */
-   num_relations = list_length(estate->es_range_table);
+   num_relations = estate->es_range_table_size;
    for (i = 0; i < num_relations; i++)
    {
        if (estate->es_relations[i])
@@ -3087,7 +3079,7 @@ EvalPlanQualBegin(EPQState *epqstate, EState *parentestate)
        /*
         * We already have a suitable child EPQ tree, so just reset it.
         */
-       int         rtsize = list_length(parentestate->es_range_table);
+       Index       rtsize = parentestate->es_range_table_size;
        PlanState  *planstate = epqstate->planstate;
 
        MemSet(estate->es_epqScanDone, 0, rtsize * sizeof(bool));
@@ -3136,11 +3128,11 @@ static void
 EvalPlanQualStart(EPQState *epqstate, EState *parentestate, Plan *planTree)
 {
    EState     *estate;
-   int         rtsize;
+   Index       rtsize;
    MemoryContext oldcontext;
    ListCell   *l;
 
-   rtsize = list_length(parentestate->es_range_table);
+   rtsize = parentestate->es_range_table_size;
 
    epqstate->estate = estate = CreateExecutorState();
 
@@ -3164,6 +3156,8 @@ EvalPlanQualStart(EPQState *epqstate, EState *parentestate, Plan *planTree)
    estate->es_snapshot = parentestate->es_snapshot;
    estate->es_crosscheck_snapshot = parentestate->es_crosscheck_snapshot;
    estate->es_range_table = parentestate->es_range_table;
+   estate->es_range_table_array = parentestate->es_range_table_array;
+   estate->es_range_table_size = parentestate->es_range_table_size;
    estate->es_relations = parentestate->es_relations;
    estate->es_plannedstmt = parentestate->es_plannedstmt;
    estate->es_junkFilter = parentestate->es_junkFilter;

diff --git a/src/backend/executor/execUtils.c b/src/backend/executor/execUtils.c
index a89ef2a482f93aca7db50b7075019fd0b4581e7e..b75062f74c4446050992de50f150fcc126d1d9fa 100644 (file)
--- a/src/backend/executor/execUtils.c
+++ b/src/backend/executor/execUtils.c
@@ -26,6 +26,8 @@
  *
  *     ExecOpenScanRelation    Common code for scan node init routines.
  *
+ *     ExecInitRangeTable      Set up executor's range-table-related data.
+ *
  *     ExecGetRangeTableRelation       Fetch Relation for a rangetable entry.
  *
  *     executor_errposition    Report syntactic position of an error.
@@ -108,6 +110,8 @@ CreateExecutorState(void)
    estate->es_snapshot = InvalidSnapshot;  /* caller must initialize this */
    estate->es_crosscheck_snapshot = InvalidSnapshot;   /* no crosscheck */
    estate->es_range_table = NIL;
+   estate->es_range_table_array = NULL;
+   estate->es_range_table_size = 0;
    estate->es_relations = NULL;
    estate->es_plannedstmt = NULL;
 
@@ -670,6 +674,43 @@ ExecOpenScanRelation(EState *estate, Index scanrelid, int eflags)
    return rel;
 }
 
+/*
+ * ExecInitRangeTable
+ *     Set up executor's range-table-related data
+ *
+ * We build an array from the range table list to allow faster lookup by RTI.
+ * (The es_range_table field is now somewhat redundant, but we keep it to
+ * avoid breaking external code unnecessarily.)
+ * This is also a convenient place to set up the parallel es_relations array.
+ */
+void
+ExecInitRangeTable(EState *estate, List *rangeTable)
+{
+   Index       rti;
+   ListCell   *lc;
+
+   /* Remember the range table List as-is */
+   estate->es_range_table = rangeTable;
+
+   /* Set up the equivalent array representation */
+   estate->es_range_table_size = list_length(rangeTable);
+   estate->es_range_table_array = (RangeTblEntry **)
+       palloc(estate->es_range_table_size * sizeof(RangeTblEntry *));
+   rti = 0;
+   foreach(lc, rangeTable)
+   {
+       estate->es_range_table_array[rti++] = lfirst_node(RangeTblEntry, lc);
+   }
+
+   /*
+    * Allocate an array to store an open Relation corresponding to each
+    * rangetable entry, and initialize entries to NULL.  Relations are opened
+    * and stored here as needed.
+    */
+   estate->es_relations = (Relation *)
+       palloc0(estate->es_range_table_size * sizeof(Relation));
+}
+
 /*
  * ExecGetRangeTableRelation
  *     Open the Relation for a range table entry, if not already done
@@ -681,13 +722,13 @@ ExecGetRangeTableRelation(EState *estate, Index rti)
 {
    Relation    rel;
 
-   Assert(rti > 0 && rti <= list_length(estate->es_range_table));
+   Assert(rti > 0 && rti <= estate->es_range_table_size);
 
    rel = estate->es_relations[rti - 1];
    if (rel == NULL)
    {
        /* First time through, so open the relation */
-       RangeTblEntry *rte = rt_fetch(rti, estate->es_range_table);
+       RangeTblEntry *rte = exec_rt_fetch(rti, estate);
 
        Assert(rte->rtekind == RTE_RELATION);
 
@@ -876,7 +917,7 @@ ExecLockNonLeafAppendTables(List *partitioned_rels, EState *estate)
        ListCell   *l;
        Index       rti = lfirst_int(lc);
        bool        is_result_rel = false;
-       Oid         relid = getrelid(rti, estate->es_range_table);
+       Oid         relid = exec_rt_fetch(rti, estate)->relid;
 
        /* If this is a result relation, already locked in InitPlan */
        foreach(l, stmt->nonleafResultRelations)
@@ -911,7 +952,7 @@ ExecLockNonLeafAppendTables(List *partitioned_rels, EState *estate)
            else
                lockmode = AccessShareLock;
 
-           Assert(lockmode == rt_fetch(rti, estate->es_range_table)->rellockmode);
+           Assert(lockmode == exec_rt_fetch(rti, estate)->rellockmode);
 
            LockRelationOid(relid, lockmode);
        }

diff --git a/src/backend/executor/nodeLockRows.c b/src/backend/executor/nodeLockRows.c
index 30de8a95ab8e2d63858932d75123e06bedcdeba5..6db345ae7acf160e4afb73252da38269cc273928 100644 (file)
--- a/src/backend/executor/nodeLockRows.c
+++ b/src/backend/executor/nodeLockRows.c
@@ -400,7 +400,7 @@ ExecInitLockRows(LockRows *node, EState *estate, int eflags)
    /*
     * Create workspace in which we can remember per-RTE locked tuples
     */
-   lrstate->lr_ntables = list_length(estate->es_range_table);
+   lrstate->lr_ntables = estate->es_range_table_size;
    lrstate->lr_curtuples = (HeapTuple *)
        palloc0(lrstate->lr_ntables * sizeof(HeapTuple));
 

diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c
index c3443c5a2ce031715cde78552cc706838a4b0cdb..277da69fa6c1e3e6787ff65723533305b4aef52c 100644 (file)
--- a/src/backend/replication/logical/worker.c
+++ b/src/backend/replication/logical/worker.c
@@ -200,8 +200,7 @@ create_estate_for_relation(LogicalRepRelMapEntry *rel)
    rte->relid = RelationGetRelid(rel->localrel);
    rte->relkind = rel->localrel->rd_rel->relkind;
    rte->rellockmode = AccessShareLock;
-   estate->es_range_table = list_make1(rte);
-   estate->es_relations = (Relation *) palloc0(1 * sizeof(Relation));
+   ExecInitRangeTable(estate, list_make1(rte));
 
    resultRelInfo = makeNode(ResultRelInfo);
    InitResultRelInfo(resultRelInfo, rel->localrel, 1, NULL, 0);

diff --git a/src/include/executor/executor.h b/src/include/executor/executor.h
index 83ce989e3a34c08dc869fa08f25f4863612fe198..830f42dfe3c1fe41fa7f543439a8fab492d5cb96 100644 (file)
--- a/src/include/executor/executor.h
+++ b/src/include/executor/executor.h
@@ -514,6 +514,15 @@ extern bool ExecRelationIsTargetRelation(EState *estate, Index scanrelid);
 
 extern Relation ExecOpenScanRelation(EState *estate, Index scanrelid, int eflags);
 
+extern void ExecInitRangeTable(EState *estate, List *rangeTable);
+
+static inline RangeTblEntry *
+exec_rt_fetch(Index rti, EState *estate)
+{
+   Assert(rti > 0 && rti <= estate->es_range_table_size);
+   return estate->es_range_table_array[rti - 1];
+}
+
 extern Relation ExecGetRangeTableRelation(EState *estate, Index rti);
 
 extern int executor_errposition(EState *estate, int location);

diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h
index 35646231a4c8207e562642676646e4f41124cda0..657b5936631f47f04b1378b465da1bb63fc4499f 100644 (file)
--- a/src/include/nodes/execnodes.h
+++ b/src/include/nodes/execnodes.h
@@ -36,6 +36,7 @@ struct PlanState;             /* forward references in this file */
 struct ParallelHashJoinState;
 struct ExprState;
 struct ExprContext;
+struct RangeTblEntry;          /* avoid including parsenodes.h here */
 struct ExprEvalStep;           /* avoid including execExpr.h everywhere */
 
 
@@ -486,7 +487,9 @@ typedef struct EState
    Snapshot    es_snapshot;    /* time qual to use */
    Snapshot    es_crosscheck_snapshot; /* crosscheck time qual for RI */
    List       *es_range_table; /* List of RangeTblEntry */
-   Relation   *es_relations;   /* Array of per-es_range_table-entry Relation
+   struct RangeTblEntry **es_range_table_array;    /* equivalent array */
+   Index       es_range_table_size;    /* size of the range table arrays */
+   Relation   *es_relations;   /* Array of per-range-table-entry Relation
                                 * pointers, or NULL if not yet opened */
    PlannedStmt *es_plannedstmt;    /* link to top of plan tree */
    const char *es_sourceText;  /* Source text from QueryDesc */
@@ -563,7 +566,7 @@ typedef struct EState
     * return, or NULL if nothing to return; es_epqTupleSet[] is true if a
     * particular array entry is valid; and es_epqScanDone[] is state to
     * remember if the tuple has been returned already.  Arrays are of size
-    * list_length(es_range_table) and are indexed by scan node scanrelid - 1.
+    * es_range_table_size and are indexed by scan node scanrelid - 1.
     */
    HeapTuple  *es_epqTuple;    /* array of EPQ substitute tuples */
    bool       *es_epqTupleSet; /* true if EPQ tuple is provided */

diff --git a/src/include/parser/parsetree.h b/src/include/parser/parsetree.h
index dd9ae658ac773f5019945de42f03141fc24ed3cf..fe16d7d1fa432ca4cd4926ee47683acc7e7c13ae 100644 (file)
--- a/src/include/parser/parsetree.h
+++ b/src/include/parser/parsetree.h
@@ -31,16 +31,6 @@
 #define rt_fetch(rangetable_index, rangetable) \
    ((RangeTblEntry *) list_nth(rangetable, (rangetable_index)-1))
 
-/*
- *     getrelid
- *
- *     Given the range index of a relation, return the corresponding
- *     relation OID.  Note that InvalidOid will be returned if the
- *     RTE is for a non-relation-type RTE.
- */
-#define getrelid(rangeindex,rangetable) \
-   (rt_fetch(rangeindex, rangetable)->relid)
-
 /*
  * Given an RTE and an attribute number, return the appropriate
  * variable name or alias for that attribute of that RTE.