genam.h File Reference

#include "access/htup.h"
#include "access/sdir.h"
#include "access/skey.h"
#include "executor/instrument_node.h"
#include "nodes/tidbitmap.h"
#include "storage/buf.h"
#include "storage/lockdefs.h"
#include "utils/snapshot.h"

Include dependency graph for genam.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	IndexBuildResult
struct	IndexVacuumInfo
struct	IndexBulkDeleteResult
struct	IndexOrderByDistance

Typedefs
typedef struct IndexInfo	IndexInfo
typedef struct TupleTableSlot	TupleTableSlot
typedef struct RelationData *	Relation
typedef struct IndexBuildResult	IndexBuildResult
typedef struct IndexVacuumInfo	IndexVacuumInfo
typedef struct IndexBulkDeleteResult	IndexBulkDeleteResult
typedef bool(*	IndexBulkDeleteCallback) (ItemPointer itemptr, void *state)
typedef struct IndexScanDescData *	IndexScanDesc
typedef struct SysScanDescData *	SysScanDesc
typedef struct ParallelIndexScanDescData *	ParallelIndexScanDesc
typedef enum IndexUniqueCheck	IndexUniqueCheck
typedef struct IndexOrderByDistance	IndexOrderByDistance

Enumerations
enum	IndexUniqueCheck { UNIQUE_CHECK_NO , UNIQUE_CHECK_YES , UNIQUE_CHECK_PARTIAL , UNIQUE_CHECK_EXISTING }

Functions
Relation	index_open (Oid relationId, LOCKMODE lockmode)
Relation	try_index_open (Oid relationId, LOCKMODE lockmode)
void	index_close (Relation relation, LOCKMODE lockmode)
bool	index_insert (Relation indexRelation, Datum *values, bool *isnull, ItemPointer heap_t_ctid, Relation heapRelation, IndexUniqueCheck checkUnique, bool indexUnchanged, IndexInfo *indexInfo)
void	index_insert_cleanup (Relation indexRelation, IndexInfo *indexInfo)
IndexScanDesc	index_beginscan (Relation heapRelation, Relation indexRelation, Snapshot snapshot, IndexScanInstrumentation *instrument, int nkeys, int norderbys)
IndexScanDesc	index_beginscan_bitmap (Relation indexRelation, Snapshot snapshot, IndexScanInstrumentation *instrument, int nkeys)
void	index_rescan (IndexScanDesc scan, ScanKey keys, int nkeys, ScanKey orderbys, int norderbys)
void	index_endscan (IndexScanDesc scan)
void	index_markpos (IndexScanDesc scan)
void	index_restrpos (IndexScanDesc scan)
Size	index_parallelscan_estimate (Relation indexRelation, int nkeys, int norderbys, Snapshot snapshot, bool instrument, bool parallel_aware, int nworkers)
void	index_parallelscan_initialize (Relation heapRelation, Relation indexRelation, Snapshot snapshot, bool instrument, bool parallel_aware, int nworkers, SharedIndexScanInstrumentation **sharedinfo, ParallelIndexScanDesc target)
void	index_parallelrescan (IndexScanDesc scan)
IndexScanDesc	index_beginscan_parallel (Relation heaprel, Relation indexrel, IndexScanInstrumentation *instrument, int nkeys, int norderbys, ParallelIndexScanDesc pscan)
ItemPointer	index_getnext_tid (IndexScanDesc scan, ScanDirection direction)
bool	index_fetch_heap (IndexScanDesc scan, TupleTableSlot *slot)
bool	index_getnext_slot (IndexScanDesc scan, ScanDirection direction, TupleTableSlot *slot)
int64	index_getbitmap (IndexScanDesc scan, TIDBitmap *bitmap)
IndexBulkDeleteResult *	index_bulk_delete (IndexVacuumInfo *info, IndexBulkDeleteResult *istat, IndexBulkDeleteCallback callback, void *callback_state)
IndexBulkDeleteResult *	index_vacuum_cleanup (IndexVacuumInfo *info, IndexBulkDeleteResult *istat)
bool	index_can_return (Relation indexRelation, int attno)
RegProcedure	index_getprocid (Relation irel, AttrNumber attnum, uint16 procnum)
FmgrInfo *	index_getprocinfo (Relation irel, AttrNumber attnum, uint16 procnum)
void	index_store_float8_orderby_distances (IndexScanDesc scan, Oid *orderByTypes, IndexOrderByDistance *distances, bool recheckOrderBy)
bytea *	index_opclass_options (Relation indrel, AttrNumber attnum, Datum attoptions, bool validate)
IndexScanDesc	RelationGetIndexScan (Relation indexRelation, int nkeys, int norderbys)
void	IndexScanEnd (IndexScanDesc scan)
char *	BuildIndexValueDescription (Relation indexRelation, const Datum *values, const bool *isnull)
TransactionId	index_compute_xid_horizon_for_tuples (Relation irel, Relation hrel, Buffer ibuf, OffsetNumber *itemnos, int nitems)
SysScanDesc	systable_beginscan (Relation heapRelation, Oid indexId, bool indexOK, Snapshot snapshot, int nkeys, ScanKey key)
HeapTuple	systable_getnext (SysScanDesc sysscan)
bool	systable_recheck_tuple (SysScanDesc sysscan, HeapTuple tup)
void	systable_endscan (SysScanDesc sysscan)
SysScanDesc	systable_beginscan_ordered (Relation heapRelation, Relation indexRelation, Snapshot snapshot, int nkeys, ScanKey key)
HeapTuple	systable_getnext_ordered (SysScanDesc sysscan, ScanDirection direction)
void	systable_endscan_ordered (SysScanDesc sysscan)
void	systable_inplace_update_begin (Relation relation, Oid indexId, bool indexOK, Snapshot snapshot, int nkeys, const ScanKeyData *key, HeapTuple *oldtupcopy, void **state)
void	systable_inplace_update_finish (void *state, HeapTuple tuple)
void	systable_inplace_update_cancel (void *state)

Typedef Documentation

IndexBuildResult

typedef struct IndexBuildResult IndexBuildResult

IndexBulkDeleteCallback

typedef bool(* IndexBulkDeleteCallback) (ItemPointer itemptr, void *state)

Definition at line 93 of file genam.h.

IndexBulkDeleteResult

typedef struct IndexBulkDeleteResult IndexBulkDeleteResult

IndexInfo

typedef struct IndexInfo IndexInfo

Definition at line 27 of file genam.h.

IndexOrderByDistance

typedef struct IndexOrderByDistance IndexOrderByDistance

IndexScanDesc

typedef struct IndexScanDescData* IndexScanDesc

Definition at line 96 of file genam.h.

IndexUniqueCheck

typedef enum IndexUniqueCheck IndexUniqueCheck

IndexVacuumInfo

typedef struct IndexVacuumInfo IndexVacuumInfo

ParallelIndexScanDesc

typedef struct ParallelIndexScanDescData* ParallelIndexScanDesc

Definition at line 99 of file genam.h.

Relation

typedef struct RelationData* Relation

Definition at line 31 of file genam.h.

SysScanDesc

typedef struct SysScanDescData* SysScanDesc

Definition at line 97 of file genam.h.

TupleTableSlot

typedef struct TupleTableSlot TupleTableSlot

Definition at line 28 of file genam.h.

Enumeration Type Documentation

IndexUniqueCheck

enum IndexUniqueCheck

Enumerator
UNIQUE_CHECK_NO
UNIQUE_CHECK_YES
UNIQUE_CHECK_PARTIAL
UNIQUE_CHECK_EXISTING

Definition at line 121 of file genam.h.

{
    UNIQUE_CHECK_NO,            /* Don't do any uniqueness checking */
    UNIQUE_CHECK_YES,           /* Enforce uniqueness at insertion time */
    UNIQUE_CHECK_PARTIAL,       /* Test uniqueness, but no error */
    UNIQUE_CHECK_EXISTING,      /* Check if existing tuple is unique */
} IndexUniqueCheck;

Function Documentation

BuildIndexValueDescription()

char * BuildIndexValueDescription ( Relation  indexRelation, const Datum *  values, const bool *  isnull  )

extern

Definition at line 178 of file genam.c.

{
    StringInfoData buf;
    Form_pg_index idxrec;
    int         indnkeyatts;
    int         i;
    int         keyno;
    Oid         indexrelid = RelationGetRelid(indexRelation);
    Oid         indrelid;
    AclResult   aclresult;
 
    indnkeyatts = IndexRelationGetNumberOfKeyAttributes(indexRelation);
 
    /*
     * Check permissions- if the user does not have access to view all of the
     * key columns then return NULL to avoid leaking data.
     *
     * First check if RLS is enabled for the relation.  If so, return NULL to
     * avoid leaking data.
     *
     * Next we need to check table-level SELECT access and then, if there is
     * no access there, check column-level permissions.
     */
    idxrec = indexRelation->rd_index;
    indrelid = idxrec->indrelid;
    Assert(indexrelid == idxrec->indexrelid);
 
    /* RLS check- if RLS is enabled then we don't return anything. */
    if (check_enable_rls(indrelid, InvalidOid, true) == RLS_ENABLED)
        return NULL;
 
    /* Table-level SELECT is enough, if the user has it */
    aclresult = pg_class_aclcheck(indrelid, GetUserId(), ACL_SELECT);
    if (aclresult != ACLCHECK_OK)
    {
        /*
         * No table-level access, so step through the columns in the index and
         * make sure the user has SELECT rights on all of them.
         */
        for (keyno = 0; keyno < indnkeyatts; keyno++)
        {
            AttrNumber  attnum = idxrec->indkey.values[keyno];
 
            /*
             * Note that if attnum == InvalidAttrNumber, then this is an index
             * based on an expression and we return no detail rather than try
             * to figure out what column(s) the expression includes and if the
             * user has SELECT rights on them.
             */
            if (attnum == InvalidAttrNumber ||
                pg_attribute_aclcheck(indrelid, attnum, GetUserId(),
                                      ACL_SELECT) != ACLCHECK_OK)
            {
                /* No access, so clean up and return */
                return NULL;
            }
        }
    }
 
    initStringInfo(&buf);
    appendStringInfo(&buf, "(%s)=(",
                     pg_get_indexdef_columns(indexrelid, true));
 
    for (i = 0; i < indnkeyatts; i++)
    {
        char       *val;
 
        if (isnull[i])
            val = "null";
        else
        {
            Oid         foutoid;
            bool        typisvarlena;
 
            /*
             * The provided data is not necessarily of the type stored in the
             * index; rather it is of the index opclass's input type. So look
             * at rd_opcintype not the index tupdesc.
             *
             * Note: this is a bit shaky for opclasses that have pseudotype
             * input types such as ANYARRAY or RECORD.  Currently, the
             * typoutput functions associated with the pseudotypes will work
             * okay, but we might have to try harder in future.
             */
            getTypeOutputInfo(indexRelation->rd_opcintype[i],
                              &foutoid, &typisvarlena);
            val = OidOutputFunctionCall(foutoid, values[i]);
        }
 
        if (i > 0)
            appendStringInfoString(&buf, ", ");
        appendStringInfoString(&buf, val);
    }
 
    appendStringInfoChar(&buf, ')');
 
    return buf.data;
}

References ACL_SELECT, ACLCHECK_OK, appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert, attnum, buf, check_enable_rls(), fb(), getTypeOutputInfo(), GetUserId(), i, IndexRelationGetNumberOfKeyAttributes, initStringInfo(), InvalidAttrNumber, InvalidOid, OidOutputFunctionCall(), pg_attribute_aclcheck(), pg_class_aclcheck(), pg_get_indexdef_columns(), RelationData::rd_index, RelationData::rd_opcintype, RelationGetRelid, RLS_ENABLED, val, and values.

Referenced by _bt_check_unique(), build_index_value_desc(), check_exclusion_or_unique_constraint(), and comparetup_index_btree_tiebreak().

index_beginscan()

IndexScanDesc index_beginscan ( Relation  heapRelation, Relation  indexRelation, Snapshot  snapshot, IndexScanInstrumentation *  instrument, int  nkeys, int  norderbys  )

extern

Definition at line 256 of file indexam.c.

{
    IndexScanDesc scan;
 
    Assert(snapshot != InvalidSnapshot);
 
    /* Check that a historic snapshot is not used for non-catalog tables */
    if (IsHistoricMVCCSnapshot(snapshot) &&
        !RelationIsAccessibleInLogicalDecoding(heapRelation))
    {
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                 errmsg("cannot query non-catalog table \"%s\" during logical decoding",
                        RelationGetRelationName(heapRelation))));
    }
 
    scan = index_beginscan_internal(indexRelation, nkeys, norderbys, snapshot, NULL, false);
 
    /*
     * Save additional parameters into the scandesc.  Everything else was set
     * up by RelationGetIndexScan.
     */
    scan->heapRelation = heapRelation;
    scan->xs_snapshot = snapshot;
    scan->instrument = instrument;
 
    /* prepare to fetch index matches from table */
    scan->xs_heapfetch = table_index_fetch_begin(heapRelation);
 
    return scan;
}

References Assert, ereport, errcode(), errmsg(), ERROR, fb(), IndexScanDescData::heapRelation, index_beginscan_internal(), IndexScanDescData::instrument, InvalidSnapshot, IsHistoricMVCCSnapshot, RelationGetRelationName, RelationIsAccessibleInLogicalDecoding, table_index_fetch_begin(), IndexScanDescData::xs_heapfetch, and IndexScanDescData::xs_snapshot.

Referenced by check_exclusion_or_unique_constraint(), get_actual_variable_endpoint(), heapam_relation_copy_for_cluster(), IndexNext(), IndexNextWithReorder(), IndexOnlyNext(), RelationFindDeletedTupleInfoByIndex(), RelationFindReplTupleByIndex(), systable_beginscan(), and systable_beginscan_ordered().

index_beginscan_bitmap()

IndexScanDesc index_beginscan_bitmap ( Relation  indexRelation, Snapshot  snapshot, IndexScanInstrumentation *  instrument, int  nkeys  )

extern

Definition at line 299 of file indexam.c.

{
    IndexScanDesc scan;
 
    Assert(snapshot != InvalidSnapshot);
 
    scan = index_beginscan_internal(indexRelation, nkeys, 0, snapshot, NULL, false);
 
    /*
     * Save additional parameters into the scandesc.  Everything else was set
     * up by RelationGetIndexScan.
     */
    scan->xs_snapshot = snapshot;
    scan->instrument = instrument;
 
    return scan;
}

References Assert, fb(), index_beginscan_internal(), IndexScanDescData::instrument, InvalidSnapshot, and IndexScanDescData::xs_snapshot.

Referenced by ExecInitBitmapIndexScan().

index_beginscan_parallel()

IndexScanDesc index_beginscan_parallel ( Relation  heaprel, Relation  indexrel, IndexScanInstrumentation *  instrument, int  nkeys, int  norderbys, ParallelIndexScanDesc  pscan  )

extern

Definition at line 593 of file indexam.c.

{
    Snapshot    snapshot;
    IndexScanDesc scan;
 
    Assert(RelFileLocatorEquals(heaprel->rd_locator, pscan->ps_locator));
    Assert(RelFileLocatorEquals(indexrel->rd_locator, pscan->ps_indexlocator));
 
    snapshot = RestoreSnapshot(pscan->ps_snapshot_data);
    RegisterSnapshot(snapshot);
    scan = index_beginscan_internal(indexrel, nkeys, norderbys, snapshot,
                                    pscan, true);
 
    /*
     * Save additional parameters into the scandesc.  Everything else was set
     * up by index_beginscan_internal.
     */
    scan->heapRelation = heaprel;
    scan->xs_snapshot = snapshot;
    scan->instrument = instrument;
 
    /* prepare to fetch index matches from table */
    scan->xs_heapfetch = table_index_fetch_begin(heaprel);
 
    return scan;
}

References Assert, fb(), IndexScanDescData::heapRelation, index_beginscan_internal(), IndexScanDescData::instrument, RelationData::rd_locator, RegisterSnapshot(), RelFileLocatorEquals, RestoreSnapshot(), table_index_fetch_begin(), IndexScanDescData::xs_heapfetch, and IndexScanDescData::xs_snapshot.

Referenced by ExecIndexOnlyScanInitializeDSM(), ExecIndexOnlyScanInitializeWorker(), ExecIndexScanInitializeDSM(), and ExecIndexScanInitializeWorker().

index_bulk_delete()

IndexBulkDeleteResult * index_bulk_delete ( IndexVacuumInfo *  info, IndexBulkDeleteResult *  istat, IndexBulkDeleteCallback  callback, void *  callback_state  )

extern

Definition at line 805 of file indexam.c.

{
    Relation    indexRelation = info->index;
 
    RELATION_CHECKS;
    CHECK_REL_PROCEDURE(ambulkdelete);
 
    return indexRelation->rd_indam->ambulkdelete(info, istat,
                                                 callback, callback_state);
}

References IndexAmRoutine::ambulkdelete, callback(), CHECK_REL_PROCEDURE, IndexVacuumInfo::index, RelationData::rd_indam, and RELATION_CHECKS.

Referenced by vac_bulkdel_one_index(), and validate_index().

index_can_return()

bool index_can_return ( Relation  indexRelation, int  attno  )

extern

Definition at line 845 of file indexam.c.

{
    RELATION_CHECKS;
 
    /* amcanreturn is optional; assume false if not provided by AM */
    if (indexRelation->rd_indam->amcanreturn == NULL)
        return false;
 
    return indexRelation->rd_indam->amcanreturn(indexRelation, attno);
}

References IndexAmRoutine::amcanreturn, fb(), RelationData::rd_indam, and RELATION_CHECKS.

Referenced by get_relation_info(), and indexam_property().

index_close()

void index_close ( Relation  relation, LOCKMODE  lockmode  )

extern

Definition at line 177 of file indexam.c.

{
    LockRelId   relid = relation->rd_lockInfo.lockRelId;
 
    Assert(lockmode >= NoLock && lockmode < MAX_LOCKMODES);
 
    /* The relcache does the real work... */
    RelationClose(relation);
 
    if (lockmode != NoLock)
        UnlockRelationId(&relid, lockmode);
}

References Assert, LockInfoData::lockRelId, MAX_LOCKMODES, NoLock, RelationData::rd_lockInfo, RelationClose(), and UnlockRelationId().

Referenced by _brin_parallel_build_main(), _bt_parallel_build_main(), _gin_parallel_build_main(), amcheck_lock_relation_and_check(), ATExecAddIndex(), ATExecAddIndexConstraint(), ATExecReplicaIdentity(), AttachPartitionEnsureIndexes(), brin_desummarize_range(), brin_page_items(), brin_summarize_range(), brincostestimate(), build_index_value_desc(), build_indices(), BuildEventTriggerCache(), check_index_is_clusterable(), CheckIndexCompatible(), close_lo_relation(), DefineIndex(), DefineRelation(), DetachPartitionFinalize(), enum_endpoint(), enum_range_internal(), ExecCloseIndices(), ExecEndBitmapIndexScan(), ExecEndIndexOnlyScan(), ExecEndIndexScan(), expandTableLikeClause(), FindReplTupleInLocalRel(), FindUsableIndexForReplicaIdentityFull(), get_actual_variable_range(), get_relation_info(), gin_clean_pending_list(), gincostestimate(), gist_page_items(), index_concurrently_build(), index_concurrently_create_copy(), index_concurrently_set_dead(), index_create(), index_drop(), indexam_property(), infer_arbiter_indexes(), InitCatCachePhase2(), lookup_ts_config_cache(), pg_nextoid(), plan_create_index_workers(), rebuild_relation(), refresh_by_match_merge(), RefreshMatViewByOid(), reindex_index(), ReindexRelationConcurrently(), RelationFindDeletedTupleInfoByIndex(), RelationFindReplTupleByIndex(), RelationGetIndexAttrBitmap(), RelationTruncateIndexes(), SetIndexStorageProperties(), systable_endscan(), toast_close_indexes(), transformIndexConstraint(), TryReuseIndex(), unique_key_recheck(), vac_close_indexes(), vac_open_indexes(), and validate_index().

index_compute_xid_horizon_for_tuples()

TransactionId index_compute_xid_horizon_for_tuples ( Relation  irel, Relation  hrel, Buffer  ibuf, OffsetNumber *  itemnos, int  nitems  )

extern

Definition at line 295 of file genam.c.

{
    TM_IndexDeleteOp delstate;
    TransactionId snapshotConflictHorizon = InvalidTransactionId;
    Page        ipage = BufferGetPage(ibuf);
    IndexTuple  itup;
 
    Assert(nitems > 0);
 
    delstate.irel = irel;
    delstate.iblknum = BufferGetBlockNumber(ibuf);
    delstate.bottomup = false;
    delstate.bottomupfreespace = 0;
    delstate.ndeltids = 0;
    delstate.deltids = palloc_array(TM_IndexDelete, nitems);
    delstate.status = palloc_array(TM_IndexStatus, nitems);
 
    /* identify what the index tuples about to be deleted point to */
    for (int i = 0; i < nitems; i++)
    {
        OffsetNumber offnum = itemnos[i];
        ItemId      iitemid;
 
        iitemid = PageGetItemId(ipage, offnum);
        itup = (IndexTuple) PageGetItem(ipage, iitemid);
 
        Assert(ItemIdIsDead(iitemid));
 
        ItemPointerCopy(&itup->t_tid, &delstate.deltids[i].tid);
        delstate.deltids[i].id = delstate.ndeltids;
        delstate.status[i].idxoffnum = offnum;
        delstate.status[i].knowndeletable = true;   /* LP_DEAD-marked */
        delstate.status[i].promising = false;   /* unused */
        delstate.status[i].freespace = 0;   /* unused */
 
        delstate.ndeltids++;
    }
 
    /* determine the actual xid horizon */
    snapshotConflictHorizon = table_index_delete_tuples(hrel, &delstate);
 
    /* assert tableam agrees that all items are deletable */
    Assert(delstate.ndeltids == nitems);
 
    pfree(delstate.deltids);
    pfree(delstate.status);
 
    return snapshotConflictHorizon;
}

References Assert, BufferGetBlockNumber(), BufferGetPage(), fb(), i, InvalidTransactionId, ItemIdIsDead, ItemPointerCopy(), nitems, PageGetItem(), PageGetItemId(), palloc_array, pfree(), IndexTupleData::t_tid, and table_index_delete_tuples().

Referenced by _hash_vacuum_one_page(), and gistprunepage().

index_endscan()

void index_endscan ( IndexScanDesc  scan )

extern

Definition at line 392 of file indexam.c.

{
    SCAN_CHECKS;
    CHECK_SCAN_PROCEDURE(amendscan);
 
    /* Release resources (like buffer pins) from table accesses */
    if (scan->xs_heapfetch)
    {
        table_index_fetch_end(scan->xs_heapfetch);
        scan->xs_heapfetch = NULL;
    }
 
    /* End the AM's scan */
    scan->indexRelation->rd_indam->amendscan(scan);
 
    /* Release index refcount acquired by index_beginscan */
    RelationDecrementReferenceCount(scan->indexRelation);
 
    if (scan->xs_temp_snap)
        UnregisterSnapshot(scan->xs_snapshot);
 
    /* Release the scan data structure itself */
    IndexScanEnd(scan);
}

References IndexAmRoutine::amendscan, CHECK_SCAN_PROCEDURE, fb(), IndexScanDescData::indexRelation, IndexScanEnd(), RelationData::rd_indam, RelationDecrementReferenceCount(), SCAN_CHECKS, table_index_fetch_end(), UnregisterSnapshot(), IndexScanDescData::xs_heapfetch, IndexScanDescData::xs_snapshot, and IndexScanDescData::xs_temp_snap.

Referenced by check_exclusion_or_unique_constraint(), ExecEndBitmapIndexScan(), ExecEndIndexOnlyScan(), ExecEndIndexScan(), get_actual_variable_endpoint(), heapam_relation_copy_for_cluster(), RelationFindDeletedTupleInfoByIndex(), RelationFindReplTupleByIndex(), systable_endscan(), and systable_endscan_ordered().

index_fetch_heap()

bool index_fetch_heap ( IndexScanDesc  scan, TupleTableSlot *  slot  )

extern

Definition at line 689 of file indexam.c.

{
    bool        all_dead = false;
    bool        found;
 
    found = table_index_fetch_tuple(scan->xs_heapfetch, &scan->xs_heaptid,
                                    scan->xs_snapshot, slot,
                                    &scan->xs_heap_continue, &all_dead);
 
    if (found)
        pgstat_count_heap_fetch(scan->indexRelation);
 
    /*
     * If we scanned a whole HOT chain and found only dead tuples, tell index
     * AM to kill its entry for that TID (this will take effect in the next
     * amgettuple call, in index_getnext_tid).  We do not do this when in
     * recovery because it may violate MVCC to do so.  See comments in
     * RelationGetIndexScan().
     */
    if (!scan->xactStartedInRecovery)
        scan->kill_prior_tuple = all_dead;
 
    return found;
}

References fb(), IndexScanDescData::indexRelation, IndexScanDescData::kill_prior_tuple, pgstat_count_heap_fetch, table_index_fetch_tuple(), IndexScanDescData::xactStartedInRecovery, IndexScanDescData::xs_heap_continue, IndexScanDescData::xs_heapfetch, IndexScanDescData::xs_heaptid, and IndexScanDescData::xs_snapshot.

Referenced by get_actual_variable_endpoint(), index_getnext_slot(), and IndexOnlyNext().

index_getbitmap()

int64 index_getbitmap ( IndexScanDesc  scan, TIDBitmap *  bitmap  )

extern

Definition at line 775 of file indexam.c.

{
    int64       ntids;
 
    SCAN_CHECKS;
    CHECK_SCAN_PROCEDURE(amgetbitmap);
 
    /* just make sure this is false... */
    scan->kill_prior_tuple = false;
 
    /*
     * have the am's getbitmap proc do all the work.
     */
    ntids = scan->indexRelation->rd_indam->amgetbitmap(scan, bitmap);
 
    pgstat_count_index_tuples(scan->indexRelation, ntids);
 
    return ntids;
}

References IndexAmRoutine::amgetbitmap, CHECK_SCAN_PROCEDURE, IndexScanDescData::indexRelation, IndexScanDescData::kill_prior_tuple, pgstat_count_index_tuples, RelationData::rd_indam, and SCAN_CHECKS.

Referenced by MultiExecBitmapIndexScan().

index_getnext_slot()

bool index_getnext_slot ( IndexScanDesc  scan, ScanDirection  direction, TupleTableSlot *  slot  )

extern

Definition at line 730 of file indexam.c.

{
    for (;;)
    {
        if (!scan->xs_heap_continue)
        {
            ItemPointer tid;
 
            /* Time to fetch the next TID from the index */
            tid = index_getnext_tid(scan, direction);
 
            /* If we're out of index entries, we're done */
            if (tid == NULL)
                break;
 
            Assert(ItemPointerEquals(tid, &scan->xs_heaptid));
        }
 
        /*
         * Fetch the next (or only) visible heap tuple for this index entry.
         * If we don't find anything, loop around and grab the next TID from
         * the index.
         */
        Assert(ItemPointerIsValid(&scan->xs_heaptid));
        if (index_fetch_heap(scan, slot))
            return true;
    }
 
    return false;
}

References Assert, fb(), index_fetch_heap(), index_getnext_tid(), ItemPointerEquals(), ItemPointerIsValid(), IndexScanDescData::xs_heap_continue, and IndexScanDescData::xs_heaptid.

Referenced by check_exclusion_or_unique_constraint(), heapam_relation_copy_for_cluster(), IndexNext(), IndexNextWithReorder(), RelationFindDeletedTupleInfoByIndex(), RelationFindReplTupleByIndex(), systable_getnext(), and systable_getnext_ordered().

index_getnext_tid()

ItemPointer index_getnext_tid ( IndexScanDesc  scan, ScanDirection  direction  )

extern

Definition at line 631 of file indexam.c.

{
    bool        found;
 
    SCAN_CHECKS;
    CHECK_SCAN_PROCEDURE(amgettuple);
 
    /* XXX: we should assert that a snapshot is pushed or registered */
    Assert(TransactionIdIsValid(RecentXmin));
 
    /*
     * The AM's amgettuple proc finds the next index entry matching the scan
     * keys, and puts the TID into scan->xs_heaptid.  It should also set
     * scan->xs_recheck and possibly scan->xs_itup/scan->xs_hitup, though we
     * pay no attention to those fields here.
     */
    found = scan->indexRelation->rd_indam->amgettuple(scan, direction);
 
    /* Reset kill flag immediately for safety */
    scan->kill_prior_tuple = false;
    scan->xs_heap_continue = false;
 
    /* If we're out of index entries, we're done */
    if (!found)
    {
        /* release resources (like buffer pins) from table accesses */
        if (scan->xs_heapfetch)
            table_index_fetch_reset(scan->xs_heapfetch);
 
        return NULL;
    }
    Assert(ItemPointerIsValid(&scan->xs_heaptid));
 
    pgstat_count_index_tuples(scan->indexRelation, 1);
 
    /* Return the TID of the tuple we found. */
    return &scan->xs_heaptid;
}

References IndexAmRoutine::amgettuple, Assert, CHECK_SCAN_PROCEDURE, fb(), IndexScanDescData::indexRelation, ItemPointerIsValid(), IndexScanDescData::kill_prior_tuple, pgstat_count_index_tuples, RelationData::rd_indam, RecentXmin, SCAN_CHECKS, table_index_fetch_reset(), TransactionIdIsValid, IndexScanDescData::xs_heap_continue, IndexScanDescData::xs_heapfetch, and IndexScanDescData::xs_heaptid.

Referenced by get_actual_variable_endpoint(), index_getnext_slot(), and IndexOnlyNext().

index_getprocid()

RegProcedure index_getprocid ( Relation  irel, AttrNumber  attnum, uint16  procnum  )

extern

Definition at line 883 of file indexam.c.

{
    RegProcedure *loc;
    int         nproc;
    int         procindex;
 
    nproc = irel->rd_indam->amsupport;
 
    Assert(procnum > 0 && procnum <= (uint16) nproc);
 
    procindex = (nproc * (attnum - 1)) + (procnum - 1);
 
    loc = irel->rd_support;
 
    Assert(loc != NULL);
 
    return loc[procindex];
}

References IndexAmRoutine::amsupport, Assert, attnum, fb(), RelationData::rd_indam, and RelationData::rd_support.

Referenced by _hash_init(), bloom_get_procinfo(), GinBufferInit(), gistbuild(), gistcanreturn(), inclusion_get_procinfo(), index_opclass_options(), initGinState(), initGISTstate(), minmax_multi_get_procinfo(), spgdoinsert(), spgGetCache(), and tuplesort_begin_index_gin().

index_getprocinfo()

FmgrInfo * index_getprocinfo ( Relation  irel, AttrNumber  attnum, uint16  procnum  )

extern

Definition at line 917 of file indexam.c.

{
    FmgrInfo   *locinfo;
    int         nproc;
    int         optsproc;
    int         procindex;
 
    nproc = irel->rd_indam->amsupport;
    optsproc = irel->rd_indam->amoptsprocnum;
 
    Assert(procnum > 0 && procnum <= (uint16) nproc);
 
    procindex = (nproc * (attnum - 1)) + (procnum - 1);
 
    locinfo = irel->rd_supportinfo;
 
    Assert(locinfo != NULL);
 
    locinfo += procindex;
 
    /* Initialize the lookup info if first time through */
    if (locinfo->fn_oid == InvalidOid)
    {
        RegProcedure *loc = irel->rd_support;
        RegProcedure procId;
 
        Assert(loc != NULL);
 
        procId = loc[procindex];
 
        /*
         * Complain if function was not found during IndexSupportInitialize.
         * This should not happen unless the system tables contain bogus
         * entries for the index opclass.  (If an AM wants to allow a support
         * function to be optional, it can use index_getprocid.)
         */
        if (!RegProcedureIsValid(procId))
            elog(ERROR, "missing support function %d for attribute %d of index \"%s\"",
                 procnum, attnum, RelationGetRelationName(irel));
 
        fmgr_info_cxt(procId, locinfo, irel->rd_indexcxt);
 
        if (procnum != optsproc)
        {
            /* Initialize locinfo->fn_expr with opclass options Const */
            bytea     **attoptions = RelationGetIndexAttOptions(irel, false);
            MemoryContext oldcxt = MemoryContextSwitchTo(irel->rd_indexcxt);
 
            set_fn_opclass_options(locinfo, attoptions[attnum - 1]);
 
            MemoryContextSwitchTo(oldcxt);
        }
    }
 
    return locinfo;
}

References IndexAmRoutine::amoptsprocnum, IndexAmRoutine::amsupport, Assert, attnum, elog, ERROR, fb(), fmgr_info_cxt(), InvalidOid, MemoryContextSwitchTo(), RelationData::rd_indam, RelationData::rd_indexcxt, RelationData::rd_support, RelationData::rd_supportinfo, RegProcedureIsValid, RelationGetIndexAttOptions(), RelationGetRelationName, and set_fn_opclass_options().

Referenced by _bt_first(), _bt_mkscankey(), _bt_setup_array_cmp(), _hash_datum2hashkey(), add_values_to_range(), bloom_get_procinfo(), brin_build_desc(), bringetbitmap(), doPickSplit(), inclusion_get_procinfo(), index_opclass_options(), initBloomState(), initGinState(), initGISTstate(), minmax_multi_get_procinfo(), spgbeginscan(), spgdoinsert(), spgGetCache(), and union_tuples().

index_insert()

bool index_insert ( Relation  indexRelation, Datum *  values, bool *  isnull, ItemPointer  heap_t_ctid, Relation  heapRelation, IndexUniqueCheck  checkUnique, bool  indexUnchanged, IndexInfo *  indexInfo  )

extern

Definition at line 213 of file indexam.c.

{
    RELATION_CHECKS;
    CHECK_REL_PROCEDURE(aminsert);
 
    if (!(indexRelation->rd_indam->ampredlocks))
        CheckForSerializableConflictIn(indexRelation,
                                       (ItemPointer) NULL,
                                       InvalidBlockNumber);
 
    return indexRelation->rd_indam->aminsert(indexRelation, values, isnull,
                                             heap_t_ctid, heapRelation,
                                             checkUnique, indexUnchanged,
                                             indexInfo);
}

References IndexAmRoutine::aminsert, IndexAmRoutine::ampredlocks, CHECK_REL_PROCEDURE, CheckForSerializableConflictIn(), fb(), InvalidBlockNumber, RelationData::rd_indam, RELATION_CHECKS, and values.

Referenced by CatalogIndexInsert(), ExecInsertIndexTuples(), heapam_index_validate_scan(), toast_save_datum(), and unique_key_recheck().

index_insert_cleanup()

void index_insert_cleanup ( Relation  indexRelation, IndexInfo *  indexInfo  )

extern

Definition at line 241 of file indexam.c.

{
    RELATION_CHECKS;
 
    if (indexRelation->rd_indam->aminsertcleanup)
        indexRelation->rd_indam->aminsertcleanup(indexRelation, indexInfo);
}

References IndexAmRoutine::aminsertcleanup, RelationData::rd_indam, and RELATION_CHECKS.

Referenced by ExecCloseIndices(), unique_key_recheck(), and validate_index().

index_markpos()

void index_markpos ( IndexScanDesc  scan )

extern

Definition at line 422 of file indexam.c.

{
    SCAN_CHECKS;
    CHECK_SCAN_PROCEDURE(ammarkpos);
 
    scan->indexRelation->rd_indam->ammarkpos(scan);
}

References IndexAmRoutine::ammarkpos, CHECK_SCAN_PROCEDURE, IndexScanDescData::indexRelation, RelationData::rd_indam, and SCAN_CHECKS.

Referenced by ExecIndexMarkPos(), and ExecIndexOnlyMarkPos().

index_opclass_options()

bytea * index_opclass_options ( Relation  indrel, AttrNumber  attnum, Datum  attoptions, bool  validate  )

extern

Definition at line 1048 of file indexam.c.

{
    int         amoptsprocnum = indrel->rd_indam->amoptsprocnum;
    Oid         procid = InvalidOid;
    FmgrInfo   *procinfo;
    local_relopts relopts;
 
    /* fetch options support procedure if specified */
    if (amoptsprocnum != 0)
        procid = index_getprocid(indrel, attnum, amoptsprocnum);
 
    if (!OidIsValid(procid))
    {
        Oid         opclass;
        Datum       indclassDatum;
        oidvector  *indclass;
 
        if (!DatumGetPointer(attoptions))
            return NULL;        /* ok, no options, no procedure */
 
        /*
         * Report an error if the opclass's options-parsing procedure does not
         * exist but the opclass options are specified.
         */
        indclassDatum = SysCacheGetAttrNotNull(INDEXRELID, indrel->rd_indextuple,
                                               Anum_pg_index_indclass);
        indclass = (oidvector *) DatumGetPointer(indclassDatum);
        opclass = indclass->values[attnum - 1];
 
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("operator class %s has no options",
                        generate_opclass_name(opclass))));
    }
 
    init_local_reloptions(&relopts, 0);
 
    procinfo = index_getprocinfo(indrel, attnum, amoptsprocnum);
 
    (void) FunctionCall1(procinfo, PointerGetDatum(&relopts));
 
    return build_local_reloptions(&relopts, attoptions, validate);
}

References attnum, build_local_reloptions(), DatumGetPointer(), ereport, errcode(), errmsg(), ERROR, fb(), FunctionCall1, generate_opclass_name(), index_getprocid(), index_getprocinfo(), init_local_reloptions(), InvalidOid, OidIsValid, PointerGetDatum(), SysCacheGetAttrNotNull(), and validate().

Referenced by index_create(), and RelationGetIndexAttOptions().

index_open()

Relation index_open ( Oid  relationId, LOCKMODE  lockmode  )

extern

Definition at line 133 of file indexam.c.

{
    Relation    r;
 
    r = relation_open(relationId, lockmode);
 
    validate_relation_kind(r);
 
    return r;
}

References fb(), relation_open(), and validate_relation_kind().

Referenced by _brin_parallel_build_main(), _bt_parallel_build_main(), _gin_parallel_build_main(), amcheck_lock_relation_and_check(), ATExecAddIndex(), ATExecAddIndexConstraint(), ATExecReplicaIdentity(), AttachPartitionEnsureIndexes(), brin_desummarize_range(), brin_page_items(), brin_summarize_range(), brincostestimate(), build_index_value_desc(), build_indices(), BuildEventTriggerCache(), check_index_is_clusterable(), CheckIndexCompatible(), cluster_rel(), DefineIndex(), DefineRelation(), DetachPartitionFinalize(), enum_endpoint(), enum_range_internal(), ExecInitBitmapIndexScan(), ExecInitIndexOnlyScan(), ExecInitIndexScan(), ExecOpenIndices(), expandTableLikeClause(), FindReplTupleInLocalRel(), FindUsableIndexForReplicaIdentityFull(), get_actual_variable_range(), get_relation_info(), gin_clean_pending_list(), gincostestimate(), gist_page_items(), index_concurrently_build(), index_concurrently_create_copy(), index_concurrently_set_dead(), index_drop(), indexam_property(), infer_arbiter_indexes(), InitCatCachePhase2(), lookup_ts_config_cache(), open_lo_relation(), pg_nextoid(), plan_create_index_workers(), refresh_by_match_merge(), RefreshMatViewByOid(), reindex_index(), ReindexRelationConcurrently(), RelationFindDeletedTupleInfoByIndex(), RelationFindReplTupleByIndex(), RelationGetIndexAttrBitmap(), RelationTruncateIndexes(), SetIndexStorageProperties(), systable_beginscan(), toast_open_indexes(), transformIndexConstraint(), TryReuseIndex(), unique_key_recheck(), vac_open_indexes(), and validate_index().

index_parallelrescan()

void index_parallelrescan ( IndexScanDesc  scan )

extern

Definition at line 575 of file indexam.c.

{
    SCAN_CHECKS;
 
    if (scan->xs_heapfetch)
        table_index_fetch_reset(scan->xs_heapfetch);
 
    /* amparallelrescan is optional; assume no-op if not provided by AM */
    if (scan->indexRelation->rd_indam->amparallelrescan != NULL)
        scan->indexRelation->rd_indam->amparallelrescan(scan);
}

References IndexAmRoutine::amparallelrescan, fb(), IndexScanDescData::indexRelation, RelationData::rd_indam, SCAN_CHECKS, table_index_fetch_reset(), and IndexScanDescData::xs_heapfetch.

Referenced by ExecIndexOnlyScanReInitializeDSM(), and ExecIndexScanReInitializeDSM().

index_parallelscan_estimate()

Size index_parallelscan_estimate ( Relation  indexRelation, int  nkeys, int  norderbys, Snapshot  snapshot, bool  instrument, bool  parallel_aware, int  nworkers  )

extern

Definition at line 471 of file indexam.c.

{
    Size        nbytes;
 
    Assert(instrument || parallel_aware);
 
    RELATION_CHECKS;
 
    nbytes = offsetof(ParallelIndexScanDescData, ps_snapshot_data);
    nbytes = add_size(nbytes, EstimateSnapshotSpace(snapshot));
    nbytes = MAXALIGN(nbytes);
 
    if (instrument)
    {
        Size        sharedinfosz;
 
        sharedinfosz = offsetof(SharedIndexScanInstrumentation, winstrument) +
            nworkers * sizeof(IndexScanInstrumentation);
        nbytes = add_size(nbytes, sharedinfosz);
        nbytes = MAXALIGN(nbytes);
    }
 
    /*
     * If parallel scan index AM interface can't be used (or index AM provides
     * no such interface), assume there is no AM-specific data needed
     */
    if (parallel_aware &&
        indexRelation->rd_indam->amestimateparallelscan != NULL)
        nbytes = add_size(nbytes,
                          indexRelation->rd_indam->amestimateparallelscan(indexRelation,
                                                                          nkeys,
                                                                          norderbys));
 
    return nbytes;
}

References add_size(), IndexAmRoutine::amestimateparallelscan, Assert, EstimateSnapshotSpace(), fb(), MAXALIGN, RelationData::rd_indam, and RELATION_CHECKS.

Referenced by ExecIndexOnlyScanEstimate(), and ExecIndexScanEstimate().

index_parallelscan_initialize()

void index_parallelscan_initialize ( Relation  heapRelation, Relation  indexRelation, Snapshot  snapshot, bool  instrument, bool  parallel_aware, int  nworkers, SharedIndexScanInstrumentation **  sharedinfo, ParallelIndexScanDesc  target  )

extern

Definition at line 520 of file indexam.c.

{
    Size        offset;
 
    Assert(instrument || parallel_aware);
 
    RELATION_CHECKS;
 
    offset = add_size(offsetof(ParallelIndexScanDescData, ps_snapshot_data),
                      EstimateSnapshotSpace(snapshot));
    offset = MAXALIGN(offset);
 
    target->ps_locator = heapRelation->rd_locator;
    target->ps_indexlocator = indexRelation->rd_locator;
    target->ps_offset_ins = 0;
    target->ps_offset_am = 0;
    SerializeSnapshot(snapshot, target->ps_snapshot_data);
 
    if (instrument)
    {
        Size        sharedinfosz;
 
        target->ps_offset_ins = offset;
        sharedinfosz = offsetof(SharedIndexScanInstrumentation, winstrument) +
            nworkers * sizeof(IndexScanInstrumentation);
        offset = add_size(offset, sharedinfosz);
        offset = MAXALIGN(offset);
 
        /* Set leader's *sharedinfo pointer, and initialize stats */
        *sharedinfo = (SharedIndexScanInstrumentation *)
            OffsetToPointer(target, target->ps_offset_ins);
        memset(*sharedinfo, 0, sharedinfosz);
        (*sharedinfo)->num_workers = nworkers;
    }
 
    /* aminitparallelscan is optional; assume no-op if not provided by AM */
    if (parallel_aware && indexRelation->rd_indam->aminitparallelscan != NULL)
    {
        void       *amtarget;
 
        target->ps_offset_am = offset;
        amtarget = OffsetToPointer(target, target->ps_offset_am);
        indexRelation->rd_indam->aminitparallelscan(amtarget);
    }
}

References add_size(), IndexAmRoutine::aminitparallelscan, Assert, EstimateSnapshotSpace(), fb(), MAXALIGN, OffsetToPointer, ParallelIndexScanDescData::ps_indexlocator, ParallelIndexScanDescData::ps_locator, ParallelIndexScanDescData::ps_offset_am, ParallelIndexScanDescData::ps_offset_ins, ParallelIndexScanDescData::ps_snapshot_data, RelationData::rd_indam, RelationData::rd_locator, RELATION_CHECKS, and SerializeSnapshot().

Referenced by ExecIndexOnlyScanInitializeDSM(), and ExecIndexScanInitializeDSM().

index_rescan()

void index_rescan ( IndexScanDesc  scan, ScanKey  keys, int  nkeys, ScanKey  orderbys, int  norderbys  )

extern

Definition at line 366 of file indexam.c.

{
    SCAN_CHECKS;
    CHECK_SCAN_PROCEDURE(amrescan);
 
    Assert(nkeys == scan->numberOfKeys);
    Assert(norderbys == scan->numberOfOrderBys);
 
    /* Release resources (like buffer pins) from table accesses */
    if (scan->xs_heapfetch)
        table_index_fetch_reset(scan->xs_heapfetch);
 
    scan->kill_prior_tuple = false; /* for safety */
    scan->xs_heap_continue = false;
 
    scan->indexRelation->rd_indam->amrescan(scan, keys, nkeys,
                                            orderbys, norderbys);
}

References IndexAmRoutine::amrescan, Assert, CHECK_SCAN_PROCEDURE, IndexScanDescData::indexRelation, IndexScanDescData::kill_prior_tuple, IndexScanDescData::numberOfKeys, IndexScanDescData::numberOfOrderBys, RelationData::rd_indam, SCAN_CHECKS, table_index_fetch_reset(), IndexScanDescData::xs_heap_continue, and IndexScanDescData::xs_heapfetch.

Referenced by check_exclusion_or_unique_constraint(), ExecIndexOnlyScanInitializeDSM(), ExecIndexOnlyScanInitializeWorker(), ExecIndexScanInitializeDSM(), ExecIndexScanInitializeWorker(), ExecInitBitmapIndexScan(), ExecReScanBitmapIndexScan(), ExecReScanIndexOnlyScan(), ExecReScanIndexScan(), get_actual_variable_endpoint(), heapam_relation_copy_for_cluster(), IndexNext(), IndexNextWithReorder(), IndexOnlyNext(), MultiExecBitmapIndexScan(), RelationFindDeletedTupleInfoByIndex(), RelationFindReplTupleByIndex(), systable_beginscan(), and systable_beginscan_ordered().

index_restrpos()

void index_restrpos ( IndexScanDesc  scan )

extern

Definition at line 446 of file indexam.c.

{
    Assert(IsMVCCSnapshot(scan->xs_snapshot));
 
    SCAN_CHECKS;
    CHECK_SCAN_PROCEDURE(amrestrpos);
 
    /* release resources (like buffer pins) from table accesses */
    if (scan->xs_heapfetch)
        table_index_fetch_reset(scan->xs_heapfetch);
 
    scan->kill_prior_tuple = false; /* for safety */
    scan->xs_heap_continue = false;
 
    scan->indexRelation->rd_indam->amrestrpos(scan);
}

References IndexAmRoutine::amrestrpos, Assert, CHECK_SCAN_PROCEDURE, IndexScanDescData::indexRelation, IsMVCCSnapshot, IndexScanDescData::kill_prior_tuple, RelationData::rd_indam, SCAN_CHECKS, table_index_fetch_reset(), IndexScanDescData::xs_heap_continue, IndexScanDescData::xs_heapfetch, and IndexScanDescData::xs_snapshot.

Referenced by ExecIndexOnlyRestrPos(), and ExecIndexRestrPos().

index_store_float8_orderby_distances()

void index_store_float8_orderby_distances ( IndexScanDesc  scan, Oid *  orderByTypes, IndexOrderByDistance *  distances, bool  recheckOrderBy  )

extern

Definition at line 985 of file indexam.c.

{
    int         i;
 
    Assert(distances || !recheckOrderBy);
 
    scan->xs_recheckorderby = recheckOrderBy;
 
    for (i = 0; i < scan->numberOfOrderBys; i++)
    {
        if (orderByTypes[i] == FLOAT8OID)
        {
            if (distances && !distances[i].isnull)
            {
                scan->xs_orderbyvals[i] = Float8GetDatum(distances[i].value);
                scan->xs_orderbynulls[i] = false;
            }
            else
            {
                scan->xs_orderbyvals[i] = (Datum) 0;
                scan->xs_orderbynulls[i] = true;
            }
        }
        else if (orderByTypes[i] == FLOAT4OID)
        {
            /* convert distance function's result to ORDER BY type */
            if (distances && !distances[i].isnull)
            {
                scan->xs_orderbyvals[i] = Float4GetDatum((float4) distances[i].value);
                scan->xs_orderbynulls[i] = false;
            }
            else
            {
                scan->xs_orderbyvals[i] = (Datum) 0;
                scan->xs_orderbynulls[i] = true;
            }
        }
        else
        {
            /*
             * If the ordering operator's return value is anything else, we
             * don't know how to convert the float8 bound calculated by the
             * distance function to that.  The executor won't actually need
             * the order by values we return here, if there are no lossy
             * results, so only insist on converting if the *recheck flag is
             * set.
             */
            if (scan->xs_recheckorderby)
                elog(ERROR, "ORDER BY operator must return float8 or float4 if the distance function is lossy");
            scan->xs_orderbynulls[i] = true;
        }
    }
}

References Assert, elog, ERROR, fb(), Float4GetDatum(), Float8GetDatum(), i, IndexScanDescData::numberOfOrderBys, value, IndexScanDescData::xs_orderbynulls, IndexScanDescData::xs_orderbyvals, and IndexScanDescData::xs_recheckorderby.

Referenced by getNextNearest(), and spggettuple().

index_vacuum_cleanup()

IndexBulkDeleteResult * index_vacuum_cleanup ( IndexVacuumInfo *  info, IndexBulkDeleteResult *  istat  )

extern

Definition at line 826 of file indexam.c.

{
    Relation    indexRelation = info->index;
 
    RELATION_CHECKS;
    CHECK_REL_PROCEDURE(amvacuumcleanup);
 
    return indexRelation->rd_indam->amvacuumcleanup(info, istat);
}

References IndexAmRoutine::amvacuumcleanup, CHECK_REL_PROCEDURE, IndexVacuumInfo::index, RelationData::rd_indam, and RELATION_CHECKS.

Referenced by do_analyze_rel(), and vac_cleanup_one_index().

IndexScanEnd()

void IndexScanEnd ( IndexScanDesc  scan )

extern

Definition at line 145 of file genam.c.

{
    if (scan->keyData != NULL)
        pfree(scan->keyData);
    if (scan->orderByData != NULL)
        pfree(scan->orderByData);
 
    pfree(scan);
}

References fb(), IndexScanDescData::keyData, IndexScanDescData::orderByData, and pfree().

Referenced by index_endscan().

RelationGetIndexScan()

IndexScanDesc RelationGetIndexScan ( Relation  indexRelation, int  nkeys, int  norderbys  )

extern

Definition at line 80 of file genam.c.

{
    IndexScanDesc scan;
 
    scan = palloc_object(IndexScanDescData);
 
    scan->heapRelation = NULL;  /* may be set later */
    scan->xs_heapfetch = NULL;
    scan->indexRelation = indexRelation;
    scan->xs_snapshot = InvalidSnapshot;    /* caller must initialize this */
    scan->numberOfKeys = nkeys;
    scan->numberOfOrderBys = norderbys;
 
    /*
     * We allocate key workspace here, but it won't get filled until amrescan.
     */
    if (nkeys > 0)
        scan->keyData = palloc_array(ScanKeyData, nkeys);
    else
        scan->keyData = NULL;
    if (norderbys > 0)
        scan->orderByData = palloc_array(ScanKeyData, norderbys);
    else
        scan->orderByData = NULL;
 
    scan->xs_want_itup = false; /* may be set later */
 
    /*
     * During recovery we ignore killed tuples and don't bother to kill them
     * either. We do this because the xmin on the primary node could easily be
     * later than the xmin on the standby node, so that what the primary
     * thinks is killed is supposed to be visible on standby. So for correct
     * MVCC for queries during recovery we must ignore these hints and check
     * all tuples. Do *not* set ignore_killed_tuples to true when running in a
     * transaction that was started during recovery. xactStartedInRecovery
     * should not be altered by index AMs.
     */
    scan->kill_prior_tuple = false;
    scan->xactStartedInRecovery = TransactionStartedDuringRecovery();
    scan->ignore_killed_tuples = !scan->xactStartedInRecovery;
 
    scan->opaque = NULL;
    scan->instrument = NULL;
 
    scan->xs_itup = NULL;
    scan->xs_itupdesc = NULL;
    scan->xs_hitup = NULL;
    scan->xs_hitupdesc = NULL;
 
    return scan;
}

References fb(), IndexScanDescData::heapRelation, IndexScanDescData::ignore_killed_tuples, IndexScanDescData::indexRelation, IndexScanDescData::instrument, InvalidSnapshot, IndexScanDescData::keyData, IndexScanDescData::kill_prior_tuple, IndexScanDescData::numberOfKeys, IndexScanDescData::numberOfOrderBys, IndexScanDescData::opaque, IndexScanDescData::orderByData, palloc_array, palloc_object, TransactionStartedDuringRecovery(), IndexScanDescData::xactStartedInRecovery, IndexScanDescData::xs_heapfetch, IndexScanDescData::xs_hitup, IndexScanDescData::xs_hitupdesc, IndexScanDescData::xs_itup, IndexScanDescData::xs_itupdesc, IndexScanDescData::xs_snapshot, and IndexScanDescData::xs_want_itup.

Referenced by blbeginscan(), brinbeginscan(), btbeginscan(), dibeginscan(), ginbeginscan(), gistbeginscan(), hashbeginscan(), and spgbeginscan().

systable_beginscan()

SysScanDesc systable_beginscan ( Relation  heapRelation, Oid  indexId, bool  indexOK, Snapshot  snapshot, int  nkeys, ScanKey  key  )

extern

Definition at line 388 of file genam.c.

{
    SysScanDesc sysscan;
    Relation    irel;
 
    if (indexOK &&
        !IgnoreSystemIndexes &&
        !ReindexIsProcessingIndex(indexId))
        irel = index_open(indexId, AccessShareLock);
    else
        irel = NULL;
 
    sysscan = palloc_object(SysScanDescData);
 
    sysscan->heap_rel = heapRelation;
    sysscan->irel = irel;
    sysscan->slot = table_slot_create(heapRelation, NULL);
 
    if (snapshot == NULL)
    {
        Oid         relid = RelationGetRelid(heapRelation);
 
        snapshot = RegisterSnapshot(GetCatalogSnapshot(relid));
        sysscan->snapshot = snapshot;
    }
    else
    {
        /* Caller is responsible for any snapshot. */
        sysscan->snapshot = NULL;
    }
 
    if (irel)
    {
        int         i;
        ScanKey     idxkey;
 
        idxkey = palloc_array(ScanKeyData, nkeys);
 
        /* Convert attribute numbers to be index column numbers. */
        for (i = 0; i < nkeys; i++)
        {
            int         j;
 
            memcpy(&idxkey[i], &key[i], sizeof(ScanKeyData));
 
            for (j = 0; j < IndexRelationGetNumberOfAttributes(irel); j++)
            {
                if (key[i].sk_attno == irel->rd_index->indkey.values[j])
                {
                    idxkey[i].sk_attno = j + 1;
                    break;
                }
            }
            if (j == IndexRelationGetNumberOfAttributes(irel))
                elog(ERROR, "column is not in index");
        }
 
        sysscan->iscan = index_beginscan(heapRelation, irel,
                                         snapshot, NULL, nkeys, 0);
        index_rescan(sysscan->iscan, idxkey, nkeys, NULL, 0);
        sysscan->scan = NULL;
 
        pfree(idxkey);
    }
    else
    {
        /*
         * We disallow synchronized scans when forced to use a heapscan on a
         * catalog.  In most cases the desired rows are near the front, so
         * that the unpredictable start point of a syncscan is a serious
         * disadvantage; and there are no compensating advantages, because
         * it's unlikely that such scans will occur in parallel.
         */
        sysscan->scan = table_beginscan_strat(heapRelation, snapshot,
                                              nkeys, key,
                                              true, false);
        sysscan->iscan = NULL;
    }
 
    /*
     * If CheckXidAlive is set then set a flag to indicate that system table
     * scan is in-progress.  See detailed comments in xact.c where these
     * variables are declared.
     */
    if (TransactionIdIsValid(CheckXidAlive))
        bsysscan = true;
 
    return sysscan;
}

References AccessShareLock, bsysscan, CheckXidAlive, elog, ERROR, fb(), GetCatalogSnapshot(), i, IgnoreSystemIndexes, index_beginscan(), index_open(), index_rescan(), IndexRelationGetNumberOfAttributes, j, palloc_array, palloc_object, pfree(), RelationData::rd_index, RegisterSnapshot(), ReindexIsProcessingIndex(), RelationGetRelid, table_beginscan_strat(), table_slot_create(), and TransactionIdIsValid.

Referenced by AfterTriggerSetState(), AlterConstraintNamespaces(), AlterConstrDeferrabilityRecurse(), AlterConstrEnforceabilityRecurse(), AlterConstrTriggerDeferrability(), AlterDatabase(), AlterDatabaseOwner(), AlterDatabaseRefreshColl(), AlterDomainDropConstraint(), AlterDomainValidateConstraint(), AlterExtensionNamespace(), AlterPolicy(), AlterSeqNamespaces(), AlterSetting(), AlterTypeRecurse(), ApplyExtensionUpdates(), ApplySetting(), ATExecAddOf(), ATExecAlterColumnType(), ATExecAlterConstraint(), ATExecAttachPartition(), ATExecDropConstraint(), ATExecValidateConstraint(), ATPrepChangePersistence(), AttrDefaultFetch(), change_owner_fix_column_acls(), change_owner_recurse_to_sequences(), changeDependenciesOf(), changeDependenciesOn(), changeDependencyFor(), CheckNNConstraintFetch(), checkSharedDependencies(), ChooseConstraintName(), ChooseRelationName(), CloneFkReferenced(), CloneRowTriggersToPartition(), ConstraintNameExists(), ConstraintNameIsUsed(), CopyStatistics(), copyTemplateDependencies(), CountDBSubscriptions(), CreateComments(), CreateInheritance(), CreatePolicy(), CreateSharedComments(), CreateTriggerFiringOn(), DefineOpClass(), DefineTSConfiguration(), DeleteAttributeTuples(), DeleteComments(), deleteDependencyRecordsFor(), deleteDependencyRecordsForClass(), deleteDependencyRecordsForSpecific(), DeleteInheritsTuple(), DeleteInitPrivs(), deleteOneObject(), DeleteSecurityLabel(), DeleteSharedComments(), DeleteSharedSecurityLabel(), DeleteSystemAttributeTuples(), drop_parent_dependency(), DropClonedTriggersFromPartition(), DropConfigurationMapping(), dropconstraint_internal(), dropDatabaseDependencies(), DropForeignKeyConstraintTriggers(), DropObjectById(), DropRole(), EnableDisableTrigger(), EnumValuesDelete(), EventTriggerSQLDropAddObject(), exec_object_restorecon(), ExecAlterExtensionStmt(), ExecGrant_Largeobject(), extension_config_remove(), fetch_statentries_for_relation(), find_composite_type_dependencies(), find_inheritance_children_extended(), findDependentObjects(), findDomainNotNullConstraint(), findNotNullConstraintAttnum(), get_catalog_object_by_oid_extended(), get_database_oid(), get_db_info(), get_domain_constraint_oid(), get_index_constraint(), get_index_ref_constraints(), get_partition_parent_worker(), get_pg_statistic_ext(), get_pkey_attnames(), get_primary_key_attnos(), get_relation_constraint_attnos(), get_relation_constraint_oid(), get_relation_idx_constraint_oid(), get_relation_policy_oid(), get_rels_with_domain(), get_trigger_oid(), GetAllTablesPublications(), GetAttrDefaultColumnAddress(), GetAttrDefaultOid(), getAutoExtensionsOfObject(), GetComment(), GetDatabaseTuple(), GetDatabaseTupleByOid(), GetDefaultOpClass(), getExtensionOfObject(), GetForeignKeyActionTriggers(), GetForeignKeyCheckTriggers(), GetNewOidWithIndex(), getObjectDescription(), getObjectIdentityParts(), getOwnedSequences_internal(), GetParentedForeignKeyRefs(), GetPublicationRelations(), GetPublicationSchemas(), GetSecurityLabel(), GetSharedSecurityLabel(), GetSubscriptionRelations(), has_superclass(), HasSubscriptionTables(), heap_truncate_find_FKs(), index_concurrently_swap(), IndexSetParentIndex(), is_schema_publication(), LargeObjectDrop(), LargeObjectExistsWithSnapshot(), load_domaintype_info(), load_enum_cache_data(), LogicalRepSyncSequences(), LookupOpclassInfo(), makeConfigurationDependencies(), MakeConfigurationMapping(), MarkInheritDetached(), MergeConstraintsIntoExisting(), MergeWithExistingConstraint(), movedb(), object_ownercheck(), PartitionHasPendingDetach(), pg_extension_config_dump(), pg_get_constraintdef_worker(), pg_get_serial_sequence(), pg_get_triggerdef_worker(), pg_largeobject_aclmask_snapshot(), QueueFKConstraintValidation(), RangeDelete(), recordExtensionInitPrivWorker(), recordExtObjInitPriv(), relation_has_policies(), RelationBuildPartitionDesc(), RelationBuildRowSecurity(), RelationBuildRuleLock(), RelationBuildTriggers(), RelationBuildTupleDesc(), RelationGetExclusionInfo(), RelationGetFKeyList(), RelationGetIndexList(), RelationGetNotNullConstraints(), RelationGetStatExtList(), RelationRemoveInheritance(), RelidByRelfilenumber(), RememberAllDependentForRebuilding(), RemoveAttrDefault(), RemoveAttrDefaultById(), RemoveExtensionById(), RemoveInheritance(), RemoveInheritedConstraint(), RemovePolicyById(), RemoveRewriteRuleById(), RemoveRoleFromInitPriv(), RemoveRoleFromObjectACL(), RemoveRoleFromObjectPolicy(), RemoveStatistics(), RemoveTriggerById(), RemoveTSConfigurationById(), rename_policy(), renametrig(), renametrig_internal(), renametrig_partition(), ReplaceRoleInInitPriv(), replorigin_create(), ScanPgRelation(), SearchCatCacheList(), SearchCatCacheMiss(), sepgsql_attribute_post_create(), sepgsql_database_post_create(), sepgsql_proc_post_create(), sepgsql_proc_setattr(), sepgsql_relation_post_create(), sepgsql_relation_setattr(), sepgsql_relation_setattr_extra(), sepgsql_schema_post_create(), sequenceIsOwned(), SetSecurityLabel(), SetSharedSecurityLabel(), shdepChangeDep(), shdepDropDependency(), shdepDropOwned(), shdepReassignOwned(), systable_inplace_update_begin(), toastrel_valueid_exists(), TriggerSetParentTrigger(), typeInheritsFrom(), vac_update_datfrozenxid(), and validatePartitionedIndex().

systable_beginscan_ordered()

SysScanDesc systable_beginscan_ordered ( Relation  heapRelation, Relation  indexRelation, Snapshot  snapshot, int  nkeys, ScanKey  key  )

extern

Definition at line 650 of file genam.c.

{
    SysScanDesc sysscan;
    int         i;
    ScanKey     idxkey;
 
    /* REINDEX can probably be a hard error here ... */
    if (ReindexIsProcessingIndex(RelationGetRelid(indexRelation)))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot access index \"%s\" while it is being reindexed",
                        RelationGetRelationName(indexRelation))));
    /* ... but we only throw a warning about violating IgnoreSystemIndexes */
    if (IgnoreSystemIndexes)
        elog(WARNING, "using index \"%s\" despite IgnoreSystemIndexes",
             RelationGetRelationName(indexRelation));
 
    sysscan = palloc_object(SysScanDescData);
 
    sysscan->heap_rel = heapRelation;
    sysscan->irel = indexRelation;
    sysscan->slot = table_slot_create(heapRelation, NULL);
 
    if (snapshot == NULL)
    {
        Oid         relid = RelationGetRelid(heapRelation);
 
        snapshot = RegisterSnapshot(GetCatalogSnapshot(relid));
        sysscan->snapshot = snapshot;
    }
    else
    {
        /* Caller is responsible for any snapshot. */
        sysscan->snapshot = NULL;
    }
 
    idxkey = palloc_array(ScanKeyData, nkeys);
 
    /* Convert attribute numbers to be index column numbers. */
    for (i = 0; i < nkeys; i++)
    {
        int         j;
 
        memcpy(&idxkey[i], &key[i], sizeof(ScanKeyData));
 
        for (j = 0; j < IndexRelationGetNumberOfAttributes(indexRelation); j++)
        {
            if (key[i].sk_attno == indexRelation->rd_index->indkey.values[j])
            {
                idxkey[i].sk_attno = j + 1;
                break;
            }
        }
        if (j == IndexRelationGetNumberOfAttributes(indexRelation))
            elog(ERROR, "column is not in index");
    }
 
    sysscan->iscan = index_beginscan(heapRelation, indexRelation,
                                     snapshot, NULL, nkeys, 0);
    index_rescan(sysscan->iscan, idxkey, nkeys, NULL, 0);
    sysscan->scan = NULL;
 
    pfree(idxkey);
 
    /*
     * If CheckXidAlive is set then set a flag to indicate that system table
     * scan is in-progress.  See detailed comments in xact.c where these
     * variables are declared.
     */
    if (TransactionIdIsValid(CheckXidAlive))
        bsysscan = true;
 
    return sysscan;
}

References bsysscan, CheckXidAlive, elog, ereport, errcode(), errmsg(), ERROR, fb(), GetCatalogSnapshot(), i, IgnoreSystemIndexes, index_beginscan(), index_rescan(), IndexRelationGetNumberOfAttributes, j, palloc_array, palloc_object, pfree(), RelationData::rd_index, RegisterSnapshot(), ReindexIsProcessingIndex(), RelationGetRelationName, RelationGetRelid, table_slot_create(), TransactionIdIsValid, and WARNING.

Referenced by BuildEventTriggerCache(), check_toasted_attribute(), enum_endpoint(), enum_range_internal(), heap_fetch_toast_slice(), inv_getsize(), inv_read(), inv_truncate(), inv_write(), lookup_ts_config_cache(), and toast_delete_datum().

systable_endscan()

void systable_endscan ( SysScanDesc  sysscan )

extern

Definition at line 603 of file genam.c.

{
    if (sysscan->slot)
    {
        ExecDropSingleTupleTableSlot(sysscan->slot);
        sysscan->slot = NULL;
    }
 
    if (sysscan->irel)
    {
        index_endscan(sysscan->iscan);
        index_close(sysscan->irel, AccessShareLock);
    }
    else
        table_endscan(sysscan->scan);
 
    if (sysscan->snapshot)
        UnregisterSnapshot(sysscan->snapshot);
 
    /*
     * Reset the bsysscan flag at the end of the systable scan.  See detailed
     * comments in xact.c where these variables are declared.
     */
    if (TransactionIdIsValid(CheckXidAlive))
        bsysscan = false;
 
    pfree(sysscan);
}

References AccessShareLock, bsysscan, CheckXidAlive, ExecDropSingleTupleTableSlot(), fb(), index_close(), index_endscan(), pfree(), table_endscan(), TransactionIdIsValid, and UnregisterSnapshot().

Referenced by AfterTriggerSetState(), AlterConstraintNamespaces(), AlterConstrDeferrabilityRecurse(), AlterConstrEnforceabilityRecurse(), AlterConstrTriggerDeferrability(), AlterDatabase(), AlterDatabaseOwner(), AlterDatabaseRefreshColl(), AlterDomainDropConstraint(), AlterDomainValidateConstraint(), AlterExtensionNamespace(), AlterPolicy(), AlterSeqNamespaces(), AlterSetting(), AlterTypeRecurse(), ApplyExtensionUpdates(), ApplySetting(), ATExecAddOf(), ATExecAlterColumnType(), ATExecAlterConstraint(), ATExecAttachPartition(), ATExecDropConstraint(), ATExecValidateConstraint(), ATPrepChangePersistence(), AttrDefaultFetch(), change_owner_fix_column_acls(), change_owner_recurse_to_sequences(), changeDependenciesOf(), changeDependenciesOn(), changeDependencyFor(), CheckNNConstraintFetch(), checkSharedDependencies(), ChooseConstraintName(), ChooseRelationName(), CloneFkReferenced(), CloneRowTriggersToPartition(), ConstraintNameExists(), ConstraintNameIsUsed(), CopyStatistics(), copyTemplateDependencies(), CountDBSubscriptions(), CreateComments(), CreateInheritance(), CreatePolicy(), CreateSharedComments(), CreateTriggerFiringOn(), DefineOpClass(), DefineTSConfiguration(), DeleteAttributeTuples(), DeleteComments(), deleteDependencyRecordsFor(), deleteDependencyRecordsForClass(), deleteDependencyRecordsForSpecific(), DeleteInheritsTuple(), DeleteInitPrivs(), deleteOneObject(), DeleteSecurityLabel(), DeleteSharedComments(), DeleteSharedSecurityLabel(), DeleteSystemAttributeTuples(), drop_parent_dependency(), DropClonedTriggersFromPartition(), DropConfigurationMapping(), dropconstraint_internal(), dropDatabaseDependencies(), DropForeignKeyConstraintTriggers(), DropObjectById(), DropRole(), EnableDisableTrigger(), EnumValuesDelete(), EventTriggerSQLDropAddObject(), exec_object_restorecon(), ExecAlterExtensionStmt(), ExecGrant_Largeobject(), extension_config_remove(), fetch_statentries_for_relation(), find_composite_type_dependencies(), find_inheritance_children_extended(), findDependentObjects(), findDomainNotNullConstraint(), findNotNullConstraintAttnum(), get_catalog_object_by_oid_extended(), get_database_oid(), get_db_info(), get_domain_constraint_oid(), get_index_constraint(), get_index_ref_constraints(), get_partition_parent_worker(), get_pg_statistic_ext(), get_pkey_attnames(), get_primary_key_attnos(), get_relation_constraint_attnos(), get_relation_constraint_oid(), get_relation_idx_constraint_oid(), get_relation_policy_oid(), get_rels_with_domain(), get_trigger_oid(), GetAllTablesPublications(), GetAttrDefaultColumnAddress(), GetAttrDefaultOid(), getAutoExtensionsOfObject(), GetComment(), GetDatabaseTuple(), GetDatabaseTupleByOid(), GetDefaultOpClass(), getExtensionOfObject(), GetForeignKeyActionTriggers(), GetForeignKeyCheckTriggers(), GetNewOidWithIndex(), getObjectDescription(), getObjectIdentityParts(), getOwnedSequences_internal(), GetParentedForeignKeyRefs(), GetPublicationRelations(), GetPublicationSchemas(), GetSecurityLabel(), GetSharedSecurityLabel(), GetSubscriptionRelations(), has_superclass(), HasSubscriptionTables(), heap_truncate_find_FKs(), index_concurrently_swap(), IndexSetParentIndex(), is_schema_publication(), LargeObjectDrop(), LargeObjectExistsWithSnapshot(), load_domaintype_info(), load_enum_cache_data(), LogicalRepSyncSequences(), LookupOpclassInfo(), makeConfigurationDependencies(), MakeConfigurationMapping(), MarkInheritDetached(), MergeConstraintsIntoExisting(), MergeWithExistingConstraint(), movedb(), object_ownercheck(), PartitionHasPendingDetach(), pg_extension_config_dump(), pg_get_constraintdef_worker(), pg_get_serial_sequence(), pg_get_triggerdef_worker(), pg_largeobject_aclmask_snapshot(), QueueFKConstraintValidation(), RangeDelete(), recordExtensionInitPrivWorker(), recordExtObjInitPriv(), relation_has_policies(), RelationBuildPartitionDesc(), RelationBuildRowSecurity(), RelationBuildRuleLock(), RelationBuildTriggers(), RelationBuildTupleDesc(), RelationGetExclusionInfo(), RelationGetFKeyList(), RelationGetIndexList(), RelationGetNotNullConstraints(), RelationGetStatExtList(), RelationRemoveInheritance(), RelidByRelfilenumber(), RememberAllDependentForRebuilding(), RemoveAttrDefault(), RemoveAttrDefaultById(), RemoveExtensionById(), RemoveInheritance(), RemoveInheritedConstraint(), RemovePolicyById(), RemoveRewriteRuleById(), RemoveRoleFromInitPriv(), RemoveRoleFromObjectACL(), RemoveRoleFromObjectPolicy(), RemoveStatistics(), RemoveTriggerById(), RemoveTSConfigurationById(), rename_policy(), renametrig(), renametrig_internal(), renametrig_partition(), ReplaceRoleInInitPriv(), replorigin_create(), ScanPgRelation(), SearchCatCacheList(), SearchCatCacheMiss(), sepgsql_attribute_post_create(), sepgsql_database_post_create(), sepgsql_proc_post_create(), sepgsql_proc_setattr(), sepgsql_relation_post_create(), sepgsql_relation_setattr(), sepgsql_relation_setattr_extra(), sepgsql_schema_post_create(), sequenceIsOwned(), SetSecurityLabel(), SetSharedSecurityLabel(), shdepChangeDep(), shdepDropDependency(), shdepDropOwned(), shdepReassignOwned(), systable_inplace_update_begin(), systable_inplace_update_cancel(), systable_inplace_update_finish(), toastrel_valueid_exists(), TriggerSetParentTrigger(), typeInheritsFrom(), vac_update_datfrozenxid(), and validatePartitionedIndex().

systable_endscan_ordered()

void systable_endscan_ordered ( SysScanDesc  sysscan )

extern

Definition at line 757 of file genam.c.

{
    if (sysscan->slot)
    {
        ExecDropSingleTupleTableSlot(sysscan->slot);
        sysscan->slot = NULL;
    }
 
    Assert(sysscan->irel);
    index_endscan(sysscan->iscan);
    if (sysscan->snapshot)
        UnregisterSnapshot(sysscan->snapshot);
 
    /*
     * Reset the bsysscan flag at the end of the systable scan.  See detailed
     * comments in xact.c where these variables are declared.
     */
    if (TransactionIdIsValid(CheckXidAlive))
        bsysscan = false;
 
    pfree(sysscan);
}

References Assert, bsysscan, CheckXidAlive, ExecDropSingleTupleTableSlot(), fb(), index_endscan(), pfree(), TransactionIdIsValid, and UnregisterSnapshot().

Referenced by BuildEventTriggerCache(), check_toasted_attribute(), enum_endpoint(), enum_range_internal(), heap_fetch_toast_slice(), inv_getsize(), inv_read(), inv_truncate(), inv_write(), lookup_ts_config_cache(), and toast_delete_datum().

systable_getnext()

HeapTuple systable_getnext ( SysScanDesc  sysscan )

extern

Definition at line 514 of file genam.c.

{
    HeapTuple   htup = NULL;
 
    if (sysscan->irel)
    {
        if (index_getnext_slot(sysscan->iscan, ForwardScanDirection, sysscan->slot))
        {
            bool        shouldFree;
 
            htup = ExecFetchSlotHeapTuple(sysscan->slot, false, &shouldFree);
            Assert(!shouldFree);
 
            /*
             * We currently don't need to support lossy index operators for
             * any system catalog scan.  It could be done here, using the scan
             * keys to drive the operator calls, if we arranged to save the
             * heap attnums during systable_beginscan(); this is practical
             * because we still wouldn't need to support indexes on
             * expressions.
             */
            if (sysscan->iscan->xs_recheck)
                elog(ERROR, "system catalog scans with lossy index conditions are not implemented");
        }
    }
    else
    {
        if (table_scan_getnextslot(sysscan->scan, ForwardScanDirection, sysscan->slot))
        {
            bool        shouldFree;
 
            htup = ExecFetchSlotHeapTuple(sysscan->slot, false, &shouldFree);
            Assert(!shouldFree);
        }
    }
 
    /*
     * Handle the concurrent abort while fetching the catalog tuple during
     * logical streaming of a transaction.
     */
    HandleConcurrentAbort();
 
    return htup;
}

References Assert, elog, ERROR, ExecFetchSlotHeapTuple(), fb(), ForwardScanDirection, HandleConcurrentAbort(), index_getnext_slot(), and table_scan_getnextslot().

Referenced by AfterTriggerSetState(), AlterConstraintNamespaces(), AlterConstrDeferrabilityRecurse(), AlterConstrEnforceabilityRecurse(), AlterConstrTriggerDeferrability(), AlterDatabase(), AlterDatabaseOwner(), AlterDatabaseRefreshColl(), AlterDomainDropConstraint(), AlterDomainValidateConstraint(), AlterExtensionNamespace(), AlterPolicy(), AlterSeqNamespaces(), AlterSetting(), AlterTypeRecurse(), ApplyExtensionUpdates(), ApplySetting(), ATExecAddOf(), ATExecAlterColumnType(), ATExecAlterConstraint(), ATExecAttachPartition(), ATExecDropConstraint(), ATExecValidateConstraint(), ATPrepChangePersistence(), AttrDefaultFetch(), change_owner_fix_column_acls(), change_owner_recurse_to_sequences(), changeDependenciesOf(), changeDependenciesOn(), changeDependencyFor(), CheckNNConstraintFetch(), checkSharedDependencies(), ChooseConstraintName(), ChooseRelationName(), CloneFkReferenced(), CloneRowTriggersToPartition(), ConstraintNameExists(), ConstraintNameIsUsed(), CopyStatistics(), copyTemplateDependencies(), CountDBSubscriptions(), CreateComments(), CreateInheritance(), CreatePolicy(), CreateSharedComments(), CreateTriggerFiringOn(), DefineOpClass(), DefineTSConfiguration(), DeleteAttributeTuples(), DeleteComments(), deleteDependencyRecordsFor(), deleteDependencyRecordsForClass(), deleteDependencyRecordsForSpecific(), DeleteInheritsTuple(), DeleteInitPrivs(), deleteOneObject(), DeleteSecurityLabel(), DeleteSharedComments(), DeleteSharedSecurityLabel(), DeleteSystemAttributeTuples(), drop_parent_dependency(), DropClonedTriggersFromPartition(), DropConfigurationMapping(), dropconstraint_internal(), dropDatabaseDependencies(), DropForeignKeyConstraintTriggers(), DropObjectById(), DropRole(), EnableDisableTrigger(), EnumValuesDelete(), EventTriggerSQLDropAddObject(), exec_object_restorecon(), ExecAlterExtensionStmt(), ExecGrant_Largeobject(), extension_config_remove(), fetch_statentries_for_relation(), find_composite_type_dependencies(), find_inheritance_children_extended(), findDependentObjects(), findDomainNotNullConstraint(), findNotNullConstraintAttnum(), get_catalog_object_by_oid_extended(), get_database_oid(), get_db_info(), get_domain_constraint_oid(), get_index_constraint(), get_index_ref_constraints(), get_partition_parent_worker(), get_pg_statistic_ext(), get_pkey_attnames(), get_primary_key_attnos(), get_relation_constraint_attnos(), get_relation_constraint_oid(), get_relation_idx_constraint_oid(), get_relation_policy_oid(), get_rels_with_domain(), get_trigger_oid(), GetAllTablesPublications(), GetAttrDefaultColumnAddress(), GetAttrDefaultOid(), getAutoExtensionsOfObject(), GetComment(), GetDatabaseTuple(), GetDatabaseTupleByOid(), GetDefaultOpClass(), getExtensionOfObject(), GetForeignKeyActionTriggers(), GetForeignKeyCheckTriggers(), GetNewOidWithIndex(), getObjectDescription(), getObjectIdentityParts(), getOwnedSequences_internal(), GetParentedForeignKeyRefs(), GetPublicationRelations(), GetPublicationSchemas(), GetSecurityLabel(), GetSharedSecurityLabel(), GetSubscriptionRelations(), has_superclass(), HasSubscriptionTables(), heap_truncate_find_FKs(), index_concurrently_swap(), IndexSetParentIndex(), is_schema_publication(), LargeObjectDrop(), LargeObjectExistsWithSnapshot(), load_domaintype_info(), load_enum_cache_data(), LogicalRepSyncSequences(), LookupOpclassInfo(), makeConfigurationDependencies(), MakeConfigurationMapping(), MarkInheritDetached(), MergeConstraintsIntoExisting(), MergeWithExistingConstraint(), movedb(), object_ownercheck(), PartitionHasPendingDetach(), pg_extension_config_dump(), pg_get_constraintdef_worker(), pg_get_serial_sequence(), pg_get_triggerdef_worker(), pg_largeobject_aclmask_snapshot(), QueueFKConstraintValidation(), RangeDelete(), recordExtensionInitPrivWorker(), recordExtObjInitPriv(), relation_has_policies(), RelationBuildPartitionDesc(), RelationBuildRowSecurity(), RelationBuildRuleLock(), RelationBuildTriggers(), RelationBuildTupleDesc(), RelationGetExclusionInfo(), RelationGetFKeyList(), RelationGetIndexList(), RelationGetNotNullConstraints(), RelationGetStatExtList(), RelationRemoveInheritance(), RelidByRelfilenumber(), RememberAllDependentForRebuilding(), RemoveAttrDefault(), RemoveAttrDefaultById(), RemoveExtensionById(), RemoveInheritance(), RemoveInheritedConstraint(), RemovePolicyById(), RemoveRewriteRuleById(), RemoveRoleFromInitPriv(), RemoveRoleFromObjectACL(), RemoveRoleFromObjectPolicy(), RemoveStatistics(), RemoveTriggerById(), RemoveTSConfigurationById(), rename_policy(), renametrig(), renametrig_internal(), renametrig_partition(), ReplaceRoleInInitPriv(), replorigin_create(), ScanPgRelation(), SearchCatCacheList(), SearchCatCacheMiss(), sepgsql_attribute_post_create(), sepgsql_database_post_create(), sepgsql_proc_post_create(), sepgsql_proc_setattr(), sepgsql_relation_post_create(), sepgsql_relation_setattr(), sepgsql_relation_setattr_extra(), sepgsql_schema_post_create(), sequenceIsOwned(), SetSecurityLabel(), SetSharedSecurityLabel(), shdepChangeDep(), shdepDropDependency(), shdepDropOwned(), shdepReassignOwned(), systable_inplace_update_begin(), toastrel_valueid_exists(), TriggerSetParentTrigger(), typeInheritsFrom(), vac_update_datfrozenxid(), and validatePartitionedIndex().

systable_getnext_ordered()

HeapTuple systable_getnext_ordered ( SysScanDesc  sysscan, ScanDirection  direction  )

extern

Definition at line 732 of file genam.c.

{
    HeapTuple   htup = NULL;
 
    Assert(sysscan->irel);
    if (index_getnext_slot(sysscan->iscan, direction, sysscan->slot))
        htup = ExecFetchSlotHeapTuple(sysscan->slot, false, NULL);
 
    /* See notes in systable_getnext */
    if (htup && sysscan->iscan->xs_recheck)
        elog(ERROR, "system catalog scans with lossy index conditions are not implemented");
 
    /*
     * Handle the concurrent abort while fetching the catalog tuple during
     * logical streaming of a transaction.
     */
    HandleConcurrentAbort();
 
    return htup;
}

References Assert, elog, ERROR, ExecFetchSlotHeapTuple(), fb(), HandleConcurrentAbort(), and index_getnext_slot().

Referenced by BuildEventTriggerCache(), check_toasted_attribute(), enum_endpoint(), enum_range_internal(), heap_fetch_toast_slice(), inv_getsize(), inv_read(), inv_truncate(), inv_write(), lookup_ts_config_cache(), and toast_delete_datum().

systable_inplace_update_begin()

void systable_inplace_update_begin ( Relation  relation, Oid  indexId, bool  indexOK, Snapshot  snapshot, int  nkeys, const ScanKeyData *  key, HeapTuple *  oldtupcopy, void **  state  )

extern

Definition at line 808 of file genam.c.

{
    int         retries = 0;
    SysScanDesc scan;
    HeapTuple   oldtup;
    BufferHeapTupleTableSlot *bslot;
 
    /*
     * For now, we don't allow parallel updates.  Unlike a regular update,
     * this should never create a combo CID, so it might be possible to relax
     * this restriction, but not without more thought and testing.  It's not
     * clear that it would be useful, anyway.
     */
    if (IsInParallelMode())
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                 errmsg("cannot update tuples during a parallel operation")));
 
    /*
     * Accept a snapshot argument, for symmetry, but this function advances
     * its snapshot as needed to reach the tail of the updated tuple chain.
     */
    Assert(snapshot == NULL);
 
    Assert(IsInplaceUpdateRelation(relation) || !IsSystemRelation(relation));
 
    /* Loop for an exclusive-locked buffer of a non-updated tuple. */
    do
    {
        TupleTableSlot *slot;
 
        CHECK_FOR_INTERRUPTS();
 
        /*
         * Processes issuing heap_update (e.g. GRANT) at maximum speed could
         * drive us to this error.  A hostile table owner has stronger ways to
         * damage their own table, so that's minor.
         */
        if (retries++ > 10000)
            elog(ERROR, "giving up after too many tries to overwrite row");
 
        INJECTION_POINT("inplace-before-pin", NULL);
        scan = systable_beginscan(relation, indexId, indexOK, snapshot,
                                  nkeys, unconstify(ScanKeyData *, key));
        oldtup = systable_getnext(scan);
        if (!HeapTupleIsValid(oldtup))
        {
            systable_endscan(scan);
            *oldtupcopy = NULL;
            return;
        }
 
        slot = scan->slot;
        Assert(TTS_IS_BUFFERTUPLE(slot));
        bslot = (BufferHeapTupleTableSlot *) slot;
    } while (!heap_inplace_lock(scan->heap_rel,
                                bslot->base.tuple, bslot->buffer,
                                (void (*) (void *)) systable_endscan, scan));
 
    *oldtupcopy = heap_copytuple(oldtup);
    *state = scan;
}

References Assert, CHECK_FOR_INTERRUPTS, elog, ereport, errcode(), errmsg(), ERROR, fb(), heap_copytuple(), heap_inplace_lock(), SysScanDescData::heap_rel, HeapTupleIsValid, INJECTION_POINT, IsInParallelMode(), IsInplaceUpdateRelation(), IsSystemRelation(), SysScanDescData::slot, systable_beginscan(), systable_endscan(), systable_getnext(), TTS_IS_BUFFERTUPLE, and unconstify.

Referenced by create_toast_table(), dropdb(), EventTriggerOnLogin(), index_update_stats(), vac_update_datfrozenxid(), and vac_update_relstats().

systable_inplace_update_cancel()

void systable_inplace_update_cancel ( void *  state )

extern

Definition at line 903 of file genam.c.

{
    SysScanDesc scan = (SysScanDesc) state;
    Relation    relation = scan->heap_rel;
    TupleTableSlot *slot = scan->slot;
    BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
    HeapTuple   oldtup = bslot->base.tuple;
    Buffer      buffer = bslot->buffer;
 
    heap_inplace_unlock(relation, oldtup, buffer);
    systable_endscan(scan);
}

References fb(), heap_inplace_unlock(), SysScanDescData::heap_rel, SysScanDescData::slot, and systable_endscan().

Referenced by EventTriggerOnLogin(), index_update_stats(), vac_update_datfrozenxid(), and vac_update_relstats().

systable_inplace_update_finish()

void systable_inplace_update_finish ( void *  state, HeapTuple  tuple  )

extern

Definition at line 884 of file genam.c.

{
    SysScanDesc scan = (SysScanDesc) state;
    Relation    relation = scan->heap_rel;
    TupleTableSlot *slot = scan->slot;
    BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
    HeapTuple   oldtup = bslot->base.tuple;
    Buffer      buffer = bslot->buffer;
 
    heap_inplace_update_and_unlock(relation, oldtup, tuple, buffer);
    systable_endscan(scan);
}

References fb(), heap_inplace_update_and_unlock(), SysScanDescData::heap_rel, SysScanDescData::slot, and systable_endscan().

Referenced by create_toast_table(), dropdb(), EventTriggerOnLogin(), index_update_stats(), vac_update_datfrozenxid(), and vac_update_relstats().

systable_recheck_tuple()

bool systable_recheck_tuple ( SysScanDesc  sysscan, HeapTuple  tup  )

extern

Definition at line 573 of file genam.c.

{
    Snapshot    freshsnap;
    bool        result;
 
    Assert(tup == ExecFetchSlotHeapTuple(sysscan->slot, false, NULL));
 
    freshsnap = GetCatalogSnapshot(RelationGetRelid(sysscan->heap_rel));
    freshsnap = RegisterSnapshot(freshsnap);
 
    result = table_tuple_satisfies_snapshot(sysscan->heap_rel,
                                            sysscan->slot,
                                            freshsnap);
    UnregisterSnapshot(freshsnap);
 
    /*
     * Handle the concurrent abort while fetching the catalog tuple during
     * logical streaming of a transaction.
     */
    HandleConcurrentAbort();
 
    return result;
}

References Assert, ExecFetchSlotHeapTuple(), fb(), GetCatalogSnapshot(), HandleConcurrentAbort(), RegisterSnapshot(), RelationGetRelid, table_tuple_satisfies_snapshot(), and UnregisterSnapshot().

Referenced by findDependentObjects(), and shdepDropOwned().

try_index_open()

Relation try_index_open ( Oid  relationId, LOCKMODE  lockmode  )

extern

Definition at line 152 of file indexam.c.

{
    Relation    r;
 
    r = try_relation_open(relationId, lockmode);
 
    /* leave if index does not exist */
    if (!r)
        return NULL;
 
    validate_relation_kind(r);
 
    return r;
}

References fb(), try_relation_open(), and validate_relation_kind().

Referenced by reindex_index().