Movatterモバイル変換

The index construction and maintenance functions that an index access method must provide are:

IndexBuildResult *ambuild (Relation heapRelation,         Relation indexRelation,         IndexInfo *indexInfo);

Build a new index. The index relation has been physically created, but is empty. It must be filled in with whatever fixed data the access method requires, plus entries for all tuples already existing in the table. Ordinarily theambuild function will callIndexBuildHeapScan() to scan the table for existing tuples and compute the keys that need to be inserted into the index. The function must return a palloc'd struct containing statistics about the new index.

voidambuildempty (Relation indexRelation);

Build an empty index, and write it to the initialization fork (INIT_FORKNUM) of the given relation. This method is called only for unlogged tables; the empty index written to the initialization fork will be copied over the main relation fork on each server restart.

boolaminsert (Relation indexRelation,          Datum *values,          bool *isnull,          ItemPointer heap_tid,          Relation heapRelation,          IndexUniqueCheck checkUnique);

Insert a new tuple into an existing index. Thevalues andisnull arrays give the key values to be indexed, andheap_tid is the TID to be indexed. If the access method supports unique indexes (itspg_am.amcanunique flag is true) thencheckUnique indicates the type of uniqueness check to perform. This varies depending on whether the unique constraint is deferrable; seeSection 58.5 for details. Normally the access method only needs theheapRelation parameter when performing uniqueness checking (since then it will have to look into the heap to verify tuple liveness).

The function's Boolean result value is significant only whencheckUnique isUNIQUE_CHECK_PARTIAL. In this case a TRUE result means the new entry is known unique, whereas FALSE means it might be non-unique (and a deferred uniqueness check must be scheduled). For other cases a constant FALSE result is recommended.

Some indexes might not index all tuples. If the tuple is not to be indexed,aminsert should just return without doing anything.

IndexBulkDeleteResult *ambulkdelete (IndexVacuumInfo *info,              IndexBulkDeleteResult *stats,              IndexBulkDeleteCallback callback,              void *callback_state);

Delete tuple(s) from the index. This is a“bulk delete” operation that is intended to be implemented by scanning the whole index and checking each entry to see if it should be deleted. The passed-incallback function must be called, in the stylecallback(TID, callback_state) returns bool, to determine whether any particular index entry, as identified by its referenced TID, is to be deleted. Must return either NULL or a palloc'd struct containing statistics about the effects of the deletion operation. It is OK to return NULL if no information needs to be passed on toamvacuumcleanup.

Because of limitedmaintenance_work_mem,ambulkdelete might need to be called more than once when many tuples are to be deleted. Thestats argument is the result of the previous call for this index (it is NULL for the first call within aVACUUM operation). This allows the AM to accumulate statistics across the whole operation. Typically,ambulkdelete will modify and return the same struct if the passedstats is not null.

IndexBulkDeleteResult *amvacuumcleanup (IndexVacuumInfo *info,                 IndexBulkDeleteResult *stats);

Clean up after aVACUUM operation (zero or moreambulkdelete calls). This does not have to do anything beyond returning index statistics, but it might perform bulk cleanup such as reclaiming empty index pages.stats is whatever the lastambulkdelete call returned, or NULL ifambulkdelete was not called because no tuples needed to be deleted. If the result is not NULL it must be a palloc'd struct. The statistics it contains will be used to updatepg_class, and will be reported byVACUUM ifVERBOSE is given. It is OK to return NULL if the index was not changed at all during theVACUUM operation, but otherwise correct stats should be returned.

As ofPostgreSQL 8.4,amvacuumcleanup will also be called at completion of anANALYZE operation. In this casestats is always NULL and any return value will be ignored. This case can be distinguished by checkinginfo->analyze_only. It is recommended that the access method do nothing except post-insert cleanup in such a call, and that only in an autovacuum worker process.

boolamcanreturn (Relation indexRelation, int attno);

Check whether the index can supportindex-only scans on the given column, by returning the indexed column values for an index entry in the form of anIndexTuple. The attribute number is 1-based, i.e. the first columns attno is 1. Returns TRUE if supported, else FALSE. If the access method does not support index-only scans at all, theamcanreturn field in itspg_am row can be set to zero.

voidamcostestimate (PlannerInfo *root,                IndexPath *path,                double loop_count,                Cost *indexStartupCost,                Cost *indexTotalCost,                Selectivity *indexSelectivity,                double *indexCorrelation);

Estimate the costs of an index scan. This function is described fully inSection 58.6, below.

bytea *amoptions (ArrayType *reloptions,           bool validate);

Parse and validate the reloptions array for an index. This is called only when a non-null reloptions array exists for the index.reloptions is atext array containing entries of the formname=value. The function should construct abytea value, which will be copied into therd_options field of the index's relcache entry. The data contents of thebytea value are open for the access method to define; most of the standard access methods use structStdRdOptions. Whenvalidate is true, the function should report a suitable error message if any of the options are unrecognized or have invalid values; whenvalidate is false, invalid entries should be silently ignored. (validate is false when loading options already stored inpg_catalog; an invalid entry could only be found if the access method has changed its rules for options, and in that case ignoring obsolete entries is appropriate.) It is OK to return NULL if default behavior is wanted.

The purpose of an index, of course, is to support scans for tuples matching an indexableWHERE condition, often called aqualifier orscan key. The semantics of index scanning are described more fully inSection 58.3, below. An index access method can support“plain” index scans,“bitmap” index scans, or both. The scan-related functions that an index access method must or may provide are:

IndexScanDescambeginscan (Relation indexRelation,             int nkeys,             int norderbys);

Prepare for an index scan. Thenkeys andnorderbys parameters indicate the number of quals and ordering operators that will be used in the scan; these may be useful for space allocation purposes. Note that the actual values of the scan keys aren't provided yet. The result must be a palloc'd struct. For implementation reasons the index access methodmust create this struct by callingRelationGetIndexScan(). In most casesambeginscan does little beyond making that call and perhaps acquiring locks; the interesting parts of index-scan startup are inamrescan.

voidamrescan (IndexScanDesc scan,          ScanKey keys,          int nkeys,          ScanKey orderbys,          int norderbys);

Start or restart an index scan, possibly with new scan keys. (To restart using previously-passed keys, NULL is passed forkeys and/ororderbys.) Note that it is not allowed for the number of keys or order-by operators to be larger than what was passed toambeginscan. In practice the restart feature is used when a new outer tuple is selected by a nested-loop join and so a new key comparison value is needed, but the scan key structure remains the same.

booleanamgettuple (IndexScanDesc scan,            ScanDirection direction);

Fetch the next tuple in the given scan, moving in the given direction (forward or backward in the index). Returns TRUE if a tuple was obtained, FALSE if no matching tuples remain. In the TRUE case the tuple TID is stored into thescan structure. Note that“success” means only that the index contains an entry that matches the scan keys, not that the tuple necessarily still exists in the heap or will pass the caller's snapshot test. On success,amgettuple must also setscan->xs_recheck to TRUE or FALSE. FALSE means it is certain that the index entry matches the scan keys. TRUE means this is not certain, and the conditions represented by the scan keys must be rechecked against the heap tuple after fetching it. This provision supports“lossy” index operators. Note that rechecking will extend only to the scan conditions; a partial index predicate (if any) is never rechecked byamgettuple callers.

If the index supports index-only scans (i.e.,amcanreturn returns TRUE for it), then on success the AM must also checkscan->xs_want_itup, and if that is true it must return the original indexed data for the index entry, in the form of anIndexTuple pointer stored atscan->xs_itup, with tuple descriptorscan->xs_itupdesc. (Management of the data referenced by the pointer is the access method's responsibility. The data must remain good at least until the nextamgettuple,amrescan, oramendscan call for the scan.)

Theamgettuple function need only be provided if the access method supports“plain” index scans. If it doesn't, theamgettuple field in itspg_am row must be set to zero.

int64amgetbitmap (IndexScanDesc scan,             TIDBitmap *tbm);

Fetch all tuples in the given scan and add them to the caller-suppliedTIDBitmap (that is, OR the set of tuple IDs into whatever set is already in the bitmap). The number of tuples fetched is returned (this might be just an approximate count, for instance some AMs do not detect duplicates). While inserting tuple IDs into the bitmap,amgetbitmap can indicate that rechecking of the scan conditions is required for specific tuple IDs. This is analogous to thexs_recheck output parameter ofamgettuple. Note: in the current implementation, support for this feature is conflated with support for lossy storage of the bitmap itself, and therefore callers recheck both the scan conditions and the partial index predicate (if any) for recheckable tuples. That might not always be true, however.amgetbitmap andamgettuple cannot be used in the same index scan; there are other restrictions too when usingamgetbitmap, as explained inSection 58.3.

Theamgetbitmap function need only be provided if the access method supports“bitmap” index scans. If it doesn't, theamgetbitmap field in itspg_am row must be set to zero.

voidamendscan (IndexScanDesc scan);

End a scan and release resources. Thescan struct itself should not be freed, but any locks or pins taken internally by the access method must be released, as well as any other memory allocated byambeginscan and other scan-related functions.

voidammarkpos (IndexScanDesc scan);

Mark current scan position. The access method need only support one remembered scan position per scan.

voidamrestrpos (IndexScanDesc scan);

Restore the scan to the most recently marked position.

By convention, thepg_proc entry for an index access method function should show the correct number of arguments, but declare them all as typeinternal (since most of the arguments have types that are not known to SQL, and we don't want users calling the functions directly anyway). The return type is declared asvoid,internal, orboolean as appropriate. The only exception isamoptions, which should be correctly declared as takingtext[] andbool and returningbytea. This provision allows client code to executeamoptions to test validity of options settings.