PostgreSQL Source Code  git master
spgutils.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * spgutils.c
4  * various support functions for SP-GiST
5  *
6  *
7  * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
8  * Portions Copyright (c) 1994, Regents of the University of California
9  *
10  * IDENTIFICATION
11  * src/backend/access/spgist/spgutils.c
12  *
13  *-------------------------------------------------------------------------
14  */
15 
16 #include "postgres.h"
17 
18 #include "access/amvalidate.h"
19 #include "access/htup_details.h"
20 #include "access/reloptions.h"
21 #include "access/spgist_private.h"
23 #include "access/transam.h"
24 #include "access/xact.h"
25 #include "catalog/pg_amop.h"
26 #include "commands/vacuum.h"
27 #include "nodes/nodeFuncs.h"
28 #include "parser/parse_coerce.h"
29 #include "storage/bufmgr.h"
30 #include "storage/indexfsm.h"
31 #include "storage/lmgr.h"
32 #include "utils/builtins.h"
33 #include "utils/catcache.h"
34 #include "utils/index_selfuncs.h"
35 #include "utils/lsyscache.h"
36 #include "utils/syscache.h"
37 
38 
39 /*
40  * SP-GiST handler function: return IndexAmRoutine with access method parameters
41  * and callbacks.
42  */
43 Datum
45 {
47 
48  amroutine->amstrategies = 0;
49  amroutine->amsupport = SPGISTNProc;
51  amroutine->amcanorder = false;
52  amroutine->amcanorderbyop = true;
53  amroutine->amcanbackward = false;
54  amroutine->amcanunique = false;
55  amroutine->amcanmulticol = false;
56  amroutine->amoptionalkey = true;
57  amroutine->amsearcharray = false;
58  amroutine->amsearchnulls = true;
59  amroutine->amstorage = true;
60  amroutine->amclusterable = false;
61  amroutine->ampredlocks = false;
62  amroutine->amcanparallel = false;
63  amroutine->amcaninclude = true;
64  amroutine->amusemaintenanceworkmem = false;
65  amroutine->amparallelvacuumoptions =
67  amroutine->amkeytype = InvalidOid;
68 
69  amroutine->ambuild = spgbuild;
70  amroutine->ambuildempty = spgbuildempty;
71  amroutine->aminsert = spginsert;
72  amroutine->ambulkdelete = spgbulkdelete;
73  amroutine->amvacuumcleanup = spgvacuumcleanup;
74  amroutine->amcanreturn = spgcanreturn;
75  amroutine->amcostestimate = spgcostestimate;
76  amroutine->amoptions = spgoptions;
77  amroutine->amproperty = spgproperty;
78  amroutine->ambuildphasename = NULL;
79  amroutine->amvalidate = spgvalidate;
80  amroutine->amadjustmembers = spgadjustmembers;
81  amroutine->ambeginscan = spgbeginscan;
82  amroutine->amrescan = spgrescan;
83  amroutine->amgettuple = spggettuple;
84  amroutine->amgetbitmap = spggetbitmap;
85  amroutine->amendscan = spgendscan;
86  amroutine->ammarkpos = NULL;
87  amroutine->amrestrpos = NULL;
88  amroutine->amestimateparallelscan = NULL;
89  amroutine->aminitparallelscan = NULL;
90  amroutine->amparallelrescan = NULL;
91 
92  PG_RETURN_POINTER(amroutine);
93 }
94 
95 /*
96  * GetIndexInputType
97  * Determine the nominal input data type for an index column
98  *
99  * We define the "nominal" input type as the associated opclass's opcintype,
100  * or if that is a polymorphic type, the base type of the heap column or
101  * expression that is the index's input. The reason for preferring the
102  * opcintype is that non-polymorphic opclasses probably don't want to hear
103  * about binary-compatible input types. For instance, if a text opclass
104  * is being used with a varchar heap column, we want to report "text" not
105  * "varchar". Likewise, opclasses don't want to hear about domain types,
106  * so if we do consult the actual input type, we make sure to flatten domains.
107  *
108  * At some point maybe this should go somewhere else, but it's not clear
109  * if any other index AMs have a use for it.
110  */
111 static Oid
113 {
114  Oid opcintype;
115  AttrNumber heapcol;
116  List *indexprs;
117  ListCell *indexpr_item;
118 
119  Assert(index->rd_index != NULL);
120  Assert(indexcol > 0 && indexcol <= index->rd_index->indnkeyatts);
121  opcintype = index->rd_opcintype[indexcol - 1];
122  if (!IsPolymorphicType(opcintype))
123  return opcintype;
124  heapcol = index->rd_index->indkey.values[indexcol - 1];
125  if (heapcol != 0) /* Simple index column? */
126  return getBaseType(get_atttype(index->rd_index->indrelid, heapcol));
127 
128  /*
129  * If the index expressions are already cached, skip calling
130  * RelationGetIndexExpressions, as it will make a copy which is overkill.
131  * We're not going to modify the trees, and we're not going to do anything
132  * that would invalidate the relcache entry before we're done.
133  */
134  if (index->rd_indexprs)
135  indexprs = index->rd_indexprs;
136  else
138  indexpr_item = list_head(indexprs);
139  for (int i = 1; i <= index->rd_index->indnkeyatts; i++)
140  {
141  if (index->rd_index->indkey.values[i - 1] == 0)
142  {
143  /* expression column */
144  if (indexpr_item == NULL)
145  elog(ERROR, "wrong number of index expressions");
146  if (i == indexcol)
147  return getBaseType(exprType((Node *) lfirst(indexpr_item)));
148  indexpr_item = lnext(indexprs, indexpr_item);
149  }
150  }
151  elog(ERROR, "wrong number of index expressions");
152  return InvalidOid; /* keep compiler quiet */
153 }
154 
155 /* Fill in a SpGistTypeDesc struct with info about the specified data type */
156 static void
158 {
159  HeapTuple tp;
160  Form_pg_type typtup;
161 
162  desc->type = type;
164  if (!HeapTupleIsValid(tp))
165  elog(ERROR, "cache lookup failed for type %u", type);
166  typtup = (Form_pg_type) GETSTRUCT(tp);
167  desc->attlen = typtup->typlen;
168  desc->attbyval = typtup->typbyval;
169  desc->attalign = typtup->typalign;
170  desc->attstorage = typtup->typstorage;
171  ReleaseSysCache(tp);
172 }
173 
174 /*
175  * Fetch local cache of AM-specific info about the index, initializing it
176  * if necessary
177  */
178 SpGistCache *
180 {
181  SpGistCache *cache;
182 
183  if (index->rd_amcache == NULL)
184  {
185  Oid atttype;
186  spgConfigIn in;
187  FmgrInfo *procinfo;
188  Buffer metabuffer;
189  SpGistMetaPageData *metadata;
190 
191  cache = MemoryContextAllocZero(index->rd_indexcxt,
192  sizeof(SpGistCache));
193 
194  /* SPGiST must have one key column and can also have INCLUDE columns */
197 
198  /*
199  * Get the actual (well, nominal) data type of the key column. We
200  * pass this to the opclass config function so that polymorphic
201  * opclasses are possible.
202  */
203  atttype = GetIndexInputType(index, spgKeyColumn + 1);
204 
205  /* Call the config function to get config info for the opclass */
206  in.attType = atttype;
207 
209  FunctionCall2Coll(procinfo,
210  index->rd_indcollation[spgKeyColumn],
211  PointerGetDatum(&in),
212  PointerGetDatum(&cache->config));
213 
214  /*
215  * If leafType isn't specified, use the declared index column type,
216  * which index.c will have derived from the opclass's opcintype.
217  * (Although we now make spgvalidate.c warn if these aren't the same,
218  * old user-defined opclasses may not set the STORAGE parameter
219  * correctly, so believe leafType if it's given.)
220  */
221  if (!OidIsValid(cache->config.leafType))
222  {
223  cache->config.leafType =
225 
226  /*
227  * If index column type is binary-coercible to atttype (for
228  * example, it's a domain over atttype), treat it as plain atttype
229  * to avoid thinking we need to compress.
230  */
231  if (cache->config.leafType != atttype &&
232  IsBinaryCoercible(cache->config.leafType, atttype))
233  cache->config.leafType = atttype;
234  }
235 
236  /* Get the information we need about each relevant datatype */
237  fillTypeDesc(&cache->attType, atttype);
238 
239  if (cache->config.leafType != atttype)
240  {
242  ereport(ERROR,
243  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
244  errmsg("compress method must be defined when leaf type is different from input type")));
245 
246  fillTypeDesc(&cache->attLeafType, cache->config.leafType);
247  }
248  else
249  {
250  /* Save lookups in this common case */
251  cache->attLeafType = cache->attType;
252  }
253 
254  fillTypeDesc(&cache->attPrefixType, cache->config.prefixType);
255  fillTypeDesc(&cache->attLabelType, cache->config.labelType);
256 
257  /* Last, get the lastUsedPages data from the metapage */
258  metabuffer = ReadBuffer(index, SPGIST_METAPAGE_BLKNO);
259  LockBuffer(metabuffer, BUFFER_LOCK_SHARE);
260 
261  metadata = SpGistPageGetMeta(BufferGetPage(metabuffer));
262 
263  if (metadata->magicNumber != SPGIST_MAGIC_NUMBER)
264  elog(ERROR, "index \"%s\" is not an SP-GiST index",
266 
267  cache->lastUsedPages = metadata->lastUsedPages;
268 
269  UnlockReleaseBuffer(metabuffer);
270 
271  index->rd_amcache = (void *) cache;
272  }
273  else
274  {
275  /* assume it's up to date */
276  cache = (SpGistCache *) index->rd_amcache;
277  }
278 
279  return cache;
280 }
281 
282 /*
283  * Compute a tuple descriptor for leaf tuples or index-only-scan result tuples.
284  *
285  * We can use the relcache's tupdesc as-is in many cases, and it's always
286  * OK so far as any INCLUDE columns are concerned. However, the entry for
287  * the key column has to match leafType in the first case or attType in the
288  * second case. While the relcache's tupdesc *should* show leafType, this
289  * might not hold for legacy user-defined opclasses, since before v14 they
290  * were not allowed to declare their true storage type in CREATE OPCLASS.
291  * Also, attType can be different from what is in the relcache.
292  *
293  * This function gives back either a pointer to the relcache's tupdesc
294  * if that is suitable, or a palloc'd copy that's been adjusted to match
295  * the specified key column type. We can avoid doing any catalog lookups
296  * here by insisting that the caller pass an SpGistTypeDesc not just an OID.
297  */
298 TupleDesc
300 {
301  TupleDesc outTupDesc;
302  Form_pg_attribute att;
303 
304  if (keyType->type ==
306  outTupDesc = RelationGetDescr(index);
307  else
308  {
310  att = TupleDescAttr(outTupDesc, spgKeyColumn);
311  /* It's sufficient to update the type-dependent fields of the column */
312  att->atttypid = keyType->type;
313  att->atttypmod = -1;
314  att->attlen = keyType->attlen;
315  att->attbyval = keyType->attbyval;
316  att->attalign = keyType->attalign;
317  att->attstorage = keyType->attstorage;
318  /* We shouldn't need to bother with making these valid: */
319  att->attcompression = InvalidCompressionMethod;
320  att->attcollation = InvalidOid;
321  /* In case we changed typlen, we'd better reset following offsets */
322  for (int i = spgFirstIncludeColumn; i < outTupDesc->natts; i++)
323  TupleDescAttr(outTupDesc, i)->attcacheoff = -1;
324  }
325  return outTupDesc;
326 }
327 
328 /* Initialize SpGistState for working with the given index */
329 void
331 {
332  SpGistCache *cache;
333 
334  state->index = index;
335 
336  /* Get cached static information about index */
337  cache = spgGetCache(index);
338 
339  state->config = cache->config;
340  state->attType = cache->attType;
341  state->attLeafType = cache->attLeafType;
342  state->attPrefixType = cache->attPrefixType;
343  state->attLabelType = cache->attLabelType;
344 
345  /* Ensure we have a valid descriptor for leaf tuples */
346  state->leafTupDesc = getSpGistTupleDesc(state->index, &state->attLeafType);
347 
348  /* Make workspace for constructing dead tuples */
349  state->deadTupleStorage = palloc0(SGDTSIZE);
350 
351  /* Set XID to use in redirection tuples */
352  state->myXid = GetTopTransactionIdIfAny();
353 
354  /* Assume we're not in an index build (spgbuild will override) */
355  state->isBuild = false;
356 }
357 
358 /*
359  * Allocate a new page (either by recycling, or by extending the index file).
360  *
361  * The returned buffer is already pinned and exclusive-locked.
362  * Caller is responsible for initializing the page by calling SpGistInitBuffer.
363  */
364 Buffer
366 {
367  Buffer buffer;
368  bool needLock;
369 
370  /* First, try to get a page from FSM */
371  for (;;)
372  {
374 
375  if (blkno == InvalidBlockNumber)
376  break; /* nothing known to FSM */
377 
378  /*
379  * The fixed pages shouldn't ever be listed in FSM, but just in case
380  * one is, ignore it.
381  */
382  if (SpGistBlockIsFixed(blkno))
383  continue;
384 
385  buffer = ReadBuffer(index, blkno);
386 
387  /*
388  * We have to guard against the possibility that someone else already
389  * recycled this page; the buffer may be locked if so.
390  */
391  if (ConditionalLockBuffer(buffer))
392  {
393  Page page = BufferGetPage(buffer);
394 
395  if (PageIsNew(page))
396  return buffer; /* OK to use, if never initialized */
397 
398  if (SpGistPageIsDeleted(page) || PageIsEmpty(page))
399  return buffer; /* OK to use */
400 
402  }
403 
404  /* Can't use it, so release buffer and try again */
405  ReleaseBuffer(buffer);
406  }
407 
408  /* Must extend the file */
409  needLock = !RELATION_IS_LOCAL(index);
410  if (needLock)
412 
413  buffer = ReadBuffer(index, P_NEW);
415 
416  if (needLock)
418 
419  return buffer;
420 }
421 
422 /*
423  * Update index metapage's lastUsedPages info from local cache, if possible
424  *
425  * Updating meta page isn't critical for index working, so
426  * 1 use ConditionalLockBuffer to improve concurrency
427  * 2 don't WAL-log metabuffer changes to decrease WAL traffic
428  */
429 void
431 {
432  SpGistCache *cache = (SpGistCache *) index->rd_amcache;
433 
434  if (cache != NULL)
435  {
436  Buffer metabuffer;
437 
438  metabuffer = ReadBuffer(index, SPGIST_METAPAGE_BLKNO);
439 
440  if (ConditionalLockBuffer(metabuffer))
441  {
442  Page metapage = BufferGetPage(metabuffer);
443  SpGistMetaPageData *metadata = SpGistPageGetMeta(metapage);
444 
445  metadata->lastUsedPages = cache->lastUsedPages;
446 
447  /*
448  * Set pd_lower just past the end of the metadata. This is
449  * essential, because without doing so, metadata will be lost if
450  * xlog.c compresses the page. (We must do this here because
451  * pre-v11 versions of PG did not set the metapage's pd_lower
452  * correctly, so a pg_upgraded index might contain the wrong
453  * value.)
454  */
455  ((PageHeader) metapage)->pd_lower =
456  ((char *) metadata + sizeof(SpGistMetaPageData)) - (char *) metapage;
457 
458  MarkBufferDirty(metabuffer);
459  UnlockReleaseBuffer(metabuffer);
460  }
461  else
462  {
463  ReleaseBuffer(metabuffer);
464  }
465  }
466 }
467 
468 /* Macro to select proper element of lastUsedPages cache depending on flags */
469 /* Masking flags with SPGIST_CACHED_PAGES is just for paranoia's sake */
470 #define GET_LUP(c, f) (&(c)->lastUsedPages.cachedPage[((unsigned int) (f)) % SPGIST_CACHED_PAGES])
471 
472 /*
473  * Allocate and initialize a new buffer of the type and parity specified by
474  * flags. The returned buffer is already pinned and exclusive-locked.
475  *
476  * When requesting an inner page, if we get one with the wrong parity,
477  * we just release the buffer and try again. We will get a different page
478  * because GetFreeIndexPage will have marked the page used in FSM. The page
479  * is entered in our local lastUsedPages cache, so there's some hope of
480  * making use of it later in this session, but otherwise we rely on VACUUM
481  * to eventually re-enter the page in FSM, making it available for recycling.
482  * Note that such a page does not get marked dirty here, so unless it's used
483  * fairly soon, the buffer will just get discarded and the page will remain
484  * as it was on disk.
485  *
486  * When we return a buffer to the caller, the page is *not* entered into
487  * the lastUsedPages cache; we expect the caller will do so after it's taken
488  * whatever space it will use. This is because after the caller has used up
489  * some space, the page might have less space than whatever was cached already
490  * so we'd rather not trash the old cache entry.
491  */
492 static Buffer
494 {
495  SpGistCache *cache = spgGetCache(index);
496  uint16 pageflags = 0;
497 
498  if (GBUF_REQ_LEAF(flags))
499  pageflags |= SPGIST_LEAF;
500  if (GBUF_REQ_NULLS(flags))
501  pageflags |= SPGIST_NULLS;
502 
503  for (;;)
504  {
505  Buffer buffer;
506 
507  buffer = SpGistNewBuffer(index);
508  SpGistInitBuffer(buffer, pageflags);
509 
510  if (pageflags & SPGIST_LEAF)
511  {
512  /* Leaf pages have no parity concerns, so just use it */
513  return buffer;
514  }
515  else
516  {
517  BlockNumber blkno = BufferGetBlockNumber(buffer);
518  int blkFlags = GBUF_INNER_PARITY(blkno);
519 
520  if ((flags & GBUF_PARITY_MASK) == blkFlags)
521  {
522  /* Page has right parity, use it */
523  return buffer;
524  }
525  else
526  {
527  /* Page has wrong parity, record it in cache and try again */
528  if (pageflags & SPGIST_NULLS)
529  blkFlags |= GBUF_NULLS;
530  cache->lastUsedPages.cachedPage[blkFlags].blkno = blkno;
531  cache->lastUsedPages.cachedPage[blkFlags].freeSpace =
533  UnlockReleaseBuffer(buffer);
534  }
535  }
536  }
537 }
538 
539 /*
540  * Get a buffer of the type and parity specified by flags, having at least
541  * as much free space as indicated by needSpace. We use the lastUsedPages
542  * cache to assign the same buffer previously requested when possible.
543  * The returned buffer is already pinned and exclusive-locked.
544  *
545  * *isNew is set true if the page was initialized here, false if it was
546  * already valid.
547  */
548 Buffer
549 SpGistGetBuffer(Relation index, int flags, int needSpace, bool *isNew)
550 {
551  SpGistCache *cache = spgGetCache(index);
552  SpGistLastUsedPage *lup;
553 
554  /* Bail out if even an empty page wouldn't meet the demand */
555  if (needSpace > SPGIST_PAGE_CAPACITY)
556  elog(ERROR, "desired SPGiST tuple size is too big");
557 
558  /*
559  * If possible, increase the space request to include relation's
560  * fillfactor. This ensures that when we add unrelated tuples to a page,
561  * we try to keep 100-fillfactor% available for adding tuples that are
562  * related to the ones already on it. But fillfactor mustn't cause an
563  * error for requests that would otherwise be legal.
564  */
565  needSpace += SpGistGetTargetPageFreeSpace(index);
566  needSpace = Min(needSpace, SPGIST_PAGE_CAPACITY);
567 
568  /* Get the cache entry for this flags setting */
569  lup = GET_LUP(cache, flags);
570 
571  /* If we have nothing cached, just turn it over to allocNewBuffer */
572  if (lup->blkno == InvalidBlockNumber)
573  {
574  *isNew = true;
575  return allocNewBuffer(index, flags);
576  }
577 
578  /* fixed pages should never be in cache */
580 
581  /* If cached freeSpace isn't enough, don't bother looking at the page */
582  if (lup->freeSpace >= needSpace)
583  {
584  Buffer buffer;
585  Page page;
586 
587  buffer = ReadBuffer(index, lup->blkno);
588 
589  if (!ConditionalLockBuffer(buffer))
590  {
591  /*
592  * buffer is locked by another process, so return a new buffer
593  */
594  ReleaseBuffer(buffer);
595  *isNew = true;
596  return allocNewBuffer(index, flags);
597  }
598 
599  page = BufferGetPage(buffer);
600 
601  if (PageIsNew(page) || SpGistPageIsDeleted(page) || PageIsEmpty(page))
602  {
603  /* OK to initialize the page */
604  uint16 pageflags = 0;
605 
606  if (GBUF_REQ_LEAF(flags))
607  pageflags |= SPGIST_LEAF;
608  if (GBUF_REQ_NULLS(flags))
609  pageflags |= SPGIST_NULLS;
610  SpGistInitBuffer(buffer, pageflags);
611  lup->freeSpace = PageGetExactFreeSpace(page) - needSpace;
612  *isNew = true;
613  return buffer;
614  }
615 
616  /*
617  * Check that page is of right type and has enough space. We must
618  * recheck this since our cache isn't necessarily up to date.
619  */
620  if ((GBUF_REQ_LEAF(flags) ? SpGistPageIsLeaf(page) : !SpGistPageIsLeaf(page)) &&
622  {
623  int freeSpace = PageGetExactFreeSpace(page);
624 
625  if (freeSpace >= needSpace)
626  {
627  /* Success, update freespace info and return the buffer */
628  lup->freeSpace = freeSpace - needSpace;
629  *isNew = false;
630  return buffer;
631  }
632  }
633 
634  /*
635  * fallback to allocation of new buffer
636  */
637  UnlockReleaseBuffer(buffer);
638  }
639 
640  /* No success with cache, so return a new buffer */
641  *isNew = true;
642  return allocNewBuffer(index, flags);
643 }
644 
645 /*
646  * Update lastUsedPages cache when done modifying a page.
647  *
648  * We update the appropriate cache entry if it already contained this page
649  * (its freeSpace is likely obsolete), or if this page has more space than
650  * whatever we had cached.
651  */
652 void
654 {
655  SpGistCache *cache = spgGetCache(index);
656  SpGistLastUsedPage *lup;
657  int freeSpace;
658  Page page = BufferGetPage(buffer);
659  BlockNumber blkno = BufferGetBlockNumber(buffer);
660  int flags;
661 
662  /* Never enter fixed pages (root pages) in cache, though */
663  if (SpGistBlockIsFixed(blkno))
664  return;
665 
666  if (SpGistPageIsLeaf(page))
667  flags = GBUF_LEAF;
668  else
669  flags = GBUF_INNER_PARITY(blkno);
670  if (SpGistPageStoresNulls(page))
671  flags |= GBUF_NULLS;
672 
673  lup = GET_LUP(cache, flags);
674 
675  freeSpace = PageGetExactFreeSpace(page);
676  if (lup->blkno == InvalidBlockNumber || lup->blkno == blkno ||
677  lup->freeSpace < freeSpace)
678  {
679  lup->blkno = blkno;
680  lup->freeSpace = freeSpace;
681  }
682 }
683 
684 /*
685  * Initialize an SPGiST page to empty, with specified flags
686  */
687 void
689 {
690  SpGistPageOpaque opaque;
691 
692  PageInit(page, BLCKSZ, sizeof(SpGistPageOpaqueData));
693  opaque = SpGistPageGetOpaque(page);
694  opaque->flags = f;
695  opaque->spgist_page_id = SPGIST_PAGE_ID;
696 }
697 
698 /*
699  * Initialize a buffer's page to empty, with specified flags
700  */
701 void
703 {
704  Assert(BufferGetPageSize(b) == BLCKSZ);
706 }
707 
708 /*
709  * Initialize metadata page
710  */
711 void
713 {
714  SpGistMetaPageData *metadata;
715  int i;
716 
718  metadata = SpGistPageGetMeta(page);
719  memset(metadata, 0, sizeof(SpGistMetaPageData));
720  metadata->magicNumber = SPGIST_MAGIC_NUMBER;
721 
722  /* initialize last-used-page cache to empty */
723  for (i = 0; i < SPGIST_CACHED_PAGES; i++)
725 
726  /*
727  * Set pd_lower just past the end of the metadata. This is essential,
728  * because without doing so, metadata will be lost if xlog.c compresses
729  * the page.
730  */
731  ((PageHeader) page)->pd_lower =
732  ((char *) metadata + sizeof(SpGistMetaPageData)) - (char *) page;
733 }
734 
735 /*
736  * reloptions processing for SPGiST
737  */
738 bytea *
739 spgoptions(Datum reloptions, bool validate)
740 {
741  static const relopt_parse_elt tab[] = {
742  {"fillfactor", RELOPT_TYPE_INT, offsetof(SpGistOptions, fillfactor)},
743  };
744 
745  return (bytea *) build_reloptions(reloptions, validate,
747  sizeof(SpGistOptions),
748  tab, lengthof(tab));
749 }
750 
751 /*
752  * Get the space needed to store a non-null datum of the indicated type
753  * in an inner tuple (that is, as a prefix or node label).
754  * Note the result is already rounded up to a MAXALIGN boundary.
755  * Here we follow the convention that pass-by-val types are just stored
756  * in their Datum representation (compare memcpyInnerDatum).
757  */
758 unsigned int
760 {
761  unsigned int size;
762 
763  if (att->attbyval)
764  size = sizeof(Datum);
765  else if (att->attlen > 0)
766  size = att->attlen;
767  else
768  size = VARSIZE_ANY(datum);
769 
770  return MAXALIGN(size);
771 }
772 
773 /*
774  * Copy the given non-null datum to *target, in the inner-tuple case
775  */
776 static void
777 memcpyInnerDatum(void *target, SpGistTypeDesc *att, Datum datum)
778 {
779  unsigned int size;
780 
781  if (att->attbyval)
782  {
783  memcpy(target, &datum, sizeof(Datum));
784  }
785  else
786  {
787  size = (att->attlen > 0) ? att->attlen : VARSIZE_ANY(datum);
788  memcpy(target, DatumGetPointer(datum), size);
789  }
790 }
791 
792 /*
793  * Compute space required for a leaf tuple holding the given data.
794  *
795  * This must match the size-calculation portion of spgFormLeafTuple.
796  */
797 Size
799  Datum *datums, bool *isnulls)
800 {
801  Size size;
802  Size data_size;
803  bool needs_null_mask = false;
804  int natts = tupleDescriptor->natts;
805 
806  /*
807  * Decide whether we need a nulls bitmask.
808  *
809  * If there is only a key attribute (natts == 1), never use a bitmask, for
810  * compatibility with the pre-v14 layout of leaf tuples. Otherwise, we
811  * need one if any attribute is null.
812  */
813  if (natts > 1)
814  {
815  for (int i = 0; i < natts; i++)
816  {
817  if (isnulls[i])
818  {
819  needs_null_mask = true;
820  break;
821  }
822  }
823  }
824 
825  /*
826  * Calculate size of the data part; same as for heap tuples.
827  */
828  data_size = heap_compute_data_size(tupleDescriptor, datums, isnulls);
829 
830  /*
831  * Compute total size.
832  */
833  size = SGLTHDRSZ(needs_null_mask);
834  size += data_size;
835  size = MAXALIGN(size);
836 
837  /*
838  * Ensure that we can replace the tuple with a dead tuple later. This test
839  * is unnecessary when there are any non-null attributes, but be safe.
840  */
841  if (size < SGDTSIZE)
842  size = SGDTSIZE;
843 
844  return size;
845 }
846 
847 /*
848  * Construct a leaf tuple containing the given heap TID and datum values
849  */
852  Datum *datums, bool *isnulls)
853 {
854  SpGistLeafTuple tup;
855  TupleDesc tupleDescriptor = state->leafTupDesc;
856  Size size;
857  Size hoff;
858  Size data_size;
859  bool needs_null_mask = false;
860  int natts = tupleDescriptor->natts;
861  char *tp; /* ptr to tuple data */
862  uint16 tupmask = 0; /* unused heap_fill_tuple output */
863 
864  /*
865  * Decide whether we need a nulls bitmask.
866  *
867  * If there is only a key attribute (natts == 1), never use a bitmask, for
868  * compatibility with the pre-v14 layout of leaf tuples. Otherwise, we
869  * need one if any attribute is null.
870  */
871  if (natts > 1)
872  {
873  for (int i = 0; i < natts; i++)
874  {
875  if (isnulls[i])
876  {
877  needs_null_mask = true;
878  break;
879  }
880  }
881  }
882 
883  /*
884  * Calculate size of the data part; same as for heap tuples.
885  */
886  data_size = heap_compute_data_size(tupleDescriptor, datums, isnulls);
887 
888  /*
889  * Compute total size.
890  */
891  hoff = SGLTHDRSZ(needs_null_mask);
892  size = hoff + data_size;
893  size = MAXALIGN(size);
894 
895  /*
896  * Ensure that we can replace the tuple with a dead tuple later. This test
897  * is unnecessary when there are any non-null attributes, but be safe.
898  */
899  if (size < SGDTSIZE)
900  size = SGDTSIZE;
901 
902  /* OK, form the tuple */
903  tup = (SpGistLeafTuple) palloc0(size);
904 
905  tup->size = size;
907  tup->heapPtr = *heapPtr;
908 
909  tp = (char *) tup + hoff;
910 
911  if (needs_null_mask)
912  {
913  bits8 *bp; /* ptr to null bitmap in tuple */
914 
915  /* Set nullmask presence bit in SpGistLeafTuple header */
916  SGLT_SET_HASNULLMASK(tup, true);
917  /* Fill the data area and null mask */
918  bp = (bits8 *) ((char *) tup + sizeof(SpGistLeafTupleData));
919  heap_fill_tuple(tupleDescriptor, datums, isnulls, tp, data_size,
920  &tupmask, bp);
921  }
922  else if (natts > 1 || !isnulls[spgKeyColumn])
923  {
924  /* Fill data area only */
925  heap_fill_tuple(tupleDescriptor, datums, isnulls, tp, data_size,
926  &tupmask, (bits8 *) NULL);
927  }
928  /* otherwise we have no data, nor a bitmap, to fill */
929 
930  return tup;
931 }
932 
933 /*
934  * Construct a node (to go into an inner tuple) containing the given label
935  *
936  * Note that the node's downlink is just set invalid here. Caller will fill
937  * it in later.
938  */
941 {
942  SpGistNodeTuple tup;
943  unsigned int size;
944  unsigned short infomask = 0;
945 
946  /* compute space needed (note result is already maxaligned) */
947  size = SGNTHDRSZ;
948  if (!isnull)
949  size += SpGistGetInnerTypeSize(&state->attLabelType, label);
950 
951  /*
952  * Here we make sure that the size will fit in the field reserved for it
953  * in t_info.
954  */
955  if ((size & INDEX_SIZE_MASK) != size)
956  ereport(ERROR,
957  (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
958  errmsg("index row requires %zu bytes, maximum size is %zu",
959  (Size) size, (Size) INDEX_SIZE_MASK)));
960 
961  tup = (SpGistNodeTuple) palloc0(size);
962 
963  if (isnull)
964  infomask |= INDEX_NULL_MASK;
965  /* we don't bother setting the INDEX_VAR_MASK bit */
966  infomask |= size;
967  tup->t_info = infomask;
968 
969  /* The TID field will be filled in later */
971 
972  if (!isnull)
973  memcpyInnerDatum(SGNTDATAPTR(tup), &state->attLabelType, label);
974 
975  return tup;
976 }
977 
978 /*
979  * Construct an inner tuple containing the given prefix and node array
980  */
982 spgFormInnerTuple(SpGistState *state, bool hasPrefix, Datum prefix,
983  int nNodes, SpGistNodeTuple *nodes)
984 {
985  SpGistInnerTuple tup;
986  unsigned int size;
987  unsigned int prefixSize;
988  int i;
989  char *ptr;
990 
991  /* Compute size needed */
992  if (hasPrefix)
993  prefixSize = SpGistGetInnerTypeSize(&state->attPrefixType, prefix);
994  else
995  prefixSize = 0;
996 
997  size = SGITHDRSZ + prefixSize;
998 
999  /* Note: we rely on node tuple sizes to be maxaligned already */
1000  for (i = 0; i < nNodes; i++)
1001  size += IndexTupleSize(nodes[i]);
1002 
1003  /*
1004  * Ensure that we can replace the tuple with a dead tuple later. This
1005  * test is unnecessary given current tuple layouts, but let's be safe.
1006  */
1007  if (size < SGDTSIZE)
1008  size = SGDTSIZE;
1009 
1010  /*
1011  * Inner tuple should be small enough to fit on a page
1012  */
1013  if (size > SPGIST_PAGE_CAPACITY - sizeof(ItemIdData))
1014  ereport(ERROR,
1015  (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1016  errmsg("SP-GiST inner tuple size %zu exceeds maximum %zu",
1017  (Size) size,
1018  SPGIST_PAGE_CAPACITY - sizeof(ItemIdData)),
1019  errhint("Values larger than a buffer page cannot be indexed.")));
1020 
1021  /*
1022  * Check for overflow of header fields --- probably can't fail if the
1023  * above succeeded, but let's be paranoid
1024  */
1025  if (size > SGITMAXSIZE ||
1026  prefixSize > SGITMAXPREFIXSIZE ||
1027  nNodes > SGITMAXNNODES)
1028  elog(ERROR, "SPGiST inner tuple header field is too small");
1029 
1030  /* OK, form the tuple */
1031  tup = (SpGistInnerTuple) palloc0(size);
1032 
1033  tup->nNodes = nNodes;
1034  tup->prefixSize = prefixSize;
1035  tup->size = size;
1036 
1037  if (hasPrefix)
1038  memcpyInnerDatum(SGITDATAPTR(tup), &state->attPrefixType, prefix);
1039 
1040  ptr = (char *) SGITNODEPTR(tup);
1041 
1042  for (i = 0; i < nNodes; i++)
1043  {
1044  SpGistNodeTuple node = nodes[i];
1045 
1046  memcpy(ptr, node, IndexTupleSize(node));
1047  ptr += IndexTupleSize(node);
1048  }
1049 
1050  return tup;
1051 }
1052 
1053 /*
1054  * Construct a "dead" tuple to replace a tuple being deleted.
1055  *
1056  * The state can be SPGIST_REDIRECT, SPGIST_DEAD, or SPGIST_PLACEHOLDER.
1057  * For a REDIRECT tuple, a pointer (blkno+offset) must be supplied, and
1058  * the xid field is filled in automatically.
1059  *
1060  * This is called in critical sections, so we don't use palloc; the tuple
1061  * is built in preallocated storage. It should be copied before another
1062  * call with different parameters can occur.
1063  */
1066  BlockNumber blkno, OffsetNumber offnum)
1067 {
1068  SpGistDeadTuple tuple = (SpGistDeadTuple) state->deadTupleStorage;
1069 
1070  tuple->tupstate = tupstate;
1071  tuple->size = SGDTSIZE;
1073 
1074  if (tupstate == SPGIST_REDIRECT)
1075  {
1076  ItemPointerSet(&tuple->pointer, blkno, offnum);
1078  tuple->xid = state->myXid;
1079  }
1080  else
1081  {
1082  ItemPointerSetInvalid(&tuple->pointer);
1083  tuple->xid = InvalidTransactionId;
1084  }
1085 
1086  return tuple;
1087 }
1088 
1089 /*
1090  * Convert an SPGiST leaf tuple into Datum/isnull arrays.
1091  *
1092  * The caller must allocate sufficient storage for the output arrays.
1093  * (INDEX_MAX_KEYS entries should be enough.)
1094  */
1095 void
1097  Datum *datums, bool *isnulls, bool keyColumnIsNull)
1098 {
1099  bool hasNullsMask = SGLT_GET_HASNULLMASK(tup);
1100  char *tp; /* ptr to tuple data */
1101  bits8 *bp; /* ptr to null bitmap in tuple */
1102 
1103  if (keyColumnIsNull && tupleDescriptor->natts == 1)
1104  {
1105  /*
1106  * Trivial case: there is only the key attribute and we're in a nulls
1107  * tree. The hasNullsMask bit in the tuple header should not be set
1108  * (and thus we can't use index_deform_tuple_internal), but
1109  * nonetheless the result is NULL.
1110  *
1111  * Note: currently this is dead code, because noplace calls this when
1112  * there is only the key attribute. But we should cover the case.
1113  */
1114  Assert(!hasNullsMask);
1115 
1116  datums[spgKeyColumn] = (Datum) 0;
1117  isnulls[spgKeyColumn] = true;
1118  return;
1119  }
1120 
1121  tp = (char *) tup + SGLTHDRSZ(hasNullsMask);
1122  bp = (bits8 *) ((char *) tup + sizeof(SpGistLeafTupleData));
1123 
1124  index_deform_tuple_internal(tupleDescriptor,
1125  datums, isnulls,
1126  tp, bp, hasNullsMask);
1127 
1128  /*
1129  * Key column isnull value from the tuple should be consistent with
1130  * keyColumnIsNull flag from the caller.
1131  */
1132  Assert(keyColumnIsNull == isnulls[spgKeyColumn]);
1133 }
1134 
1135 /*
1136  * Extract the label datums of the nodes within innerTuple
1137  *
1138  * Returns NULL if label datums are NULLs
1139  */
1140 Datum *
1142 {
1143  Datum *nodeLabels;
1144  int i;
1145  SpGistNodeTuple node;
1146 
1147  /* Either all the labels must be NULL, or none. */
1148  node = SGITNODEPTR(innerTuple);
1149  if (IndexTupleHasNulls(node))
1150  {
1151  SGITITERATE(innerTuple, i, node)
1152  {
1153  if (!IndexTupleHasNulls(node))
1154  elog(ERROR, "some but not all node labels are null in SPGiST inner tuple");
1155  }
1156  /* They're all null, so just return NULL */
1157  return NULL;
1158  }
1159  else
1160  {
1161  nodeLabels = (Datum *) palloc(sizeof(Datum) * innerTuple->nNodes);
1162  SGITITERATE(innerTuple, i, node)
1163  {
1164  if (IndexTupleHasNulls(node))
1165  elog(ERROR, "some but not all node labels are null in SPGiST inner tuple");
1166  nodeLabels[i] = SGNTDATUM(node, state);
1167  }
1168  return nodeLabels;
1169  }
1170 }
1171 
1172 /*
1173  * Add a new item to the page, replacing a PLACEHOLDER item if possible.
1174  * Return the location it's inserted at, or InvalidOffsetNumber on failure.
1175  *
1176  * If startOffset isn't NULL, we start searching for placeholders at
1177  * *startOffset, and update that to the next place to search. This is just
1178  * an optimization for repeated insertions.
1179  *
1180  * If errorOK is false, we throw error when there's not enough room,
1181  * rather than returning InvalidOffsetNumber.
1182  */
1185  OffsetNumber *startOffset, bool errorOK)
1186 {
1187  SpGistPageOpaque opaque = SpGistPageGetOpaque(page);
1188  OffsetNumber i,
1189  maxoff,
1190  offnum;
1191 
1192  if (opaque->nPlaceholder > 0 &&
1193  PageGetExactFreeSpace(page) + SGDTSIZE >= MAXALIGN(size))
1194  {
1195  /* Try to replace a placeholder */
1196  maxoff = PageGetMaxOffsetNumber(page);
1197  offnum = InvalidOffsetNumber;
1198 
1199  for (;;)
1200  {
1201  if (startOffset && *startOffset != InvalidOffsetNumber)
1202  i = *startOffset;
1203  else
1204  i = FirstOffsetNumber;
1205  for (; i <= maxoff; i++)
1206  {
1208  PageGetItemId(page, i));
1209 
1210  if (it->tupstate == SPGIST_PLACEHOLDER)
1211  {
1212  offnum = i;
1213  break;
1214  }
1215  }
1216 
1217  /* Done if we found a placeholder */
1218  if (offnum != InvalidOffsetNumber)
1219  break;
1220 
1221  if (startOffset && *startOffset != InvalidOffsetNumber)
1222  {
1223  /* Hint was no good, re-search from beginning */
1224  *startOffset = InvalidOffsetNumber;
1225  continue;
1226  }
1227 
1228  /* Hmm, no placeholder found? */
1229  opaque->nPlaceholder = 0;
1230  break;
1231  }
1232 
1233  if (offnum != InvalidOffsetNumber)
1234  {
1235  /* Replace the placeholder tuple */
1236  PageIndexTupleDelete(page, offnum);
1237 
1238  offnum = PageAddItem(page, item, size, offnum, false, false);
1239 
1240  /*
1241  * We should not have failed given the size check at the top of
1242  * the function, but test anyway. If we did fail, we must PANIC
1243  * because we've already deleted the placeholder tuple, and
1244  * there's no other way to keep the damage from getting to disk.
1245  */
1246  if (offnum != InvalidOffsetNumber)
1247  {
1248  Assert(opaque->nPlaceholder > 0);
1249  opaque->nPlaceholder--;
1250  if (startOffset)
1251  *startOffset = offnum + 1;
1252  }
1253  else
1254  elog(PANIC, "failed to add item of size %zu to SPGiST index page",
1255  size);
1256 
1257  return offnum;
1258  }
1259  }
1260 
1261  /* No luck in replacing a placeholder, so just add it to the page */
1262  offnum = PageAddItem(page, item, size,
1263  InvalidOffsetNumber, false, false);
1264 
1265  if (offnum == InvalidOffsetNumber && !errorOK)
1266  elog(ERROR, "failed to add item of size %zu to SPGiST index page",
1267  size);
1268 
1269  return offnum;
1270 }
1271 
1272 /*
1273  * spgproperty() -- Check boolean properties of indexes.
1274  *
1275  * This is optional for most AMs, but is required for SP-GiST because the core
1276  * property code doesn't support AMPROP_DISTANCE_ORDERABLE.
1277  */
1278 bool
1279 spgproperty(Oid index_oid, int attno,
1280  IndexAMProperty prop, const char *propname,
1281  bool *res, bool *isnull)
1282 {
1283  Oid opclass,
1284  opfamily,
1285  opcintype;
1286  CatCList *catlist;
1287  int i;
1288 
1289  /* Only answer column-level inquiries */
1290  if (attno == 0)
1291  return false;
1292 
1293  switch (prop)
1294  {
1296  break;
1297  default:
1298  return false;
1299  }
1300 
1301  /*
1302  * Currently, SP-GiST distance-ordered scans require that there be a
1303  * distance operator in the opclass with the default types. So we assume
1304  * that if such a operator exists, then there's a reason for it.
1305  */
1306 
1307  /* First we need to know the column's opclass. */
1308  opclass = get_index_column_opclass(index_oid, attno);
1309  if (!OidIsValid(opclass))
1310  {
1311  *isnull = true;
1312  return true;
1313  }
1314 
1315  /* Now look up the opclass family and input datatype. */
1316  if (!get_opclass_opfamily_and_input_type(opclass, &opfamily, &opcintype))
1317  {
1318  *isnull = true;
1319  return true;
1320  }
1321 
1322  /* And now we can check whether the operator is provided. */
1324  ObjectIdGetDatum(opfamily));
1325 
1326  *res = false;
1327 
1328  for (i = 0; i < catlist->n_members; i++)
1329  {
1330  HeapTuple amoptup = &catlist->members[i]->tuple;
1331  Form_pg_amop amopform = (Form_pg_amop) GETSTRUCT(amoptup);
1332 
1333  if (amopform->amoppurpose == AMOP_ORDER &&
1334  (amopform->amoplefttype == opcintype ||
1335  amopform->amoprighttype == opcintype) &&
1336  opfamily_can_sort_type(amopform->amopsortfamily,
1337  get_op_rettype(amopform->amopopr)))
1338  {
1339  *res = true;
1340  break;
1341  }
1342  }
1343 
1344  ReleaseSysCacheList(catlist);
1345 
1346  *isnull = false;
1347 
1348  return true;
1349 }
IndexAMProperty
Definition: amapi.h:35
@ AMPROP_DISTANCE_ORDERABLE
Definition: amapi.h:42
bool opfamily_can_sort_type(Oid opfamilyoid, Oid datatypeoid)
Definition: amvalidate.c:271
int16 AttrNumber
Definition: attnum.h:21
uint32 BlockNumber
Definition: block.h:31
#define InvalidBlockNumber
Definition: block.h:33
int Buffer
Definition: buf.h:23
BlockNumber BufferGetBlockNumber(Buffer buffer)
Definition: bufmgr.c:2763
bool ConditionalLockBuffer(Buffer buffer)
Definition: bufmgr.c:4198
void ReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:3931
void UnlockReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:3954
void MarkBufferDirty(Buffer buffer)
Definition: bufmgr.c:1583
void LockBuffer(Buffer buffer, int mode)
Definition: bufmgr.c:4172
Buffer ReadBuffer(Relation reln, BlockNumber blockNum)
Definition: bufmgr.c:712
#define BUFFER_LOCK_UNLOCK
Definition: bufmgr.h:105
#define BUFFER_LOCK_SHARE
Definition: bufmgr.h:106
#define P_NEW
Definition: bufmgr.h:100
static Page BufferGetPage(Buffer buffer)
Definition: bufmgr.h:280
static Size BufferGetPageSize(Buffer buffer)
Definition: bufmgr.h:266
#define BUFFER_LOCK_EXCLUSIVE
Definition: bufmgr.h:107
void PageIndexTupleDelete(Page page, OffsetNumber offnum)
Definition: bufpage.c:1052
void PageInit(Page page, Size pageSize, Size specialSize)
Definition: bufpage.c:42
Size PageGetExactFreeSpace(Page page)
Definition: bufpage.c:958
PageHeaderData * PageHeader
Definition: bufpage.h:170
static bool PageIsEmpty(Page page)
Definition: bufpage.h:220
Pointer Page
Definition: bufpage.h:78
static Item PageGetItem(Page page, ItemId itemId)
Definition: bufpage.h:351
static ItemId PageGetItemId(Page page, OffsetNumber offsetNumber)
Definition: bufpage.h:240
static bool PageIsNew(Page page)
Definition: bufpage.h:230
static OffsetNumber PageGetMaxOffsetNumber(Page page)
Definition: bufpage.h:369
#define PageAddItem(page, item, size, offsetNumber, overwrite, is_heap)
Definition: bufpage.h:468
unsigned short uint16
Definition: c.h:441
#define Min(x, y)
Definition: c.h:937
#define MAXALIGN(LEN)
Definition: c.h:747
uint8 bits8
Definition: c.h:449
#define lengthof(array)
Definition: c.h:724
#define OidIsValid(objectId)
Definition: c.h:711
size_t Size
Definition: c.h:541
int errhint(const char *fmt,...)
Definition: elog.c:1153
int errcode(int sqlerrcode)
Definition: elog.c:695
int errmsg(const char *fmt,...)
Definition: elog.c:906
#define PANIC
Definition: elog.h:38
#define ERROR
Definition: elog.h:35
#define ereport(elevel,...)
Definition: elog.h:145
Datum FunctionCall2Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2)
Definition: fmgr.c:1134
#define PG_RETURN_POINTER(x)
Definition: fmgr.h:361
#define PG_FUNCTION_ARGS
Definition: fmgr.h:193
Size heap_compute_data_size(TupleDesc tupleDesc, Datum *values, bool *isnull)
Definition: heaptuple.c:119
void heap_fill_tuple(TupleDesc tupleDesc, Datum *values, bool *isnull, char *data, Size data_size, uint16 *infomask, bits8 *bit)
Definition: heaptuple.c:304
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
#define GETSTRUCT(TUP)
Definition: htup_details.h:649
FmgrInfo * index_getprocinfo(Relation irel, AttrNumber attnum, uint16 procnum)
Definition: indexam.c:803
RegProcedure index_getprocid(Relation irel, AttrNumber attnum, uint16 procnum)
Definition: indexam.c:769
BlockNumber GetFreeIndexPage(Relation rel)
Definition: indexfsm.c:38
void index_deform_tuple_internal(TupleDesc tupleDescriptor, Datum *values, bool *isnull, char *tp, bits8 *bp, int hasnulls)
Definition: indextuple.c:479
int b
Definition: isn.c:70
int i
Definition: isn.c:73
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:77
Pointer Item
Definition: item.h:17
static void ItemPointerSet(ItemPointerData *pointer, BlockNumber blockNumber, OffsetNumber offNum)
Definition: itemptr.h:135
static void ItemPointerSetInvalid(ItemPointerData *pointer)
Definition: itemptr.h:184
#define IndexTupleHasNulls(itup)
Definition: itup.h:71
#define INDEX_NULL_MASK
Definition: itup.h:68
#define IndexTupleSize(itup)
Definition: itup.h:70
#define INDEX_SIZE_MASK
Definition: itup.h:65
Assert(fmt[strlen(fmt) - 1] !='\n')
void LockRelationForExtension(Relation relation, LOCKMODE lockmode)
Definition: lmgr.c:431
void UnlockRelationForExtension(Relation relation, LOCKMODE lockmode)
Definition: lmgr.c:481
#define ExclusiveLock
Definition: lockdefs.h:42
bool get_opclass_opfamily_and_input_type(Oid opclass, Oid *opfamily, Oid *opcintype)
Definition: lsyscache.c:1239
Oid get_op_rettype(Oid opno)
Definition: lsyscache.c:1315
Oid get_index_column_opclass(Oid index_oid, int attno)
Definition: lsyscache.c:3477
Oid getBaseType(Oid typid)
Definition: lsyscache.c:2479
Oid get_atttype(Oid relid, AttrNumber attnum)
Definition: lsyscache.c:939
void * palloc0(Size size)
Definition: mcxt.c:1230
void * MemoryContextAllocZero(MemoryContext context, Size size)
Definition: mcxt.c:1037
void * palloc(Size size)
Definition: mcxt.c:1199
Oid exprType(const Node *expr)
Definition: nodeFuncs.c:43
#define makeNode(_type_)
Definition: nodes.h:159
#define InvalidOffsetNumber
Definition: off.h:26
uint16 OffsetNumber
Definition: off.h:24
#define FirstOffsetNumber
Definition: off.h:27
bool IsBinaryCoercible(Oid srctype, Oid targettype)
FormData_pg_amop * Form_pg_amop
Definition: pg_amop.h:88
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:207
static char * label
#define INDEX_MAX_KEYS
#define lfirst(lc)
Definition: pg_list.h:170
static ListCell * list_head(const List *l)
Definition: pg_list.h:126
static ListCell * lnext(const List *l, const ListCell *c)
Definition: pg_list.h:341
FormData_pg_type * Form_pg_type
Definition: pg_type.h:261
int fillfactor
Definition: pgbench.c:196
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:670
uintptr_t Datum
Definition: postgres.h:412
#define VARSIZE_ANY(PTR)
Definition: postgres.h:349
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:600
static Pointer DatumGetPointer(Datum X)
Definition: postgres.h:660
#define InvalidOid
Definition: postgres_ext.h:36
unsigned int Oid
Definition: postgres_ext.h:31
#define RELATION_IS_LOCAL(relation)
Definition: rel.h:646
#define RelationGetDescr(relation)
Definition: rel.h:527
#define RelationGetRelationName(relation)
Definition: rel.h:535
#define IndexRelationGetNumberOfAttributes(relation)
Definition: rel.h:513
#define IndexRelationGetNumberOfKeyAttributes(relation)
Definition: rel.h:520
List * RelationGetIndexExpressions(Relation relation)
Definition: relcache.c:4965
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:1910
@ RELOPT_KIND_SPGIST
Definition: reloptions.h:50
@ RELOPT_TYPE_INT
Definition: reloptions.h:32
void spgcostestimate(PlannerInfo *root, IndexPath *path, double loop_count, Cost *indexStartupCost, Cost *indexTotalCost, Selectivity *indexSelectivity, double *indexCorrelation, double *indexPages)
Definition: selfuncs.c:7068
bool spginsert(Relation index, Datum *values, bool *isnull, ItemPointer ht_ctid, Relation heapRel, IndexUniqueCheck checkUnique, bool indexUnchanged, IndexInfo *indexInfo)
Definition: spginsert.c:207
void spgbuildempty(Relation index)
Definition: spginsert.c:156
IndexBuildResult * spgbuild(Relation heap, Relation index, IndexInfo *indexInfo)
Definition: spginsert.c:75
#define SPGIST_OPTIONS_PROC
Definition: spgist.h:29
#define SPGIST_COMPRESS_PROC
Definition: spgist.h:28
#define SPGISTNProc
Definition: spgist.h:31
#define SPGIST_CONFIG_PROC
Definition: spgist.h:23
#define SGNTDATAPTR(x)
SpGistDeadTupleData * SpGistDeadTuple
#define SGLT_GET_HASNULLMASK(spgLeafTuple)
#define GBUF_NULLS
#define SPGIST_REDIRECT
SpGistInnerTupleData * SpGistInnerTuple
#define SGDTSIZE
#define SpGistPageStoresNulls(page)
#define SPGIST_PLACEHOLDER
#define SGITDATAPTR(x)
#define SGLT_SET_HASNULLMASK(spgLeafTuple, hasnulls)
#define SGITITERATE(x, i, nt)
#define SpGistGetTargetPageFreeSpace(relation)
#define GBUF_PARITY_MASK
#define GBUF_LEAF
#define spgFirstIncludeColumn
#define SGITMAXSIZE
#define SpGistPageGetMeta(p)
SpGistNodeTupleData * SpGistNodeTuple
#define SGITMAXPREFIXSIZE
#define SpGistPageIsLeaf(page)
#define SPGIST_METAPAGE_BLKNO
#define SpGistPageIsDeleted(page)
#define SGLTHDRSZ(hasnulls)
#define SGLT_SET_NEXTOFFSET(spgLeafTuple, offsetNumber)
#define SGITHDRSZ
#define SPGIST_META
struct SpGistLeafTupleData * SpGistLeafTuple
#define SPGIST_MAGIC_NUMBER
#define SPGIST_CACHED_PAGES
#define SPGIST_NULLS
#define GBUF_REQ_NULLS(flags)
#define SPGIST_PAGE_CAPACITY
#define SGITMAXNNODES
#define SGNTDATUM(x, s)
#define SpGistPageGetOpaque(page)
#define SPGIST_PAGE_ID
#define SGNTHDRSZ
#define GBUF_INNER_PARITY(x)
#define SGITNODEPTR(x)
#define SpGistBlockIsFixed(blkno)
#define GBUF_REQ_LEAF(flags)
struct SpGistLeafTupleData SpGistLeafTupleData
#define SPGIST_LEAF
#define spgKeyColumn
IndexScanDesc spgbeginscan(Relation rel, int keysz, int orderbysz)
Definition: spgscan.c:304
bool spgcanreturn(Relation index, int attno)
Definition: spgscan.c:1085
bool spggettuple(IndexScanDesc scan, ScanDirection dir)
Definition: spgscan.c:1027
void spgendscan(IndexScanDesc scan)
Definition: spgscan.c:429
void spgrescan(IndexScanDesc scan, ScanKey scankey, int nscankeys, ScanKey orderbys, int norderbys)
Definition: spgscan.c:380
int64 spggetbitmap(IndexScanDesc scan, TIDBitmap *tbm)
Definition: spgscan.c:943
bytea * spgoptions(Datum reloptions, bool validate)
Definition: spgutils.c:739
Datum * spgExtractNodeLabels(SpGistState *state, SpGistInnerTuple innerTuple)
Definition: spgutils.c:1141
void initSpGistState(SpGistState *state, Relation index)
Definition: spgutils.c:330
void SpGistUpdateMetaPage(Relation index)
Definition: spgutils.c:430
TupleDesc getSpGistTupleDesc(Relation index, SpGistTypeDesc *keyType)
Definition: spgutils.c:299
Buffer SpGistNewBuffer(Relation index)
Definition: spgutils.c:365
SpGistInnerTuple spgFormInnerTuple(SpGistState *state, bool hasPrefix, Datum prefix, int nNodes, SpGistNodeTuple *nodes)
Definition: spgutils.c:982
static void memcpyInnerDatum(void *target, SpGistTypeDesc *att, Datum datum)
Definition: spgutils.c:777
void spgDeformLeafTuple(SpGistLeafTuple tup, TupleDesc tupleDescriptor, Datum *datums, bool *isnulls, bool keyColumnIsNull)
Definition: spgutils.c:1096
SpGistDeadTuple spgFormDeadTuple(SpGistState *state, int tupstate, BlockNumber blkno, OffsetNumber offnum)
Definition: spgutils.c:1065
SpGistLeafTuple spgFormLeafTuple(SpGistState *state, ItemPointer heapPtr, Datum *datums, bool *isnulls)
Definition: spgutils.c:851
unsigned int SpGistGetInnerTypeSize(SpGistTypeDesc *att, Datum datum)
Definition: spgutils.c:759
static Oid GetIndexInputType(Relation index, AttrNumber indexcol)
Definition: spgutils.c:112
void SpGistInitBuffer(Buffer b, uint16 f)
Definition: spgutils.c:702
Buffer SpGistGetBuffer(Relation index, int flags, int needSpace, bool *isNew)
Definition: spgutils.c:549
static Buffer allocNewBuffer(Relation index, int flags)
Definition: spgutils.c:493
bool spgproperty(Oid index_oid, int attno, IndexAMProperty prop, const char *propname, bool *res, bool *isnull)
Definition: spgutils.c:1279
Size SpGistGetLeafTupleSize(TupleDesc tupleDescriptor, Datum *datums, bool *isnulls)
Definition: spgutils.c:798
void SpGistSetLastUsedPage(Relation index, Buffer buffer)
Definition: spgutils.c:653
static void fillTypeDesc(SpGistTypeDesc *desc, Oid type)
Definition: spgutils.c:157
SpGistCache * spgGetCache(Relation index)
Definition: spgutils.c:179
OffsetNumber SpGistPageAddNewItem(SpGistState *state, Page page, Item item, Size size, OffsetNumber *startOffset, bool errorOK)
Definition: spgutils.c:1184
Datum spghandler(PG_FUNCTION_ARGS)
Definition: spgutils.c:44
void SpGistInitPage(Page page, uint16 f)
Definition: spgutils.c:688
#define GET_LUP(c, f)
Definition: spgutils.c:470
SpGistNodeTuple spgFormNodeTuple(SpGistState *state, Datum label, bool isnull)
Definition: spgutils.c:940
void SpGistInitMetapage(Page page)
Definition: spgutils.c:712
IndexBulkDeleteResult * spgvacuumcleanup(IndexVacuumInfo *info, IndexBulkDeleteResult *stats)
Definition: spgvacuum.c:937
IndexBulkDeleteResult * spgbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats, IndexBulkDeleteCallback callback, void *callback_state)
Definition: spgvacuum.c:906
bool spgvalidate(Oid opclassoid)
Definition: spgvalidate.c:39
void spgadjustmembers(Oid opfamilyoid, Oid opclassoid, List *operators, List *functions)
Definition: spgvalidate.c:332
Definition: fmgr.h:57
ambuildphasename_function ambuildphasename
Definition: amapi.h:268
ambuildempty_function ambuildempty
Definition: amapi.h:260
amvacuumcleanup_function amvacuumcleanup
Definition: amapi.h:263
bool amclusterable
Definition: amapi.h:238
amoptions_function amoptions
Definition: amapi.h:266
amestimateparallelscan_function amestimateparallelscan
Definition: amapi.h:280
amrestrpos_function amrestrpos
Definition: amapi.h:277
aminsert_function aminsert
Definition: amapi.h:261
amendscan_function amendscan
Definition: amapi.h:275
uint16 amoptsprocnum
Definition: amapi.h:218
amparallelrescan_function amparallelrescan
Definition: amapi.h:282
Oid amkeytype
Definition: amapi.h:250
bool ampredlocks
Definition: amapi.h:240
uint16 amsupport
Definition: amapi.h:216
amcostestimate_function amcostestimate
Definition: amapi.h:265
bool amcanorderbyop
Definition: amapi.h:222
amadjustmembers_function amadjustmembers
Definition: amapi.h:270
ambuild_function ambuild
Definition: amapi.h:259
bool amstorage
Definition: amapi.h:236
uint16 amstrategies
Definition: amapi.h:214
bool amoptionalkey
Definition: amapi.h:230
amgettuple_function amgettuple
Definition: amapi.h:273
amcanreturn_function amcanreturn
Definition: amapi.h:264
bool amcanunique
Definition: amapi.h:226
amgetbitmap_function amgetbitmap
Definition: amapi.h:274
amproperty_function amproperty
Definition: amapi.h:267
ambulkdelete_function ambulkdelete
Definition: amapi.h:262
bool amsearcharray
Definition: amapi.h:232
amvalidate_function amvalidate
Definition: amapi.h:269
ammarkpos_function ammarkpos
Definition: amapi.h:276
bool amcanmulticol
Definition: amapi.h:228
bool amusemaintenanceworkmem
Definition: amapi.h:246
ambeginscan_function ambeginscan
Definition: amapi.h:271
bool amcanparallel
Definition: amapi.h:242
amrescan_function amrescan
Definition: amapi.h:272
bool amcanorder
Definition: amapi.h:220
aminitparallelscan_function aminitparallelscan
Definition: amapi.h:281
uint8 amparallelvacuumoptions
Definition: amapi.h:248
bool amcanbackward
Definition: amapi.h:224
bool amcaninclude
Definition: amapi.h:244
bool amsearchnulls
Definition: amapi.h:234
ItemPointerData t_tid
Definition: itup.h:37
unsigned short t_info
Definition: itup.h:49
Definition: pg_list.h:52
Definition: nodes.h:112
SpGistTypeDesc attPrefixType
SpGistTypeDesc attLeafType
SpGistTypeDesc attType
SpGistLUPCache lastUsedPages
spgConfigOut config
SpGistTypeDesc attLabelType
unsigned int tupstate
ItemPointerData pointer
unsigned int prefixSize
SpGistLastUsedPage cachedPage[SPGIST_CACHED_PAGES]
ItemPointerData heapPtr
SpGistLUPCache lastUsedPages
CatCTup * members[FLEXIBLE_ARRAY_MEMBER]
Definition: catcache.h:178
int n_members
Definition: catcache.h:176
HeapTupleData tuple
Definition: catcache.h:121
Definition: type.h:95
Oid attType
Definition: spgist.h:38
Oid leafType
Definition: spgist.h:45
Oid labelType
Definition: spgist.h:44
Oid prefixType
Definition: spgist.h:43
Definition: regguts.h:318
Definition: c.h:623
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:1221
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:1173
@ TYPEOID
Definition: syscache.h:114
@ AMOPSTRATEGY
Definition: syscache.h:38
#define ReleaseSysCacheList(x)
Definition: syscache.h:222
#define SearchSysCacheList1(cacheId, key1)
Definition: syscache.h:215
#define InvalidCompressionMethod
#define InvalidTransactionId
Definition: transam.h:31
#define TransactionIdIsValid(xid)
Definition: transam.h:41
TupleDesc CreateTupleDescCopy(TupleDesc tupdesc)
Definition: tupdesc.c:111
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92
#define VACUUM_OPTION_PARALLEL_BULKDEL
Definition: vacuum.h:47
#define VACUUM_OPTION_PARALLEL_COND_CLEANUP
Definition: vacuum.h:54
TransactionId GetTopTransactionIdIfAny(void)
Definition: xact.c:431