Sophie: postgresql8.3-docs-8.3.6-2mdv2008.1 x86

postgresql8.3-docs-8.3.6-2mdv2008.1.x86_64.rpm

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<HTML
><HEAD
><TITLE
>Index Access Method Functions</TITLE
><META
NAME="GENERATOR"
CONTENT="Modular DocBook HTML Stylesheet Version 1.79"><LINK
REV="MADE"
HREF="mailto:pgsql-docs@postgresql.org"><LINK
REL="HOME"
TITLE="PostgreSQL 8.3.6 Documentation"
HREF="index.html"><LINK
REL="UP"
TITLE="Index Access Method Interface Definition"
HREF="indexam.html"><LINK
REL="PREVIOUS"
TITLE="Catalog Entries for Indexes"
HREF="index-catalog.html"><LINK
REL="NEXT"
TITLE="Index Scanning"
HREF="index-scanning.html"><LINK
REL="STYLESHEET"
TYPE="text/css"
HREF="stylesheet.css"><META
HTTP-EQUIV="Content-Type"
CONTENT="text/html; charset=ISO-8859-1"><META
NAME="creation"
CONTENT="2009-02-03T04:34:16"></HEAD
><BODY
CLASS="SECT1"
><DIV
CLASS="NAVHEADER"
><TABLE
SUMMARY="Header navigation table"
WIDTH="100%"
BORDER="0"
CELLPADDING="0"
CELLSPACING="0"
><TR
><TH
COLSPAN="5"
ALIGN="center"
VALIGN="bottom"
>PostgreSQL 8.3.6 Documentation</TH
></TR
><TR
><TD
WIDTH="10%"
ALIGN="left"
VALIGN="top"
><A
HREF="index-catalog.html"
ACCESSKEY="P"
>Prev</A
></TD
><TD
WIDTH="10%"
ALIGN="left"
VALIGN="top"
><A
HREF="indexam.html"
>Fast Backward</A
></TD
><TD
WIDTH="60%"
ALIGN="center"
VALIGN="bottom"
>Chapter 50. Index Access Method Interface Definition</TD
><TD
WIDTH="10%"
ALIGN="right"
VALIGN="top"
><A
HREF="indexam.html"
>Fast Forward</A
></TD
><TD
WIDTH="10%"
ALIGN="right"
VALIGN="top"
><A
HREF="index-scanning.html"
ACCESSKEY="N"
>Next</A
></TD
></TR
></TABLE
><HR
ALIGN="LEFT"
WIDTH="100%"></DIV
><DIV
CLASS="SECT1"
><H1
CLASS="SECT1"
><A
NAME="INDEX-FUNCTIONS"
>50.2. Index Access Method Functions</A
></H1
><P
>   The index construction and maintenance functions that an index access
   method must provide are:
  </P
><P
></P><PRE
CLASS="PROGRAMLISTING"
>IndexBuildResult *
ambuild (Relation heapRelation,
         Relation indexRelation,
         IndexInfo *indexInfo);</PRE
><P>
   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 the <CODE
CLASS="FUNCTION"
>ambuild</CODE
> function will call
   <CODE
CLASS="FUNCTION"
>IndexBuildHeapScan()</CODE
> 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.
  </P
><P
></P><PRE
CLASS="PROGRAMLISTING"
>bool
aminsert (Relation indexRelation,
          Datum *values,
          bool *isnull,
          ItemPointer heap_tid,
          Relation heapRelation,
          bool check_uniqueness);</PRE
><P>
   Insert a new tuple into an existing index.  The <TT
CLASS="LITERAL"
>values</TT
> and
   <TT
CLASS="LITERAL"
>isnull</TT
> arrays give the key values to be indexed, and
   <TT
CLASS="LITERAL"
>heap_tid</TT
> is the TID to be indexed.
   If the access method supports unique indexes (its
   <TT
CLASS="STRUCTNAME"
>pg_am</TT
>.<TT
CLASS="STRUCTFIELD"
>amcanunique</TT
> flag is true) then
   <TT
CLASS="LITERAL"
>check_uniqueness</TT
> might be true, in which case the access method
   must verify that there is no conflicting row; this is the only situation in
   which the access method normally needs the <TT
CLASS="LITERAL"
>heapRelation</TT
>
   parameter.  See <A
HREF="index-unique-checks.html"
>Section 50.5</A
> for details.
   The result is TRUE if an index entry was inserted, FALSE if not. (A FALSE
   result does not denote an error condition, but is used for cases such
   as an index AM refusing to index a NULL.)
  </P
><P
></P><PRE
CLASS="PROGRAMLISTING"
>IndexBulkDeleteResult *
ambulkdelete (IndexVacuumInfo *info,
              IndexBulkDeleteResult *stats,
              IndexBulkDeleteCallback callback,
              void *callback_state);</PRE
><P>
   Delete tuple(s) from the index.  This is a <SPAN
CLASS="QUOTE"
>"bulk delete"</SPAN
> 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-in <TT
CLASS="LITERAL"
>callback</TT
> function must be called, in the style
   <TT
CLASS="LITERAL"
>callback(<TT
CLASS="REPLACEABLE"
><I
>TID</I
></TT
>, callback_state) returns bool</TT
>,
   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 to
   <CODE
CLASS="FUNCTION"
>amvacuumcleanup</CODE
>.
  </P
><P
>   Because of limited <TT
CLASS="VARNAME"
>maintenance_work_mem</TT
>,
   <CODE
CLASS="FUNCTION"
>ambulkdelete</CODE
> might need to be called more than once when many
   tuples are to be deleted.  The <TT
CLASS="LITERAL"
>stats</TT
> argument is the result
   of the previous call for this index (it is NULL for the first call within a
   <TT
CLASS="COMMAND"
>VACUUM</TT
> operation).  This allows the AM to accumulate statistics
   across the whole operation.  Typically, <CODE
CLASS="FUNCTION"
>ambulkdelete</CODE
> will
   modify and return the same struct if the passed <TT
CLASS="LITERAL"
>stats</TT
> is not
   null.
  </P
><P
></P><PRE
CLASS="PROGRAMLISTING"
>IndexBulkDeleteResult *
amvacuumcleanup (IndexVacuumInfo *info,
                 IndexBulkDeleteResult *stats);</PRE
><P>
   Clean up after a <TT
CLASS="COMMAND"
>VACUUM</TT
> operation (zero or more
   <CODE
CLASS="FUNCTION"
>ambulkdelete</CODE
> calls).  This does not have to do anything
   beyond returning index statistics, but it might perform bulk cleanup
   such as reclaiming empty index pages.  <TT
CLASS="LITERAL"
>stats</TT
> is whatever the
   last <CODE
CLASS="FUNCTION"
>ambulkdelete</CODE
> call returned, or NULL if
   <CODE
CLASS="FUNCTION"
>ambulkdelete</CODE
> 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 update <TT
CLASS="STRUCTNAME"
>pg_class</TT
>,
   and will be reported by <TT
CLASS="COMMAND"
>VACUUM</TT
> if <TT
CLASS="LITERAL"
>VERBOSE</TT
> is given.
   It is OK to return NULL if the index was not changed at all during the
   <TT
CLASS="COMMAND"
>VACUUM</TT
> operation, but otherwise correct stats should
   be returned.
  </P
><P
></P><PRE
CLASS="PROGRAMLISTING"
>void
amcostestimate (PlannerInfo *root,
                IndexOptInfo *index,
                List *indexQuals,
                RelOptInfo *outer_rel,
                Cost *indexStartupCost,
                Cost *indexTotalCost,
                Selectivity *indexSelectivity,
                double *indexCorrelation);</PRE
><P>
   Estimate the costs of an index scan.  This function is described fully
   in <A
HREF="index-cost-estimation.html"
>Section 50.6</A
>, below.
  </P
><P
></P><PRE
CLASS="PROGRAMLISTING"
>bytea *
amoptions (ArrayType *reloptions,
           bool validate);</PRE
><P>
   Parse and validate the reloptions array for an index.  This is called only
   when a non-null reloptions array exists for the index.
   <TT
CLASS="PARAMETER"
>reloptions</TT
> is a <TT
CLASS="TYPE"
>text</TT
> array containing entries of the
   form <TT
CLASS="REPLACEABLE"
><I
>name</I
></TT
><TT
CLASS="LITERAL"
>=</TT
><TT
CLASS="REPLACEABLE"
><I
>value</I
></TT
>.
   The function should construct a <TT
CLASS="TYPE"
>bytea</TT
> value, which will be copied
   into the <TT
CLASS="STRUCTFIELD"
>rd_options</TT
> field of the index's relcache entry.
   The data contents of the <TT
CLASS="TYPE"
>bytea</TT
> value are open for the access
   method to define, but the standard access methods currently all use struct
   <TT
CLASS="STRUCTNAME"
>StdRdOptions</TT
>.
   When <TT
CLASS="PARAMETER"
>validate</TT
> is true, the function should report a suitable
   error message if any of the options are unrecognized or have invalid
   values; when <TT
CLASS="PARAMETER"
>validate</TT
> is false, invalid entries should be
   silently ignored.  (<TT
CLASS="PARAMETER"
>validate</TT
> is false when loading options
   already stored in <TT
CLASS="STRUCTNAME"
>pg_catalog</TT
>; 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.
  </P
><P
>   The purpose of an index, of course, is to support scans for tuples matching
   an indexable <TT
CLASS="LITERAL"
>WHERE</TT
> condition, often called a
   <I
CLASS="FIRSTTERM"
>qualifier</I
> or <I
CLASS="FIRSTTERM"
>scan key</I
>.  The semantics of
   index scanning are described more fully in <A
HREF="index-scanning.html"
>Section 50.3</A
>,
   below.  The scan-related functions that an index access method must provide
   are:
  </P
><P
></P><PRE
CLASS="PROGRAMLISTING"
>IndexScanDesc
ambeginscan (Relation indexRelation,
             int nkeys,
             ScanKey key);</PRE
><P>
   Begin a new scan.  The <TT
CLASS="LITERAL"
>key</TT
> array (of length <TT
CLASS="LITERAL"
>nkeys</TT
>)
   describes the scan key(s) for the index scan.  The result must be a
   palloc'd struct. For implementation reasons the index access method
   <SPAN
CLASS="emphasis"
><I
CLASS="EMPHASIS"
>must</I
></SPAN
> create this struct by calling
   <CODE
CLASS="FUNCTION"
>RelationGetIndexScan()</CODE
>.  In most cases
   <CODE
CLASS="FUNCTION"
>ambeginscan</CODE
> itself does little beyond making that call;
   the interesting parts of index-scan startup are in <CODE
CLASS="FUNCTION"
>amrescan</CODE
>.
  </P
><P
></P><PRE
CLASS="PROGRAMLISTING"
>boolean
amgettuple (IndexScanDesc scan,
            ScanDirection direction);</PRE
><P>
   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 the <TT
CLASS="LITERAL"
>scan</TT
> structure.  Note that
   <SPAN
CLASS="QUOTE"
>"success"</SPAN
> 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.
  </P
><P
></P><PRE
CLASS="PROGRAMLISTING"
>boolean
amgetmulti (IndexScanDesc scan,
            ItemPointer tids,
            int32 max_tids,
            int32 *returned_tids);</PRE
><P>
   Fetch multiple tuples in the given scan.  Returns TRUE if the scan should
   continue, FALSE if no matching tuples remain.  <TT
CLASS="LITERAL"
>tids</TT
> points to
   a caller-supplied array of <TT
CLASS="LITERAL"
>max_tids</TT
>
   <TT
CLASS="STRUCTNAME"
>ItemPointerData</TT
> records, which the call fills with TIDs of
   matching tuples.  <TT
CLASS="LITERAL"
>*returned_tids</TT
> is set to the number of TIDs
   actually returned.  This can be less than <TT
CLASS="LITERAL"
>max_tids</TT
>, or even
   zero, even when the return value is TRUE.  (This provision allows the
   access method to choose the most efficient stopping points in its scan,
   for example index page boundaries.)  <CODE
CLASS="FUNCTION"
>amgetmulti</CODE
> and
   <CODE
CLASS="FUNCTION"
>amgettuple</CODE
> cannot be used in the same index scan; there
   are other restrictions too when using <CODE
CLASS="FUNCTION"
>amgetmulti</CODE
>, as explained
   in <A
HREF="index-scanning.html"
>Section 50.3</A
>.
  </P
><P
></P><PRE
CLASS="PROGRAMLISTING"
>void
amrescan (IndexScanDesc scan,
          ScanKey key);</PRE
><P>
   Restart the given scan, possibly with new scan keys (to continue using
   the old keys, NULL is passed for <TT
CLASS="LITERAL"
>key</TT
>).  Note that it is not
   possible for the number of keys to be changed.  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.  This function is also called by
   <CODE
CLASS="FUNCTION"
>RelationGetIndexScan()</CODE
>, so it is used for initial setup
   of an index scan as well as rescanning.
  </P
><P
></P><PRE
CLASS="PROGRAMLISTING"
>void
amendscan (IndexScanDesc scan);</PRE
><P>
   End a scan and release resources.  The <TT
CLASS="LITERAL"
>scan</TT
> struct itself
   should not be freed, but any locks or pins taken internally by the
   access method must be released.
  </P
><P
></P><PRE
CLASS="PROGRAMLISTING"
>void
ammarkpos (IndexScanDesc scan);</PRE
><P>
   Mark current scan position.  The access method need only support one
   remembered scan position per scan.
  </P
><P
></P><PRE
CLASS="PROGRAMLISTING"
>void
amrestrpos (IndexScanDesc scan);</PRE
><P>
   Restore the scan to the most recently marked position.
  </P
><P
>   By convention, the <TT
CLASS="LITERAL"
>pg_proc</TT
> entry for an index
   access method function should show the correct number of arguments,
   but declare them all as type <TT
CLASS="TYPE"
>internal</TT
> (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 as
   <TT
CLASS="TYPE"
>void</TT
>, <TT
CLASS="TYPE"
>internal</TT
>, or <TT
CLASS="TYPE"
>boolean</TT
> as appropriate.
   The only exception is <CODE
CLASS="FUNCTION"
>amoptions</CODE
>, which should be correctly
   declared as taking <TT
CLASS="TYPE"
>text[]</TT
> and <TT
CLASS="TYPE"
>bool</TT
> and returning
   <TT
CLASS="TYPE"
>bytea</TT
>.  This provision allows client code to execute
   <CODE
CLASS="FUNCTION"
>amoptions</CODE
> to test validity of options settings.
  </P
></DIV
><DIV
CLASS="NAVFOOTER"
><HR
ALIGN="LEFT"
WIDTH="100%"><TABLE
SUMMARY="Footer navigation table"
WIDTH="100%"
BORDER="0"
CELLPADDING="0"
CELLSPACING="0"
><TR
><TD
WIDTH="33%"
ALIGN="left"
VALIGN="top"
><A
HREF="index-catalog.html"
ACCESSKEY="P"
>Prev</A
></TD
><TD
WIDTH="34%"
ALIGN="center"
VALIGN="top"
><A
HREF="index.html"
ACCESSKEY="H"
>Home</A
></TD
><TD
WIDTH="33%"
ALIGN="right"
VALIGN="top"
><A
HREF="index-scanning.html"
ACCESSKEY="N"
>Next</A
></TD
></TR
><TR
><TD
WIDTH="33%"
ALIGN="left"
VALIGN="top"
>Catalog Entries for Indexes</TD
><TD
WIDTH="34%"
ALIGN="center"
VALIGN="top"
><A
HREF="indexam.html"
ACCESSKEY="U"
>Up</A
></TD
><TD
WIDTH="33%"
ALIGN="right"
VALIGN="top"
>Index Scanning</TD
></TR
></TABLE
></DIV
></BODY
></HTML
>