LCOV - code coverage report
Current view: top level - src/backend/access/index - genam.c (source / functions) Hit Total Coverage
Test: PostgreSQL 17devel Lines: 161 192 83.9 %
Date: 2023-12-11 16:10:55 Functions: 11 12 91.7 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * genam.c
       4             :  *    general index access method routines
       5             :  *
       6             :  * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  *
      10             :  * IDENTIFICATION
      11             :  *    src/backend/access/index/genam.c
      12             :  *
      13             :  * NOTES
      14             :  *    many of the old access method routines have been turned into
      15             :  *    macros and moved to genam.h -cim 4/30/91
      16             :  *
      17             :  *-------------------------------------------------------------------------
      18             :  */
      19             : 
      20             : #include "postgres.h"
      21             : 
      22             : #include "access/genam.h"
      23             : #include "access/heapam.h"
      24             : #include "access/relscan.h"
      25             : #include "access/tableam.h"
      26             : #include "access/transam.h"
      27             : #include "catalog/index.h"
      28             : #include "lib/stringinfo.h"
      29             : #include "miscadmin.h"
      30             : #include "storage/bufmgr.h"
      31             : #include "storage/procarray.h"
      32             : #include "utils/acl.h"
      33             : #include "utils/builtins.h"
      34             : #include "utils/lsyscache.h"
      35             : #include "utils/rel.h"
      36             : #include "utils/rls.h"
      37             : #include "utils/ruleutils.h"
      38             : #include "utils/snapmgr.h"
      39             : #include "utils/syscache.h"
      40             : 
      41             : 
      42             : /* ----------------------------------------------------------------
      43             :  *      general access method routines
      44             :  *
      45             :  *      All indexed access methods use an identical scan structure.
      46             :  *      We don't know how the various AMs do locking, however, so we don't
      47             :  *      do anything about that here.
      48             :  *
      49             :  *      The intent is that an AM implementor will define a beginscan routine
      50             :  *      that calls RelationGetIndexScan, to fill in the scan, and then does
      51             :  *      whatever kind of locking he wants.
      52             :  *
      53             :  *      At the end of a scan, the AM's endscan routine undoes the locking,
      54             :  *      but does *not* call IndexScanEnd --- the higher-level index_endscan
      55             :  *      routine does that.  (We can't do it in the AM because index_endscan
      56             :  *      still needs to touch the IndexScanDesc after calling the AM.)
      57             :  *
      58             :  *      Because of this, the AM does not have a choice whether to call
      59             :  *      RelationGetIndexScan or not; its beginscan routine must return an
      60             :  *      object made by RelationGetIndexScan.  This is kinda ugly but not
      61             :  *      worth cleaning up now.
      62             :  * ----------------------------------------------------------------
      63             :  */
      64             : 
      65             : /* ----------------
      66             :  *  RelationGetIndexScan -- Create and fill an IndexScanDesc.
      67             :  *
      68             :  *      This routine creates an index scan structure and sets up initial
      69             :  *      contents for it.
      70             :  *
      71             :  *      Parameters:
      72             :  *              indexRelation -- index relation for scan.
      73             :  *              nkeys -- count of scan keys (index qual conditions).
      74             :  *              norderbys -- count of index order-by operators.
      75             :  *
      76             :  *      Returns:
      77             :  *              An initialized IndexScanDesc.
      78             :  * ----------------
      79             :  */
      80             : IndexScanDesc
      81     9930400 : RelationGetIndexScan(Relation indexRelation, int nkeys, int norderbys)
      82             : {
      83             :     IndexScanDesc scan;
      84             : 
      85     9930400 :     scan = (IndexScanDesc) palloc(sizeof(IndexScanDescData));
      86             : 
      87     9930400 :     scan->heapRelation = NULL;   /* may be set later */
      88     9930400 :     scan->xs_heapfetch = NULL;
      89     9930400 :     scan->indexRelation = indexRelation;
      90     9930400 :     scan->xs_snapshot = InvalidSnapshot; /* caller must initialize this */
      91     9930400 :     scan->numberOfKeys = nkeys;
      92     9930400 :     scan->numberOfOrderBys = norderbys;
      93             : 
      94             :     /*
      95             :      * We allocate key workspace here, but it won't get filled until amrescan.
      96             :      */
      97     9930400 :     if (nkeys > 0)
      98     9919932 :         scan->keyData = (ScanKey) palloc(sizeof(ScanKeyData) * nkeys);
      99             :     else
     100       10468 :         scan->keyData = NULL;
     101     9930400 :     if (norderbys > 0)
     102         192 :         scan->orderByData = (ScanKey) palloc(sizeof(ScanKeyData) * norderbys);
     103             :     else
     104     9930208 :         scan->orderByData = NULL;
     105             : 
     106     9930400 :     scan->xs_want_itup = false; /* may be set later */
     107             : 
     108             :     /*
     109             :      * During recovery we ignore killed tuples and don't bother to kill them
     110             :      * either. We do this because the xmin on the primary node could easily be
     111             :      * later than the xmin on the standby node, so that what the primary
     112             :      * thinks is killed is supposed to be visible on standby. So for correct
     113             :      * MVCC for queries during recovery we must ignore these hints and check
     114             :      * all tuples. Do *not* set ignore_killed_tuples to true when running in a
     115             :      * transaction that was started during recovery. xactStartedInRecovery
     116             :      * should not be altered by index AMs.
     117             :      */
     118     9930400 :     scan->kill_prior_tuple = false;
     119     9930400 :     scan->xactStartedInRecovery = TransactionStartedDuringRecovery();
     120     9930400 :     scan->ignore_killed_tuples = !scan->xactStartedInRecovery;
     121             : 
     122     9930400 :     scan->opaque = NULL;
     123             : 
     124     9930400 :     scan->xs_itup = NULL;
     125     9930400 :     scan->xs_itupdesc = NULL;
     126     9930400 :     scan->xs_hitup = NULL;
     127     9930400 :     scan->xs_hitupdesc = NULL;
     128             : 
     129     9930400 :     return scan;
     130             : }
     131             : 
     132             : /* ----------------
     133             :  *  IndexScanEnd -- End an index scan.
     134             :  *
     135             :  *      This routine just releases the storage acquired by
     136             :  *      RelationGetIndexScan().  Any AM-level resources are
     137             :  *      assumed to already have been released by the AM's
     138             :  *      endscan routine.
     139             :  *
     140             :  *  Returns:
     141             :  *      None.
     142             :  * ----------------
     143             :  */
     144             : void
     145     9928918 : IndexScanEnd(IndexScanDesc scan)
     146             : {
     147     9928918 :     if (scan->keyData != NULL)
     148     9918560 :         pfree(scan->keyData);
     149     9928918 :     if (scan->orderByData != NULL)
     150         186 :         pfree(scan->orderByData);
     151             : 
     152     9928918 :     pfree(scan);
     153     9928918 : }
     154             : 
     155             : /*
     156             :  * BuildIndexValueDescription
     157             :  *
     158             :  * Construct a string describing the contents of an index entry, in the
     159             :  * form "(key_name, ...)=(key_value, ...)".  This is currently used
     160             :  * for building unique-constraint and exclusion-constraint error messages,
     161             :  * so only key columns of the index are checked and printed.
     162             :  *
     163             :  * Note that if the user does not have permissions to view all of the
     164             :  * columns involved then a NULL is returned.  Returning a partial key seems
     165             :  * unlikely to be useful and we have no way to know which of the columns the
     166             :  * user provided (unlike in ExecBuildSlotValueDescription).
     167             :  *
     168             :  * The passed-in values/nulls arrays are the "raw" input to the index AM,
     169             :  * e.g. results of FormIndexDatum --- this is not necessarily what is stored
     170             :  * in the index, but it's what the user perceives to be stored.
     171             :  *
     172             :  * Note: if you change anything here, check whether
     173             :  * ExecBuildSlotPartitionKeyDescription() in execMain.c needs a similar
     174             :  * change.
     175             :  */
     176             : char *
     177         736 : BuildIndexValueDescription(Relation indexRelation,
     178             :                            const Datum *values, const bool *isnull)
     179             : {
     180             :     StringInfoData buf;
     181             :     Form_pg_index idxrec;
     182             :     int         indnkeyatts;
     183             :     int         i;
     184             :     int         keyno;
     185         736 :     Oid         indexrelid = RelationGetRelid(indexRelation);
     186             :     Oid         indrelid;
     187             :     AclResult   aclresult;
     188             : 
     189         736 :     indnkeyatts = IndexRelationGetNumberOfKeyAttributes(indexRelation);
     190             : 
     191             :     /*
     192             :      * Check permissions- if the user does not have access to view all of the
     193             :      * key columns then return NULL to avoid leaking data.
     194             :      *
     195             :      * First check if RLS is enabled for the relation.  If so, return NULL to
     196             :      * avoid leaking data.
     197             :      *
     198             :      * Next we need to check table-level SELECT access and then, if there is
     199             :      * no access there, check column-level permissions.
     200             :      */
     201         736 :     idxrec = indexRelation->rd_index;
     202         736 :     indrelid = idxrec->indrelid;
     203             :     Assert(indexrelid == idxrec->indexrelid);
     204             : 
     205             :     /* RLS check- if RLS is enabled then we don't return anything. */
     206         736 :     if (check_enable_rls(indrelid, InvalidOid, true) == RLS_ENABLED)
     207          12 :         return NULL;
     208             : 
     209             :     /* Table-level SELECT is enough, if the user has it */
     210         724 :     aclresult = pg_class_aclcheck(indrelid, GetUserId(), ACL_SELECT);
     211         724 :     if (aclresult != ACLCHECK_OK)
     212             :     {
     213             :         /*
     214             :          * No table-level access, so step through the columns in the index and
     215             :          * make sure the user has SELECT rights on all of them.
     216             :          */
     217          24 :         for (keyno = 0; keyno < indnkeyatts; keyno++)
     218             :         {
     219          24 :             AttrNumber  attnum = idxrec->indkey.values[keyno];
     220             : 
     221             :             /*
     222             :              * Note that if attnum == InvalidAttrNumber, then this is an index
     223             :              * based on an expression and we return no detail rather than try
     224             :              * to figure out what column(s) the expression includes and if the
     225             :              * user has SELECT rights on them.
     226             :              */
     227          48 :             if (attnum == InvalidAttrNumber ||
     228          24 :                 pg_attribute_aclcheck(indrelid, attnum, GetUserId(),
     229             :                                       ACL_SELECT) != ACLCHECK_OK)
     230             :             {
     231             :                 /* No access, so clean up and return */
     232          12 :                 return NULL;
     233             :             }
     234             :         }
     235             :     }
     236             : 
     237         712 :     initStringInfo(&buf);
     238         712 :     appendStringInfo(&buf, "(%s)=(",
     239             :                      pg_get_indexdef_columns(indexrelid, true));
     240             : 
     241        1562 :     for (i = 0; i < indnkeyatts; i++)
     242             :     {
     243             :         char       *val;
     244             : 
     245         850 :         if (isnull[i])
     246          18 :             val = "null";
     247             :         else
     248             :         {
     249             :             Oid         foutoid;
     250             :             bool        typisvarlena;
     251             : 
     252             :             /*
     253             :              * The provided data is not necessarily of the type stored in the
     254             :              * index; rather it is of the index opclass's input type. So look
     255             :              * at rd_opcintype not the index tupdesc.
     256             :              *
     257             :              * Note: this is a bit shaky for opclasses that have pseudotype
     258             :              * input types such as ANYARRAY or RECORD.  Currently, the
     259             :              * typoutput functions associated with the pseudotypes will work
     260             :              * okay, but we might have to try harder in future.
     261             :              */
     262         832 :             getTypeOutputInfo(indexRelation->rd_opcintype[i],
     263             :                               &foutoid, &typisvarlena);
     264         832 :             val = OidOutputFunctionCall(foutoid, values[i]);
     265             :         }
     266             : 
     267         850 :         if (i > 0)
     268         138 :             appendStringInfoString(&buf, ", ");
     269         850 :         appendStringInfoString(&buf, val);
     270             :     }
     271             : 
     272         712 :     appendStringInfoChar(&buf, ')');
     273             : 
     274         712 :     return buf.data;
     275             : }
     276             : 
     277             : /*
     278             :  * Get the snapshotConflictHorizon from the table entries pointed to by the
     279             :  * index tuples being deleted using an AM-generic approach.
     280             :  *
     281             :  * This is a table_index_delete_tuples() shim used by index AMs that only need
     282             :  * to consult the tableam to get a snapshotConflictHorizon value, and only
     283             :  * expect to delete index tuples that are already known deletable (typically
     284             :  * due to having LP_DEAD bits set).  When a snapshotConflictHorizon value
     285             :  * isn't needed in index AM's deletion WAL record, it is safe for it to skip
     286             :  * calling here entirely.
     287             :  *
     288             :  * We assume that caller index AM uses the standard IndexTuple representation,
     289             :  * with table TIDs stored in the t_tid field.  We also expect (and assert)
     290             :  * that the line pointers on page for 'itemnos' offsets are already marked
     291             :  * LP_DEAD.
     292             :  */
     293             : TransactionId
     294           0 : index_compute_xid_horizon_for_tuples(Relation irel,
     295             :                                      Relation hrel,
     296             :                                      Buffer ibuf,
     297             :                                      OffsetNumber *itemnos,
     298             :                                      int nitems)
     299             : {
     300             :     TM_IndexDeleteOp delstate;
     301           0 :     TransactionId snapshotConflictHorizon = InvalidTransactionId;
     302           0 :     Page        ipage = BufferGetPage(ibuf);
     303             :     IndexTuple  itup;
     304             : 
     305             :     Assert(nitems > 0);
     306             : 
     307           0 :     delstate.irel = irel;
     308           0 :     delstate.iblknum = BufferGetBlockNumber(ibuf);
     309           0 :     delstate.bottomup = false;
     310           0 :     delstate.bottomupfreespace = 0;
     311           0 :     delstate.ndeltids = 0;
     312           0 :     delstate.deltids = palloc(nitems * sizeof(TM_IndexDelete));
     313           0 :     delstate.status = palloc(nitems * sizeof(TM_IndexStatus));
     314             : 
     315             :     /* identify what the index tuples about to be deleted point to */
     316           0 :     for (int i = 0; i < nitems; i++)
     317             :     {
     318           0 :         OffsetNumber offnum = itemnos[i];
     319             :         ItemId      iitemid;
     320             : 
     321           0 :         iitemid = PageGetItemId(ipage, offnum);
     322           0 :         itup = (IndexTuple) PageGetItem(ipage, iitemid);
     323             : 
     324             :         Assert(ItemIdIsDead(iitemid));
     325             : 
     326           0 :         ItemPointerCopy(&itup->t_tid, &delstate.deltids[i].tid);
     327           0 :         delstate.deltids[i].id = delstate.ndeltids;
     328           0 :         delstate.status[i].idxoffnum = offnum;
     329           0 :         delstate.status[i].knowndeletable = true;   /* LP_DEAD-marked */
     330           0 :         delstate.status[i].promising = false;   /* unused */
     331           0 :         delstate.status[i].freespace = 0;   /* unused */
     332             : 
     333           0 :         delstate.ndeltids++;
     334             :     }
     335             : 
     336             :     /* determine the actual xid horizon */
     337           0 :     snapshotConflictHorizon = table_index_delete_tuples(hrel, &delstate);
     338             : 
     339             :     /* assert tableam agrees that all items are deletable */
     340             :     Assert(delstate.ndeltids == nitems);
     341             : 
     342           0 :     pfree(delstate.deltids);
     343           0 :     pfree(delstate.status);
     344             : 
     345           0 :     return snapshotConflictHorizon;
     346             : }
     347             : 
     348             : 
     349             : /* ----------------------------------------------------------------
     350             :  *      heap-or-index-scan access to system catalogs
     351             :  *
     352             :  *      These functions support system catalog accesses that normally use
     353             :  *      an index but need to be capable of being switched to heap scans
     354             :  *      if the system indexes are unavailable.
     355             :  *
     356             :  *      The specified scan keys must be compatible with the named index.
     357             :  *      Generally this means that they must constrain either all columns
     358             :  *      of the index, or the first K columns of an N-column index.
     359             :  *
     360             :  *      These routines could work with non-system tables, actually,
     361             :  *      but they're only useful when there is a known index to use with
     362             :  *      the given scan keys; so in practice they're only good for
     363             :  *      predetermined types of scans of system catalogs.
     364             :  * ----------------------------------------------------------------
     365             :  */
     366             : 
     367             : /*
     368             :  * systable_beginscan --- set up for heap-or-index scan
     369             :  *
     370             :  *  rel: catalog to scan, already opened and suitably locked
     371             :  *  indexId: OID of index to conditionally use
     372             :  *  indexOK: if false, forces a heap scan (see notes below)
     373             :  *  snapshot: time qual to use (NULL for a recent catalog snapshot)
     374             :  *  nkeys, key: scan keys
     375             :  *
     376             :  * The attribute numbers in the scan key should be set for the heap case.
     377             :  * If we choose to index, we reset them to 1..n to reference the index
     378             :  * columns.  Note this means there must be one scankey qualification per
     379             :  * index column!  This is checked by the Asserts in the normal, index-using
     380             :  * case, but won't be checked if the heapscan path is taken.
     381             :  *
     382             :  * The routine checks the normal cases for whether an indexscan is safe,
     383             :  * but caller can make additional checks and pass indexOK=false if needed.
     384             :  * In standard case indexOK can simply be constant TRUE.
     385             :  */
     386             : SysScanDesc
     387     9713318 : systable_beginscan(Relation heapRelation,
     388             :                    Oid indexId,
     389             :                    bool indexOK,
     390             :                    Snapshot snapshot,
     391             :                    int nkeys, ScanKey key)
     392             : {
     393             :     SysScanDesc sysscan;
     394             :     Relation    irel;
     395             : 
     396     9713318 :     if (indexOK &&
     397     9550236 :         !IgnoreSystemIndexes &&
     398     9491548 :         !ReindexIsProcessingIndex(indexId))
     399     9482462 :         irel = index_open(indexId, AccessShareLock);
     400             :     else
     401      230856 :         irel = NULL;
     402             : 
     403     9713310 :     sysscan = (SysScanDesc) palloc(sizeof(SysScanDescData));
     404             : 
     405     9713310 :     sysscan->heap_rel = heapRelation;
     406     9713310 :     sysscan->irel = irel;
     407     9713310 :     sysscan->slot = table_slot_create(heapRelation, NULL);
     408             : 
     409     9713310 :     if (snapshot == NULL)
     410             :     {
     411     8783306 :         Oid         relid = RelationGetRelid(heapRelation);
     412             : 
     413     8783306 :         snapshot = RegisterSnapshot(GetCatalogSnapshot(relid));
     414     8783306 :         sysscan->snapshot = snapshot;
     415             :     }
     416             :     else
     417             :     {
     418             :         /* Caller is responsible for any snapshot. */
     419      930004 :         sysscan->snapshot = NULL;
     420             :     }
     421             : 
     422     9713310 :     if (irel)
     423             :     {
     424             :         int         i;
     425             : 
     426             :         /* Change attribute numbers to be index column numbers. */
     427    25326274 :         for (i = 0; i < nkeys; i++)
     428             :         {
     429             :             int         j;
     430             : 
     431    23602364 :             for (j = 0; j < IndexRelationGetNumberOfAttributes(irel); j++)
     432             :             {
     433    23602364 :                 if (key[i].sk_attno == irel->rd_index->indkey.values[j])
     434             :                 {
     435    15843820 :                     key[i].sk_attno = j + 1;
     436    15843820 :                     break;
     437             :                 }
     438             :             }
     439    15843820 :             if (j == IndexRelationGetNumberOfAttributes(irel))
     440           0 :                 elog(ERROR, "column is not in index");
     441             :         }
     442             : 
     443     9482454 :         sysscan->iscan = index_beginscan(heapRelation, irel,
     444             :                                          snapshot, nkeys, 0);
     445     9482454 :         index_rescan(sysscan->iscan, key, nkeys, NULL, 0);
     446     9482454 :         sysscan->scan = NULL;
     447             :     }
     448             :     else
     449             :     {
     450             :         /*
     451             :          * We disallow synchronized scans when forced to use a heapscan on a
     452             :          * catalog.  In most cases the desired rows are near the front, so
     453             :          * that the unpredictable start point of a syncscan is a serious
     454             :          * disadvantage; and there are no compensating advantages, because
     455             :          * it's unlikely that such scans will occur in parallel.
     456             :          */
     457      230856 :         sysscan->scan = table_beginscan_strat(heapRelation, snapshot,
     458             :                                               nkeys, key,
     459             :                                               true, false);
     460      230856 :         sysscan->iscan = NULL;
     461             :     }
     462             : 
     463             :     /*
     464             :      * If CheckXidAlive is set then set a flag to indicate that system table
     465             :      * scan is in-progress.  See detailed comments in xact.c where these
     466             :      * variables are declared.
     467             :      */
     468     9713310 :     if (TransactionIdIsValid(CheckXidAlive))
     469        1398 :         bsysscan = true;
     470             : 
     471     9713310 :     return sysscan;
     472             : }
     473             : 
     474             : /*
     475             :  * HandleConcurrentAbort - Handle concurrent abort of the CheckXidAlive.
     476             :  *
     477             :  * Error out, if CheckXidAlive is aborted. We can't directly use
     478             :  * TransactionIdDidAbort as after crash such transaction might not have been
     479             :  * marked as aborted.  See detailed comments in xact.c where the variable
     480             :  * is declared.
     481             :  */
     482             : static inline void
     483    19972162 : HandleConcurrentAbort()
     484             : {
     485    19972162 :     if (TransactionIdIsValid(CheckXidAlive) &&
     486        2012 :         !TransactionIdIsInProgress(CheckXidAlive) &&
     487          14 :         !TransactionIdDidCommit(CheckXidAlive))
     488          14 :         ereport(ERROR,
     489             :                 (errcode(ERRCODE_TRANSACTION_ROLLBACK),
     490             :                  errmsg("transaction aborted during system catalog scan")));
     491    19972148 : }
     492             : 
     493             : /*
     494             :  * systable_getnext --- get next tuple in a heap-or-index scan
     495             :  *
     496             :  * Returns NULL if no more tuples available.
     497             :  *
     498             :  * Note that returned tuple is a reference to data in a disk buffer;
     499             :  * it must not be modified, and should be presumed inaccessible after
     500             :  * next getnext() or endscan() call.
     501             :  *
     502             :  * XXX: It'd probably make sense to offer a slot based interface, at least
     503             :  * optionally.
     504             :  */
     505             : HeapTuple
     506    19593194 : systable_getnext(SysScanDesc sysscan)
     507             : {
     508    19593194 :     HeapTuple   htup = NULL;
     509             : 
     510    19593194 :     if (sysscan->irel)
     511             :     {
     512    18043010 :         if (index_getnext_slot(sysscan->iscan, ForwardScanDirection, sysscan->slot))
     513             :         {
     514             :             bool        shouldFree;
     515             : 
     516    13494496 :             htup = ExecFetchSlotHeapTuple(sysscan->slot, false, &shouldFree);
     517             :             Assert(!shouldFree);
     518             : 
     519             :             /*
     520             :              * We currently don't need to support lossy index operators for
     521             :              * any system catalog scan.  It could be done here, using the scan
     522             :              * keys to drive the operator calls, if we arranged to save the
     523             :              * heap attnums during systable_beginscan(); this is practical
     524             :              * because we still wouldn't need to support indexes on
     525             :              * expressions.
     526             :              */
     527    13494496 :             if (sysscan->iscan->xs_recheck)
     528           0 :                 elog(ERROR, "system catalog scans with lossy index conditions are not implemented");
     529             :         }
     530             :     }
     531             :     else
     532             :     {
     533     1550184 :         if (table_scan_getnextslot(sysscan->scan, ForwardScanDirection, sysscan->slot))
     534             :         {
     535             :             bool        shouldFree;
     536             : 
     537     1490788 :             htup = ExecFetchSlotHeapTuple(sysscan->slot, false, &shouldFree);
     538             :             Assert(!shouldFree);
     539             :         }
     540             :     }
     541             : 
     542             :     /*
     543             :      * Handle the concurrent abort while fetching the catalog tuple during
     544             :      * logical streaming of a transaction.
     545             :      */
     546    19593188 :     HandleConcurrentAbort();
     547             : 
     548    19593174 :     return htup;
     549             : }
     550             : 
     551             : /*
     552             :  * systable_recheck_tuple --- recheck visibility of most-recently-fetched tuple
     553             :  *
     554             :  * In particular, determine if this tuple would be visible to a catalog scan
     555             :  * that started now.  We don't handle the case of a non-MVCC scan snapshot,
     556             :  * because no caller needs that yet.
     557             :  *
     558             :  * This is useful to test whether an object was deleted while we waited to
     559             :  * acquire lock on it.
     560             :  *
     561             :  * Note: we don't actually *need* the tuple to be passed in, but it's a
     562             :  * good crosscheck that the caller is interested in the right tuple.
     563             :  */
     564             : bool
     565      181078 : systable_recheck_tuple(SysScanDesc sysscan, HeapTuple tup)
     566             : {
     567             :     Snapshot    freshsnap;
     568             :     bool        result;
     569             : 
     570             :     Assert(tup == ExecFetchSlotHeapTuple(sysscan->slot, false, NULL));
     571             : 
     572             :     /*
     573             :      * Trust that table_tuple_satisfies_snapshot() and its subsidiaries
     574             :      * (commonly LockBuffer() and HeapTupleSatisfiesMVCC()) do not themselves
     575             :      * acquire snapshots, so we need not register the snapshot.  Those
     576             :      * facilities are too low-level to have any business scanning tables.
     577             :      */
     578      181078 :     freshsnap = GetCatalogSnapshot(RelationGetRelid(sysscan->heap_rel));
     579             : 
     580      181078 :     result = table_tuple_satisfies_snapshot(sysscan->heap_rel,
     581      181078 :                                             sysscan->slot,
     582             :                                             freshsnap);
     583             : 
     584             :     /*
     585             :      * Handle the concurrent abort while fetching the catalog tuple during
     586             :      * logical streaming of a transaction.
     587             :      */
     588      181078 :     HandleConcurrentAbort();
     589             : 
     590      181078 :     return result;
     591             : }
     592             : 
     593             : /*
     594             :  * systable_endscan --- close scan, release resources
     595             :  *
     596             :  * Note that it's still up to the caller to close the heap relation.
     597             :  */
     598             : void
     599     9712756 : systable_endscan(SysScanDesc sysscan)
     600             : {
     601     9712756 :     if (sysscan->slot)
     602             :     {
     603     9712756 :         ExecDropSingleTupleTableSlot(sysscan->slot);
     604     9712756 :         sysscan->slot = NULL;
     605             :     }
     606             : 
     607     9712756 :     if (sysscan->irel)
     608             :     {
     609     9481918 :         index_endscan(sysscan->iscan);
     610     9481918 :         index_close(sysscan->irel, AccessShareLock);
     611             :     }
     612             :     else
     613      230838 :         table_endscan(sysscan->scan);
     614             : 
     615     9712756 :     if (sysscan->snapshot)
     616     8782752 :         UnregisterSnapshot(sysscan->snapshot);
     617             : 
     618             :     /*
     619             :      * Reset the bsysscan flag at the end of the systable scan.  See detailed
     620             :      * comments in xact.c where these variables are declared.
     621             :      */
     622     9712756 :     if (TransactionIdIsValid(CheckXidAlive))
     623        1384 :         bsysscan = false;
     624             : 
     625     9712756 :     pfree(sysscan);
     626     9712756 : }
     627             : 
     628             : 
     629             : /*
     630             :  * systable_beginscan_ordered --- set up for ordered catalog scan
     631             :  *
     632             :  * These routines have essentially the same API as systable_beginscan etc,
     633             :  * except that they guarantee to return multiple matching tuples in
     634             :  * index order.  Also, for largely historical reasons, the index to use
     635             :  * is opened and locked by the caller, not here.
     636             :  *
     637             :  * Currently we do not support non-index-based scans here.  (In principle
     638             :  * we could do a heapscan and sort, but the uses are in places that
     639             :  * probably don't need to still work with corrupted catalog indexes.)
     640             :  * For the moment, therefore, these functions are merely the thinest of
     641             :  * wrappers around index_beginscan/index_getnext_slot.  The main reason for
     642             :  * their existence is to centralize possible future support of lossy operators
     643             :  * in catalog scans.
     644             :  */
     645             : SysScanDesc
     646       49538 : systable_beginscan_ordered(Relation heapRelation,
     647             :                            Relation indexRelation,
     648             :                            Snapshot snapshot,
     649             :                            int nkeys, ScanKey key)
     650             : {
     651             :     SysScanDesc sysscan;
     652             :     int         i;
     653             : 
     654             :     /* REINDEX can probably be a hard error here ... */
     655       49538 :     if (ReindexIsProcessingIndex(RelationGetRelid(indexRelation)))
     656           0 :         elog(ERROR, "cannot do ordered scan on index \"%s\", because it is being reindexed",
     657             :              RelationGetRelationName(indexRelation));
     658             :     /* ... but we only throw a warning about violating IgnoreSystemIndexes */
     659       49538 :     if (IgnoreSystemIndexes)
     660           0 :         elog(WARNING, "using index \"%s\" despite IgnoreSystemIndexes",
     661             :              RelationGetRelationName(indexRelation));
     662             : 
     663       49538 :     sysscan = (SysScanDesc) palloc(sizeof(SysScanDescData));
     664             : 
     665       49538 :     sysscan->heap_rel = heapRelation;
     666       49538 :     sysscan->irel = indexRelation;
     667       49538 :     sysscan->slot = table_slot_create(heapRelation, NULL);
     668             : 
     669       49538 :     if (snapshot == NULL)
     670             :     {
     671        7692 :         Oid         relid = RelationGetRelid(heapRelation);
     672             : 
     673        7692 :         snapshot = RegisterSnapshot(GetCatalogSnapshot(relid));
     674        7692 :         sysscan->snapshot = snapshot;
     675             :     }
     676             :     else
     677             :     {
     678             :         /* Caller is responsible for any snapshot. */
     679       41846 :         sysscan->snapshot = NULL;
     680             :     }
     681             : 
     682             :     /* Change attribute numbers to be index column numbers. */
     683       96490 :     for (i = 0; i < nkeys; i++)
     684             :     {
     685             :         int         j;
     686             : 
     687       50198 :         for (j = 0; j < IndexRelationGetNumberOfAttributes(indexRelation); j++)
     688             :         {
     689       50198 :             if (key[i].sk_attno == indexRelation->rd_index->indkey.values[j])
     690             :             {
     691       46952 :                 key[i].sk_attno = j + 1;
     692       46952 :                 break;
     693             :             }
     694             :         }
     695       46952 :         if (j == IndexRelationGetNumberOfAttributes(indexRelation))
     696           0 :             elog(ERROR, "column is not in index");
     697             :     }
     698             : 
     699       49538 :     sysscan->iscan = index_beginscan(heapRelation, indexRelation,
     700             :                                      snapshot, nkeys, 0);
     701       49538 :     index_rescan(sysscan->iscan, key, nkeys, NULL, 0);
     702       49538 :     sysscan->scan = NULL;
     703             : 
     704       49538 :     return sysscan;
     705             : }
     706             : 
     707             : /*
     708             :  * systable_getnext_ordered --- get next tuple in an ordered catalog scan
     709             :  */
     710             : HeapTuple
     711      197902 : systable_getnext_ordered(SysScanDesc sysscan, ScanDirection direction)
     712             : {
     713      197902 :     HeapTuple   htup = NULL;
     714             : 
     715             :     Assert(sysscan->irel);
     716      197902 :     if (index_getnext_slot(sysscan->iscan, direction, sysscan->slot))
     717      149600 :         htup = ExecFetchSlotHeapTuple(sysscan->slot, false, NULL);
     718             : 
     719             :     /* See notes in systable_getnext */
     720      197896 :     if (htup && sysscan->iscan->xs_recheck)
     721           0 :         elog(ERROR, "system catalog scans with lossy index conditions are not implemented");
     722             : 
     723             :     /*
     724             :      * Handle the concurrent abort while fetching the catalog tuple during
     725             :      * logical streaming of a transaction.
     726             :      */
     727      197896 :     HandleConcurrentAbort();
     728             : 
     729      197896 :     return htup;
     730             : }
     731             : 
     732             : /*
     733             :  * systable_endscan_ordered --- close scan, release resources
     734             :  */
     735             : void
     736       49514 : systable_endscan_ordered(SysScanDesc sysscan)
     737             : {
     738       49514 :     if (sysscan->slot)
     739             :     {
     740       49514 :         ExecDropSingleTupleTableSlot(sysscan->slot);
     741       49514 :         sysscan->slot = NULL;
     742             :     }
     743             : 
     744             :     Assert(sysscan->irel);
     745       49514 :     index_endscan(sysscan->iscan);
     746       49514 :     if (sysscan->snapshot)
     747        7674 :         UnregisterSnapshot(sysscan->snapshot);
     748       49514 :     pfree(sysscan);
     749       49514 : }

Generated by: LCOV version 1.14