diff options
Diffstat (limited to 'src/backend/access/index/indexam.c')
| -rw-r--r-- | src/backend/access/index/indexam.c | 984 |
1 files changed, 984 insertions, 0 deletions
diff --git a/src/backend/access/index/indexam.c b/src/backend/access/index/indexam.c new file mode 100644 index 0000000..fe80b8b --- /dev/null +++ b/src/backend/access/index/indexam.c @@ -0,0 +1,984 @@ +/*------------------------------------------------------------------------- + * + * indexam.c + * general index access method routines + * + * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * + * IDENTIFICATION + * src/backend/access/index/indexam.c + * + * INTERFACE ROUTINES + * index_open - open an index relation by relation OID + * index_close - close an index relation + * index_beginscan - start a scan of an index with amgettuple + * index_beginscan_bitmap - start a scan of an index with amgetbitmap + * index_rescan - restart a scan of an index + * index_endscan - end a scan + * index_insert - insert an index tuple into a relation + * index_markpos - mark a scan position + * index_restrpos - restore a scan position + * index_parallelscan_estimate - estimate shared memory for parallel scan + * index_parallelscan_initialize - initialize parallel scan + * index_parallelrescan - (re)start a parallel scan of an index + * index_beginscan_parallel - join parallel index scan + * index_getnext_tid - get the next TID from a scan + * index_fetch_heap - get the scan's next heap tuple + * index_getnext_slot - get the next tuple from a scan + * index_getbitmap - get all tuples from a scan + * index_bulk_delete - bulk deletion of index tuples + * index_vacuum_cleanup - post-deletion cleanup of an index + * index_can_return - does index support index-only scans? + * index_getprocid - get a support procedure OID + * index_getprocinfo - get a support procedure's lookup info + * + * NOTES + * This file contains the index_ routines which used + * to be a scattered collection of stuff in access/genam. + * + *------------------------------------------------------------------------- + */ + +#include "postgres.h" + +#include "access/amapi.h" +#include "access/heapam.h" +#include "access/reloptions.h" +#include "access/relscan.h" +#include "access/tableam.h" +#include "access/transam.h" +#include "access/xlog.h" +#include "catalog/index.h" +#include "catalog/pg_amproc.h" +#include "catalog/pg_type.h" +#include "commands/defrem.h" +#include "nodes/makefuncs.h" +#include "pgstat.h" +#include "storage/bufmgr.h" +#include "storage/lmgr.h" +#include "storage/predicate.h" +#include "utils/ruleutils.h" +#include "utils/snapmgr.h" +#include "utils/syscache.h" + + +/* ---------------------------------------------------------------- + * macros used in index_ routines + * + * Note: the ReindexIsProcessingIndex() check in RELATION_CHECKS is there + * to check that we don't try to scan or do retail insertions into an index + * that is currently being rebuilt or pending rebuild. This helps to catch + * things that don't work when reindexing system catalogs. The assertion + * doesn't prevent the actual rebuild because we don't use RELATION_CHECKS + * when calling the index AM's ambuild routine, and there is no reason for + * ambuild to call its subsidiary routines through this file. + * ---------------------------------------------------------------- + */ +#define RELATION_CHECKS \ +( \ + AssertMacro(RelationIsValid(indexRelation)), \ + AssertMacro(PointerIsValid(indexRelation->rd_indam)), \ + AssertMacro(!ReindexIsProcessingIndex(RelationGetRelid(indexRelation))) \ +) + +#define SCAN_CHECKS \ +( \ + AssertMacro(IndexScanIsValid(scan)), \ + AssertMacro(RelationIsValid(scan->indexRelation)), \ + AssertMacro(PointerIsValid(scan->indexRelation->rd_indam)) \ +) + +#define CHECK_REL_PROCEDURE(pname) \ +do { \ + if (indexRelation->rd_indam->pname == NULL) \ + elog(ERROR, "function \"%s\" is not defined for index \"%s\"", \ + CppAsString(pname), RelationGetRelationName(indexRelation)); \ +} while(0) + +#define CHECK_SCAN_PROCEDURE(pname) \ +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) + +static IndexScanDesc index_beginscan_internal(Relation indexRelation, + int nkeys, int norderbys, Snapshot snapshot, + ParallelIndexScanDesc pscan, bool temp_snap); + + +/* ---------------------------------------------------------------- + * index_ interface functions + * ---------------------------------------------------------------- + */ + +/* ---------------- + * index_open - open an index relation by relation OID + * + * If lockmode is not "NoLock", the specified kind of lock is + * obtained on the index. (Generally, NoLock should only be + * used if the caller knows it has some appropriate lock on the + * index already.) + * + * An error is raised if the index does not exist. + * + * This is a convenience routine adapted for indexscan use. + * Some callers may prefer to use relation_open directly. + * ---------------- + */ +Relation +index_open(Oid relationId, LOCKMODE lockmode) +{ + Relation r; + + r = relation_open(relationId, lockmode); + + if (r->rd_rel->relkind != RELKIND_INDEX && + r->rd_rel->relkind != RELKIND_PARTITIONED_INDEX) + ereport(ERROR, + (errcode(ERRCODE_WRONG_OBJECT_TYPE), + errmsg("\"%s\" is not an index", + RelationGetRelationName(r)))); + + return r; +} + +/* ---------------- + * index_close - close an index relation + * + * If lockmode is not "NoLock", we then release the specified lock. + * + * Note that it is often sensible to hold a lock beyond index_close; + * in that case, the lock is released automatically at xact end. + * ---------------- + */ +void +index_close(Relation relation, LOCKMODE lockmode) +{ + 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); +} + +/* ---------------- + * index_insert - insert an index tuple into a relation + * ---------------- + */ +bool +index_insert(Relation indexRelation, + Datum *values, + bool *isnull, + ItemPointer heap_t_ctid, + Relation heapRelation, + IndexUniqueCheck checkUnique, + bool indexUnchanged, + IndexInfo *indexInfo) +{ + 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); +} + +/* + * index_beginscan - start a scan of an index with amgettuple + * + * Caller must be holding suitable locks on the heap and the index. + */ +IndexScanDesc +index_beginscan(Relation heapRelation, + Relation indexRelation, + Snapshot snapshot, + int nkeys, int norderbys) +{ + IndexScanDesc scan; + + 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; + + /* prepare to fetch index matches from table */ + scan->xs_heapfetch = table_index_fetch_begin(heapRelation); + + return scan; +} + +/* + * index_beginscan_bitmap - start a scan of an index with amgetbitmap + * + * As above, caller had better be holding some lock on the parent heap + * relation, even though it's not explicitly mentioned here. + */ +IndexScanDesc +index_beginscan_bitmap(Relation indexRelation, + Snapshot snapshot, + int nkeys) +{ + IndexScanDesc scan; + + 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; + + return scan; +} + +/* + * index_beginscan_internal --- common code for index_beginscan variants + */ +static IndexScanDesc +index_beginscan_internal(Relation indexRelation, + int nkeys, int norderbys, Snapshot snapshot, + ParallelIndexScanDesc pscan, bool temp_snap) +{ + IndexScanDesc scan; + + RELATION_CHECKS; + CHECK_REL_PROCEDURE(ambeginscan); + + if (!(indexRelation->rd_indam->ampredlocks)) + PredicateLockRelation(indexRelation, snapshot); + + /* + * We hold a reference count to the relcache entry throughout the scan. + */ + RelationIncrementReferenceCount(indexRelation); + + /* + * Tell the AM to open a scan. + */ + scan = indexRelation->rd_indam->ambeginscan(indexRelation, nkeys, + norderbys); + /* Initialize information for parallel scan. */ + scan->parallel_scan = pscan; + scan->xs_temp_snap = temp_snap; + + return scan; +} + +/* ---------------- + * index_rescan - (re)start a scan of an index + * + * During a restart, the caller may specify a new set of scankeys and/or + * orderbykeys; but the number of keys cannot differ from what index_beginscan + * was told. (Later we might relax that to "must not exceed", but currently + * the index AMs tend to assume that scan->numberOfKeys is what to believe.) + * To restart the scan without changing keys, pass NULL for the key arrays. + * (Of course, keys *must* be passed on the first call, unless + * scan->numberOfKeys is zero.) + * ---------------- + */ +void +index_rescan(IndexScanDesc scan, + ScanKey keys, int nkeys, + ScanKey orderbys, int norderbys) +{ + 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); +} + +/* ---------------- + * index_endscan - end a scan + * ---------------- + */ +void +index_endscan(IndexScanDesc scan) +{ + 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); +} + +/* ---------------- + * index_markpos - mark a scan position + * ---------------- + */ +void +index_markpos(IndexScanDesc scan) +{ + SCAN_CHECKS; + CHECK_SCAN_PROCEDURE(ammarkpos); + + scan->indexRelation->rd_indam->ammarkpos(scan); +} + +/* ---------------- + * index_restrpos - restore a scan position + * + * NOTE: this only restores the internal scan state of the index AM. See + * comments for ExecRestrPos(). + * + * NOTE: For heap, in the presence of HOT chains, mark/restore only works + * correctly if the scan's snapshot is MVCC-safe; that ensures that there's at + * most one returnable tuple in each HOT chain, and so restoring the prior + * state at the granularity of the index AM is sufficient. Since the only + * current user of mark/restore functionality is nodeMergejoin.c, this + * effectively means that merge-join plans only work for MVCC snapshots. This + * could be fixed if necessary, but for now it seems unimportant. + * ---------------- + */ +void +index_restrpos(IndexScanDesc scan) +{ + 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); +} + +/* + * index_parallelscan_estimate - estimate shared memory for parallel scan + * + * Currently, we don't pass any information to the AM-specific estimator, + * so it can probably only return a constant. In the future, we might need + * to pass more information. + */ +Size +index_parallelscan_estimate(Relation indexRelation, Snapshot snapshot) +{ + Size nbytes; + + RELATION_CHECKS; + + nbytes = offsetof(ParallelIndexScanDescData, ps_snapshot_data); + nbytes = add_size(nbytes, EstimateSnapshotSpace(snapshot)); + nbytes = MAXALIGN(nbytes); + + /* + * If amestimateparallelscan is not provided, assume there is no + * AM-specific data needed. (It's hard to believe that could work, but + * it's easy enough to cater to it here.) + */ + if (indexRelation->rd_indam->amestimateparallelscan != NULL) + nbytes = add_size(nbytes, + indexRelation->rd_indam->amestimateparallelscan()); + + return nbytes; +} + +/* + * index_parallelscan_initialize - initialize parallel scan + * + * We initialize both the ParallelIndexScanDesc proper and the AM-specific + * information which follows it. + * + * This function calls access method specific initialization routine to + * initialize am specific information. Call this just once in the leader + * process; then, individual workers attach via index_beginscan_parallel. + */ +void +index_parallelscan_initialize(Relation heapRelation, Relation indexRelation, + Snapshot snapshot, ParallelIndexScanDesc target) +{ + Size offset; + + RELATION_CHECKS; + + offset = add_size(offsetof(ParallelIndexScanDescData, ps_snapshot_data), + EstimateSnapshotSpace(snapshot)); + offset = MAXALIGN(offset); + + target->ps_relid = RelationGetRelid(heapRelation); + target->ps_indexid = RelationGetRelid(indexRelation); + target->ps_offset = offset; + SerializeSnapshot(snapshot, target->ps_snapshot_data); + + /* aminitparallelscan is optional; assume no-op if not provided by AM */ + if (indexRelation->rd_indam->aminitparallelscan != NULL) + { + void *amtarget; + + amtarget = OffsetToPointer(target, offset); + indexRelation->rd_indam->aminitparallelscan(amtarget); + } +} + +/* ---------------- + * index_parallelrescan - (re)start a parallel scan of an index + * ---------------- + */ +void +index_parallelrescan(IndexScanDesc scan) +{ + 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); +} + +/* + * index_beginscan_parallel - join parallel index scan + * + * Caller must be holding suitable locks on the heap and the index. + */ +IndexScanDesc +index_beginscan_parallel(Relation heaprel, Relation indexrel, int nkeys, + int norderbys, ParallelIndexScanDesc pscan) +{ + Snapshot snapshot; + IndexScanDesc scan; + + Assert(RelationGetRelid(heaprel) == pscan->ps_relid); + 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; + + /* prepare to fetch index matches from table */ + scan->xs_heapfetch = table_index_fetch_begin(heaprel); + + return scan; +} + +/* ---------------- + * index_getnext_tid - get the next TID from a scan + * + * The result is the next TID satisfying the scan keys, + * or NULL if no more matching tuples exist. + * ---------------- + */ +ItemPointer +index_getnext_tid(IndexScanDesc scan, ScanDirection direction) +{ + 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; +} + +/* ---------------- + * index_fetch_heap - get the scan's next heap tuple + * + * The result is a visible heap tuple associated with the index TID most + * recently fetched by index_getnext_tid, or NULL if no more matching tuples + * exist. (There can be more than one matching tuple because of HOT chains, + * although when using an MVCC snapshot it should be impossible for more than + * one such tuple to exist.) + * + * On success, the buffer containing the heap tup is pinned (the pin will be + * dropped in a future index_getnext_tid, index_fetch_heap or index_endscan + * call). + * + * Note: caller must check scan->xs_recheck, and perform rechecking of the + * scan keys if required. We do not do that here because we don't have + * enough information to do it efficiently in the general case. + * ---------------- + */ +bool +index_fetch_heap(IndexScanDesc scan, TupleTableSlot *slot) +{ + 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; +} + +/* ---------------- + * index_getnext_slot - get the next tuple from a scan + * + * The result is true if a tuple satisfying the scan keys and the snapshot was + * found, false otherwise. The tuple is stored in the specified slot. + * + * On success, resources (like buffer pins) are likely to be held, and will be + * dropped by a future index_getnext_tid, index_fetch_heap or index_endscan + * call). + * + * Note: caller must check scan->xs_recheck, and perform rechecking of the + * scan keys if required. We do not do that here because we don't have + * enough information to do it efficiently in the general case. + * ---------------- + */ +bool +index_getnext_slot(IndexScanDesc scan, ScanDirection direction, TupleTableSlot *slot) +{ + 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; +} + +/* ---------------- + * index_getbitmap - get all tuples at once from an index scan + * + * Adds the TIDs of all heap tuples satisfying the scan keys to a bitmap. + * Since there's no interlock between the index scan and the eventual heap + * access, this is only safe to use with MVCC-based snapshots: the heap + * item slot could have been replaced by a newer tuple by the time we get + * to it. + * + * Returns the number of matching tuples found. (Note: this might be only + * approximate, so it should only be used for statistical purposes.) + * ---------------- + */ +int64 +index_getbitmap(IndexScanDesc scan, TIDBitmap *bitmap) +{ + 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; +} + +/* ---------------- + * index_bulk_delete - do mass deletion of index entries + * + * callback routine tells whether a given main-heap tuple is + * to be deleted + * + * return value is an optional palloc'd struct of statistics + * ---------------- + */ +IndexBulkDeleteResult * +index_bulk_delete(IndexVacuumInfo *info, + IndexBulkDeleteResult *istat, + IndexBulkDeleteCallback callback, + void *callback_state) +{ + Relation indexRelation = info->index; + + RELATION_CHECKS; + CHECK_REL_PROCEDURE(ambulkdelete); + + return indexRelation->rd_indam->ambulkdelete(info, istat, + callback, callback_state); +} + +/* ---------------- + * index_vacuum_cleanup - do post-deletion cleanup of an index + * + * return value is an optional palloc'd struct of statistics + * ---------------- + */ +IndexBulkDeleteResult * +index_vacuum_cleanup(IndexVacuumInfo *info, + IndexBulkDeleteResult *istat) +{ + Relation indexRelation = info->index; + + RELATION_CHECKS; + CHECK_REL_PROCEDURE(amvacuumcleanup); + + return indexRelation->rd_indam->amvacuumcleanup(info, istat); +} + +/* ---------------- + * index_can_return + * + * Does the index access method support index-only scans for the given + * column? + * ---------------- + */ +bool +index_can_return(Relation indexRelation, int attno) +{ + 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); +} + +/* ---------------- + * index_getprocid + * + * Index access methods typically require support routines that are + * not directly the implementation of any WHERE-clause query operator + * and so cannot be kept in pg_amop. Instead, such routines are kept + * in pg_amproc. These registered procedure OIDs are assigned numbers + * according to a convention established by the access method. + * The general index code doesn't know anything about the routines + * involved; it just builds an ordered list of them for + * each attribute on which an index is defined. + * + * As of Postgres 8.3, support routines within an operator family + * are further subdivided by the "left type" and "right type" of the + * query operator(s) that they support. The "default" functions for a + * particular indexed attribute are those with both types equal to + * the index opclass' opcintype (note that this is subtly different + * from the indexed attribute's own type: it may be a binary-compatible + * type instead). Only the default functions are stored in relcache + * entries --- access methods can use the syscache to look up non-default + * functions. + * + * This routine returns the requested default procedure OID for a + * particular indexed attribute. + * ---------------- + */ +RegProcedure +index_getprocid(Relation irel, + AttrNumber attnum, + uint16 procnum) +{ + 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]; +} + +/* ---------------- + * index_getprocinfo + * + * This routine allows index AMs to keep fmgr lookup info for + * support procs in the relcache. As above, only the "default" + * functions for any particular indexed attribute are cached. + * + * Note: the return value points into cached data that will be lost during + * any relcache rebuild! Therefore, either use the callinfo right away, + * or save it only after having acquired some type of lock on the index rel. + * ---------------- + */ +FmgrInfo * +index_getprocinfo(Relation irel, + AttrNumber attnum, + uint16 procnum) +{ + 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; +} + +/* ---------------- + * index_store_float8_orderby_distances + * + * Convert AM distance function's results (that can be inexact) + * to ORDER BY types and save them into xs_orderbyvals/xs_orderbynulls + * for a possible recheck. + * ---------------- + */ +void +index_store_float8_orderby_distances(IndexScanDesc scan, Oid *orderByTypes, + IndexOrderByDistance *distances, + bool recheckOrderBy) +{ + int i; + + Assert(distances || !recheckOrderBy); + + scan->xs_recheckorderby = recheckOrderBy; + + for (i = 0; i < scan->numberOfOrderBys; i++) + { + if (orderByTypes[i] == FLOAT8OID) + { +#ifndef USE_FLOAT8_BYVAL + /* must free any old value to avoid memory leakage */ + if (!scan->xs_orderbynulls[i]) + pfree(DatumGetPointer(scan->xs_orderbyvals[i])); +#endif + 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; + } + } +} + +/* ---------------- + * index_opclass_options + * + * Parse opclass-specific options for index column. + * ---------------- + */ +bytea * +index_opclass_options(Relation indrel, AttrNumber attnum, Datum attoptions, + bool validate) +{ + 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; + bool isnull; + + 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 = SysCacheGetAttr(INDEXRELID, indrel->rd_indextuple, + Anum_pg_index_indclass, &isnull); + Assert(!isnull); + 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); +} |