OSDN Git Service

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