LCOV - code coverage report
Current view: top level - src/backend/access/gin - ginutil.c (source / functions) Hit Total Coverage
Test: PostgreSQL 16beta1 Lines: 246 256 96.1 %
Date: 2023-05-31 00:12:04 Functions: 15 15 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * ginutil.c
       4             :  *    Utility routines for the Postgres inverted index access method.
       5             :  *
       6             :  *
       7             :  * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
       8             :  * Portions Copyright (c) 1994, Regents of the University of California
       9             :  *
      10             :  * IDENTIFICATION
      11             :  *          src/backend/access/gin/ginutil.c
      12             :  *-------------------------------------------------------------------------
      13             :  */
      14             : 
      15             : #include "postgres.h"
      16             : 
      17             : #include "access/gin_private.h"
      18             : #include "access/ginxlog.h"
      19             : #include "access/reloptions.h"
      20             : #include "access/xloginsert.h"
      21             : #include "catalog/pg_collation.h"
      22             : #include "catalog/pg_type.h"
      23             : #include "commands/vacuum.h"
      24             : #include "miscadmin.h"
      25             : #include "storage/indexfsm.h"
      26             : #include "storage/lmgr.h"
      27             : #include "storage/predicate.h"
      28             : #include "utils/builtins.h"
      29             : #include "utils/index_selfuncs.h"
      30             : #include "utils/typcache.h"
      31             : 
      32             : 
      33             : /*
      34             :  * GIN handler function: return IndexAmRoutine with access method parameters
      35             :  * and callbacks.
      36             :  */
      37             : Datum
      38        1738 : ginhandler(PG_FUNCTION_ARGS)
      39             : {
      40        1738 :     IndexAmRoutine *amroutine = makeNode(IndexAmRoutine);
      41             : 
      42        1738 :     amroutine->amstrategies = 0;
      43        1738 :     amroutine->amsupport = GINNProcs;
      44        1738 :     amroutine->amoptsprocnum = GIN_OPTIONS_PROC;
      45        1738 :     amroutine->amcanorder = false;
      46        1738 :     amroutine->amcanorderbyop = false;
      47        1738 :     amroutine->amcanbackward = false;
      48        1738 :     amroutine->amcanunique = false;
      49        1738 :     amroutine->amcanmulticol = true;
      50        1738 :     amroutine->amoptionalkey = true;
      51        1738 :     amroutine->amsearcharray = false;
      52        1738 :     amroutine->amsearchnulls = false;
      53        1738 :     amroutine->amstorage = true;
      54        1738 :     amroutine->amclusterable = false;
      55        1738 :     amroutine->ampredlocks = true;
      56        1738 :     amroutine->amcanparallel = false;
      57        1738 :     amroutine->amcaninclude = false;
      58        1738 :     amroutine->amusemaintenanceworkmem = true;
      59        1738 :     amroutine->amsummarizing = false;
      60        1738 :     amroutine->amparallelvacuumoptions =
      61             :         VACUUM_OPTION_PARALLEL_BULKDEL | VACUUM_OPTION_PARALLEL_CLEANUP;
      62        1738 :     amroutine->amkeytype = InvalidOid;
      63             : 
      64        1738 :     amroutine->ambuild = ginbuild;
      65        1738 :     amroutine->ambuildempty = ginbuildempty;
      66        1738 :     amroutine->aminsert = gininsert;
      67        1738 :     amroutine->ambulkdelete = ginbulkdelete;
      68        1738 :     amroutine->amvacuumcleanup = ginvacuumcleanup;
      69        1738 :     amroutine->amcanreturn = NULL;
      70        1738 :     amroutine->amcostestimate = gincostestimate;
      71        1738 :     amroutine->amoptions = ginoptions;
      72        1738 :     amroutine->amproperty = NULL;
      73        1738 :     amroutine->ambuildphasename = NULL;
      74        1738 :     amroutine->amvalidate = ginvalidate;
      75        1738 :     amroutine->amadjustmembers = ginadjustmembers;
      76        1738 :     amroutine->ambeginscan = ginbeginscan;
      77        1738 :     amroutine->amrescan = ginrescan;
      78        1738 :     amroutine->amgettuple = NULL;
      79        1738 :     amroutine->amgetbitmap = gingetbitmap;
      80        1738 :     amroutine->amendscan = ginendscan;
      81        1738 :     amroutine->ammarkpos = NULL;
      82        1738 :     amroutine->amrestrpos = NULL;
      83        1738 :     amroutine->amestimateparallelscan = NULL;
      84        1738 :     amroutine->aminitparallelscan = NULL;
      85        1738 :     amroutine->amparallelrescan = NULL;
      86             : 
      87        1738 :     PG_RETURN_POINTER(amroutine);
      88             : }
      89             : 
      90             : /*
      91             :  * initGinState: fill in an empty GinState struct to describe the index
      92             :  *
      93             :  * Note: assorted subsidiary data is allocated in the CurrentMemoryContext.
      94             :  */
      95             : void
      96        2128 : initGinState(GinState *state, Relation index)
      97             : {
      98        2128 :     TupleDesc   origTupdesc = RelationGetDescr(index);
      99             :     int         i;
     100             : 
     101        2128 :     MemSet(state, 0, sizeof(GinState));
     102             : 
     103        2128 :     state->index = index;
     104        2128 :     state->oneCol = (origTupdesc->natts == 1);
     105        2128 :     state->origTupdesc = origTupdesc;
     106             : 
     107        4538 :     for (i = 0; i < origTupdesc->natts; i++)
     108             :     {
     109        2410 :         Form_pg_attribute attr = TupleDescAttr(origTupdesc, i);
     110             : 
     111        2410 :         if (state->oneCol)
     112        1846 :             state->tupdesc[i] = state->origTupdesc;
     113             :         else
     114             :         {
     115         564 :             state->tupdesc[i] = CreateTemplateTupleDesc(2);
     116             : 
     117         564 :             TupleDescInitEntry(state->tupdesc[i], (AttrNumber) 1, NULL,
     118             :                                INT2OID, -1, 0);
     119         564 :             TupleDescInitEntry(state->tupdesc[i], (AttrNumber) 2, NULL,
     120             :                                attr->atttypid,
     121             :                                attr->atttypmod,
     122         564 :                                attr->attndims);
     123         564 :             TupleDescInitEntryCollation(state->tupdesc[i], (AttrNumber) 2,
     124             :                                         attr->attcollation);
     125             :         }
     126             : 
     127             :         /*
     128             :          * If the compare proc isn't specified in the opclass definition, look
     129             :          * up the index key type's default btree comparator.
     130             :          */
     131        2410 :         if (index_getprocid(index, i + 1, GIN_COMPARE_PROC) != InvalidOid)
     132             :         {
     133        1280 :             fmgr_info_copy(&(state->compareFn[i]),
     134        1280 :                            index_getprocinfo(index, i + 1, GIN_COMPARE_PROC),
     135             :                            CurrentMemoryContext);
     136             :         }
     137             :         else
     138             :         {
     139             :             TypeCacheEntry *typentry;
     140             : 
     141        1130 :             typentry = lookup_type_cache(attr->atttypid,
     142             :                                          TYPECACHE_CMP_PROC_FINFO);
     143        1130 :             if (!OidIsValid(typentry->cmp_proc_finfo.fn_oid))
     144           0 :                 ereport(ERROR,
     145             :                         (errcode(ERRCODE_UNDEFINED_FUNCTION),
     146             :                          errmsg("could not identify a comparison function for type %s",
     147             :                                 format_type_be(attr->atttypid))));
     148        1130 :             fmgr_info_copy(&(state->compareFn[i]),
     149             :                            &(typentry->cmp_proc_finfo),
     150             :                            CurrentMemoryContext);
     151             :         }
     152             : 
     153             :         /* Opclass must always provide extract procs */
     154        2410 :         fmgr_info_copy(&(state->extractValueFn[i]),
     155        2410 :                        index_getprocinfo(index, i + 1, GIN_EXTRACTVALUE_PROC),
     156             :                        CurrentMemoryContext);
     157        2410 :         fmgr_info_copy(&(state->extractQueryFn[i]),
     158        2410 :                        index_getprocinfo(index, i + 1, GIN_EXTRACTQUERY_PROC),
     159             :                        CurrentMemoryContext);
     160             : 
     161             :         /*
     162             :          * Check opclass capability to do tri-state or binary logic consistent
     163             :          * check.
     164             :          */
     165        2410 :         if (index_getprocid(index, i + 1, GIN_TRICONSISTENT_PROC) != InvalidOid)
     166             :         {
     167        2006 :             fmgr_info_copy(&(state->triConsistentFn[i]),
     168        2006 :                            index_getprocinfo(index, i + 1, GIN_TRICONSISTENT_PROC),
     169             :                            CurrentMemoryContext);
     170             :         }
     171             : 
     172        2410 :         if (index_getprocid(index, i + 1, GIN_CONSISTENT_PROC) != InvalidOid)
     173             :         {
     174        2410 :             fmgr_info_copy(&(state->consistentFn[i]),
     175        2410 :                            index_getprocinfo(index, i + 1, GIN_CONSISTENT_PROC),
     176             :                            CurrentMemoryContext);
     177             :         }
     178             : 
     179        2410 :         if (state->consistentFn[i].fn_oid == InvalidOid &&
     180           0 :             state->triConsistentFn[i].fn_oid == InvalidOid)
     181             :         {
     182           0 :             elog(ERROR, "missing GIN support function (%d or %d) for attribute %d of index \"%s\"",
     183             :                  GIN_CONSISTENT_PROC, GIN_TRICONSISTENT_PROC,
     184             :                  i + 1, RelationGetRelationName(index));
     185             :         }
     186             : 
     187             :         /*
     188             :          * Check opclass capability to do partial match.
     189             :          */
     190        2410 :         if (index_getprocid(index, i + 1, GIN_COMPARE_PARTIAL_PROC) != InvalidOid)
     191             :         {
     192         604 :             fmgr_info_copy(&(state->comparePartialFn[i]),
     193         604 :                            index_getprocinfo(index, i + 1, GIN_COMPARE_PARTIAL_PROC),
     194             :                            CurrentMemoryContext);
     195         604 :             state->canPartialMatch[i] = true;
     196             :         }
     197             :         else
     198             :         {
     199        1806 :             state->canPartialMatch[i] = false;
     200             :         }
     201             : 
     202             :         /*
     203             :          * If the index column has a specified collation, we should honor that
     204             :          * while doing comparisons.  However, we may have a collatable storage
     205             :          * type for a noncollatable indexed data type (for instance, hstore
     206             :          * uses text index entries).  If there's no index collation then
     207             :          * specify default collation in case the support functions need
     208             :          * collation.  This is harmless if the support functions don't care
     209             :          * about collation, so we just do it unconditionally.  (We could
     210             :          * alternatively call get_typcollation, but that seems like expensive
     211             :          * overkill --- there aren't going to be any cases where a GIN storage
     212             :          * type has a nondefault collation.)
     213             :          */
     214        2410 :         if (OidIsValid(index->rd_indcollation[i]))
     215         342 :             state->supportCollation[i] = index->rd_indcollation[i];
     216             :         else
     217        2068 :             state->supportCollation[i] = DEFAULT_COLLATION_OID;
     218             :     }
     219        2128 : }
     220             : 
     221             : /*
     222             :  * Extract attribute (column) number of stored entry from GIN tuple
     223             :  */
     224             : OffsetNumber
     225    12810094 : gintuple_get_attrnum(GinState *ginstate, IndexTuple tuple)
     226             : {
     227             :     OffsetNumber colN;
     228             : 
     229    12810094 :     if (ginstate->oneCol)
     230             :     {
     231             :         /* column number is not stored explicitly */
     232     4151164 :         colN = FirstOffsetNumber;
     233             :     }
     234             :     else
     235             :     {
     236             :         Datum       res;
     237             :         bool        isnull;
     238             : 
     239             :         /*
     240             :          * First attribute is always int16, so we can safely use any tuple
     241             :          * descriptor to obtain first attribute of tuple
     242             :          */
     243     8658930 :         res = index_getattr(tuple, FirstOffsetNumber, ginstate->tupdesc[0],
     244             :                             &isnull);
     245             :         Assert(!isnull);
     246             : 
     247     8658930 :         colN = DatumGetUInt16(res);
     248             :         Assert(colN >= FirstOffsetNumber && colN <= ginstate->origTupdesc->natts);
     249             :     }
     250             : 
     251    12810094 :     return colN;
     252             : }
     253             : 
     254             : /*
     255             :  * Extract stored datum (and possible null category) from GIN tuple
     256             :  */
     257             : Datum
     258     8479824 : gintuple_get_key(GinState *ginstate, IndexTuple tuple,
     259             :                  GinNullCategory *category)
     260             : {
     261             :     Datum       res;
     262             :     bool        isnull;
     263             : 
     264     8479824 :     if (ginstate->oneCol)
     265             :     {
     266             :         /*
     267             :          * Single column index doesn't store attribute numbers in tuples
     268             :          */
     269     4151088 :         res = index_getattr(tuple, FirstOffsetNumber, ginstate->origTupdesc,
     270             :                             &isnull);
     271             :     }
     272             :     else
     273             :     {
     274             :         /*
     275             :          * Since the datum type depends on which index column it's from, we
     276             :          * must be careful to use the right tuple descriptor here.
     277             :          */
     278     4328736 :         OffsetNumber colN = gintuple_get_attrnum(ginstate, tuple);
     279             : 
     280     4328736 :         res = index_getattr(tuple, OffsetNumberNext(FirstOffsetNumber),
     281     4328736 :                             ginstate->tupdesc[colN - 1],
     282             :                             &isnull);
     283             :     }
     284             : 
     285     8479824 :     if (isnull)
     286        1794 :         *category = GinGetNullCategory(tuple, ginstate);
     287             :     else
     288     8478030 :         *category = GIN_CAT_NORM_KEY;
     289             : 
     290     8479824 :     return res;
     291             : }
     292             : 
     293             : /*
     294             :  * Allocate a new page (either by recycling, or by extending the index file)
     295             :  * The returned buffer is already pinned and exclusive-locked
     296             :  * Caller is responsible for initializing the page by calling GinInitBuffer
     297             :  */
     298             : Buffer
     299        7522 : GinNewBuffer(Relation index)
     300             : {
     301             :     Buffer      buffer;
     302             : 
     303             :     /* First, try to get a page from FSM */
     304             :     for (;;)
     305           0 :     {
     306        7522 :         BlockNumber blkno = GetFreeIndexPage(index);
     307             : 
     308        7522 :         if (blkno == InvalidBlockNumber)
     309        7414 :             break;
     310             : 
     311         108 :         buffer = ReadBuffer(index, blkno);
     312             : 
     313             :         /*
     314             :          * We have to guard against the possibility that someone else already
     315             :          * recycled this page; the buffer may be locked if so.
     316             :          */
     317         108 :         if (ConditionalLockBuffer(buffer))
     318             :         {
     319         108 :             if (GinPageIsRecyclable(BufferGetPage(buffer)))
     320         108 :                 return buffer;  /* OK to use */
     321             : 
     322           0 :             LockBuffer(buffer, GIN_UNLOCK);
     323             :         }
     324             : 
     325             :         /* Can't use it, so release buffer and try again */
     326           0 :         ReleaseBuffer(buffer);
     327             :     }
     328             : 
     329             :     /* Must extend the file */
     330        7414 :     buffer = ExtendBufferedRel(EB_REL(index), MAIN_FORKNUM, NULL,
     331             :                                EB_LOCK_FIRST);
     332             : 
     333        7414 :     return buffer;
     334             : }
     335             : 
     336             : void
     337       59954 : GinInitPage(Page page, uint32 f, Size pageSize)
     338             : {
     339             :     GinPageOpaque opaque;
     340             : 
     341       59954 :     PageInit(page, pageSize, sizeof(GinPageOpaqueData));
     342             : 
     343       59954 :     opaque = GinPageGetOpaque(page);
     344       59954 :     opaque->flags = f;
     345       59954 :     opaque->rightlink = InvalidBlockNumber;
     346       59954 : }
     347             : 
     348             : void
     349        3904 : GinInitBuffer(Buffer b, uint32 f)
     350             : {
     351        3904 :     GinInitPage(BufferGetPage(b), f, BufferGetPageSize(b));
     352        3904 : }
     353             : 
     354             : void
     355       48302 : GinInitMetabuffer(Buffer b)
     356             : {
     357             :     GinMetaPageData *metadata;
     358       48302 :     Page        page = BufferGetPage(b);
     359             : 
     360       48302 :     GinInitPage(page, GIN_META, BufferGetPageSize(b));
     361             : 
     362       48302 :     metadata = GinPageGetMeta(page);
     363             : 
     364       48302 :     metadata->head = metadata->tail = InvalidBlockNumber;
     365       48302 :     metadata->tailFreeSize = 0;
     366       48302 :     metadata->nPendingPages = 0;
     367       48302 :     metadata->nPendingHeapTuples = 0;
     368       48302 :     metadata->nTotalPages = 0;
     369       48302 :     metadata->nEntryPages = 0;
     370       48302 :     metadata->nDataPages = 0;
     371       48302 :     metadata->nEntries = 0;
     372       48302 :     metadata->ginVersion = GIN_CURRENT_VERSION;
     373             : 
     374             :     /*
     375             :      * Set pd_lower just past the end of the metadata.  This is essential,
     376             :      * because without doing so, metadata will be lost if xlog.c compresses
     377             :      * the page.
     378             :      */
     379       48302 :     ((PageHeader) page)->pd_lower =
     380       48302 :         ((char *) metadata + sizeof(GinMetaPageData)) - (char *) page;
     381       48302 : }
     382             : 
     383             : /*
     384             :  * Compare two keys of the same index column
     385             :  */
     386             : int
     387    31538410 : ginCompareEntries(GinState *ginstate, OffsetNumber attnum,
     388             :                   Datum a, GinNullCategory categorya,
     389             :                   Datum b, GinNullCategory categoryb)
     390             : {
     391             :     /* if not of same null category, sort by that first */
     392    31538410 :     if (categorya != categoryb)
     393      623814 :         return (categorya < categoryb) ? -1 : 1;
     394             : 
     395             :     /* all null items in same category are equal */
     396    30914596 :     if (categorya != GIN_CAT_NORM_KEY)
     397        8296 :         return 0;
     398             : 
     399             :     /* both not null, so safe to call the compareFn */
     400    30906300 :     return DatumGetInt32(FunctionCall2Coll(&ginstate->compareFn[attnum - 1],
     401    30906300 :                                            ginstate->supportCollation[attnum - 1],
     402             :                                            a, b));
     403             : }
     404             : 
     405             : /*
     406             :  * Compare two keys of possibly different index columns
     407             :  */
     408             : int
     409    32071674 : ginCompareAttEntries(GinState *ginstate,
     410             :                      OffsetNumber attnuma, Datum a, GinNullCategory categorya,
     411             :                      OffsetNumber attnumb, Datum b, GinNullCategory categoryb)
     412             : {
     413             :     /* attribute number is the first sort key */
     414    32071674 :     if (attnuma != attnumb)
     415      537780 :         return (attnuma < attnumb) ? -1 : 1;
     416             : 
     417    31533894 :     return ginCompareEntries(ginstate, attnuma, a, categorya, b, categoryb);
     418             : }
     419             : 
     420             : 
     421             : /*
     422             :  * Support for sorting key datums in ginExtractEntries
     423             :  *
     424             :  * Note: we only have to worry about null and not-null keys here;
     425             :  * ginExtractEntries never generates more than one placeholder null,
     426             :  * so it doesn't have to sort those.
     427             :  */
     428             : typedef struct
     429             : {
     430             :     Datum       datum;
     431             :     bool        isnull;
     432             : } keyEntryData;
     433             : 
     434             : typedef struct
     435             : {
     436             :     FmgrInfo   *cmpDatumFunc;
     437             :     Oid         collation;
     438             :     bool        haveDups;
     439             : } cmpEntriesArg;
     440             : 
     441             : static int
     442     1857410 : cmpEntries(const void *a, const void *b, void *arg)
     443             : {
     444     1857410 :     const keyEntryData *aa = (const keyEntryData *) a;
     445     1857410 :     const keyEntryData *bb = (const keyEntryData *) b;
     446     1857410 :     cmpEntriesArg *data = (cmpEntriesArg *) arg;
     447             :     int         res;
     448             : 
     449     1857410 :     if (aa->isnull)
     450             :     {
     451           0 :         if (bb->isnull)
     452           0 :             res = 0;            /* NULL "=" NULL */
     453             :         else
     454           0 :             res = 1;            /* NULL ">" not-NULL */
     455             :     }
     456     1857410 :     else if (bb->isnull)
     457           0 :         res = -1;               /* not-NULL "<" NULL */
     458             :     else
     459     1857410 :         res = DatumGetInt32(FunctionCall2Coll(data->cmpDatumFunc,
     460             :                                               data->collation,
     461             :                                               aa->datum, bb->datum));
     462             : 
     463             :     /*
     464             :      * Detect if we have any duplicates.  If there are equal keys, qsort must
     465             :      * compare them at some point, else it wouldn't know whether one should go
     466             :      * before or after the other.
     467             :      */
     468     1857410 :     if (res == 0)
     469       31004 :         data->haveDups = true;
     470             : 
     471     1857410 :     return res;
     472             : }
     473             : 
     474             : 
     475             : /*
     476             :  * Extract the index key values from an indexable item
     477             :  *
     478             :  * The resulting key values are sorted, and any duplicates are removed.
     479             :  * This avoids generating redundant index entries.
     480             :  */
     481             : Datum *
     482     1285414 : ginExtractEntries(GinState *ginstate, OffsetNumber attnum,
     483             :                   Datum value, bool isNull,
     484             :                   int32 *nentries, GinNullCategory **categories)
     485             : {
     486             :     Datum      *entries;
     487             :     bool       *nullFlags;
     488             :     int32       i;
     489             : 
     490             :     /*
     491             :      * We don't call the extractValueFn on a null item.  Instead generate a
     492             :      * placeholder.
     493             :      */
     494     1285414 :     if (isNull)
     495             :     {
     496        6622 :         *nentries = 1;
     497        6622 :         entries = (Datum *) palloc(sizeof(Datum));
     498        6622 :         entries[0] = (Datum) 0;
     499        6622 :         *categories = (GinNullCategory *) palloc(sizeof(GinNullCategory));
     500        6622 :         (*categories)[0] = GIN_CAT_NULL_ITEM;
     501        6622 :         return entries;
     502             :     }
     503             : 
     504             :     /* OK, call the opclass's extractValueFn */
     505     1278792 :     nullFlags = NULL;           /* in case extractValue doesn't set it */
     506             :     entries = (Datum *)
     507     2557584 :         DatumGetPointer(FunctionCall3Coll(&ginstate->extractValueFn[attnum - 1],
     508     1278792 :                                           ginstate->supportCollation[attnum - 1],
     509             :                                           value,
     510             :                                           PointerGetDatum(nentries),
     511             :                                           PointerGetDatum(&nullFlags)));
     512             : 
     513             :     /*
     514             :      * Generate a placeholder if the item contained no keys.
     515             :      */
     516     1278792 :     if (entries == NULL || *nentries <= 0)
     517             :     {
     518        1776 :         *nentries = 1;
     519        1776 :         entries = (Datum *) palloc(sizeof(Datum));
     520        1776 :         entries[0] = (Datum) 0;
     521        1776 :         *categories = (GinNullCategory *) palloc(sizeof(GinNullCategory));
     522        1776 :         (*categories)[0] = GIN_CAT_EMPTY_ITEM;
     523        1776 :         return entries;
     524             :     }
     525             : 
     526             :     /*
     527             :      * If the extractValueFn didn't create a nullFlags array, create one,
     528             :      * assuming that everything's non-null.
     529             :      */
     530     1277016 :     if (nullFlags == NULL)
     531      220742 :         nullFlags = (bool *) palloc0(*nentries * sizeof(bool));
     532             : 
     533             :     /*
     534             :      * If there's more than one key, sort and unique-ify.
     535             :      *
     536             :      * XXX Using qsort here is notationally painful, and the overhead is
     537             :      * pretty bad too.  For small numbers of keys it'd likely be better to use
     538             :      * a simple insertion sort.
     539             :      */
     540     1277016 :     if (*nentries > 1)
     541             :     {
     542             :         keyEntryData *keydata;
     543             :         cmpEntriesArg arg;
     544             : 
     545      518804 :         keydata = (keyEntryData *) palloc(*nentries * sizeof(keyEntryData));
     546     2360316 :         for (i = 0; i < *nentries; i++)
     547             :         {
     548     1841512 :             keydata[i].datum = entries[i];
     549     1841512 :             keydata[i].isnull = nullFlags[i];
     550             :         }
     551             : 
     552      518804 :         arg.cmpDatumFunc = &ginstate->compareFn[attnum - 1];
     553      518804 :         arg.collation = ginstate->supportCollation[attnum - 1];
     554      518804 :         arg.haveDups = false;
     555      518804 :         qsort_arg(keydata, *nentries, sizeof(keyEntryData),
     556             :                   cmpEntries, &arg);
     557             : 
     558      518804 :         if (arg.haveDups)
     559             :         {
     560             :             /* there are duplicates, must get rid of 'em */
     561             :             int32       j;
     562             : 
     563       15028 :             entries[0] = keydata[0].datum;
     564       15028 :             nullFlags[0] = keydata[0].isnull;
     565       15028 :             j = 1;
     566       67930 :             for (i = 1; i < *nentries; i++)
     567             :             {
     568       52902 :                 if (cmpEntries(&keydata[i - 1], &keydata[i], &arg) != 0)
     569             :                 {
     570       37490 :                     entries[j] = keydata[i].datum;
     571       37490 :                     nullFlags[j] = keydata[i].isnull;
     572       37490 :                     j++;
     573             :                 }
     574             :             }
     575       15028 :             *nentries = j;
     576             :         }
     577             :         else
     578             :         {
     579             :             /* easy, no duplicates */
     580     2277358 :             for (i = 0; i < *nentries; i++)
     581             :             {
     582     1773582 :                 entries[i] = keydata[i].datum;
     583     1773582 :                 nullFlags[i] = keydata[i].isnull;
     584             :             }
     585             :         }
     586             : 
     587      518804 :         pfree(keydata);
     588             :     }
     589             : 
     590             :     /*
     591             :      * Create GinNullCategory representation from nullFlags.
     592             :      */
     593     1277016 :     *categories = (GinNullCategory *) palloc0(*nentries * sizeof(GinNullCategory));
     594     3861328 :     for (i = 0; i < *nentries; i++)
     595     2584312 :         (*categories)[i] = (nullFlags[i] ? GIN_CAT_NULL_KEY : GIN_CAT_NORM_KEY);
     596             : 
     597     1277016 :     return entries;
     598             : }
     599             : 
     600             : bytea *
     601         500 : ginoptions(Datum reloptions, bool validate)
     602             : {
     603             :     static const relopt_parse_elt tab[] = {
     604             :         {"fastupdate", RELOPT_TYPE_BOOL, offsetof(GinOptions, useFastUpdate)},
     605             :         {"gin_pending_list_limit", RELOPT_TYPE_INT, offsetof(GinOptions,
     606             :                                                              pendingListCleanupSize)}
     607             :     };
     608             : 
     609         500 :     return (bytea *) build_reloptions(reloptions, validate,
     610             :                                       RELOPT_KIND_GIN,
     611             :                                       sizeof(GinOptions),
     612             :                                       tab, lengthof(tab));
     613             : }
     614             : 
     615             : /*
     616             :  * Fetch index's statistical data into *stats
     617             :  *
     618             :  * Note: in the result, nPendingPages can be trusted to be up-to-date,
     619             :  * as can ginVersion; but the other fields are as of the last VACUUM.
     620             :  */
     621             : void
     622        2176 : ginGetStats(Relation index, GinStatsData *stats)
     623             : {
     624             :     Buffer      metabuffer;
     625             :     Page        metapage;
     626             :     GinMetaPageData *metadata;
     627             : 
     628        2176 :     metabuffer = ReadBuffer(index, GIN_METAPAGE_BLKNO);
     629        2176 :     LockBuffer(metabuffer, GIN_SHARE);
     630        2176 :     metapage = BufferGetPage(metabuffer);
     631        2176 :     metadata = GinPageGetMeta(metapage);
     632             : 
     633        2176 :     stats->nPendingPages = metadata->nPendingPages;
     634        2176 :     stats->nTotalPages = metadata->nTotalPages;
     635        2176 :     stats->nEntryPages = metadata->nEntryPages;
     636        2176 :     stats->nDataPages = metadata->nDataPages;
     637        2176 :     stats->nEntries = metadata->nEntries;
     638        2176 :     stats->ginVersion = metadata->ginVersion;
     639             : 
     640        2176 :     UnlockReleaseBuffer(metabuffer);
     641        2176 : }
     642             : 
     643             : /*
     644             :  * Write the given statistics to the index's metapage
     645             :  *
     646             :  * Note: nPendingPages and ginVersion are *not* copied over
     647             :  */
     648             : void
     649         358 : ginUpdateStats(Relation index, const GinStatsData *stats, bool is_build)
     650             : {
     651             :     Buffer      metabuffer;
     652             :     Page        metapage;
     653             :     GinMetaPageData *metadata;
     654             : 
     655         358 :     metabuffer = ReadBuffer(index, GIN_METAPAGE_BLKNO);
     656         358 :     LockBuffer(metabuffer, GIN_EXCLUSIVE);
     657         358 :     metapage = BufferGetPage(metabuffer);
     658         358 :     metadata = GinPageGetMeta(metapage);
     659             : 
     660         358 :     START_CRIT_SECTION();
     661             : 
     662         358 :     metadata->nTotalPages = stats->nTotalPages;
     663         358 :     metadata->nEntryPages = stats->nEntryPages;
     664         358 :     metadata->nDataPages = stats->nDataPages;
     665         358 :     metadata->nEntries = stats->nEntries;
     666             : 
     667             :     /*
     668             :      * Set pd_lower just past the end of the metadata.  This is essential,
     669             :      * because without doing so, metadata will be lost if xlog.c compresses
     670             :      * the page.  (We must do this here because pre-v11 versions of PG did not
     671             :      * set the metapage's pd_lower correctly, so a pg_upgraded index might
     672             :      * contain the wrong value.)
     673             :      */
     674         358 :     ((PageHeader) metapage)->pd_lower =
     675         358 :         ((char *) metadata + sizeof(GinMetaPageData)) - (char *) metapage;
     676             : 
     677         358 :     MarkBufferDirty(metabuffer);
     678             : 
     679         358 :     if (RelationNeedsWAL(index) && !is_build)
     680             :     {
     681             :         XLogRecPtr  recptr;
     682             :         ginxlogUpdateMeta data;
     683             : 
     684          48 :         data.locator = index->rd_locator;
     685          48 :         data.ntuples = 0;
     686          48 :         data.newRightlink = data.prevTail = InvalidBlockNumber;
     687          48 :         memcpy(&data.metadata, metadata, sizeof(GinMetaPageData));
     688             : 
     689          48 :         XLogBeginInsert();
     690          48 :         XLogRegisterData((char *) &data, sizeof(ginxlogUpdateMeta));
     691          48 :         XLogRegisterBuffer(0, metabuffer, REGBUF_WILL_INIT | REGBUF_STANDARD);
     692             : 
     693          48 :         recptr = XLogInsert(RM_GIN_ID, XLOG_GIN_UPDATE_META_PAGE);
     694          48 :         PageSetLSN(metapage, recptr);
     695             :     }
     696             : 
     697         358 :     UnlockReleaseBuffer(metabuffer);
     698             : 
     699         358 :     END_CRIT_SECTION();
     700         358 : }

Generated by: LCOV version 1.14