granicus.if.org Git - postgresql/blob - src/backend/access/index/indexam.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * indexam.c--
   4  *        general index access method routines
   5  *
   6  * Copyright (c) 1994, Regents of the University of California
   7  *
   8  *
   9  * IDENTIFICATION
  10  *        $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.29 1998/12/15 12:45:15 vadim Exp $
  11  *
  12  * INTERFACE ROUTINES
  13  *              index_open              - open an index relation by relationId
  14  *              index_openr             - open a index relation by name
  15  *              index_close             - close a index relation
  16  *              index_beginscan - start a scan of an index
  17  *              index_rescan    - restart a scan of an index
  18  *              index_endscan   - end a scan
  19  *              index_insert    - insert an index tuple into a relation
  20  *              index_delete    - delete an item from an index relation
  21  *              index_markpos   - mark a scan position
  22  *              index_restrpos  - restore a scan position
  23  *              index_getnext   - get the next tuple from a scan
  24  * **   index_fetch             - retrieve tuple with tid
  25  * **   index_replace   - replace a tuple
  26  * **   index_getattr   - get an attribute from an index tuple
  27  *              index_getprocid - get a support procedure id from the rel tuple
  28  *
  29  *              IndexScanIsValid - check index scan
  30  *
  31  * NOTES
  32  *              This file contains the index_ routines which used
  33  *              to be a scattered collection of stuff in access/genam.
  34  *
  35  *              The ** routines: index_fetch, index_replace, and index_getattr
  36  *              have not yet been implemented.  They may not be needed.
  37  *
  38  * old comments
  39  *              Scans are implemented as follows:
  40  *
  41  *              `0' represents an invalid item pointer.
  42  *              `-' represents an unknown item pointer.
  43  *              `X' represents a known item pointers.
  44  *              `+' represents known or invalid item pointers.
  45  *              `*' represents any item pointers.
  46  *
  47  *              State is represented by a triple of these symbols in the order of
  48  *              previous, current, next.  Note that the case of reverse scans works
  49  *              identically.
  50  *
  51  *                              State   Result
  52  *              (1)             + + -   + 0 0                   (if the next item pointer is invalid)
  53  *              (2)                             + X -                   (otherwise)
  54  *              (3)             * 0 0   * 0 0                   (no change)
  55  *              (4)             + X 0   X 0 0                   (shift)
  56  *              (5)             * + X   + X -                   (shift, add unknown)
  57  *
  58  *              All other states cannot occur.
  59  *
  60  *              Note: It would be possible to cache the status of the previous and
  61  *                        next item pointer using the flags.
  62  *
  63  *-------------------------------------------------------------------------
  64  */
  65
  66 #include <postgres.h>
  67
  68 #include <access/genam.h>
  69 #include <utils/relcache.h>
  70 #include <fmgr.h>
  71 #include <storage/lmgr.h>
  72 #include <access/heapam.h>
  73
  74 /* ----------------
  75  *       undefine macros we aren't going to use that would otherwise
  76  *       get in our way..  delete is defined in c.h and the am's are
  77  *       defined in heapam.h
  78  * ----------------
  79  */
  80 #undef delete
  81 #undef aminsert
  82 #undef amdelete
  83 #undef ambeginscan
  84 #undef amrescan
  85 #undef amendscan
  86 #undef ammarkpos
  87 #undef amrestrpos
  88 #undef amgettuple
  89
  90 /* ----------------------------------------------------------------
  91  *                                      macros used in index_ routines
  92  * ----------------------------------------------------------------
  93  */
  94 #define RELATION_CHECKS \
  95 ( \
  96         AssertMacro(RelationIsValid(relation)), \
  97         AssertMacro(PointerIsValid(relation->rd_am)) \
  98 )
  99
 100 #define SCAN_CHECKS \
 101 ( \
 102         AssertMacro(IndexScanIsValid(scan)), \
 103         AssertMacro(RelationIsValid(scan->relation)), \
 104         AssertMacro(PointerIsValid(scan->relation->rd_am)) \
 105 )
 106
 107 #define GET_REL_PROCEDURE(x,y) \
 108 ( \
 109         procedure = relation->rd_am->y, \
 110         (!RegProcedureIsValid(procedure)) ? \
 111                 elog(ERROR, "index_%s: invalid %s regproc", \
 112                         CppAsString(x), CppAsString(y)) \
 113         : (void)NULL \
 114 )
 115
 116 #define GET_SCAN_PROCEDURE(x,y) \
 117 ( \
 118         procedure = scan->relation->rd_am->y, \
 119         (!RegProcedureIsValid(procedure)) ? \
 120                 elog(ERROR, "index_%s: invalid %s regproc", \
 121                         CppAsString(x), CppAsString(y)) \
 122         : (void)NULL \
 123 )
 124
 125
 126 /* ----------------------------------------------------------------
 127  *                                 index_ interface functions
 128  * ----------------------------------------------------------------
 129  */
 130 /* ----------------
 131  *              index_open - open an index relation by relationId
 132  *
 133  *              presently the relcache routines do all the work we need
 134  *              to open/close index relations.
 135  * ----------------
 136  */
 137 Relation
 138 index_open(Oid relationId)
 139 {
 140         return RelationIdGetRelation(relationId);
 141 }
 142
 143 /* ----------------
 144  *              index_openr - open a index relation by name
 145  *
 146  *              presently the relcache routines do all the work we need
 147  *              to open/close index relations.
 148  * ----------------
 149  */
 150 Relation
 151 index_openr(char *relationName)
 152 {
 153         return RelationNameGetRelation(relationName);
 154 }
 155
 156 /* ----------------
 157  *              index_close - close a index relation
 158  *
 159  *              presently the relcache routines do all the work we need
 160  *              to open/close index relations.
 161  * ----------------
 162  */
 163 void
 164 index_close(Relation relation)
 165 {
 166         RelationClose(relation);
 167 }
 168
 169 /* ----------------
 170  *              index_insert - insert an index tuple into a relation
 171  * ----------------
 172  */
 173 InsertIndexResult
 174 index_insert(Relation relation,
 175                          Datum *datum,
 176                          char *nulls,
 177                          ItemPointer heap_t_ctid,
 178                          Relation heapRel)
 179 {
 180         RegProcedure procedure;
 181         InsertIndexResult specificResult;
 182
 183         RELATION_CHECKS;
 184         GET_REL_PROCEDURE(insert, aminsert);
 185
 186         /* ----------------
 187          *      have the am's insert proc do all the work.
 188          * ----------------
 189          */
 190         specificResult = (InsertIndexResult)
 191                 fmgr(procedure, relation, datum, nulls, heap_t_ctid, heapRel, NULL);
 192
 193         /* must be pfree'ed */
 194         return specificResult;
 195 }
 196
 197 /* ----------------
 198  *              index_delete - delete an item from an index relation
 199  * ----------------
 200  */
 201 void
 202 index_delete(Relation relation, ItemPointer indexItem)
 203 {
 204         RegProcedure procedure;
 205
 206         RELATION_CHECKS;
 207         GET_REL_PROCEDURE(delete, amdelete);
 208
 209         fmgr(procedure, relation, indexItem);
 210 }
 211
 212 /* ----------------
 213  *              index_beginscan - start a scan of an index
 214  * ----------------
 215  */
 216 IndexScanDesc
 217 index_beginscan(Relation relation,
 218                                 bool scanFromEnd,
 219                                 uint16 numberOfKeys,
 220                                 ScanKey key)
 221 {
 222         IndexScanDesc scandesc;
 223         RegProcedure procedure;
 224
 225         RELATION_CHECKS;
 226         GET_REL_PROCEDURE(beginscan, ambeginscan);
 227
 228         LockRelation(relation, AccessShareLock);
 229
 230         scandesc = (IndexScanDesc)
 231                 fmgr(procedure, relation, scanFromEnd, numberOfKeys, key);
 232
 233         return scandesc;
 234 }
 235
 236 /* ----------------
 237  *              index_rescan  - restart a scan of an index
 238  * ----------------
 239  */
 240 void
 241 index_rescan(IndexScanDesc scan, bool scanFromEnd, ScanKey key)
 242 {
 243         RegProcedure procedure;
 244
 245         SCAN_CHECKS;
 246         GET_SCAN_PROCEDURE(rescan, amrescan);
 247
 248         fmgr(procedure, scan, scanFromEnd, key);
 249 }
 250
 251 /* ----------------
 252  *              index_endscan - end a scan
 253  * ----------------
 254  */
 255 void
 256 index_endscan(IndexScanDesc scan)
 257 {
 258         RegProcedure procedure;
 259
 260         SCAN_CHECKS;
 261         GET_SCAN_PROCEDURE(endscan, amendscan);
 262
 263         fmgr(procedure, scan);
 264
 265         UnlockRelation(scan->relation, AccessShareLock);
 266 }
 267
 268 /* ----------------
 269  *              index_markpos  - mark a scan position
 270  * ----------------
 271  */
 272 void
 273 index_markpos(IndexScanDesc scan)
 274 {
 275         RegProcedure procedure;
 276
 277         SCAN_CHECKS;
 278         GET_SCAN_PROCEDURE(markpos, ammarkpos);
 279
 280         fmgr(procedure, scan);
 281 }
 282
 283 /* ----------------
 284  *              index_restrpos  - restore a scan position
 285  * ----------------
 286  */
 287 void
 288 index_restrpos(IndexScanDesc scan)
 289 {
 290         RegProcedure procedure;
 291
 292         SCAN_CHECKS;
 293         GET_SCAN_PROCEDURE(restrpos, amrestrpos);
 294
 295         fmgr(procedure, scan);
 296 }
 297
 298 /* ----------------
 299  *              index_getnext - get the next tuple from a scan
 300  *
 301  *              A RetrieveIndexResult is a index tuple/heap tuple pair
 302  * ----------------
 303  */
 304 RetrieveIndexResult
 305 index_getnext(IndexScanDesc scan,
 306                           ScanDirection direction)
 307 {
 308         RegProcedure procedure;
 309         RetrieveIndexResult result;
 310
 311         SCAN_CHECKS;
 312         GET_SCAN_PROCEDURE(getnext, amgettuple);
 313
 314         /* ----------------
 315          *      have the am's gettuple proc do all the work.
 316          * ----------------
 317          */
 318         result = (RetrieveIndexResult) fmgr(procedure, scan, direction);
 319
 320         return result;
 321 }
 322
 323 /* ----------------
 324  *              index_getprocid
 325  *
 326  *              Some indexed access methods may require support routines that are
 327  *              not in the operator class/operator model imposed by pg_am.      These
 328  *              access methods may store the OIDs of registered procedures they
 329  *              need in pg_amproc.      These registered procedure OIDs are ordered in
 330  *              a way that makes sense to the access method, and used only by the
 331  *              access method.  The general index code doesn't know anything about
 332  *              the routines involved; it just builds an ordered list of them for
 333  *              each attribute on which an index is defined.
 334  *
 335  *              This routine returns the requested procedure OID for a particular
 336  *              indexed attribute.
 337  * ----------------
 338  */
 339 RegProcedure
 340 index_getprocid(Relation irel,
 341                                 AttrNumber attnum,
 342                                 uint16 procnum)
 343 {
 344         RegProcedure *loc;
 345         int                     natts;
 346
 347         natts = irel->rd_rel->relnatts;
 348
 349         loc = irel->rd_support;
 350
 351         Assert(loc != NULL);
 352
 353         return loc[(natts * (procnum - 1)) + (attnum - 1)];
 354 }
 355
 356 Datum
 357 GetIndexValue(HeapTuple tuple,
 358                           TupleDesc hTupDesc,
 359                           int attOff,
 360                           AttrNumber *attrNums,
 361                           FuncIndexInfo *fInfo,
 362                           bool *attNull)
 363 {
 364         Datum           returnVal;
 365         bool            isNull = FALSE;
 366
 367         if (PointerIsValid(fInfo) && FIgetProcOid(fInfo) != InvalidOid)
 368         {
 369                 int                     i;
 370                 Datum      *attData = (Datum *) palloc(FIgetnArgs(fInfo) * sizeof(Datum));
 371
 372                 for (i = 0; i < FIgetnArgs(fInfo); i++)
 373                 {
 374                         attData[i] = heap_getattr(tuple,
 375                                                                           attrNums[i],
 376                                                                           hTupDesc,
 377                                                                           attNull);
 378                         if (*attNull)
 379                                 isNull = TRUE;
 380                 }
 381                 returnVal = (Datum) fmgr_array_args(FIgetProcOid(fInfo),
 382                                                                                         FIgetnArgs(fInfo),
 383                                                                                         (char **) attData,
 384                                                                                         &isNull);
 385                 pfree(attData);
 386                 *attNull = isNull;
 387         }
 388         else
 389                 returnVal = heap_getattr(tuple, attrNums[attOff], hTupDesc, attNull);
 390
 391         return returnVal;
 392 }