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