PostgreSQL Source Code git master
indexam.c File Reference
#include "postgres.h"
#include "access/amapi.h"
#include "access/relation.h"
#include "access/reloptions.h"
#include "access/relscan.h"
#include "access/tableam.h"
#include "catalog/index.h"
#include "catalog/pg_type.h"
#include "nodes/execnodes.h"
#include "pgstat.h"
#include "storage/lmgr.h"
#include "storage/predicate.h"
#include "utils/ruleutils.h"
#include "utils/snapmgr.h"
#include "utils/syscache.h"
Include dependency graph for indexam.c:

Go to the source code of this file.

Macros

#define RELATION_CHECKS
 
#define SCAN_CHECKS
 
#define CHECK_REL_PROCEDURE(pname)
 
#define CHECK_SCAN_PROCEDURE(pname)
 

Functions

static IndexScanDesc index_beginscan_internal (Relation indexRelation, int nkeys, int norderbys, Snapshot snapshot, ParallelIndexScanDesc pscan, bool temp_snap)
 
static void validate_relation_kind (Relation r)
 
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)
 
IndexBulkDeleteResultindex_bulk_delete (IndexVacuumInfo *info, IndexBulkDeleteResult *istat, IndexBulkDeleteCallback callback, void *callback_state)
 
IndexBulkDeleteResultindex_vacuum_cleanup (IndexVacuumInfo *info, IndexBulkDeleteResult *istat)
 
bool index_can_return (Relation indexRelation, int attno)
 
RegProcedure index_getprocid (Relation irel, AttrNumber attnum, uint16 procnum)
 
FmgrInfoindex_getprocinfo (Relation irel, AttrNumber attnum, uint16 procnum)
 
void index_store_float8_orderby_distances (IndexScanDesc scan, Oid *orderByTypes, IndexOrderByDistance *distances, bool recheckOrderBy)
 
byteaindex_opclass_options (Relation indrel, AttrNumber attnum, Datum attoptions, bool validate)
 

Macro Definition Documentation

◆ CHECK_REL_PROCEDURE

#define CHECK_REL_PROCEDURE (   pname)
Value:
do { \
if (indexRelation->rd_indam->pname == NULL) \
elog(ERROR, "function \"%s\" is not defined for index \"%s\"", \
CppAsString(pname), RelationGetRelationName(indexRelation)); \
} while(0)
#define CppAsString(identifier)
Definition: c.h:362
#define ERROR
Definition: elog.h:39
#define RelationGetRelationName(relation)
Definition: rel.h:547

Definition at line 93 of file indexam.c.

◆ CHECK_SCAN_PROCEDURE

#define CHECK_SCAN_PROCEDURE (   pname)
Value:
do { \
if (scan->indexRelation->rd_indam->pname == NULL) \
elog(ERROR, "function \"%s\" is not defined for index \"%s\"", \
CppAsString(pname), RelationGetRelationName(scan->indexRelation)); \
} while(0)

Definition at line 100 of file indexam.c.

◆ RELATION_CHECKS

#define RELATION_CHECKS
Value:
do { \
Assert(RelationIsValid(indexRelation)); \
Assert(PointerIsValid(indexRelation->rd_indam)); \
ereport(ERROR, \
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED), \
errmsg("cannot access index \"%s\" while it is being reindexed", \
RelationGetRelationName(indexRelation)))); \
} while(0)
#define PointerIsValid(pointer)
Definition: c.h:734
#define unlikely(x)
Definition: c.h:347
int errcode(int sqlerrcode)
Definition: elog.c:853
int errmsg(const char *fmt,...)
Definition: elog.c:1070
bool ReindexIsProcessingIndex(Oid indexOid)
Definition: index.c:4140
#define RelationGetRelid(relation)
Definition: rel.h:513
#define RelationIsValid(relation)
Definition: rel.h:486

Definition at line 75 of file indexam.c.

◆ SCAN_CHECKS

#define SCAN_CHECKS
Value:
( \
AssertMacro(IndexScanIsValid(scan)), \
AssertMacro(RelationIsValid(scan->indexRelation)), \
AssertMacro(PointerIsValid(scan->indexRelation->rd_indam)) \
)
#define IndexScanIsValid(scan)
Definition: genam.h:162

Definition at line 86 of file indexam.c.

Function Documentation

◆ index_beginscan()

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

Definition at line 256 of file indexam.c.

261{
262 IndexScanDesc scan;
263
264 Assert(snapshot != InvalidSnapshot);
265
266 scan = index_beginscan_internal(indexRelation, nkeys, norderbys, snapshot, NULL, false);
267
268 /*
269 * Save additional parameters into the scandesc. Everything else was set
270 * up by RelationGetIndexScan.
271 */
272 scan->heapRelation = heapRelation;
273 scan->xs_snapshot = snapshot;
274 scan->instrument = instrument;
275
276 /* prepare to fetch index matches from table */
277 scan->xs_heapfetch = table_index_fetch_begin(heapRelation);
278
279 return scan;
280}
Assert(PointerIsAligned(start, uint64))
static IndexScanDesc index_beginscan_internal(Relation indexRelation, int nkeys, int norderbys, Snapshot snapshot, ParallelIndexScanDesc pscan, bool temp_snap)
Definition: indexam.c:314
#define InvalidSnapshot
Definition: snapshot.h:119
IndexFetchTableData * xs_heapfetch
Definition: relscan.h:175
struct IndexScanInstrumentation * instrument
Definition: relscan.h:159
struct SnapshotData * xs_snapshot
Definition: relscan.h:138
Relation heapRelation
Definition: relscan.h:136
static IndexFetchTableData * table_index_fetch_begin(Relation rel)
Definition: tableam.h:1162

References Assert(), IndexScanDescData::heapRelation, index_beginscan_internal(), IndexScanDescData::instrument, InvalidSnapshot, 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(), RelationFindReplTupleByIndex(), systable_beginscan(), and systable_beginscan_ordered().

◆ index_beginscan_bitmap()

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

Definition at line 289 of file indexam.c.

293{
294 IndexScanDesc scan;
295
296 Assert(snapshot != InvalidSnapshot);
297
298 scan = index_beginscan_internal(indexRelation, nkeys, 0, snapshot, NULL, false);
299
300 /*
301 * Save additional parameters into the scandesc. Everything else was set
302 * up by RelationGetIndexScan.
303 */
304 scan->xs_snapshot = snapshot;
305 scan->instrument = instrument;
306
307 return scan;
308}

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

Referenced by ExecInitBitmapIndexScan().

◆ index_beginscan_internal()

static IndexScanDesc index_beginscan_internal ( Relation  indexRelation,
int  nkeys,
int  norderbys,
Snapshot  snapshot,
ParallelIndexScanDesc  pscan,
bool  temp_snap 
)
static

Definition at line 314 of file indexam.c.

317{
318 IndexScanDesc scan;
319
321 CHECK_REL_PROCEDURE(ambeginscan);
322
323 if (!(indexRelation->rd_indam->ampredlocks))
324 PredicateLockRelation(indexRelation, snapshot);
325
326 /*
327 * We hold a reference count to the relcache entry throughout the scan.
328 */
329 RelationIncrementReferenceCount(indexRelation);
330
331 /*
332 * Tell the AM to open a scan.
333 */
334 scan = indexRelation->rd_indam->ambeginscan(indexRelation, nkeys,
335 norderbys);
336 /* Initialize information for parallel scan. */
337 scan->parallel_scan = pscan;
338 scan->xs_temp_snap = temp_snap;
339
340 return scan;
341}
#define CHECK_REL_PROCEDURE(pname)
Definition: indexam.c:93
#define RELATION_CHECKS
Definition: indexam.c:75
void PredicateLockRelation(Relation relation, Snapshot snapshot)
Definition: predicate.c:2566
void RelationIncrementReferenceCount(Relation rel)
Definition: relcache.c:2145
bool ampredlocks
Definition: amapi.h:269
ambeginscan_function ambeginscan
Definition: amapi.h:306
struct ParallelIndexScanDescData * parallel_scan
Definition: relscan.h:191
struct IndexAmRoutine * rd_indam
Definition: rel.h:206

References IndexAmRoutine::ambeginscan, IndexAmRoutine::ampredlocks, CHECK_REL_PROCEDURE, IndexScanDescData::parallel_scan, PredicateLockRelation(), RelationData::rd_indam, RELATION_CHECKS, RelationIncrementReferenceCount(), and IndexScanDescData::xs_temp_snap.

Referenced by index_beginscan(), index_beginscan_bitmap(), and index_beginscan_parallel().

◆ index_beginscan_parallel()

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

Definition at line 582 of file indexam.c.

586{
587 Snapshot snapshot;
588 IndexScanDesc scan;
589
592
593 snapshot = RestoreSnapshot(pscan->ps_snapshot_data);
594 RegisterSnapshot(snapshot);
595 scan = index_beginscan_internal(indexrel, nkeys, norderbys, snapshot,
596 pscan, true);
597
598 /*
599 * Save additional parameters into the scandesc. Everything else was set
600 * up by index_beginscan_internal.
601 */
602 scan->heapRelation = heaprel;
603 scan->xs_snapshot = snapshot;
604 scan->instrument = instrument;
605
606 /* prepare to fetch index matches from table */
607 scan->xs_heapfetch = table_index_fetch_begin(heaprel);
608
609 return scan;
610}
#define RelFileLocatorEquals(locator1, locator2)
Snapshot RestoreSnapshot(char *start_address)
Definition: snapmgr.c:1780
Snapshot RegisterSnapshot(Snapshot snapshot)
Definition: snapmgr.c:811
RelFileLocator ps_indexlocator
Definition: relscan.h:198
RelFileLocator ps_locator
Definition: relscan.h:197
char ps_snapshot_data[FLEXIBLE_ARRAY_MEMBER]
Definition: relscan.h:201
RelFileLocator rd_locator
Definition: rel.h:57

References Assert(), IndexScanDescData::heapRelation, index_beginscan_internal(), IndexScanDescData::instrument, ParallelIndexScanDescData::ps_indexlocator, ParallelIndexScanDescData::ps_locator, ParallelIndexScanDescData::ps_snapshot_data, 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 
)

Definition at line 794 of file indexam.c.

798{
799 Relation indexRelation = info->index;
800
802 CHECK_REL_PROCEDURE(ambulkdelete);
803
804 return indexRelation->rd_indam->ambulkdelete(info, istat,
805 callback, callback_state);
806}
ambulkdelete_function ambulkdelete
Definition: amapi.h:296
Relation index
Definition: genam.h:69
static void callback(struct sockaddr *addr, struct sockaddr *mask, void *unused)
Definition: test_ifaddrs.c:46

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 
)

Definition at line 834 of file indexam.c.

835{
837
838 /* amcanreturn is optional; assume false if not provided by AM */
839 if (indexRelation->rd_indam->amcanreturn == NULL)
840 return false;
841
842 return indexRelation->rd_indam->amcanreturn(indexRelation, attno);
843}
amcanreturn_function amcanreturn
Definition: amapi.h:298

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

Referenced by get_relation_info(), and indexam_property().

◆ index_close()

void index_close ( Relation  relation,
LOCKMODE  lockmode 
)

Definition at line 177 of file indexam.c.

178{
179 LockRelId relid = relation->rd_lockInfo.lockRelId;
180
181 Assert(lockmode >= NoLock && lockmode < MAX_LOCKMODES);
182
183 /* The relcache does the real work... */
184 RelationClose(relation);
185
186 if (lockmode != NoLock)
187 UnlockRelationId(&relid, lockmode);
188}
void UnlockRelationId(LockRelId *relid, LOCKMODE lockmode)
Definition: lmgr.c:214
#define MAX_LOCKMODES
Definition: lock.h:83
#define NoLock
Definition: lockdefs.h:34
void RelationClose(Relation relation)
Definition: relcache.c:2178
LockRelId lockRelId
Definition: rel.h:46
Definition: rel.h:39
LockInfoData rd_lockInfo
Definition: rel.h:114

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(), ATExecAddIndex(), ATExecAddIndexConstraint(), ATExecReplicaIdentity(), AttachPartitionEnsureIndexes(), brin_page_items(), brincostestimate(), bt_index_check_internal(), 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(), hash_bitmap_info(), 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(), pgstathashindex(), plan_create_index_workers(), rebuild_relation(), refresh_by_match_merge(), RefreshMatViewByOid(), reindex_index(), ReindexRelationConcurrently(), RelationFindReplTupleByIndex(), RelationGetIndexAttrBitmap(), RelationTruncateIndexes(), SetIndexStorageProperties(), systable_endscan(), toast_close_indexes(), TryReuseIndex(), vac_close_indexes(), vac_open_indexes(), and validate_index().

◆ index_endscan()

void index_endscan ( IndexScanDesc  scan)

Definition at line 382 of file indexam.c.

383{
385 CHECK_SCAN_PROCEDURE(amendscan);
386
387 /* Release resources (like buffer pins) from table accesses */
388 if (scan->xs_heapfetch)
389 {
391 scan->xs_heapfetch = NULL;
392 }
393
394 /* End the AM's scan */
395 scan->indexRelation->rd_indam->amendscan(scan);
396
397 /* Release index refcount acquired by index_beginscan */
399
400 if (scan->xs_temp_snap)
402
403 /* Release the scan data structure itself */
404 IndexScanEnd(scan);
405}
void IndexScanEnd(IndexScanDesc scan)
Definition: genam.c:145
#define CHECK_SCAN_PROCEDURE(pname)
Definition: indexam.c:100
#define SCAN_CHECKS
Definition: indexam.c:86
void RelationDecrementReferenceCount(Relation rel)
Definition: relcache.c:2158
void UnregisterSnapshot(Snapshot snapshot)
Definition: snapmgr.c:853
amendscan_function amendscan
Definition: amapi.h:310
Relation indexRelation
Definition: relscan.h:137
static void table_index_fetch_end(struct IndexFetchTableData *scan)
Definition: tableam.h:1181

References IndexAmRoutine::amendscan, CHECK_SCAN_PROCEDURE, 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(), RelationFindReplTupleByIndex(), systable_endscan(), and systable_endscan_ordered().

◆ index_fetch_heap()

bool index_fetch_heap ( IndexScanDesc  scan,
TupleTableSlot slot 
)

Definition at line 678 of file indexam.c.

679{
680 bool all_dead = false;
681 bool found;
682
683 found = table_index_fetch_tuple(scan->xs_heapfetch, &scan->xs_heaptid,
684 scan->xs_snapshot, slot,
685 &scan->xs_heap_continue, &all_dead);
686
687 if (found)
689
690 /*
691 * If we scanned a whole HOT chain and found only dead tuples, tell index
692 * AM to kill its entry for that TID (this will take effect in the next
693 * amgettuple call, in index_getnext_tid). We do not do this when in
694 * recovery because it may violate MVCC to do so. See comments in
695 * RelationGetIndexScan().
696 */
697 if (!scan->xactStartedInRecovery)
698 scan->kill_prior_tuple = all_dead;
699
700 return found;
701}
#define pgstat_count_heap_fetch(rel)
Definition: pgstat.h:689
bool xs_heap_continue
Definition: relscan.h:173
bool xactStartedInRecovery
Definition: relscan.h:149
bool kill_prior_tuple
Definition: relscan.h:147
ItemPointerData xs_heaptid
Definition: relscan.h:172
static bool table_index_fetch_tuple(struct IndexFetchTableData *scan, ItemPointer tid, Snapshot snapshot, TupleTableSlot *slot, bool *call_again, bool *all_dead)
Definition: tableam.h:1211

References 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 
)

Definition at line 764 of file indexam.c.

765{
766 int64 ntids;
767
769 CHECK_SCAN_PROCEDURE(amgetbitmap);
770
771 /* just make sure this is false... */
772 scan->kill_prior_tuple = false;
773
774 /*
775 * have the am's getbitmap proc do all the work.
776 */
777 ntids = scan->indexRelation->rd_indam->amgetbitmap(scan, bitmap);
778
780
781 return ntids;
782}
int64_t int64
Definition: c.h:499
#define pgstat_count_index_tuples(rel, n)
Definition: pgstat.h:699
amgetbitmap_function amgetbitmap
Definition: amapi.h:309

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 
)

Definition at line 719 of file indexam.c.

720{
721 for (;;)
722 {
723 if (!scan->xs_heap_continue)
724 {
725 ItemPointer tid;
726
727 /* Time to fetch the next TID from the index */
728 tid = index_getnext_tid(scan, direction);
729
730 /* If we're out of index entries, we're done */
731 if (tid == NULL)
732 break;
733
734 Assert(ItemPointerEquals(tid, &scan->xs_heaptid));
735 }
736
737 /*
738 * Fetch the next (or only) visible heap tuple for this index entry.
739 * If we don't find anything, loop around and grab the next TID from
740 * the index.
741 */
743 if (index_fetch_heap(scan, slot))
744 return true;
745 }
746
747 return false;
748}
ItemPointer index_getnext_tid(IndexScanDesc scan, ScanDirection direction)
Definition: indexam.c:620
bool index_fetch_heap(IndexScanDesc scan, TupleTableSlot *slot)
Definition: indexam.c:678
bool ItemPointerEquals(ItemPointer pointer1, ItemPointer pointer2)
Definition: itemptr.c:35
static bool ItemPointerIsValid(const ItemPointerData *pointer)
Definition: itemptr.h:83

References Assert(), 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(), RelationFindReplTupleByIndex(), systable_getnext(), and systable_getnext_ordered().

◆ index_getnext_tid()

ItemPointer index_getnext_tid ( IndexScanDesc  scan,
ScanDirection  direction 
)

Definition at line 620 of file indexam.c.

621{
622 bool found;
623
625 CHECK_SCAN_PROCEDURE(amgettuple);
626
627 /* XXX: we should assert that a snapshot is pushed or registered */
629
630 /*
631 * The AM's amgettuple proc finds the next index entry matching the scan
632 * keys, and puts the TID into scan->xs_heaptid. It should also set
633 * scan->xs_recheck and possibly scan->xs_itup/scan->xs_hitup, though we
634 * pay no attention to those fields here.
635 */
636 found = scan->indexRelation->rd_indam->amgettuple(scan, direction);
637
638 /* Reset kill flag immediately for safety */
639 scan->kill_prior_tuple = false;
640 scan->xs_heap_continue = false;
641
642 /* If we're out of index entries, we're done */
643 if (!found)
644 {
645 /* release resources (like buffer pins) from table accesses */
646 if (scan->xs_heapfetch)
648
649 return NULL;
650 }
652
654
655 /* Return the TID of the tuple we found. */
656 return &scan->xs_heaptid;
657}
TransactionId RecentXmin
Definition: snapmgr.c:159
amgettuple_function amgettuple
Definition: amapi.h:308
static void table_index_fetch_reset(struct IndexFetchTableData *scan)
Definition: tableam.h:1172
#define TransactionIdIsValid(xid)
Definition: transam.h:41

References IndexAmRoutine::amgettuple, Assert(), CHECK_SCAN_PROCEDURE, 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 
)

Definition at line 872 of file indexam.c.

875{
876 RegProcedure *loc;
877 int nproc;
878 int procindex;
879
880 nproc = irel->rd_indam->amsupport;
881
882 Assert(procnum > 0 && procnum <= (uint16) nproc);
883
884 procindex = (nproc * (attnum - 1)) + (procnum - 1);
885
886 loc = irel->rd_support;
887
888 Assert(loc != NULL);
889
890 return loc[procindex];
891}
regproc RegProcedure
Definition: c.h:621
uint16_t uint16
Definition: c.h:501
int16 attnum
Definition: pg_attribute.h:74
uint16 amsupport
Definition: amapi.h:239
RegProcedure * rd_support
Definition: rel.h:209

References IndexAmRoutine::amsupport, Assert(), attnum, 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(), and spgGetCache().

◆ index_getprocinfo()

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

Definition at line 906 of file indexam.c.

909{
910 FmgrInfo *locinfo;
911 int nproc;
912 int optsproc;
913 int procindex;
914
915 nproc = irel->rd_indam->amsupport;
916 optsproc = irel->rd_indam->amoptsprocnum;
917
918 Assert(procnum > 0 && procnum <= (uint16) nproc);
919
920 procindex = (nproc * (attnum - 1)) + (procnum - 1);
921
922 locinfo = irel->rd_supportinfo;
923
924 Assert(locinfo != NULL);
925
926 locinfo += procindex;
927
928 /* Initialize the lookup info if first time through */
929 if (locinfo->fn_oid == InvalidOid)
930 {
931 RegProcedure *loc = irel->rd_support;
932 RegProcedure procId;
933
934 Assert(loc != NULL);
935
936 procId = loc[procindex];
937
938 /*
939 * Complain if function was not found during IndexSupportInitialize.
940 * This should not happen unless the system tables contain bogus
941 * entries for the index opclass. (If an AM wants to allow a support
942 * function to be optional, it can use index_getprocid.)
943 */
944 if (!RegProcedureIsValid(procId))
945 elog(ERROR, "missing support function %d for attribute %d of index \"%s\"",
946 procnum, attnum, RelationGetRelationName(irel));
947
948 fmgr_info_cxt(procId, locinfo, irel->rd_indexcxt);
949
950 if (procnum != optsproc)
951 {
952 /* Initialize locinfo->fn_expr with opclass options Const */
953 bytea **attoptions = RelationGetIndexAttOptions(irel, false);
955
956 set_fn_opclass_options(locinfo, attoptions[attnum - 1]);
957
958 MemoryContextSwitchTo(oldcxt);
959 }
960 }
961
962 return locinfo;
963}
#define RegProcedureIsValid(p)
Definition: c.h:748
#define elog(elevel,...)
Definition: elog.h:225
void set_fn_opclass_options(FmgrInfo *flinfo, bytea *options)
Definition: fmgr.c:2070
void fmgr_info_cxt(Oid functionId, FmgrInfo *finfo, MemoryContext mcxt)
Definition: fmgr.c:137
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:124
#define InvalidOid
Definition: postgres_ext.h:37
bytea ** RelationGetIndexAttOptions(Relation relation, bool copy)
Definition: relcache.c:5916
Definition: fmgr.h:57
Oid fn_oid
Definition: fmgr.h:59
uint16 amoptsprocnum
Definition: amapi.h:241
MemoryContext rd_indexcxt
Definition: rel.h:204
struct FmgrInfo * rd_supportinfo
Definition: rel.h:210
Definition: c.h:658

References IndexAmRoutine::amoptsprocnum, IndexAmRoutine::amsupport, Assert(), attnum, elog, ERROR, fmgr_info_cxt(), FmgrInfo::fn_oid, 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 
)

Definition at line 213 of file indexam.c.

221{
223 CHECK_REL_PROCEDURE(aminsert);
224
225 if (!(indexRelation->rd_indam->ampredlocks))
226 CheckForSerializableConflictIn(indexRelation,
227 (ItemPointer) NULL,
229
230 return indexRelation->rd_indam->aminsert(indexRelation, values, isnull,
231 heap_t_ctid, heapRelation,
232 checkUnique, indexUnchanged,
233 indexInfo);
234}
#define InvalidBlockNumber
Definition: block.h:33
static Datum values[MAXATTR]
Definition: bootstrap.c:151
void CheckForSerializableConflictIn(Relation relation, ItemPointer tid, BlockNumber blkno)
Definition: predicate.c:4326
aminsert_function aminsert
Definition: amapi.h:294

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

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

◆ index_insert_cleanup()

void index_insert_cleanup ( Relation  indexRelation,
IndexInfo indexInfo 
)

Definition at line 241 of file indexam.c.

243{
245
246 if (indexRelation->rd_indam->aminsertcleanup)
247 indexRelation->rd_indam->aminsertcleanup(indexRelation, indexInfo);
248}
aminsertcleanup_function aminsertcleanup
Definition: amapi.h:295

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

Referenced by ExecCloseIndices(), and validate_index().

◆ index_markpos()

void index_markpos ( IndexScanDesc  scan)

Definition at line 412 of file indexam.c.

413{
415 CHECK_SCAN_PROCEDURE(ammarkpos);
416
417 scan->indexRelation->rd_indam->ammarkpos(scan);
418}
ammarkpos_function ammarkpos
Definition: amapi.h:311

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 
)

Definition at line 1042 of file indexam.c.

1044{
1045 int amoptsprocnum = indrel->rd_indam->amoptsprocnum;
1046 Oid procid = InvalidOid;
1047 FmgrInfo *procinfo;
1048 local_relopts relopts;
1049
1050 /* fetch options support procedure if specified */
1051 if (amoptsprocnum != 0)
1052 procid = index_getprocid(indrel, attnum, amoptsprocnum);
1053
1054 if (!OidIsValid(procid))
1055 {
1056 Oid opclass;
1057 Datum indclassDatum;
1058 oidvector *indclass;
1059
1060 if (!DatumGetPointer(attoptions))
1061 return NULL; /* ok, no options, no procedure */
1062
1063 /*
1064 * Report an error if the opclass's options-parsing procedure does not
1065 * exist but the opclass options are specified.
1066 */
1067 indclassDatum = SysCacheGetAttrNotNull(INDEXRELID, indrel->rd_indextuple,
1068 Anum_pg_index_indclass);
1069 indclass = (oidvector *) DatumGetPointer(indclassDatum);
1070 opclass = indclass->values[attnum - 1];
1071
1072 ereport(ERROR,
1073 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1074 errmsg("operator class %s has no options",
1075 generate_opclass_name(opclass))));
1076 }
1077
1078 init_local_reloptions(&relopts, 0);
1079
1080 procinfo = index_getprocinfo(indrel, attnum, amoptsprocnum);
1081
1082 (void) FunctionCall1(procinfo, PointerGetDatum(&relopts));
1083
1084 return build_local_reloptions(&relopts, attoptions, validate);
1085}
static bool validate(Port *port, const char *auth)
Definition: auth-oauth.c:638
#define OidIsValid(objectId)
Definition: c.h:746
#define ereport(elevel,...)
Definition: elog.h:149
#define FunctionCall1(flinfo, arg1)
Definition: fmgr.h:659
FmgrInfo * index_getprocinfo(Relation irel, AttrNumber attnum, uint16 procnum)
Definition: indexam.c:906
RegProcedure index_getprocid(Relation irel, AttrNumber attnum, uint16 procnum)
Definition: indexam.c:872
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:327
uintptr_t Datum
Definition: postgres.h:69
static Pointer DatumGetPointer(Datum X)
Definition: postgres.h:317
unsigned int Oid
Definition: postgres_ext.h:32
void init_local_reloptions(local_relopts *relopts, Size relopt_struct_size)
Definition: reloptions.c:753
void * build_local_reloptions(local_relopts *relopts, Datum options, bool validate)
Definition: reloptions.c:1979
char * generate_opclass_name(Oid opclass)
Definition: ruleutils.c:12889
struct HeapTupleData * rd_indextuple
Definition: rel.h:194
Definition: c.h:697
Oid values[FLEXIBLE_ARRAY_MEMBER]
Definition: c.h:704
Datum SysCacheGetAttrNotNull(int cacheId, HeapTuple tup, AttrNumber attributeNumber)
Definition: syscache.c:631

References IndexAmRoutine::amoptsprocnum, attnum, build_local_reloptions(), DatumGetPointer(), ereport, errcode(), errmsg(), ERROR, FunctionCall1, generate_opclass_name(), index_getprocid(), index_getprocinfo(), init_local_reloptions(), InvalidOid, OidIsValid, PointerGetDatum(), RelationData::rd_indam, RelationData::rd_indextuple, SysCacheGetAttrNotNull(), validate(), and oidvector::values.

Referenced by index_create(), and RelationGetIndexAttOptions().

◆ index_open()

Relation index_open ( Oid  relationId,
LOCKMODE  lockmode 
)

Definition at line 133 of file indexam.c.

134{
135 Relation r;
136
137 r = relation_open(relationId, lockmode);
138
140
141 return r;
142}
static void validate_relation_kind(Relation r)
Definition: indexam.c:197
Relation relation_open(Oid relationId, LOCKMODE lockmode)
Definition: relation.c:47

References relation_open(), and validate_relation_kind().

Referenced by _brin_parallel_build_main(), _bt_parallel_build_main(), _gin_parallel_build_main(), ATExecAddIndex(), ATExecAddIndexConstraint(), ATExecReplicaIdentity(), AttachPartitionEnsureIndexes(), brin_desummarize_range(), brin_page_items(), brin_summarize_range(), brincostestimate(), bt_index_check_internal(), 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(), RelationFindReplTupleByIndex(), RelationGetIndexAttrBitmap(), RelationTruncateIndexes(), SetIndexStorageProperties(), systable_beginscan(), toast_open_indexes(), transformIndexConstraint(), TryReuseIndex(), vac_open_indexes(), and validate_index().

◆ index_parallelrescan()

void index_parallelrescan ( IndexScanDesc  scan)

Definition at line 564 of file indexam.c.

565{
567
568 if (scan->xs_heapfetch)
570
571 /* amparallelrescan is optional; assume no-op if not provided by AM */
572 if (scan->indexRelation->rd_indam->amparallelrescan != NULL)
574}
amparallelrescan_function amparallelrescan
Definition: amapi.h:317

References IndexAmRoutine::amparallelrescan, 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 
)

Definition at line 461 of file indexam.c.

464{
465 Size nbytes;
466
467 Assert(instrument || parallel_aware);
468
470
471 nbytes = offsetof(ParallelIndexScanDescData, ps_snapshot_data);
472 nbytes = add_size(nbytes, EstimateSnapshotSpace(snapshot));
473 nbytes = MAXALIGN(nbytes);
474
475 if (instrument)
476 {
477 Size sharedinfosz;
478
479 sharedinfosz = offsetof(SharedIndexScanInstrumentation, winstrument) +
480 nworkers * sizeof(IndexScanInstrumentation);
481 nbytes = add_size(nbytes, sharedinfosz);
482 nbytes = MAXALIGN(nbytes);
483 }
484
485 /*
486 * If parallel scan index AM interface can't be used (or index AM provides
487 * no such interface), assume there is no AM-specific data needed
488 */
489 if (parallel_aware &&
490 indexRelation->rd_indam->amestimateparallelscan != NULL)
491 nbytes = add_size(nbytes,
492 indexRelation->rd_indam->amestimateparallelscan(nkeys,
493 norderbys));
494
495 return nbytes;
496}
#define MAXALIGN(LEN)
Definition: c.h:782
size_t Size
Definition: c.h:576
struct IndexScanInstrumentation IndexScanInstrumentation
Size add_size(Size s1, Size s2)
Definition: shmem.c:488
Size EstimateSnapshotSpace(Snapshot snapshot)
Definition: snapmgr.c:1699
amestimateparallelscan_function amestimateparallelscan
Definition: amapi.h:315

References add_size(), IndexAmRoutine::amestimateparallelscan, Assert(), EstimateSnapshotSpace(), 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 
)

Definition at line 509 of file indexam.c.

514{
515 Size offset;
516
517 Assert(instrument || parallel_aware);
518
520
521 offset = add_size(offsetof(ParallelIndexScanDescData, ps_snapshot_data),
522 EstimateSnapshotSpace(snapshot));
523 offset = MAXALIGN(offset);
524
525 target->ps_locator = heapRelation->rd_locator;
526 target->ps_indexlocator = indexRelation->rd_locator;
527 target->ps_offset_ins = 0;
528 target->ps_offset_am = 0;
529 SerializeSnapshot(snapshot, target->ps_snapshot_data);
530
531 if (instrument)
532 {
533 Size sharedinfosz;
534
535 target->ps_offset_ins = offset;
536 sharedinfosz = offsetof(SharedIndexScanInstrumentation, winstrument) +
537 nworkers * sizeof(IndexScanInstrumentation);
538 offset = add_size(offset, sharedinfosz);
539 offset = MAXALIGN(offset);
540
541 /* Set leader's *sharedinfo pointer, and initialize stats */
542 *sharedinfo = (SharedIndexScanInstrumentation *)
543 OffsetToPointer(target, target->ps_offset_ins);
544 memset(*sharedinfo, 0, sharedinfosz);
545 (*sharedinfo)->num_workers = nworkers;
546 }
547
548 /* aminitparallelscan is optional; assume no-op if not provided by AM */
549 if (parallel_aware && indexRelation->rd_indam->aminitparallelscan != NULL)
550 {
551 void *amtarget;
552
553 target->ps_offset_am = offset;
554 amtarget = OffsetToPointer(target, target->ps_offset_am);
555 indexRelation->rd_indam->aminitparallelscan(amtarget);
556 }
557}
#define OffsetToPointer(base, offset)
Definition: c.h:743
void SerializeSnapshot(Snapshot snapshot, char *start_address)
Definition: snapmgr.c:1723
aminitparallelscan_function aminitparallelscan
Definition: amapi.h:316

References add_size(), IndexAmRoutine::aminitparallelscan, Assert(), EstimateSnapshotSpace(), 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 
)

Definition at line 356 of file indexam.c.

359{
361 CHECK_SCAN_PROCEDURE(amrescan);
362
363 Assert(nkeys == scan->numberOfKeys);
364 Assert(norderbys == scan->numberOfOrderBys);
365
366 /* Release resources (like buffer pins) from table accesses */
367 if (scan->xs_heapfetch)
369
370 scan->kill_prior_tuple = false; /* for safety */
371 scan->xs_heap_continue = false;
372
373 scan->indexRelation->rd_indam->amrescan(scan, keys, nkeys,
374 orderbys, norderbys);
375}
amrescan_function amrescan
Definition: amapi.h:307
int numberOfOrderBys
Definition: relscan.h:140

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(), RelationFindReplTupleByIndex(), systable_beginscan(), and systable_beginscan_ordered().

◆ index_restrpos()

void index_restrpos ( IndexScanDesc  scan)

Definition at line 436 of file indexam.c.

437{
439
441 CHECK_SCAN_PROCEDURE(amrestrpos);
442
443 /* release resources (like buffer pins) from table accesses */
444 if (scan->xs_heapfetch)
446
447 scan->kill_prior_tuple = false; /* for safety */
448 scan->xs_heap_continue = false;
449
450 scan->indexRelation->rd_indam->amrestrpos(scan);
451}
#define IsMVCCSnapshot(snapshot)
Definition: snapmgr.h:55
amrestrpos_function amrestrpos
Definition: amapi.h:312

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 
)

Definition at line 974 of file indexam.c.

977{
978 int i;
979
980 Assert(distances || !recheckOrderBy);
981
982 scan->xs_recheckorderby = recheckOrderBy;
983
984 for (i = 0; i < scan->numberOfOrderBys; i++)
985 {
986 if (orderByTypes[i] == FLOAT8OID)
987 {
988#ifndef USE_FLOAT8_BYVAL
989 /* must free any old value to avoid memory leakage */
990 if (!scan->xs_orderbynulls[i])
992#endif
993 if (distances && !distances[i].isnull)
994 {
995 scan->xs_orderbyvals[i] = Float8GetDatum(distances[i].value);
996 scan->xs_orderbynulls[i] = false;
997 }
998 else
999 {
1000 scan->xs_orderbyvals[i] = (Datum) 0;
1001 scan->xs_orderbynulls[i] = true;
1002 }
1003 }
1004 else if (orderByTypes[i] == FLOAT4OID)
1005 {
1006 /* convert distance function's result to ORDER BY type */
1007 if (distances && !distances[i].isnull)
1008 {
1009 scan->xs_orderbyvals[i] = Float4GetDatum((float4) distances[i].value);
1010 scan->xs_orderbynulls[i] = false;
1011 }
1012 else
1013 {
1014 scan->xs_orderbyvals[i] = (Datum) 0;
1015 scan->xs_orderbynulls[i] = true;
1016 }
1017 }
1018 else
1019 {
1020 /*
1021 * If the ordering operator's return value is anything else, we
1022 * don't know how to convert the float8 bound calculated by the
1023 * distance function to that. The executor won't actually need
1024 * the order by values we return here, if there are no lossy
1025 * results, so only insist on converting if the *recheck flag is
1026 * set.
1027 */
1028 if (scan->xs_recheckorderby)
1029 elog(ERROR, "ORDER BY operator must return float8 or float4 if the distance function is lossy");
1030 scan->xs_orderbynulls[i] = true;
1031 }
1032 }
1033}
float float4
Definition: c.h:600
Datum Float8GetDatum(float8 X)
Definition: fmgr.c:1816
static struct @165 value
int i
Definition: isn.c:74
void pfree(void *pointer)
Definition: mcxt.c:1524
static Datum Float4GetDatum(float4 X)
Definition: postgres.h:480
bool * xs_orderbynulls
Definition: relscan.h:187
bool xs_recheckorderby
Definition: relscan.h:188
Datum * xs_orderbyvals
Definition: relscan.h:186

References Assert(), DatumGetPointer(), elog, ERROR, Float4GetDatum(), Float8GetDatum(), i, IndexScanDescData::numberOfOrderBys, pfree(), 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 
)

Definition at line 815 of file indexam.c.

817{
818 Relation indexRelation = info->index;
819
821 CHECK_REL_PROCEDURE(amvacuumcleanup);
822
823 return indexRelation->rd_indam->amvacuumcleanup(info, istat);
824}
amvacuumcleanup_function amvacuumcleanup
Definition: amapi.h:297

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

Referenced by do_analyze_rel(), and vac_cleanup_one_index().

◆ try_index_open()

Relation try_index_open ( Oid  relationId,
LOCKMODE  lockmode 
)

Definition at line 152 of file indexam.c.

153{
154 Relation r;
155
156 r = try_relation_open(relationId, lockmode);
157
158 /* leave if index does not exist */
159 if (!r)
160 return NULL;
161
163
164 return r;
165}
Relation try_relation_open(Oid relationId, LOCKMODE lockmode)
Definition: relation.c:88

References try_relation_open(), and validate_relation_kind().

Referenced by reindex_index().

◆ validate_relation_kind()

static void validate_relation_kind ( Relation  r)
inlinestatic

Definition at line 197 of file indexam.c.

198{
199 if (r->rd_rel->relkind != RELKIND_INDEX &&
200 r->rd_rel->relkind != RELKIND_PARTITIONED_INDEX)
202 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
203 errmsg("\"%s\" is not an index",
205}
Form_pg_class rd_rel
Definition: rel.h:111

References ereport, errcode(), errmsg(), ERROR, RelationData::rd_rel, and RelationGetRelationName.

Referenced by index_open(), and try_index_open().