← Back to branch summary

~ubuntu-branches/ubuntu/natty/postgresql-8.4/natty-security

« back to all changes in this revision

Viewing changes to src/include/access/gin.h

  • Committer: Bazaar Package Importer
  • Author(s): Martin Pitt
  • Date: 2009-07-11 16:59:35 UTC
  • mfrom: (5.1.1 karmic)
  • Revision ID: james.westby@ubuntu.com-20090711165935-jfwin6gfrxf0gfsi
Tags: 8.4.0-2
http://bugs.debian.org/536139
* debian/libpq-dev.install: Ship catalog/genbki.h. (Closes: #536139)
* debian/rules: Drop --enable-cassert for final release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/include/access/gin.h
4
4
 *
5
5
 *      Copyright (c) 2006-2009, PostgreSQL Global Development Group
6
6
 *
7
 
 *      $PostgreSQL: pgsql/src/include/access/gin.h,v 1.31 2009/03/25 22:19:01 tgl Exp $
 
7
 *      $PostgreSQL: pgsql/src/include/access/gin.h,v 1.34 2009/06/11 14:49:08 momjian Exp $
8
8
 *--------------------------------------------------------------------------
9
9
 */
10
10
#ifndef GIN_H
29
29
/*
30
30
 * Max depth allowed in search tree during bulk inserts.  This is to keep from
31
31
 * degenerating to O(N^2) behavior when the tree is unbalanced due to sorted
32
 
 * or nearly-sorted input.  (Perhaps it would be better to use a balanced-tree
 
32
 * or nearly-sorted input.      (Perhaps it would be better to use a balanced-tree
33
33
 * algorithm, but in common cases that would only add useless overhead.)
34
34
 */
35
35
#define GIN_MAX_TREE_DEPTH 100
59
59
#define GIN_DELETED               (1 << 2)
60
60
#define GIN_META                  (1 << 3)
61
61
#define GIN_LIST                  (1 << 4)
62
 
#define GIN_LIST_FULLROW  (1 << 5)   /* makes sense only on GIN_LIST page */
 
62
#define GIN_LIST_FULLROW  (1 << 5)              /* makes sense only on GIN_LIST page */
63
63
 
64
64
/* Page numbers of fixed-location pages */
65
65
#define GIN_METAPAGE_BLKNO      (0)
72
72
         * pages.  These store fast-inserted entries that haven't yet been moved
73
73
         * into the regular GIN structure.
74
74
         */
75
 
        BlockNumber                     head;
76
 
        BlockNumber         tail;
 
75
        BlockNumber head;
 
76
        BlockNumber tail;
77
77
 
78
78
        /*
79
79
         * Free space in bytes in the pending list's tail page.
80
80
         */
81
 
        uint32                          tailFreeSize;
 
81
        uint32          tailFreeSize;
82
82
 
83
83
        /*
84
 
         * We store both number of pages and number of heap tuples
85
 
         * that are in the pending list.
 
84
         * We store both number of pages and number of heap tuples that are in the
 
85
         * pending list.
86
86
         */
87
 
        BlockNumber                     nPendingPages;
88
 
        int64                           nPendingHeapTuples;
 
87
        BlockNumber nPendingPages;
 
88
        int64           nPendingHeapTuples;
89
89
} GinMetaPageData;
90
90
 
91
91
#define GinPageGetMeta(p) \
124
124
#define ItemPointerSetMin(p)  \
125
125
        ItemPointerSet((p), (BlockNumber)0, (OffsetNumber)0)
126
126
#define ItemPointerIsMin(p)  \
127
 
        (ItemPointerGetOffsetNumber(p) == (OffsetNumber)0 && \
128
 
         ItemPointerGetBlockNumber(p) == (BlockNumber)0)
 
127
        (GinItemPointerGetOffsetNumber(p) == (OffsetNumber)0 && \
 
128
         GinItemPointerGetBlockNumber(p) == (BlockNumber)0)
129
129
#define ItemPointerSetMax(p)  \
130
130
        ItemPointerSet((p), InvalidBlockNumber, (OffsetNumber)0xffff)
131
131
#define ItemPointerIsMax(p)  \
132
 
        (ItemPointerGetOffsetNumber(p) == (OffsetNumber)0xffff && \
133
 
         ItemPointerGetBlockNumber(p) == InvalidBlockNumber)
 
132
        (GinItemPointerGetOffsetNumber(p) == (OffsetNumber)0xffff && \
 
133
         GinItemPointerGetBlockNumber(p) == InvalidBlockNumber)
134
134
#define ItemPointerSetLossyPage(p, b)  \
135
135
        ItemPointerSet((p), (b), (OffsetNumber)0xffff)
136
136
#define ItemPointerIsLossyPage(p)  \
137
 
        (ItemPointerGetOffsetNumber(p) == (OffsetNumber)0xffff && \
138
 
         ItemPointerGetBlockNumber(p) != InvalidBlockNumber)
 
137
        (GinItemPointerGetOffsetNumber(p) == (OffsetNumber)0xffff && \
 
138
         GinItemPointerGetBlockNumber(p) != InvalidBlockNumber)
139
139
 
140
140
typedef struct
141
141
{
175
175
#define GinDataPageGetRightBound(page)  ((ItemPointer) PageGetContents(page))
176
176
#define GinDataPageGetData(page)        \
177
177
        (PageGetContents(page) + MAXALIGN(sizeof(ItemPointerData)))
178
 
#define GinSizeOfItem(page)     \
 
178
#define GinSizeOfItem(page) \
179
179
        (GinPageIsLeaf(page) ? sizeof(ItemPointerData) : sizeof(PostingItem))
180
180
#define GinDataPageGetItem(page,i)      \
181
181
        (GinDataPageGetData(page) + ((i)-1) * GinSizeOfItem(page))
190
190
 * List pages
191
191
 */
192
192
#define GinListPageSize  \
193
 
    ( BLCKSZ - SizeOfPageHeaderData - MAXALIGN(sizeof(GinPageOpaqueData)) )
 
193
        ( BLCKSZ - SizeOfPageHeaderData - MAXALIGN(sizeof(GinPageOpaqueData)) )
194
194
 
195
195
/*
196
196
 * Storage type for GIN's reloptions
197
197
 */
198
198
typedef struct GinOptions
199
199
{
200
 
        int32       vl_len_;        /* varlena header (do not touch directly!) */
 
200
        int32           vl_len_;                /* varlena header (do not touch directly!) */
201
201
        bool            useFastUpdate;  /* use fast updates? */
202
202
} GinOptions;
203
203
 
204
 
#define GIN_DEFAULT_USE_FASTUPDATE  true
 
204
#define GIN_DEFAULT_USE_FASTUPDATE      true
205
205
#define GinGetUseFastUpdate(relation) \
206
206
        ((relation)->rd_options ? \
207
207
         ((GinOptions *) (relation)->rd_options)->useFastUpdate : GIN_DEFAULT_USE_FASTUPDATE)
217
217
        FmgrInfo        extractValueFn[INDEX_MAX_KEYS];
218
218
        FmgrInfo        extractQueryFn[INDEX_MAX_KEYS];
219
219
        FmgrInfo        consistentFn[INDEX_MAX_KEYS];
220
 
        FmgrInfo        comparePartialFn[INDEX_MAX_KEYS];       /* optional method */
221
 
 
222
 
        bool            canPartialMatch[INDEX_MAX_KEYS];        /* can opclass perform partial
223
 
                                                                                                         * match (prefix search)? */
224
 
 
225
 
        TupleDesc   tupdesc[INDEX_MAX_KEYS];
226
 
        TupleDesc   origTupdesc;
227
 
        bool        oneCol;
 
220
        FmgrInfo        comparePartialFn[INDEX_MAX_KEYS];               /* optional method */
 
221
 
 
222
        bool            canPartialMatch[INDEX_MAX_KEYS];                /* can opclass perform
 
223
                                                                                                                 * partial match (prefix
 
224
                                                                                                                 * search)? */
 
225
 
 
226
        TupleDesc       tupdesc[INDEX_MAX_KEYS];
 
227
        TupleDesc       origTupdesc;
 
228
        bool            oneCol;
228
229
} GinState;
229
230
 
230
231
/* XLog stuff */
309
310
 
310
311
typedef struct ginxlogUpdateMeta
311
312
{
312
 
        RelFileNode     node;
 
313
        RelFileNode node;
313
314
        GinMetaPageData metadata;
314
 
        BlockNumber     prevTail;
315
 
        BlockNumber     newRightlink;
316
 
        int32           ntuples; /* if ntuples > 0 then metadata.tail was updated
317
 
                                                          * with that many tuples; else new sub list was
318
 
                                                          * inserted */
 
315
        BlockNumber prevTail;
 
316
        BlockNumber newRightlink;
 
317
        int32           ntuples;                /* if ntuples > 0 then metadata.tail was
 
318
                                                                 * updated with that many tuples; else new sub
 
319
                                                                 * list was inserted */
319
320
        /* array of inserted tuples follows */
320
321
} ginxlogUpdateMeta;
321
322
 
323
324
 
324
325
typedef struct ginxlogInsertListPage
325
326
{
326
 
        RelFileNode     node;
327
 
        BlockNumber     blkno;
328
 
        BlockNumber     rightlink;
329
 
        int32           ntuples;
 
327
        RelFileNode node;
 
328
        BlockNumber blkno;
 
329
        BlockNumber rightlink;
 
330
        int32           ntuples;
330
331
        /* array of inserted tuples follows */
331
332
} ginxlogInsertListPage;
332
333
 
335
336
#define GIN_NDELETE_AT_ONCE 16
336
337
typedef struct ginxlogDeleteListPages
337
338
{
338
 
        RelFileNode     node;
 
339
        RelFileNode node;
339
340
        GinMetaPageData metadata;
340
 
        int32           ndeleted;
341
 
        BlockNumber     toDelete[GIN_NDELETE_AT_ONCE];
 
341
        int32           ndeleted;
 
342
        BlockNumber toDelete[GIN_NDELETE_AT_ONCE];
342
343
} ginxlogDeleteListPages;
343
344
 
344
345
 
350
351
extern void GinInitPage(Page page, uint32 f, Size pageSize);
351
352
extern void GinInitMetabuffer(Buffer b);
352
353
extern int      compareEntries(GinState *ginstate, OffsetNumber attnum, Datum a, Datum b);
353
 
extern int      compareAttEntries(GinState *ginstate, OffsetNumber attnum_a, Datum a,
354
 
                                                                                                  OffsetNumber attnum_b, Datum b);
 
354
extern int compareAttEntries(GinState *ginstate, OffsetNumber attnum_a, Datum a,
 
355
                                  OffsetNumber attnum_b, Datum b);
355
356
extern Datum *extractEntriesS(GinState *ginstate, OffsetNumber attnum, Datum value,
356
357
                                int32 *nentries, bool *needUnique);
357
358
extern Datum *extractEntriesSU(GinState *ginstate, OffsetNumber attnum, Datum value, int32 *nentries);
363
364
extern Datum ginbuild(PG_FUNCTION_ARGS);
364
365
extern Datum gininsert(PG_FUNCTION_ARGS);
365
366
extern void ginEntryInsert(Relation index, GinState *ginstate,
366
 
                                                   OffsetNumber attnum, Datum value,
367
 
                                                   ItemPointerData *items, uint32 nitem,
368
 
                                                   bool isBuild);
 
367
                           OffsetNumber attnum, Datum value,
 
368
                           ItemPointerData *items, uint32 nitem,
 
369
                           bool isBuild);
369
370
 
370
371
/* ginxlog.c */
371
372
extern void gin_redo(XLogRecPtr lsn, XLogRecord *record);
413
414
        BlockNumber rightblkno;
414
415
 
415
416
        /* Entry options */
416
 
        OffsetNumber    entryAttnum;
 
417
        OffsetNumber entryAttnum;
417
418
        Datum           entryValue;
418
419
        IndexTuple      entry;
419
420
        bool            isDelete;
434
435
 
435
436
/* ginentrypage.c */
436
437
extern IndexTuple GinFormTuple(GinState *ginstate, OffsetNumber attnum, Datum key,
437
 
                                                                                ItemPointerData *ipd, uint32 nipd);
 
438
                         ItemPointerData *ipd, uint32 nipd);
 
439
extern void GinShortenTuple(IndexTuple itup, uint32 nipd);
438
440
extern void prepareEntryScan(GinBtree btree, Relation index, OffsetNumber attnum,
439
 
                                                                Datum value, GinState *ginstate);
 
441
                                 Datum value, GinState *ginstate);
440
442
extern void entryFillRoot(GinBtree btree, Buffer root, Buffer lbuf, Buffer rbuf);
441
443
extern IndexTuple ginPageGetLinkItup(Buffer buf);
442
444
 
443
445
/* gindatapage.c */
444
446
extern int      compareItemPointers(ItemPointer a, ItemPointer b);
445
 
extern void MergeItemPointers(ItemPointerData *dst,
 
447
extern uint32 MergeItemPointers(ItemPointerData *dst,
446
448
                                  ItemPointerData *a, uint32 na,
447
449
                                  ItemPointerData *b, uint32 nb);
448
450
 
480
482
 
481
483
        /* entry, got from extractQueryFn */
482
484
        Datum           entry;
483
 
        OffsetNumber    attnum;
484
 
        Pointer                 extra_data;
 
485
        OffsetNumber attnum;
 
486
        Pointer         extra_data;
485
487
 
486
488
        /* Current page in posting tree */
487
489
        Buffer          buffer;
498
500
 
499
501
        /* used for Posting list and one page in Posting tree */
500
502
        ItemPointerData *list;
501
 
        uint32                   nlist;
502
 
        OffsetNumber     offset;
 
503
        uint32          nlist;
 
504
        OffsetNumber offset;
503
505
 
504
506
        bool            isFinished;
505
507
        bool            reduceResult;
516
518
 
517
519
        /* array of scans per entry */
518
520
        GinScanEntry scanEntry;
519
 
        Pointer          *extra_data;
 
521
        Pointer    *extra_data;
520
522
 
521
523
        /* for calling consistentFn(GinScanKey->entryRes, strategy, query) */
522
524
        StrategyNumber strategy;
523
525
        Datum           query;
524
 
        OffsetNumber    attnum;
 
526
        OffsetNumber attnum;
525
527
 
526
528
        ItemPointerData curItem;
527
529
        bool            firstCall;
567
569
/* ginbulk.c */
568
570
typedef struct EntryAccumulator
569
571
{
570
 
        OffsetNumber    attnum;
571
 
        Datum                   value;
572
 
        uint32                  length;
573
 
        uint32                  number;
 
572
        OffsetNumber attnum;
 
573
        Datum           value;
 
574
        uint32          length;
 
575
        uint32          number;
574
576
        ItemPointerData *list;
575
 
        bool                    shouldSort;
 
577
        bool            shouldSort;
576
578
        struct EntryAccumulator *left;
577
579
        struct EntryAccumulator *right;
578
580
} EntryAccumulator;
600
602
 
601
603
typedef struct GinTupleCollector
602
604
{
603
 
        IndexTuple      *tuples;
604
 
        uint32           ntuples;
605
 
        uint32           lentuples;
606
 
        uint32           sumsize;
 
605
        IndexTuple *tuples;
 
606
        uint32          ntuples;
 
607
        uint32          lentuples;
 
608
        uint32          sumsize;
607
609
} GinTupleCollector;
608
610
 
609
611
extern void ginHeapTupleFastInsert(Relation index, GinState *ginstate,
610
 
                                                                   GinTupleCollector *collector);
 
612
                                           GinTupleCollector *collector);
611
613
extern uint32 ginHeapTupleFastCollect(Relation index, GinState *ginstate,
612
 
                                        GinTupleCollector *collector,
613
 
                                        OffsetNumber attnum, Datum value, ItemPointer item);
 
614
                                                GinTupleCollector *collector,
 
615
                                                OffsetNumber attnum, Datum value, ItemPointer item);
614
616
extern void ginInsertCleanup(Relation index, GinState *ginstate,
615
 
                                                         bool vac_delay, IndexBulkDeleteResult *stats);
 
617
                                 bool vac_delay, IndexBulkDeleteResult *stats);
616
618
 
617
 
#endif /* GIN_H */
 
619
#endif   /* GIN_H */