PostgreSQL Source Code git master
Data Structures | Macros | Typedefs | Enumerations | Functions
spgist.h File Reference
#include "access/amapi.h"
#include "access/xlogreader.h"
#include "lib/stringinfo.h"
Include dependency graph for spgist.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct   spgConfigIn
 
struct   spgConfigOut
 
struct   spgChooseIn
 
struct   spgChooseOut
 
struct   spgPickSplitIn
 
struct   spgPickSplitOut
 
struct   spgInnerConsistentIn
 
struct   spgInnerConsistentOut
 
struct   spgLeafConsistentIn
 
struct   spgLeafConsistentOut
 

Macros

#define  SPGIST_CONFIG_PROC   1
 
#define  SPGIST_CHOOSE_PROC   2
 
#define  SPGIST_PICKSPLIT_PROC   3
 
#define  SPGIST_INNER_CONSISTENT_PROC   4
 
#define  SPGIST_LEAF_CONSISTENT_PROC   5
 
#define  SPGIST_COMPRESS_PROC   6
 
#define  SPGIST_OPTIONS_PROC   7
 
#define  SPGISTNRequiredProc   5
 
#define  SPGISTNProc   7
 

Typedefs

typedef struct spgConfigIn  spgConfigIn
 
typedef struct spgConfigOut  spgConfigOut
 
typedef struct spgChooseIn  spgChooseIn
 
typedef enum spgChooseResultType  spgChooseResultType
 
typedef struct spgChooseOut  spgChooseOut
 
typedef struct spgPickSplitIn  spgPickSplitIn
 
typedef struct spgPickSplitOut  spgPickSplitOut
 
typedef struct spgInnerConsistentIn  spgInnerConsistentIn
 
typedef struct spgInnerConsistentOut  spgInnerConsistentOut
 
typedef struct spgLeafConsistentIn  spgLeafConsistentIn
 
typedef struct spgLeafConsistentOut  spgLeafConsistentOut
 

Enumerations

enum   spgChooseResultType { spgMatchNode = 1 , spgAddNode , spgSplitTuple }
 

Functions

bytea *  spgoptions (Datum reloptions, bool validate)
 
IndexBuildResult *  spgbuild (Relation heap, Relation index, struct IndexInfo *indexInfo)
 
void  spgbuildempty (Relation index)
 
bool  spginsert (Relation index, Datum *values, bool *isnull, ItemPointer ht_ctid, Relation heapRel, IndexUniqueCheck checkUnique, bool indexUnchanged, struct IndexInfo *indexInfo)
 
IndexScanDesc  spgbeginscan (Relation rel, int keysz, int orderbysz)
 
void  spgendscan (IndexScanDesc scan)
 
void  spgrescan (IndexScanDesc scan, ScanKey scankey, int nscankeys, ScanKey orderbys, int norderbys)
 
int64  spggetbitmap (IndexScanDesc scan, TIDBitmap *tbm)
 
bool  spggettuple (IndexScanDesc scan, ScanDirection dir)
 
bool  spgcanreturn (Relation index, int attno)
 
IndexBulkDeleteResult *  spgbulkdelete (IndexVacuumInfo *info, IndexBulkDeleteResult *stats, IndexBulkDeleteCallback callback, void *callback_state)
 
IndexBulkDeleteResult *  spgvacuumcleanup (IndexVacuumInfo *info, IndexBulkDeleteResult *stats)
 
bool  spgvalidate (Oid opclassoid)
 
void  spgadjustmembers (Oid opfamilyoid, Oid opclassoid, List *operators, List *functions)
 

Macro Definition Documentation

◆ SPGIST_CHOOSE_PROC

#define SPGIST_CHOOSE_PROC   2

Definition at line 24 of file spgist.h.

◆ SPGIST_COMPRESS_PROC

#define SPGIST_COMPRESS_PROC   6

Definition at line 28 of file spgist.h.

◆ SPGIST_CONFIG_PROC

#define SPGIST_CONFIG_PROC   1

Definition at line 23 of file spgist.h.

◆ SPGIST_INNER_CONSISTENT_PROC

#define SPGIST_INNER_CONSISTENT_PROC   4

Definition at line 26 of file spgist.h.

◆ SPGIST_LEAF_CONSISTENT_PROC

#define SPGIST_LEAF_CONSISTENT_PROC   5

Definition at line 27 of file spgist.h.

◆ SPGIST_OPTIONS_PROC

#define SPGIST_OPTIONS_PROC   7

Definition at line 29 of file spgist.h.

◆ SPGIST_PICKSPLIT_PROC

#define SPGIST_PICKSPLIT_PROC   3

Definition at line 25 of file spgist.h.

◆ SPGISTNProc

#define SPGISTNProc   7

Definition at line 31 of file spgist.h.

◆ SPGISTNRequiredProc

#define SPGISTNRequiredProc   5

Definition at line 30 of file spgist.h.

Typedef Documentation

◆ spgChooseIn

typedef struct spgChooseIn spgChooseIn

◆ spgChooseOut

typedef struct spgChooseOut spgChooseOut

◆ spgChooseResultType

typedef enum spgChooseResultType spgChooseResultType

◆ spgConfigIn

typedef struct spgConfigIn spgConfigIn

◆ spgConfigOut

typedef struct spgConfigOut spgConfigOut

◆ spgInnerConsistentIn

typedef struct spgInnerConsistentIn spgInnerConsistentIn

◆ spgInnerConsistentOut

typedef struct spgInnerConsistentOut spgInnerConsistentOut

◆ spgLeafConsistentIn

typedef struct spgLeafConsistentIn spgLeafConsistentIn

◆ spgLeafConsistentOut

typedef struct spgLeafConsistentOut spgLeafConsistentOut

◆ spgPickSplitIn

typedef struct spgPickSplitIn spgPickSplitIn

◆ spgPickSplitOut

typedef struct spgPickSplitOut spgPickSplitOut

Enumeration Type Documentation

◆ spgChooseResultType

enum spgChooseResultType
Enumerator
spgMatchNode 
spgAddNode 
spgSplitTuple 

Definition at line 67 of file spgist.h.

68{
69 spgMatchNode = 1, /* descend into existing node */
70 spgAddNode, /* add a node to the inner tuple */
71 spgSplitTuple, /* split inner tuple (change its prefix) */
spgChooseResultType
Definition: spgist.h:68
@ spgMatchNode
Definition: spgist.h:69
@ spgAddNode
Definition: spgist.h:70
@ spgSplitTuple
Definition: spgist.h:71

Function Documentation

◆ spgadjustmembers()

void spgadjustmembers ( Oid  opfamilyoid,
Oid  opclassoid,
List *  operators,
List *  functions 
)

Definition at line 323 of file spgvalidate.c.

327{
328 ListCell *lc;
329
330 /*
331 * Operator members of an SP-GiST opfamily should never have hard
332 * dependencies, since their connection to the opfamily depends only on
333 * what the support functions think, and that can be altered. For
334 * consistency, we make all soft dependencies point to the opfamily,
335 * though a soft dependency on the opclass would work as well in the
336 * CREATE OPERATOR CLASS case.
337 */
338 foreach(lc, operators)
339 {
341
342 op->ref_is_hard = false;
343 op->ref_is_family = true;
344 op->refobjid = opfamilyoid;
345 }
346
347 /*
348 * Required support functions should have hard dependencies. Preferably
349 * those are just dependencies on the opclass, but if we're in ALTER
350 * OPERATOR FAMILY, we leave the dependency pointing at the whole
351 * opfamily. (Given that SP-GiST opclasses generally don't share
352 * opfamilies, it seems unlikely to be worth working harder.)
353 */
354 foreach(lc, functions)
355 {
357
358 switch (op->number)
359 {
365 /* Required support function */
366 op->ref_is_hard = true;
367 break;
370 /* Optional, so force it to be a soft family dependency */
371 op->ref_is_hard = false;
372 op->ref_is_family = true;
373 op->refobjid = opfamilyoid;
374 break;
375 default:
377 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
378 errmsg("support function number %d is invalid for access method %s",
379 op->number, "spgist")));
380 break;
381 }
382 }
383}
int errcode(int sqlerrcode)
Definition: elog.c:854
int errmsg(const char *fmt,...)
Definition: elog.c:1071
#define ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:150
#define lfirst(lc)
Definition: pg_list.h:172
static const struct fns functions
Definition: regcomp.c:358
#define SPGIST_OPTIONS_PROC
Definition: spgist.h:29
#define SPGIST_COMPRESS_PROC
Definition: spgist.h:28
#define SPGIST_CHOOSE_PROC
Definition: spgist.h:24
#define SPGIST_LEAF_CONSISTENT_PROC
Definition: spgist.h:27
#define SPGIST_CONFIG_PROC
Definition: spgist.h:23
#define SPGIST_PICKSPLIT_PROC
Definition: spgist.h:25
#define SPGIST_INNER_CONSISTENT_PROC
Definition: spgist.h:26
Oid refobjid
Definition: amapi.h:98
bool ref_is_family
Definition: amapi.h:97
int number
Definition: amapi.h:92
bool ref_is_hard
Definition: amapi.h:96
Definition: pg_list.h:46

References ereport, errcode(), errmsg(), ERROR, functions, lfirst, OpFamilyMember::number, OpFamilyMember::ref_is_family, OpFamilyMember::ref_is_hard, OpFamilyMember::refobjid, SPGIST_CHOOSE_PROC, SPGIST_COMPRESS_PROC, SPGIST_CONFIG_PROC, SPGIST_INNER_CONSISTENT_PROC, SPGIST_LEAF_CONSISTENT_PROC, SPGIST_OPTIONS_PROC, and SPGIST_PICKSPLIT_PROC.

Referenced by spghandler().

◆ spgbeginscan()

IndexScanDesc spgbeginscan ( Relation  rel,
int  keysz,
int  orderbysz 
)

Definition at line 304 of file spgscan.c.

305{
306 IndexScanDesc scan;
308 int i;
309
310 scan = RelationGetIndexScan(rel, keysz, orderbysz);
311
313 if (keysz > 0)
314 so->keyData = (ScanKey) palloc(sizeof(ScanKeyData) * keysz);
315 else
316 so->keyData = NULL;
318
320 "SP-GiST search temporary context",
323 "SP-GiST traversal-value context",
325
326 /*
327 * Set up reconTupDesc and xs_hitupdesc in case it's an index-only scan,
328 * making sure that the key column is shown as being of type attType.
329 * (It's rather annoying to do this work when it might be wasted, but for
330 * most opclasses we can re-use the index reldesc instead of making one.)
331 */
332 so->reconTupDesc = scan->xs_hitupdesc =
334
335 /* Allocate various arrays needed for order-by scans */
336 if (scan->numberOfOrderBys > 0)
337 {
338 /* This will be filled in spgrescan, but allocate the space here */
339 so->orderByTypes = (Oid *)
340 palloc(sizeof(Oid) * scan->numberOfOrderBys);
341 so->nonNullOrderByOffsets = (int *)
342 palloc(sizeof(int) * scan->numberOfOrderBys);
343
344 /* These arrays have constant contents, so we can fill them now */
345 so->zeroDistances = (double *)
346 palloc(sizeof(double) * scan->numberOfOrderBys);
347 so->infDistances = (double *)
348 palloc(sizeof(double) * scan->numberOfOrderBys);
349
350 for (i = 0; i < scan->numberOfOrderBys; i++)
351 {
352 so->zeroDistances[i] = 0.0;
354 }
355
356 scan->xs_orderbyvals = (Datum *)
357 palloc0(sizeof(Datum) * scan->numberOfOrderBys);
358 scan->xs_orderbynulls = (bool *)
359 palloc(sizeof(bool) * scan->numberOfOrderBys);
360 memset(scan->xs_orderbynulls, true,
361 sizeof(bool) * scan->numberOfOrderBys);
362 }
363
367
371
372 so->indexCollation = rel->rd_indcollation[0];
373
374 scan->opaque = so;
375
376 return scan;
377}
static float8 get_float8_infinity(void)
Definition: float.h:94
void fmgr_info_copy(FmgrInfo *dstinfo, FmgrInfo *srcinfo, MemoryContext destcxt)
Definition: fmgr.c:580
IndexScanDesc RelationGetIndexScan(Relation indexRelation, int nkeys, int norderbys)
Definition: genam.c:80
FmgrInfo * index_getprocinfo(Relation irel, AttrNumber attnum, uint16 procnum)
Definition: indexam.c:917
i
int i
Definition: isn.c:77
void * palloc0(Size size)
Definition: mcxt.c:1395
void * palloc(Size size)
Definition: mcxt.c:1365
MemoryContext CurrentMemoryContext
Definition: mcxt.c:160
#define AllocSetContextCreate
Definition: memutils.h:129
#define ALLOCSET_DEFAULT_SIZES
Definition: memutils.h:160
uint64_t Datum
Definition: postgres.h:70
unsigned int Oid
Definition: postgres_ext.h:32
ScanKeyData * ScanKey
Definition: skey.h:75
SpGistScanOpaqueData * SpGistScanOpaque
void initSpGistState(SpGistState *state, Relation index)
Definition: spgutils.c:348
TupleDesc getSpGistTupleDesc(Relation index, SpGistTypeDesc *keyType)
Definition: spgutils.c:315
bool * xs_orderbynulls
Definition: relscan.h:187
int numberOfOrderBys
Definition: relscan.h:140
struct TupleDescData * xs_hitupdesc
Definition: relscan.h:170
Relation indexRelation
Definition: relscan.h:137
void * opaque
Definition: relscan.h:153
Datum * xs_orderbyvals
Definition: relscan.h:186
Oid * rd_indcollation
Definition: rel.h:217
Definition: skey.h:65
MemoryContext traversalCxt
TupleDesc reconTupDesc
MemoryContext tempCxt
FmgrInfo leafConsistentFn
FmgrInfo innerConsistentFn
SpGistTypeDesc attType

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, SpGistState::attType, CurrentMemoryContext, fmgr_info_copy(), get_float8_infinity(), getSpGistTupleDesc(), i, index_getprocinfo(), SpGistScanOpaqueData::indexCollation, IndexScanDescData::indexRelation, SpGistScanOpaqueData::infDistances, initSpGistState(), SpGistScanOpaqueData::innerConsistentFn, SpGistScanOpaqueData::keyData, SpGistScanOpaqueData::leafConsistentFn, SpGistScanOpaqueData::nonNullOrderByOffsets, IndexScanDescData::numberOfOrderBys, IndexScanDescData::opaque, SpGistScanOpaqueData::orderByTypes, palloc(), palloc0(), RelationData::rd_indcollation, SpGistScanOpaqueData::reconTupDesc, RelationGetIndexScan(), SPGIST_INNER_CONSISTENT_PROC, SPGIST_LEAF_CONSISTENT_PROC, SpGistScanOpaqueData::state, SpGistScanOpaqueData::tempCxt, SpGistScanOpaqueData::traversalCxt, IndexScanDescData::xs_hitupdesc, IndexScanDescData::xs_orderbynulls, IndexScanDescData::xs_orderbyvals, and SpGistScanOpaqueData::zeroDistances.

Referenced by spghandler().

◆ spgbuild()

IndexBuildResult * spgbuild ( Relation  heap,
Relation  index,
struct IndexInfo *  indexInfo 
)

Definition at line 73 of file spginsert.c.

74{
75 IndexBuildResult *result;
76 double reltuples;
77 SpGistBuildState buildstate;
78 Buffer metabuffer,
79 rootbuffer,
80 nullbuffer;
81
83 elog(ERROR, "index \"%s\" already contains data",
85
86 /*
87 * Initialize the meta page and root pages
88 */
89 metabuffer = SpGistNewBuffer(index);
90 rootbuffer = SpGistNewBuffer(index);
91 nullbuffer = SpGistNewBuffer(index);
92
96
98
100 MarkBufferDirty(metabuffer);
101 SpGistInitBuffer(rootbuffer, SPGIST_LEAF);
102 MarkBufferDirty(rootbuffer);
104 MarkBufferDirty(nullbuffer);
105
106
108
109 UnlockReleaseBuffer(metabuffer);
110 UnlockReleaseBuffer(rootbuffer);
111 UnlockReleaseBuffer(nullbuffer);
112
113 /*
114 * Now insert all the heap data into the index
115 */
116 initSpGistState(&buildstate.spgstate, index);
117 buildstate.spgstate.isBuild = true;
118 buildstate.indtuples = 0;
119
121 "SP-GiST build temporary context",
123
124 reltuples = table_index_build_scan(heap, index, indexInfo, true, true,
125 spgistBuildCallback, &buildstate,
126 NULL);
127
128 MemoryContextDelete(buildstate.tmpCtx);
129
131
132 /*
133 * We didn't write WAL records as we built the index, so if WAL-logging is
134 * required, write all pages to the WAL now.
135 */
137 {
140 true);
141 }
142
143 result = (IndexBuildResult *) palloc0(sizeof(IndexBuildResult));
144 result->heap_tuples = reltuples;
145 result->index_tuples = buildstate.indtuples;
146
147 return result;
148}
int Buffer
Definition: buf.h:23
BlockNumber BufferGetBlockNumber(Buffer buffer)
Definition: bufmgr.c:4198
void UnlockReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:5355
void MarkBufferDirty(Buffer buffer)
Definition: bufmgr.c:2921
#define RelationGetNumberOfBlocks(reln)
Definition: bufmgr.h:283
static Page BufferGetPage(Buffer buffer)
Definition: bufmgr.h:417
#define elog(elevel,...)
Definition: elog.h:226
Assert(PointerIsAligned(start, uint64))
void MemoryContextDelete(MemoryContext context)
Definition: mcxt.c:469
#define START_CRIT_SECTION()
Definition: miscadmin.h:149
#define END_CRIT_SECTION()
Definition: miscadmin.h:151
#define RelationGetRelationName(relation)
Definition: rel.h:548
#define RelationNeedsWAL(relation)
Definition: rel.h:637
@ MAIN_FORKNUM
Definition: relpath.h:58
static void spgistBuildCallback(Relation index, ItemPointer tid, Datum *values, bool *isnull, bool tupleIsAlive, void *state)
Definition: spginsert.c:41
#define SPGIST_NULL_BLKNO
Definition: spgist_private.h:49
#define SPGIST_METAPAGE_BLKNO
Definition: spgist_private.h:47
#define SPGIST_NULLS
Definition: spgist_private.h:75
#define SPGIST_LEAF
Definition: spgist_private.h:74
#define SPGIST_ROOT_BLKNO
Definition: spgist_private.h:48
void SpGistUpdateMetaPage(Relation index)
Definition: spgutils.c:450
Buffer SpGistNewBuffer(Relation index)
Definition: spgutils.c:394
void SpGistInitBuffer(Buffer b, uint16 f)
Definition: spgutils.c:722
void SpGistInitMetapage(Page page)
Definition: spgutils.c:732
double heap_tuples
Definition: genam.h:59
double index_tuples
Definition: genam.h:60
MemoryContext tmpCtx
Definition: spginsert.c:35
int64 indtuples
Definition: spginsert.c:34
SpGistState spgstate
Definition: spginsert.c:33
Definition: type.h:96
static double table_index_build_scan(Relation table_rel, Relation index_rel, IndexInfo *index_info, bool allow_sync, bool progress, IndexBuildCallback callback, void *callback_state, TableScanDesc scan)
Definition: tableam.h:1744
void log_newpage_range(Relation rel, ForkNumber forknum, BlockNumber startblk, BlockNumber endblk, bool page_std)
Definition: xloginsert.c:1282

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert(), BufferGetBlockNumber(), BufferGetPage(), CurrentMemoryContext, elog, END_CRIT_SECTION, ERROR, IndexBuildResult::heap_tuples, IndexBuildResult::index_tuples, SpGistBuildState::indtuples, initSpGistState(), SpGistState::isBuild, log_newpage_range(), MAIN_FORKNUM, MarkBufferDirty(), MemoryContextDelete(), palloc0(), RelationGetNumberOfBlocks, RelationGetRelationName, RelationNeedsWAL, SPGIST_LEAF, SPGIST_METAPAGE_BLKNO, SPGIST_NULL_BLKNO, SPGIST_NULLS, SPGIST_ROOT_BLKNO, spgistBuildCallback(), SpGistInitBuffer(), SpGistInitMetapage(), SpGistNewBuffer(), SpGistUpdateMetaPage(), SpGistBuildState::spgstate, START_CRIT_SECTION, table_index_build_scan(), SpGistBuildState::tmpCtx, and UnlockReleaseBuffer().

Referenced by spghandler().

◆ spgbuildempty()

void spgbuildempty ( Relation  index )

Definition at line 154 of file spginsert.c.

155{
156 BulkWriteState *bulkstate;
158
160
161 /* Construct metapage. */
162 buf = smgr_bulk_get_buf(bulkstate);
164 smgr_bulk_write(bulkstate, SPGIST_METAPAGE_BLKNO, buf, true);
165
166 /* Likewise for the root page. */
167 buf = smgr_bulk_get_buf(bulkstate);
169 smgr_bulk_write(bulkstate, SPGIST_ROOT_BLKNO, buf, true);
170
171 /* Likewise for the null-tuples root page. */
172 buf = smgr_bulk_get_buf(bulkstate);
174 smgr_bulk_write(bulkstate, SPGIST_NULL_BLKNO, buf, true);
175
176 smgr_bulk_finish(bulkstate);
177}
PageData * Page
Definition: bufpage.h:82
BulkWriteState * smgr_bulk_start_rel(Relation rel, ForkNumber forknum)
Definition: bulk_write.c:87
void smgr_bulk_write(BulkWriteState *bulkstate, BlockNumber blocknum, BulkWriteBuffer buf, bool page_std)
Definition: bulk_write.c:323
BulkWriteBuffer smgr_bulk_get_buf(BulkWriteState *bulkstate)
Definition: bulk_write.c:347
void smgr_bulk_finish(BulkWriteState *bulkstate)
Definition: bulk_write.c:130
static char * buf
Definition: pg_test_fsync.c:72
@ INIT_FORKNUM
Definition: relpath.h:61
void SpGistInitPage(Page page, uint16 f)
Definition: spgutils.c:708

References buf, INIT_FORKNUM, smgr_bulk_finish(), smgr_bulk_get_buf(), smgr_bulk_start_rel(), smgr_bulk_write(), SPGIST_LEAF, SPGIST_METAPAGE_BLKNO, SPGIST_NULL_BLKNO, SPGIST_NULLS, SPGIST_ROOT_BLKNO, SpGistInitMetapage(), and SpGistInitPage().

Referenced by spghandler().

◆ spgbulkdelete()

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

Definition at line 950 of file spgvacuum.c.

952{
954
955 /* allocate stats if first time through, else re-use existing struct */
956 if (stats == NULL)
958 bds.info = info;
959 bds.stats = stats;
960 bds.callback = callback;
961 bds.callback_state = callback_state;
962
963 spgvacuumscan(&bds);
964
965 return stats;
966}
static void spgvacuumscan(spgBulkDeleteState *bds)
Definition: spgvacuum.c:800
IndexBulkDeleteResult * stats
Definition: spgvacuum.c:45
IndexBulkDeleteCallback callback
Definition: spgvacuum.c:46
void * callback_state
Definition: spgvacuum.c:47
IndexVacuumInfo * info
Definition: spgvacuum.c:44
static void callback(struct sockaddr *addr, struct sockaddr *mask, void *unused)
Definition: test_ifaddrs.c:46

References spgBulkDeleteState::callback, callback(), spgBulkDeleteState::callback_state, spgBulkDeleteState::info, palloc0(), spgvacuumscan(), and spgBulkDeleteState::stats.

Referenced by spghandler().

◆ spgcanreturn()

bool spgcanreturn ( Relation  index,
int  attno 
)

Definition at line 1083 of file spgscan.c.

1084{
1085 SpGistCache *cache;
1086
1087 /* INCLUDE attributes can always be fetched for index-only scans */
1088 if (attno > 1)
1089 return true;
1090
1091 /* We can do it if the opclass config function says so */
1092 cache = spgGetCache(index);
1093
1094 return cache->config.canReturnData;
1095}
SpGistCache * spgGetCache(Relation index)
Definition: spgutils.c:188
spgConfigOut config
bool canReturnData
Definition: spgist.h:46

References spgConfigOut::canReturnData, SpGistCache::config, and spgGetCache().

Referenced by spghandler().

◆ spgendscan()

void spgendscan ( IndexScanDesc  scan )

Definition at line 429 of file spgscan.c.

430{
432
435
436 if (so->keyData)
437 pfree(so->keyData);
438
439 if (so->state.leafTupDesc &&
442
443 if (so->state.deadTupleStorage)
445
446 if (scan->numberOfOrderBys > 0)
447 {
448 pfree(so->orderByTypes);
450 pfree(so->zeroDistances);
451 pfree(so->infDistances);
452 pfree(scan->xs_orderbyvals);
453 pfree(scan->xs_orderbynulls);
454 }
455
456 pfree(so);
457}
void pfree(void *pointer)
Definition: mcxt.c:1594
#define RelationGetDescr(relation)
Definition: rel.h:540
Relation index
TupleDesc leafTupDesc
char * deadTupleStorage
void FreeTupleDesc(TupleDesc tupdesc)
Definition: tupdesc.c:502

References SpGistState::deadTupleStorage, FreeTupleDesc(), SpGistState::index, SpGistScanOpaqueData::infDistances, SpGistScanOpaqueData::keyData, SpGistState::leafTupDesc, MemoryContextDelete(), SpGistScanOpaqueData::nonNullOrderByOffsets, IndexScanDescData::numberOfOrderBys, IndexScanDescData::opaque, SpGistScanOpaqueData::orderByTypes, pfree(), RelationGetDescr, SpGistScanOpaqueData::state, SpGistScanOpaqueData::tempCxt, SpGistScanOpaqueData::traversalCxt, IndexScanDescData::xs_orderbynulls, IndexScanDescData::xs_orderbyvals, and SpGistScanOpaqueData::zeroDistances.

Referenced by spghandler().

◆ spggetbitmap()

int64 spggetbitmap ( IndexScanDesc  scan,
TIDBitmap *  tbm 
)

Definition at line 942 of file spgscan.c.

943{
945
946 /* Copy want_itup to *so so we don't need to pass it around separately */
947 so->want_itup = false;
948
949 so->tbm = tbm;
950 so->ntids = 0;
951
952 spgWalk(scan->indexRelation, so, true, storeBitmap);
953
954 return so->ntids;
955}
static void spgWalk(Relation index, SpGistScanOpaque so, bool scanWholeIndex, storeRes_func storeRes)
Definition: spgscan.c:817
static void storeBitmap(SpGistScanOpaque so, ItemPointer heapPtr, Datum leafValue, bool isnull, SpGistLeafTuple leafTuple, bool recheck, bool recheckDistances, double *distances)
Definition: spgscan.c:931

References IndexScanDescData::indexRelation, SpGistScanOpaqueData::ntids, IndexScanDescData::opaque, spgWalk(), storeBitmap(), SpGistScanOpaqueData::tbm, and SpGistScanOpaqueData::want_itup.

Referenced by spghandler().

◆ spggettuple()

bool spggettuple ( IndexScanDesc  scan,
ScanDirection  dir 
)

Definition at line 1026 of file spgscan.c.

1027{
1029
1030 if (dir != ForwardScanDirection)
1031 elog(ERROR, "SP-GiST only supports forward scan direction");
1032
1033 /* Copy want_itup to *so so we don't need to pass it around separately */
1034 so->want_itup = scan->xs_want_itup;
1035
1036 for (;;)
1037 {
1038 if (so->iPtr < so->nPtrs)
1039 {
1040 /* continuing to return reported tuples */
1041 scan->xs_heaptid = so->heapPtrs[so->iPtr];
1042 scan->xs_recheck = so->recheck[so->iPtr];
1043 scan->xs_hitup = so->reconTups[so->iPtr];
1044
1045 if (so->numberOfOrderBys > 0)
1047 so->distances[so->iPtr],
1048 so->recheckDistances[so->iPtr]);
1049 so->iPtr++;
1050 return true;
1051 }
1052
1053 if (so->numberOfOrderBys > 0)
1054 {
1055 /* Must pfree distances to avoid memory leak */
1056 int i;
1057
1058 for (i = 0; i < so->nPtrs; i++)
1059 if (so->distances[i])
1060 pfree(so->distances[i]);
1061 }
1062
1063 if (so->want_itup)
1064 {
1065 /* Must pfree reconstructed tuples to avoid memory leak */
1066 int i;
1067
1068 for (i = 0; i < so->nPtrs; i++)
1069 pfree(so->reconTups[i]);
1070 }
1071 so->iPtr = so->nPtrs = 0;
1072
1073 spgWalk(scan->indexRelation, so, false, storeGettuple);
1074
1075 if (so->nPtrs == 0)
1076 break; /* must have completed scan */
1077 }
1078
1079 return false;
1080}
void index_store_float8_orderby_distances(IndexScanDesc scan, Oid *orderByTypes, IndexOrderByDistance *distances, bool recheckOrderBy)
Definition: indexam.c:985
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:81
@ ForwardScanDirection
Definition: sdir.h:28
static void storeGettuple(SpGistScanOpaque so, ItemPointer heapPtr, Datum leafValue, bool isnull, SpGistLeafTuple leafTuple, bool recheck, bool recheckDistances, double *nonNullDistances)
Definition: spgscan.c:959
HeapTuple xs_hitup
Definition: relscan.h:169
bool xs_recheck
Definition: relscan.h:177
bool xs_want_itup
Definition: relscan.h:143
ItemPointerData xs_heaptid
Definition: relscan.h:172
HeapTuple reconTups[MaxIndexTuplesPerPage]
ItemPointerData heapPtrs[MaxIndexTuplesPerPage]
bool recheckDistances[MaxIndexTuplesPerPage]
IndexOrderByDistance * distances[MaxIndexTuplesPerPage]
bool recheck[MaxIndexTuplesPerPage]

References SpGistScanOpaqueData::distances, elog, ERROR, ForwardScanDirection, SpGistScanOpaqueData::heapPtrs, i, if(), index_store_float8_orderby_distances(), IndexScanDescData::indexRelation, SpGistScanOpaqueData::iPtr, SpGistScanOpaqueData::nPtrs, SpGistScanOpaqueData::numberOfOrderBys, IndexScanDescData::opaque, SpGistScanOpaqueData::orderByTypes, pfree(), SpGistScanOpaqueData::recheck, SpGistScanOpaqueData::recheckDistances, SpGistScanOpaqueData::reconTups, spgWalk(), storeGettuple(), SpGistScanOpaqueData::want_itup, IndexScanDescData::xs_heaptid, IndexScanDescData::xs_hitup, IndexScanDescData::xs_recheck, and IndexScanDescData::xs_want_itup.

Referenced by spghandler().

◆ spginsert()

bool spginsert ( Relation  index,
Datum *  values,
bool *  isnull,
ItemPointer  ht_ctid,
Relation  heapRel,
IndexUniqueCheck  checkUnique,
bool  indexUnchanged,
struct IndexInfo *  indexInfo 
)

Definition at line 183 of file spginsert.c.

188{
189 SpGistState spgstate;
190 MemoryContext oldCtx;
191 MemoryContext insertCtx;
192
194 "SP-GiST insert temporary context",
196 oldCtx = MemoryContextSwitchTo(insertCtx);
197
198 initSpGistState(&spgstate, index);
199
200 /*
201 * We might have to repeat spgdoinsert() multiple times, if conflicts
202 * occur with concurrent insertions. If so, reset the insertCtx each time
203 * to avoid cumulative memory consumption. That means we also have to
204 * redo initSpGistState(), but it's cheap enough not to matter.
205 */
206 while (!spgdoinsert(index, &spgstate, ht_ctid, values, isnull))
207 {
208 MemoryContextReset(insertCtx);
209 initSpGistState(&spgstate, index);
210 }
211
213
214 MemoryContextSwitchTo(oldCtx);
215 MemoryContextDelete(insertCtx);
216
217 /* return false since we've not done any unique check */
218 return false;
219}
static Datum values[MAXATTR]
Definition: bootstrap.c:153
void MemoryContextReset(MemoryContext context)
Definition: mcxt.c:400
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:124
bool spgdoinsert(Relation index, SpGistState *state, ItemPointer heapPtr, Datum *datums, bool *isnulls)
Definition: spgdoinsert.c:1914

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, CurrentMemoryContext, initSpGistState(), MemoryContextDelete(), MemoryContextReset(), MemoryContextSwitchTo(), spgdoinsert(), SpGistUpdateMetaPage(), and values.

Referenced by spghandler().

◆ spgoptions()

bytea * spgoptions ( Datum  reloptions,
bool  validate 
)

Definition at line 759 of file spgutils.c.

760{
761 static const relopt_parse_elt tab[] = {
762 {"fillfactor", RELOPT_TYPE_INT, offsetof(SpGistOptions, fillfactor)},
763 };
764
765 return (bytea *) build_reloptions(reloptions, validate,
767 sizeof(SpGistOptions),
768 tab, lengthof(tab));
769}
static bool validate(Port *port, const char *auth)
Definition: auth-oauth.c:638
#define lengthof(array)
Definition: c.h:787
static int fillfactor
Definition: pgbench.c:188
void * build_reloptions(Datum reloptions, bool validate, relopt_kind kind, Size relopt_struct_size, const relopt_parse_elt *relopt_elems, int num_relopt_elems)
Definition: reloptions.c:1943
@ RELOPT_KIND_SPGIST
Definition: reloptions.h:50
@ RELOPT_TYPE_INT
Definition: reloptions.h:32
Definition: reloptions.h:151
Definition: c.h:692

References build_reloptions(), fillfactor, lengthof, RELOPT_KIND_SPGIST, RELOPT_TYPE_INT, and validate().

Referenced by spghandler().

◆ spgrescan()

void spgrescan ( IndexScanDesc  scan,
ScanKey  scankey,
int  nscankeys,
ScanKey  orderbys,
int  norderbys 
)

Definition at line 380 of file spgscan.c.

382{
384
385 /* copy scankeys into local storage */
386 if (scankey && scan->numberOfKeys > 0)
387 memcpy(scan->keyData, scankey, scan->numberOfKeys * sizeof(ScanKeyData));
388
389 /* initialize order-by data if needed */
390 if (orderbys && scan->numberOfOrderBys > 0)
391 {
392 int i;
393
394 memcpy(scan->orderByData, orderbys, scan->numberOfOrderBys * sizeof(ScanKeyData));
395
396 for (i = 0; i < scan->numberOfOrderBys; i++)
397 {
398 ScanKey skey = &scan->orderByData[i];
399
400 /*
401 * Look up the datatype returned by the original ordering
402 * operator. SP-GiST always uses a float8 for the distance
403 * function, but the ordering operator could be anything else.
404 *
405 * XXX: The distance function is only allowed to be lossy if the
406 * ordering operator's result type is float4 or float8. Otherwise
407 * we don't know how to return the distance to the executor. But
408 * we cannot check that here, as we won't know if the distance
409 * function is lossy until it returns *recheck = true for the
410 * first time.
411 */
413 }
414 }
415
416 /* preprocess scankeys, set up the representation in *so */
417 spgPrepareScanKeys(scan);
418
419 /* set up starting queue entries */
421
422 /* count an indexscan for stats */
424 if (scan->instrument)
425 scan->instrument->nsearches++;
426}
Oid get_func_rettype(Oid funcid)
Definition: lsyscache.c:1822
#define pgstat_count_index_scan(rel)
Definition: pgstat.h:695
static void resetSpGistScanOpaque(SpGistScanOpaque so)
Definition: spgscan.c:154
static void spgPrepareScanKeys(IndexScanDesc scan)
Definition: spgscan.c:208
Oid fn_oid
Definition: fmgr.h:59
struct ScanKeyData * keyData
Definition: relscan.h:141
struct ScanKeyData * orderByData
Definition: relscan.h:142
int numberOfKeys
Definition: relscan.h:139
struct IndexScanInstrumentation * instrument
Definition: relscan.h:159
uint64 nsearches
Definition: genam.h:42
FmgrInfo sk_func
Definition: skey.h:71

References FmgrInfo::fn_oid, get_func_rettype(), i, if(), IndexScanDescData::indexRelation, IndexScanDescData::instrument, IndexScanDescData::keyData, IndexScanInstrumentation::nsearches, IndexScanDescData::numberOfKeys, IndexScanDescData::numberOfOrderBys, IndexScanDescData::opaque, IndexScanDescData::orderByData, SpGistScanOpaqueData::orderByTypes, pgstat_count_index_scan, resetSpGistScanOpaque(), ScanKeyData::sk_func, and spgPrepareScanKeys().

Referenced by spghandler().

◆ spgvacuumcleanup()

IndexBulkDeleteResult * spgvacuumcleanup ( IndexVacuumInfo *  info,
IndexBulkDeleteResult *  stats 
)

Definition at line 981 of file spgvacuum.c.

982{
984
985 /* No-op in ANALYZE ONLY mode */
986 if (info->analyze_only)
987 return stats;
988
989 /*
990 * We don't need to scan the index if there was a preceding bulkdelete
991 * pass. Otherwise, make a pass that won't delete any live tuples, but
992 * might still accomplish useful stuff with redirect/placeholder cleanup
993 * and/or FSM housekeeping, and in any case will provide stats.
994 */
995 if (stats == NULL)
996 {
998 bds.info = info;
999 bds.stats = stats;
1001 bds.callback_state = NULL;
1002
1003 spgvacuumscan(&bds);
1004 }
1005
1006 /*
1007 * It's quite possible for us to be fooled by concurrent tuple moves into
1008 * double-counting some index tuples, so disbelieve any total that exceeds
1009 * the underlying heap's count ... if we know that accurately. Otherwise
1010 * this might just make matters worse.
1011 */
1012 if (!info->estimated_count)
1013 {
1014 if (stats->num_index_tuples > info->num_heap_tuples)
1015 stats->num_index_tuples = info->num_heap_tuples;
1016 }
1017
1018 return stats;
1019}
static bool dummy_callback(ItemPointer itemptr, void *state)
Definition: spgvacuum.c:970
double num_index_tuples
Definition: genam.h:106
double num_heap_tuples
Definition: genam.h:79
bool analyze_only
Definition: genam.h:75
bool estimated_count
Definition: genam.h:77

References IndexVacuumInfo::analyze_only, spgBulkDeleteState::callback, spgBulkDeleteState::callback_state, dummy_callback(), IndexVacuumInfo::estimated_count, spgBulkDeleteState::info, IndexVacuumInfo::num_heap_tuples, IndexBulkDeleteResult::num_index_tuples, palloc0(), spgvacuumscan(), and spgBulkDeleteState::stats.

Referenced by spghandler().

◆ spgvalidate()

bool spgvalidate ( Oid  opclassoid )

Definition at line 38 of file spgvalidate.c.

39{
40 bool result = true;
41 HeapTuple classtup;
42 Form_pg_opclass classform;
43 Oid opfamilyoid;
44 Oid opcintype;
45 Oid opckeytype;
46 char *opclassname;
47 char *opfamilyname;
48 CatCList *proclist,
49 *oprlist;
50 List *grouplist;
51 OpFamilyOpFuncGroup *opclassgroup;
52 int i;
53 ListCell *lc;
54 spgConfigIn configIn;
55 spgConfigOut configOut;
56 Oid configOutLefttype = InvalidOid;
57 Oid configOutRighttype = InvalidOid;
58 Oid configOutLeafType = InvalidOid;
59
60 /* Fetch opclass information */
61 classtup = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclassoid));
62 if (!HeapTupleIsValid(classtup))
63 elog(ERROR, "cache lookup failed for operator class %u", opclassoid);
64 classform = (Form_pg_opclass) GETSTRUCT(classtup);
65
66 opfamilyoid = classform->opcfamily;
67 opcintype = classform->opcintype;
68 opckeytype = classform->opckeytype;
69 opclassname = NameStr(classform->opcname);
70
71 /* Fetch opfamily information */
72 opfamilyname = get_opfamily_name(opfamilyoid, false);
73
74 /* Fetch all operators and support functions of the opfamily */
75 oprlist = SearchSysCacheList1(AMOPSTRATEGY, ObjectIdGetDatum(opfamilyoid));
76 proclist = SearchSysCacheList1(AMPROCNUM, ObjectIdGetDatum(opfamilyoid));
77 grouplist = identify_opfamily_groups(oprlist, proclist);
78
79 /* Check individual support functions */
80 for (i = 0; i < proclist->n_members; i++)
81 {
82 HeapTuple proctup = &proclist->members[i]->tuple;
83 Form_pg_amproc procform = (Form_pg_amproc) GETSTRUCT(proctup);
84 bool ok;
85
86 /*
87 * All SP-GiST support functions should be registered with matching
88 * left/right types
89 */
90 if (procform->amproclefttype != procform->amprocrighttype)
91 {
93 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
94 errmsg("operator family \"%s\" of access method %s contains support function %s with different left and right input types",
95 opfamilyname, "spgist",
96 format_procedure(procform->amproc))));
97 result = false;
98 }
99
100 /* Check procedure numbers and function signatures */
101 switch (procform->amprocnum)
102 {
104 ok = check_amproc_signature(procform->amproc, VOIDOID, true,
105 2, 2, INTERNALOID, INTERNALOID);
106 configIn.attType = procform->amproclefttype;
107 memset(&configOut, 0, sizeof(configOut));
108
109 OidFunctionCall2(procform->amproc,
110 PointerGetDatum(&configIn),
111 PointerGetDatum(&configOut));
112
113 configOutLefttype = procform->amproclefttype;
114 configOutRighttype = procform->amprocrighttype;
115
116 /* Default leaf type is opckeytype or input type */
117 if (OidIsValid(opckeytype))
118 configOutLeafType = opckeytype;
119 else
120 configOutLeafType = procform->amproclefttype;
121
122 /* If some other leaf datum type is specified, warn */
123 if (OidIsValid(configOut.leafType) &&
124 configOutLeafType != configOut.leafType)
125 {
127 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
128 errmsg("SP-GiST leaf data type %s does not match declared type %s",
129 format_type_be(configOut.leafType),
130 format_type_be(configOutLeafType))));
131 result = false;
132 configOutLeafType = configOut.leafType;
133 }
134
135 /*
136 * When leaf and attribute types are the same, compress
137 * function is not required and we set corresponding bit in
138 * functionset for later group consistency check.
139 */
140 if (configOutLeafType == configIn.attType)
141 {
142 foreach(lc, grouplist)
143 {
144 OpFamilyOpFuncGroup *group = lfirst(lc);
145
146 if (group->lefttype == procform->amproclefttype &&
147 group->righttype == procform->amprocrighttype)
148 {
149 group->functionset |=
151 break;
152 }
153 }
154 }
155 break;
159 ok = check_amproc_signature(procform->amproc, VOIDOID, true,
160 2, 2, INTERNALOID, INTERNALOID);
161 break;
163 ok = check_amproc_signature(procform->amproc, BOOLOID, true,
164 2, 2, INTERNALOID, INTERNALOID);
165 break;
167 if (configOutLefttype != procform->amproclefttype ||
168 configOutRighttype != procform->amprocrighttype)
169 ok = false;
170 else
171 ok = check_amproc_signature(procform->amproc,
172 configOutLeafType, true,
173 1, 1, procform->amproclefttype);
174 break;
176 ok = check_amoptsproc_signature(procform->amproc);
177 break;
178 default:
180 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
181 errmsg("operator family \"%s\" of access method %s contains function %s with invalid support number %d",
182 opfamilyname, "spgist",
183 format_procedure(procform->amproc),
184 procform->amprocnum)));
185 result = false;
186 continue; /* don't want additional message */
187 }
188
189 if (!ok)
190 {
192 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
193 errmsg("operator family \"%s\" of access method %s contains function %s with wrong signature for support number %d",
194 opfamilyname, "spgist",
195 format_procedure(procform->amproc),
196 procform->amprocnum)));
197 result = false;
198 }
199 }
200
201 /* Check individual operators */
202 for (i = 0; i < oprlist->n_members; i++)
203 {
204 HeapTuple oprtup = &oprlist->members[i]->tuple;
205 Form_pg_amop oprform = (Form_pg_amop) GETSTRUCT(oprtup);
206 Oid op_rettype;
207
208 /* TODO: Check that only allowed strategy numbers exist */
209 if (oprform->amopstrategy < 1 || oprform->amopstrategy > 63)
210 {
212 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
213 errmsg("operator family \"%s\" of access method %s contains operator %s with invalid strategy number %d",
214 opfamilyname, "spgist",
215 format_operator(oprform->amopopr),
216 oprform->amopstrategy)));
217 result = false;
218 }
219
220 /* spgist supports ORDER BY operators */
221 if (oprform->amoppurpose != AMOP_SEARCH)
222 {
223 /* ... and operator result must match the claimed btree opfamily */
224 op_rettype = get_op_rettype(oprform->amopopr);
225 if (!opfamily_can_sort_type(oprform->amopsortfamily, op_rettype))
226 {
228 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
229 errmsg("operator family \"%s\" of access method %s contains invalid ORDER BY specification for operator %s",
230 opfamilyname, "spgist",
231 format_operator(oprform->amopopr))));
232 result = false;
233 }
234 }
235 else
236 op_rettype = BOOLOID;
237
238 /* Check operator signature --- same for all spgist strategies */
239 if (!check_amop_signature(oprform->amopopr, op_rettype,
240 oprform->amoplefttype,
241 oprform->amoprighttype))
242 {
244 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
245 errmsg("operator family \"%s\" of access method %s contains operator %s with wrong signature",
246 opfamilyname, "spgist",
247 format_operator(oprform->amopopr))));
248 result = false;
249 }
250 }
251
252 /* Now check for inconsistent groups of operators/functions */
253 opclassgroup = NULL;
254 foreach(lc, grouplist)
255 {
257
258 /* Remember the group exactly matching the test opclass */
259 if (thisgroup->lefttype == opcintype &&
260 thisgroup->righttype == opcintype)
261 opclassgroup = thisgroup;
262
263 /*
264 * Complain if there are any datatype pairs with functions but no
265 * operators. This is about the best we can do for now to detect
266 * missing operators.
267 */
268 if (thisgroup->operatorset == 0)
269 {
271 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
272 errmsg("operator family \"%s\" of access method %s is missing operator(s) for types %s and %s",
273 opfamilyname, "spgist",
274 format_type_be(thisgroup->lefttype),
275 format_type_be(thisgroup->righttype))));
276 result = false;
277 }
278
279 /*
280 * Complain if we're missing functions for any datatype, remembering
281 * that SP-GiST doesn't use cross-type support functions.
282 */
283 if (thisgroup->lefttype != thisgroup->righttype)
284 continue;
285
286 for (i = 1; i <= SPGISTNProc; i++)
287 {
288 if ((thisgroup->functionset & (((uint64) 1) << i)) != 0)
289 continue; /* got it */
290 if (i == SPGIST_OPTIONS_PROC)
291 continue; /* optional method */
293 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
294 errmsg("operator family \"%s\" of access method %s is missing support function %d for type %s",
295 opfamilyname, "spgist", i,
296 format_type_be(thisgroup->lefttype))));
297 result = false;
298 }
299 }
300
301 /* Check that the originally-named opclass is supported */
302 /* (if group is there, we already checked it adequately above) */
303 if (!opclassgroup)
304 {
306 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
307 errmsg("operator class \"%s\" of access method %s is missing operator(s)",
308 opclassname, "spgist")));
309 result = false;
310 }
311
312 ReleaseCatCacheList(proclist);
313 ReleaseCatCacheList(oprlist);
314 ReleaseSysCache(classtup);
315
316 return result;
317}
bool check_amproc_signature(Oid funcid, Oid restype, bool exact, int minargs, int maxargs,...)
Definition: amvalidate.c:152
bool check_amop_signature(Oid opno, Oid restype, Oid lefttype, Oid righttype)
Definition: amvalidate.c:206
List * identify_opfamily_groups(CatCList *oprlist, CatCList *proclist)
Definition: amvalidate.c:43
bool opfamily_can_sort_type(Oid opfamilyoid, Oid datatypeoid)
Definition: amvalidate.c:271
bool check_amoptsproc_signature(Oid funcid)
Definition: amvalidate.c:192
#define NameStr(name)
Definition: c.h:751
uint64_t uint64
Definition: c.h:539
#define OidIsValid(objectId)
Definition: c.h:774
void ReleaseCatCacheList(CatCList *list)
Definition: catcache.c:2094
#define INFO
Definition: elog.h:34
#define OidFunctionCall2(functionId, arg1, arg2)
Definition: fmgr.h:722
char * format_type_be(Oid type_oid)
Definition: format_type.c:343
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
static void * GETSTRUCT(const HeapTupleData *tuple)
Definition: htup_details.h:728
Oid get_op_rettype(Oid opno)
Definition: lsyscache.c:1500
char * get_opfamily_name(Oid opfid, bool missing_ok)
Definition: lsyscache.c:1420
FormData_pg_amop * Form_pg_amop
Definition: pg_amop.h:88
FormData_pg_amproc * Form_pg_amproc
Definition: pg_amproc.h:68
FormData_pg_opclass * Form_pg_opclass
Definition: pg_opclass.h:83
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:332
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:262
#define InvalidOid
Definition: postgres_ext.h:37
char * format_procedure(Oid procedure_oid)
Definition: regproc.c:305
char * format_operator(Oid operator_oid)
Definition: regproc.c:801
#define SPGISTNProc
Definition: spgist.h:31
Definition: pg_list.h:54
uint64 operatorset
Definition: amvalidate.h:24
uint64 functionset
Definition: amvalidate.h:25
CatCTup * members[FLEXIBLE_ARRAY_MEMBER]
Definition: catcache.h:185
int n_members
Definition: catcache.h:183
HeapTupleData tuple
Definition: catcache.h:124
Oid attType
Definition: spgist.h:38
Oid leafType
Definition: spgist.h:45
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:264
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:220
#define SearchSysCacheList1(cacheId, key1)
Definition: syscache.h:127

References spgConfigIn::attType, check_amop_signature(), check_amoptsproc_signature(), check_amproc_signature(), elog, ereport, errcode(), errmsg(), ERROR, format_operator(), format_procedure(), format_type_be(), OpFamilyOpFuncGroup::functionset, get_op_rettype(), get_opfamily_name(), GETSTRUCT(), HeapTupleIsValid, i, identify_opfamily_groups(), INFO, InvalidOid, spgConfigOut::leafType, OpFamilyOpFuncGroup::lefttype, lfirst, catclist::members, catclist::n_members, NameStr, ObjectIdGetDatum(), OidFunctionCall2, OidIsValid, OpFamilyOpFuncGroup::operatorset, opfamily_can_sort_type(), PointerGetDatum(), ReleaseCatCacheList(), ReleaseSysCache(), OpFamilyOpFuncGroup::righttype, SearchSysCache1(), SearchSysCacheList1, SPGIST_CHOOSE_PROC, SPGIST_COMPRESS_PROC, SPGIST_CONFIG_PROC, SPGIST_INNER_CONSISTENT_PROC, SPGIST_LEAF_CONSISTENT_PROC, SPGIST_OPTIONS_PROC, SPGIST_PICKSPLIT_PROC, SPGISTNProc, and catctup::tuple.

Referenced by spghandler().

AltStyle によって変換されたページ (->オリジナル) /