/src/postgres/src/backend/executor/nodeIndexonlyscan.c

Source
/*-------------------------------------------------------------------------
 *
 * nodeIndexonlyscan.c
 *    Routines to support index-only scans
 *
 * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *    src/backend/executor/nodeIndexonlyscan.c
 *
 *-------------------------------------------------------------------------
 */
/*
 * INTERFACE ROUTINES
 *    ExecIndexOnlyScan     scans an index
 *    IndexOnlyNext       retrieve next tuple
 *    ExecInitIndexOnlyScan   creates and initializes state info.
 *    ExecReScanIndexOnlyScan   rescans the indexed relation.
 *    ExecEndIndexOnlyScan    releases all storage.
 *    ExecIndexOnlyMarkPos    marks scan position.
 *    ExecIndexOnlyRestrPos   restores scan position.
 *    ExecIndexOnlyScanEstimate estimates DSM space needed for
 *            parallel index-only scan
 *    ExecIndexOnlyScanInitializeDSM  initialize DSM for parallel
 *            index-only scan
 *    ExecIndexOnlyScanReInitializeDSM  reinitialize DSM for fresh scan
 *    ExecIndexOnlyScanInitializeWorker attach to DSM info in parallel worker
 */
#include "postgres.h"

#include "access/genam.h"
#include "access/htup_details.h"
#include "access/relscan.h"
#include "access/tableam.h"
#include "access/tupdesc.h"
#include "access/visibilitymap.h"
#include "catalog/pg_type.h"
#include "executor/executor.h"
#include "executor/instrument.h"
#include "executor/nodeIndexonlyscan.h"
#include "executor/nodeIndexscan.h"
#include "miscadmin.h"
#include "storage/bufmgr.h"
#include "storage/predicate.h"
#include "utils/builtins.h"
#include "utils/rel.h"


static TupleTableSlot *IndexOnlyNext(IndexOnlyScanState *node);
static void StoreIndexTuple(IndexOnlyScanState *node, TupleTableSlot *slot,
              IndexScanDesc scandesc);


/* ----------------------------------------------------------------
 *    IndexOnlyNext
 *
 *    Retrieve a tuple from the IndexOnlyScan node's index.
 * ----------------------------------------------------------------
 */
static TupleTableSlot *
IndexOnlyNext(IndexOnlyScanState *node)
{
  EState     *estate;
  ExprContext *econtext;
  ScanDirection direction;
  IndexScanDesc scandesc;
  TupleTableSlot *slot;
  ItemPointer tid;

  /*
   * extract necessary information from index scan node
   */
  estate = node->ss.ps.state;

  /*
   * Determine which direction to scan the index in based on the plan's scan
   * direction and the current direction of execution.
   */
  direction = ScanDirectionCombine(estate->es_direction,
                   ((IndexOnlyScan *) node->ss.ps.plan)->indexorderdir);
  scandesc = node->ioss_ScanDesc;
  econtext = node->ss.ps.ps_ExprContext;
  slot = node->ss.ss_ScanTupleSlot;

  if (scandesc == NULL)
  {
    /*
     * We reach here if the index only scan is not parallel, or if we're
     * serially executing an index only scan that was planned to be
     * parallel.
     */
    scandesc = index_beginscan(node->ss.ss_currentRelation,
                   node->ioss_RelationDesc,
                   estate->es_snapshot,
                   node->ioss_Instrument,
                   node->ioss_NumScanKeys,
                   node->ioss_NumOrderByKeys,
                   ScanRelIsReadOnly(&node->ss) ?
                   SO_HINT_REL_READ_ONLY : SO_NONE);

    node->ioss_ScanDesc = scandesc;


    /* Set it up for index-only scan */
    node->ioss_ScanDesc->xs_want_itup = true;
    node->ioss_VMBuffer = InvalidBuffer;

    /*
     * If no run-time keys to calculate or they are ready, go ahead and
     * pass the scankeys to the index AM.
     */
    if (node->ioss_NumRuntimeKeys == 0 || node->ioss_RuntimeKeysReady)
      index_rescan(scandesc,
             node->ioss_ScanKeys,
             node->ioss_NumScanKeys,
             node->ioss_OrderByKeys,
             node->ioss_NumOrderByKeys);
  }

  /*
   * OK, now that we have what we need, fetch the next tuple.
   */
  while ((tid = index_getnext_tid(scandesc, direction)) != NULL)
  {
    bool    tuple_from_heap = false;

    CHECK_FOR_INTERRUPTS();

    /*
     * We can skip the heap fetch if the TID references a heap page on
     * which all tuples are known visible to everybody.  In any case,
     * we'll use the index tuple not the heap tuple as the data source.
     *
     * Note on Memory Ordering Effects: visibilitymap_get_status does not
     * lock the visibility map buffer, and therefore the result we read
     * here could be slightly stale.  However, it can't be stale enough to
     * matter.
     *
     * We need to detect clearing a VM bit due to an insert right away,
     * because the tuple is present in the index page but not visible. The
     * reading of the TID by this scan (using a shared lock on the index
     * buffer) is serialized with the insert of the TID into the index
     * (using an exclusive lock on the index buffer). Because the VM bit
     * is cleared before updating the index, and locking/unlocking of the
     * index page acts as a full memory barrier, we are sure to see the
     * cleared bit if we see a recently-inserted TID.
     *
     * Deletes do not update the index page (only VACUUM will clear out
     * the TID), so the clearing of the VM bit by a delete is not
     * serialized with this test below, and we may see a value that is
     * significantly stale. However, we don't care about the delete right
     * away, because the tuple is still visible until the deleting
     * transaction commits or the statement ends (if it's our
     * transaction). In either case, the lock on the VM buffer will have
     * been released (acting as a write barrier) after clearing the bit.
     * And for us to have a snapshot that includes the deleting
     * transaction (making the tuple invisible), we must have acquired
     * ProcArrayLock after that time, acting as a read barrier.
     *
     * It's worth going through this complexity to avoid needing to lock
     * the VM buffer, which could cause significant contention.
     */
    if (!VM_ALL_VISIBLE(scandesc->heapRelation,
              ItemPointerGetBlockNumber(tid),
              &node->ioss_VMBuffer))
    {
      /*
       * Rats, we have to visit the heap to check visibility.
       */
      InstrCountTuples2(node, 1);
      if (!index_fetch_heap(scandesc, node->ioss_TableSlot))
        continue;   /* no visible tuple, try next index entry */

      ExecClearTuple(node->ioss_TableSlot);

      /*
       * Only MVCC snapshots are supported here, so there should be no
       * need to keep following the HOT chain once a visible entry has
       * been found.  If we did want to allow that, we'd need to keep
       * more state to remember not to call index_getnext_tid next time.
       */
      if (scandesc->xs_heap_continue)
        elog(ERROR, "non-MVCC snapshots are not supported in index-only scans");

      /*
       * Note: at this point we are holding a pin on the heap page, as
       * recorded in scandesc->xs_cbuf.  We could release that pin now,
       * but it's not clear whether it's a win to do so.  The next index
       * entry might require a visit to the same heap page.
       */

      tuple_from_heap = true;
    }

    /* Fill the scan tuple slot with data from the index */
    StoreIndexTuple(node, slot, scandesc);

    /*
     * If the index was lossy, we have to recheck the index quals.
     */
    if (scandesc->xs_recheck)
    {
      econtext->ecxt_scantuple = slot;
      if (!ExecQualAndReset(node->recheckqual, econtext))
      {
        /* Fails recheck, so drop it and loop back for another */
        InstrCountFiltered2(node, 1);
        continue;
      }
    }

    /*
     * We don't currently support rechecking ORDER BY distances.  (In
     * principle, if the index can support retrieval of the originally
     * indexed value, it should be able to produce an exact distance
     * calculation too.  So it's not clear that adding code here for
     * recheck/re-sort would be worth the trouble.  But we should at least
     * throw an error if someone tries it.)
     */
    if (scandesc->numberOfOrderBys > 0 && scandesc->xs_recheckorderby)
      ereport(ERROR,
          (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
           errmsg("lossy distance functions are not supported in index-only scans")));

    /*
     * If we didn't access the heap, then we'll need to take a predicate
     * lock explicitly, as if we had.  For now we do that at page level.
     */
    if (!tuple_from_heap)
      PredicateLockPage(scandesc->heapRelation,
                ItemPointerGetBlockNumber(tid),
                estate->es_snapshot);

    return slot;
  }

  /*
   * if we get here it means the index scan failed so we are at the end of
   * the scan..
   */
  return ExecClearTuple(slot);
}

/*
 * StoreIndexTuple
 *    Fill the slot with the data the index AM returned.
 *
 * The data might be provided in either HeapTuple (xs_hitup) or IndexTuple
 * (xs_itup) format.  Conceivably an index AM might fill both fields, in which
 * case we prefer the heap format, since it's probably a bit cheaper to fill a
 * slot from.
 *
 * At some point this might be generally-useful functionality, but
 * right now we don't need it elsewhere.
 */
static void
StoreIndexTuple(IndexOnlyScanState *node, TupleTableSlot *slot,
        IndexScanDesc scandesc)
{
  ExecClearTuple(slot);

  /*
   * We must deform the tuple using the tupdesc the index AM formed it with
   * (xs_hitupdesc or xs_itupdesc), not the slot's tupdesc.  The datums
   * returned by the index AM must be binary compatible, but the descriptors
   * may align each column differently in certain rare cases. (Actually,
   * btree's "name" opclass stores cstring tuples that _aren't_ even binary
   * compatible, in the strictest sense.  We directly handle that here.)
   */
  if (scandesc->xs_hitup)
  {
    Assert(slot->tts_tupleDescriptor->natts == scandesc->xs_hitupdesc->natts);

    heap_deform_tuple(scandesc->xs_hitup, scandesc->xs_hitupdesc,
              slot->tts_values, slot->tts_isnull);
  }
  else if (scandesc->xs_itup)
  {
    Assert(slot->tts_tupleDescriptor->natts == scandesc->xs_itupdesc->natts);

    index_deform_tuple(scandesc->xs_itup, scandesc->xs_itupdesc,
               slot->tts_values, slot->tts_isnull);

    /*
     * Copy all name columns stored as cstrings back into a NAMEDATALEN
     * byte sized allocation.  We mark this branch as unlikely as
     * generally "name" is used only for the system catalogs and this
     * would have to be a user query running on those or some other user
     * table with an index on a name column.
     */
    if (unlikely(node->ioss_NameCStringAttNums != NULL))
    {
      int     attcount = node->ioss_NameCStringCount;

      for (int idx = 0; idx < attcount; idx++)
      {
        int     attnum = node->ioss_NameCStringAttNums[idx];
        Name    name;

        /* skip null Datums */
        if (slot->tts_isnull[attnum])
          continue;

        /*
         * allocate the NAMEDATALEN and copy the datum into that
         * memory
         */
        name = (Name) MemoryContextAlloc(node->ss.ps.ps_ExprContext->ecxt_per_tuple_memory,
                         NAMEDATALEN);

        /* use namestrcpy to zero-pad all trailing bytes */
        namestrcpy(name, DatumGetCString(slot->tts_values[attnum]));
        slot->tts_values[attnum] = NameGetDatum(name);
      }
    }
  }
  else
    elog(ERROR, "no data returned for index-only scan");

  ExecStoreVirtualTuple(slot);
}

/*
 * IndexOnlyRecheck -- access method routine to recheck a tuple in EvalPlanQual
 *
 * This can't really happen, since an index can't supply CTID which would
 * be necessary data for any potential EvalPlanQual target relation.  If it
 * did happen, the EPQ code would pass us the wrong data, namely a heap
 * tuple not an index tuple.  So throw an error.
 */
static bool
IndexOnlyRecheck(IndexOnlyScanState *node, TupleTableSlot *slot)
{
  elog(ERROR, "EvalPlanQual recheck is not supported in index-only scans");
  return false;       /* keep compiler quiet */
}

/* ----------------------------------------------------------------
 *    ExecIndexOnlyScan(node)
 * ----------------------------------------------------------------
 */
static TupleTableSlot *
ExecIndexOnlyScan(PlanState *pstate)
{
  IndexOnlyScanState *node = castNode(IndexOnlyScanState, pstate);

  /*
   * If we have runtime keys and they've not already been set up, do it now.
   */
  if (node->ioss_NumRuntimeKeys != 0 && !node->ioss_RuntimeKeysReady)
    ExecReScan((PlanState *) node);

  return ExecScan(&node->ss,
          (ExecScanAccessMtd) IndexOnlyNext,
          (ExecScanRecheckMtd) IndexOnlyRecheck);
}

/* ----------------------------------------------------------------
 *    ExecReScanIndexOnlyScan(node)
 *
 *    Recalculates the values of any scan keys whose value depends on
 *    information known at runtime, then rescans the indexed relation.
 *
 *    Updating the scan key was formerly done separately in
 *    ExecUpdateIndexScanKeys. Integrating it into ReScan makes
 *    rescans of indices and relations/general streams more uniform.
 * ----------------------------------------------------------------
 */
void
ExecReScanIndexOnlyScan(IndexOnlyScanState *node)
{
  /*
   * If we are doing runtime key calculations (ie, any of the index key
   * values weren't simple Consts), compute the new key values.  But first,
   * reset the context so we don't leak memory as each outer tuple is
   * scanned.  Note this assumes that we will recalculate *all* runtime keys
   * on each call.
   */
  if (node->ioss_NumRuntimeKeys != 0)
  {
    ExprContext *econtext = node->ioss_RuntimeContext;

    ResetExprContext(econtext);
    ExecIndexEvalRuntimeKeys(econtext,
                 node->ioss_RuntimeKeys,
                 node->ioss_NumRuntimeKeys);
  }
  node->ioss_RuntimeKeysReady = true;

  /* reset index scan */
  if (node->ioss_ScanDesc)
    index_rescan(node->ioss_ScanDesc,
           node->ioss_ScanKeys, node->ioss_NumScanKeys,
           node->ioss_OrderByKeys, node->ioss_NumOrderByKeys);

  ExecScanReScan(&node->ss);
}


/* ----------------------------------------------------------------
 *    ExecEndIndexOnlyScan
 * ----------------------------------------------------------------
 */
void
ExecEndIndexOnlyScan(IndexOnlyScanState *node)
{
  Relation  indexRelationDesc;
  IndexScanDesc indexScanDesc;

  /*
   * extract information from the node
   */
  indexRelationDesc = node->ioss_RelationDesc;
  indexScanDesc = node->ioss_ScanDesc;

  /* Release VM buffer pin, if any. */
  if (node->ioss_VMBuffer != InvalidBuffer)
  {
    ReleaseBuffer(node->ioss_VMBuffer);
    node->ioss_VMBuffer = InvalidBuffer;
  }

  /*
   * When ending a parallel worker, copy the statistics gathered by the
   * worker back into shared memory so that it can be picked up by the main
   * process to report in EXPLAIN ANALYZE
   */
  if (node->ioss_SharedInfo != NULL && IsParallelWorker())
  {
    IndexScanInstrumentation *winstrument;

    Assert(ParallelWorkerNumber < node->ioss_SharedInfo->num_workers);
    winstrument = &node->ioss_SharedInfo->winstrument[ParallelWorkerNumber];

    /*
     * We have to accumulate the stats rather than performing a memcpy.
     * When a Gather/GatherMerge node finishes it will perform planner
     * shutdown on the workers.  On rescan it will spin up new workers
     * which will have a new IndexOnlyScanState and zeroed stats.
     */
    winstrument->nsearches += node->ioss_Instrument->nsearches;
  }

  /*
   * close the index relation (no-op if we didn't open it)
   */
  if (indexScanDesc)
    index_endscan(indexScanDesc);
  if (indexRelationDesc)
    index_close(indexRelationDesc, NoLock);
}

/* ----------------------------------------------------------------
 *    ExecIndexOnlyMarkPos
 *
 * Note: we assume that no caller attempts to set a mark before having read
 * at least one tuple.  Otherwise, ioss_ScanDesc might still be NULL.
 * ----------------------------------------------------------------
 */
void
ExecIndexOnlyMarkPos(IndexOnlyScanState *node)
{
  EState     *estate = node->ss.ps.state;
  EPQState   *epqstate = estate->es_epq_active;

  if (epqstate != NULL)
  {
    /*
     * We are inside an EvalPlanQual recheck.  If a test tuple exists for
     * this relation, then we shouldn't access the index at all.  We would
     * instead need to save, and later restore, the state of the
     * relsubs_done flag, so that re-fetching the test tuple is possible.
     * However, given the assumption that no caller sets a mark at the
     * start of the scan, we can only get here with relsubs_done[i]
     * already set, and so no state need be saved.
     */
    Index   scanrelid = ((Scan *) node->ss.ps.plan)->scanrelid;

    Assert(scanrelid > 0);
    if (epqstate->relsubs_slot[scanrelid - 1] != NULL ||
      epqstate->relsubs_rowmark[scanrelid - 1] != NULL)
    {
      /* Verify the claim above */
      if (!epqstate->relsubs_done[scanrelid - 1])
        elog(ERROR, "unexpected ExecIndexOnlyMarkPos call in EPQ recheck");
      return;
    }
  }

  index_markpos(node->ioss_ScanDesc);
}

/* ----------------------------------------------------------------
 *    ExecIndexOnlyRestrPos
 * ----------------------------------------------------------------
 */
void
ExecIndexOnlyRestrPos(IndexOnlyScanState *node)
{
  EState     *estate = node->ss.ps.state;
  EPQState   *epqstate = estate->es_epq_active;

  if (estate->es_epq_active != NULL)
  {
    /* See comments in ExecIndexMarkPos */
    Index   scanrelid = ((Scan *) node->ss.ps.plan)->scanrelid;

    Assert(scanrelid > 0);
    if (epqstate->relsubs_slot[scanrelid - 1] != NULL ||
      epqstate->relsubs_rowmark[scanrelid - 1] != NULL)
    {
      /* Verify the claim above */
      if (!epqstate->relsubs_done[scanrelid - 1])
        elog(ERROR, "unexpected ExecIndexOnlyRestrPos call in EPQ recheck");
      return;
    }
  }

  index_restrpos(node->ioss_ScanDesc);
}

/* ----------------------------------------------------------------
 *    ExecInitIndexOnlyScan
 *
 *    Initializes the index scan's state information, creates
 *    scan keys, and opens the base and index relations.
 *
 *    Note: index scans have 2 sets of state information because
 *        we have to keep track of the base relation and the
 *        index relation.
 * ----------------------------------------------------------------
 */
IndexOnlyScanState *
ExecInitIndexOnlyScan(IndexOnlyScan *node, EState *estate, int eflags)
{
  IndexOnlyScanState *indexstate;
  Relation  currentRelation;
  Relation  indexRelation;
  LOCKMODE  lockmode;
  TupleDesc tupDesc;
  int     indnkeyatts;
  int     namecount;

  /*
   * create state structure
   */
  indexstate = makeNode(IndexOnlyScanState);
  indexstate->ss.ps.plan = (Plan *) node;
  indexstate->ss.ps.state = estate;
  indexstate->ss.ps.ExecProcNode = ExecIndexOnlyScan;

  /*
   * Miscellaneous initialization
   *
   * create expression context for node
   */
  ExecAssignExprContext(estate, &indexstate->ss.ps);

  /*
   * open the scan relation
   */
  currentRelation = ExecOpenScanRelation(estate, node->scan.scanrelid, eflags);

  indexstate->ss.ss_currentRelation = currentRelation;
  indexstate->ss.ss_currentScanDesc = NULL; /* no heap scan here */

  /*
   * Build the scan tuple type using the indextlist generated by the
   * planner.  We use this, rather than the index's physical tuple
   * descriptor, because the latter contains storage column types not the
   * types of the original datums.  (It's the AM's responsibility to return
   * suitable data anyway.)
   */
  tupDesc = ExecTypeFromTL(node->indextlist);
  ExecInitScanTupleSlot(estate, &indexstate->ss, tupDesc,
              &TTSOpsVirtual,
              0);

  /*
   * We need another slot, in a format that's suitable for the table AM, for
   * when we need to fetch a tuple from the table for rechecking visibility.
   */
  indexstate->ioss_TableSlot =
    ExecAllocTableSlot(&estate->es_tupleTable,
               RelationGetDescr(currentRelation),
               table_slot_callbacks(currentRelation), 0);

  /*
   * Initialize result type and projection info.  The node's targetlist will
   * contain Vars with varno = INDEX_VAR, referencing the scan tuple.
   */
  ExecInitResultTypeTL(&indexstate->ss.ps);
  ExecAssignScanProjectionInfoWithVarno(&indexstate->ss, INDEX_VAR);

  /*
   * initialize child expressions
   *
   * Note: we don't initialize all of the indexorderby expression, only the
   * sub-parts corresponding to runtime keys (see below).
   */
  indexstate->ss.ps.qual =
    ExecInitQual(node->scan.plan.qual, (PlanState *) indexstate);
  indexstate->recheckqual =
    ExecInitQual(node->recheckqual, (PlanState *) indexstate);

  /*
   * If we are just doing EXPLAIN (ie, aren't going to run the plan), stop
   * here.  This allows an index-advisor plugin to EXPLAIN a plan containing
   * references to nonexistent indexes.
   */
  if (eflags & EXEC_FLAG_EXPLAIN_ONLY)
    return indexstate;

  /* Set up instrumentation of index-only scans if requested */
  if (estate->es_instrument)
    indexstate->ioss_Instrument = palloc0_object(IndexScanInstrumentation);

  /* Open the index relation. */
  lockmode = exec_rt_fetch(node->scan.scanrelid, estate)->rellockmode;
  indexRelation = index_open(node->indexid, lockmode);
  indexstate->ioss_RelationDesc = indexRelation;

  /*
   * Initialize index-specific scan state
   */
  indexstate->ioss_RuntimeKeysReady = false;
  indexstate->ioss_RuntimeKeys = NULL;
  indexstate->ioss_NumRuntimeKeys = 0;

  /*
   * build the index scan keys from the index qualification
   */
  ExecIndexBuildScanKeys((PlanState *) indexstate,
               indexRelation,
               node->indexqual,
               false,
               &indexstate->ioss_ScanKeys,
               &indexstate->ioss_NumScanKeys,
               &indexstate->ioss_RuntimeKeys,
               &indexstate->ioss_NumRuntimeKeys,
               NULL, /* no ArrayKeys */
               NULL);

  /*
   * any ORDER BY exprs have to be turned into scankeys in the same way
   */
  ExecIndexBuildScanKeys((PlanState *) indexstate,
               indexRelation,
               node->indexorderby,
               true,
               &indexstate->ioss_OrderByKeys,
               &indexstate->ioss_NumOrderByKeys,
               &indexstate->ioss_RuntimeKeys,
               &indexstate->ioss_NumRuntimeKeys,
               NULL, /* no ArrayKeys */
               NULL);

  /*
   * If we have runtime keys, we need an ExprContext to evaluate them. The
   * node's standard context won't do because we want to reset that context
   * for every tuple.  So, build another context just like the other one...
   * -tgl 7/11/00
   */
  if (indexstate->ioss_NumRuntimeKeys != 0)
  {
    ExprContext *stdecontext = indexstate->ss.ps.ps_ExprContext;

    ExecAssignExprContext(estate, &indexstate->ss.ps);
    indexstate->ioss_RuntimeContext = indexstate->ss.ps.ps_ExprContext;
    indexstate->ss.ps.ps_ExprContext = stdecontext;
  }
  else
  {
    indexstate->ioss_RuntimeContext = NULL;
  }

  indexstate->ioss_NameCStringAttNums = NULL;
  indnkeyatts = indexRelation->rd_index->indnkeyatts;
  namecount = 0;

  /*
   * The "name" type for btree uses text_ops which results in storing
   * cstrings in the indexed keys rather than names.  Here we detect that in
   * a generic way in case other index AMs want to do the same optimization.
   * Check for opclasses with an opcintype of NAMEOID and an index tuple
   * descriptor with CSTRINGOID.  If any of these are found, create an array
   * marking the index attribute number of each of them.  StoreIndexTuple()
   * handles copying the name Datums into a NAMEDATALEN-byte allocation.
   */

  /* First, count the number of such index keys */
  for (int attnum = 0; attnum < indnkeyatts; attnum++)
  {
    if (TupleDescAttr(indexRelation->rd_att, attnum)->atttypid == CSTRINGOID &&
      indexRelation->rd_opcintype[attnum] == NAMEOID)
      namecount++;
  }

  if (namecount > 0)
  {
    int     idx = 0;

    /*
     * Now create an array to mark the attribute numbers of the keys that
     * need to be converted from cstring to name.
     */
    indexstate->ioss_NameCStringAttNums = palloc_array(AttrNumber, namecount);

    for (int attnum = 0; attnum < indnkeyatts; attnum++)
    {
      if (TupleDescAttr(indexRelation->rd_att, attnum)->atttypid == CSTRINGOID &&
        indexRelation->rd_opcintype[attnum] == NAMEOID)
        indexstate->ioss_NameCStringAttNums[idx++] = (AttrNumber) attnum;
    }
  }

  indexstate->ioss_NameCStringCount = namecount;

  /*
   * all done.
   */
  return indexstate;
}

/* ----------------------------------------------------------------
 *    Parallel Index-only Scan Support
 * ----------------------------------------------------------------
 */

/* ----------------------------------------------------------------
 *    ExecIndexOnlyScanEstimate
 *
 *    Compute the amount of space we'll need in the parallel
 *    query DSM, and inform pcxt->estimator about our needs.
 * ----------------------------------------------------------------
 */
void
ExecIndexOnlyScanEstimate(IndexOnlyScanState *node,
              ParallelContext *pcxt)
{
  EState     *estate = node->ss.ps.state;

  node->ioss_PscanLen = index_parallelscan_estimate(node->ioss_RelationDesc,
                            node->ioss_NumScanKeys,
                            node->ioss_NumOrderByKeys,
                            estate->es_snapshot);
  shm_toc_estimate_chunk(&pcxt->estimator, node->ioss_PscanLen);
  shm_toc_estimate_keys(&pcxt->estimator, 1);
}

/* ----------------------------------------------------------------
 *    ExecIndexOnlyScanInitializeDSM
 *
 *    Set up a parallel index-only scan descriptor.
 * ----------------------------------------------------------------
 */
void
ExecIndexOnlyScanInitializeDSM(IndexOnlyScanState *node,
                 ParallelContext *pcxt)
{
  EState     *estate = node->ss.ps.state;
  ParallelIndexScanDesc piscan;

  piscan = shm_toc_allocate(pcxt->toc, node->ioss_PscanLen);
  index_parallelscan_initialize(node->ss.ss_currentRelation,
                  node->ioss_RelationDesc,
                  estate->es_snapshot,
                  piscan);
  shm_toc_insert(pcxt->toc, node->ss.ps.plan->plan_node_id, piscan);

  node->ioss_ScanDesc =
    index_beginscan_parallel(node->ss.ss_currentRelation,
                 node->ioss_RelationDesc,
                 node->ioss_Instrument,
                 node->ioss_NumScanKeys,
                 node->ioss_NumOrderByKeys,
                 piscan,
                 ScanRelIsReadOnly(&node->ss) ?
                 SO_HINT_REL_READ_ONLY : SO_NONE);
  node->ioss_ScanDesc->xs_want_itup = true;
  node->ioss_VMBuffer = InvalidBuffer;

  /*
   * If no run-time keys to calculate or they are ready, go ahead and pass
   * the scankeys to the index AM.
   */
  if (node->ioss_NumRuntimeKeys == 0 || node->ioss_RuntimeKeysReady)
    index_rescan(node->ioss_ScanDesc,
           node->ioss_ScanKeys, node->ioss_NumScanKeys,
           node->ioss_OrderByKeys, node->ioss_NumOrderByKeys);
}

/* ----------------------------------------------------------------
 *    ExecIndexOnlyScanReInitializeDSM
 *
 *    Reset shared state before beginning a fresh scan.
 * ----------------------------------------------------------------
 */
void
ExecIndexOnlyScanReInitializeDSM(IndexOnlyScanState *node,
                 ParallelContext *pcxt)
{
  Assert(node->ss.ps.plan->parallel_aware);
  index_parallelrescan(node->ioss_ScanDesc);
}

/* ----------------------------------------------------------------
 *    ExecIndexOnlyScanInitializeWorker
 *
 *    Copy relevant information from TOC into planstate.
 * ----------------------------------------------------------------
 */
void
ExecIndexOnlyScanInitializeWorker(IndexOnlyScanState *node,
                  ParallelWorkerContext *pwcxt)
{
  ParallelIndexScanDesc piscan;

  piscan = shm_toc_lookup(pwcxt->toc, node->ss.ps.plan->plan_node_id, false);

  node->ioss_ScanDesc =
    index_beginscan_parallel(node->ss.ss_currentRelation,
                 node->ioss_RelationDesc,
                 node->ioss_Instrument,
                 node->ioss_NumScanKeys,
                 node->ioss_NumOrderByKeys,
                 piscan,
                 ScanRelIsReadOnly(&node->ss) ?
                 SO_HINT_REL_READ_ONLY : SO_NONE);
  node->ioss_ScanDesc->xs_want_itup = true;

  /*
   * If no run-time keys to calculate or they are ready, go ahead and pass
   * the scankeys to the index AM.
   */
  if (node->ioss_NumRuntimeKeys == 0 || node->ioss_RuntimeKeysReady)
    index_rescan(node->ioss_ScanDesc,
           node->ioss_ScanKeys, node->ioss_NumScanKeys,
           node->ioss_OrderByKeys, node->ioss_NumOrderByKeys);
}

/*
 * Compute the amount of space we'll need for the shared instrumentation and
 * inform pcxt->estimator.
 */
void
ExecIndexOnlyScanInstrumentEstimate(IndexOnlyScanState *node,
                  ParallelContext *pcxt)
{
  Size    size;

  if (!node->ss.ps.instrument || pcxt->nworkers == 0)
    return;

  /*
   * This size calculation is trivial enough that we don't bother saving it
   * in the IndexOnlyScanState. We'll recalculate the needed size in
   * ExecIndexOnlyScanInstrumentInitDSM().
   */
  size = add_size(offsetof(SharedIndexScanInstrumentation, winstrument),
          mul_size(pcxt->nworkers, sizeof(IndexScanInstrumentation)));
  shm_toc_estimate_chunk(&pcxt->estimator, size);
  shm_toc_estimate_keys(&pcxt->estimator, 1);
}

/*
 * Set up parallel index-only scan instrumentation.
 */
void
ExecIndexOnlyScanInstrumentInitDSM(IndexOnlyScanState *node,
                   ParallelContext *pcxt)
{
  Size    size;

  if (!node->ss.ps.instrument || pcxt->nworkers == 0)
    return;

  size = add_size(offsetof(SharedIndexScanInstrumentation, winstrument),
          mul_size(pcxt->nworkers, sizeof(IndexScanInstrumentation)));
  node->ioss_SharedInfo =
    (SharedIndexScanInstrumentation *) shm_toc_allocate(pcxt->toc, size);

  /* Each per-worker area must start out as zeroes */
  memset(node->ioss_SharedInfo, 0, size);
  node->ioss_SharedInfo->num_workers = pcxt->nworkers;
  shm_toc_insert(pcxt->toc,
           node->ss.ps.plan->plan_node_id +
           PARALLEL_KEY_SCAN_INSTRUMENT_OFFSET,
           node->ioss_SharedInfo);
}

/*
 * Look up and save the location of the shared instrumentation.
 */
void
ExecIndexOnlyScanInstrumentInitWorker(IndexOnlyScanState *node,
                    ParallelWorkerContext *pwcxt)
{
  if (!node->ss.ps.instrument)
    return;

  node->ioss_SharedInfo = (SharedIndexScanInstrumentation *)
    shm_toc_lookup(pwcxt->toc,
             node->ss.ps.plan->plan_node_id +
             PARALLEL_KEY_SCAN_INSTRUMENT_OFFSET,
             false);
}

/* ----------------------------------------------------------------
 *    ExecIndexOnlyScanRetrieveInstrumentation
 *
 *    Transfer index-only scan statistics from DSM to private memory.
 * ----------------------------------------------------------------
 */
void
ExecIndexOnlyScanRetrieveInstrumentation(IndexOnlyScanState *node)
{
  SharedIndexScanInstrumentation *SharedInfo = node->ioss_SharedInfo;
  size_t    size;

  if (SharedInfo == NULL)
    return;

  /* Create a copy of SharedInfo in backend-local memory */
  size = offsetof(SharedIndexScanInstrumentation, winstrument) +
    SharedInfo->num_workers * sizeof(IndexScanInstrumentation);
  node->ioss_SharedInfo = palloc(size);
  memcpy(node->ioss_SharedInfo, SharedInfo, size);
}

Coverage Report

Created: 2026-08-13 07:12