LCOV - code coverage report
Current view: top level - src/backend/access/common - toast_internals.c (source / functions) Hit Total Coverage
Test: PostgreSQL 17beta1 Lines: 138 161 85.7 %
Date: 2024-06-14 18:11:26 Functions: 8 9 88.9 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * toast_internals.c
       4             :  *    Functions for internal use by the TOAST system.
       5             :  *
       6             :  * Copyright (c) 2000-2024, PostgreSQL Global Development Group
       7             :  *
       8             :  * IDENTIFICATION
       9             :  *    src/backend/access/common/toast_internals.c
      10             :  *
      11             :  *-------------------------------------------------------------------------
      12             :  */
      13             : 
      14             : #include "postgres.h"
      15             : 
      16             : #include "access/detoast.h"
      17             : #include "access/genam.h"
      18             : #include "access/heapam.h"
      19             : #include "access/heaptoast.h"
      20             : #include "access/table.h"
      21             : #include "access/toast_internals.h"
      22             : #include "access/xact.h"
      23             : #include "catalog/catalog.h"
      24             : #include "miscadmin.h"
      25             : #include "utils/fmgroids.h"
      26             : #include "utils/rel.h"
      27             : #include "utils/snapmgr.h"
      28             : 
      29             : static bool toastrel_valueid_exists(Relation toastrel, Oid valueid);
      30             : static bool toastid_valueid_exists(Oid toastrelid, Oid valueid);
      31             : 
      32             : /* ----------
      33             :  * toast_compress_datum -
      34             :  *
      35             :  *  Create a compressed version of a varlena datum
      36             :  *
      37             :  *  If we fail (ie, compressed result is actually bigger than original)
      38             :  *  then return NULL.  We must not use compressed data if it'd expand
      39             :  *  the tuple!
      40             :  *
      41             :  *  We use VAR{SIZE,DATA}_ANY so we can handle short varlenas here without
      42             :  *  copying them.  But we can't handle external or compressed datums.
      43             :  * ----------
      44             :  */
      45             : Datum
      46       43872 : toast_compress_datum(Datum value, char cmethod)
      47             : {
      48       43872 :     struct varlena *tmp = NULL;
      49             :     int32       valsize;
      50       43872 :     ToastCompressionId cmid = TOAST_INVALID_COMPRESSION_ID;
      51             : 
      52             :     Assert(!VARATT_IS_EXTERNAL(DatumGetPointer(value)));
      53             :     Assert(!VARATT_IS_COMPRESSED(DatumGetPointer(value)));
      54             : 
      55       43872 :     valsize = VARSIZE_ANY_EXHDR(DatumGetPointer(value));
      56             : 
      57             :     /* If the compression method is not valid, use the current default */
      58       43872 :     if (!CompressionMethodIsValid(cmethod))
      59       43800 :         cmethod = default_toast_compression;
      60             : 
      61             :     /*
      62             :      * Call appropriate compression routine for the compression method.
      63             :      */
      64       43872 :     switch (cmethod)
      65             :     {
      66       43836 :         case TOAST_PGLZ_COMPRESSION:
      67       43836 :             tmp = pglz_compress_datum((const struct varlena *) value);
      68       43836 :             cmid = TOAST_PGLZ_COMPRESSION_ID;
      69       43836 :             break;
      70          36 :         case TOAST_LZ4_COMPRESSION:
      71          36 :             tmp = lz4_compress_datum((const struct varlena *) value);
      72          36 :             cmid = TOAST_LZ4_COMPRESSION_ID;
      73          36 :             break;
      74           0 :         default:
      75           0 :             elog(ERROR, "invalid compression method %c", cmethod);
      76             :     }
      77             : 
      78       43872 :     if (tmp == NULL)
      79       11428 :         return PointerGetDatum(NULL);
      80             : 
      81             :     /*
      82             :      * We recheck the actual size even if compression reports success, because
      83             :      * it might be satisfied with having saved as little as one byte in the
      84             :      * compressed data --- which could turn into a net loss once you consider
      85             :      * header and alignment padding.  Worst case, the compressed format might
      86             :      * require three padding bytes (plus header, which is included in
      87             :      * VARSIZE(tmp)), whereas the uncompressed format would take only one
      88             :      * header byte and no padding if the value is short enough.  So we insist
      89             :      * on a savings of more than 2 bytes to ensure we have a gain.
      90             :      */
      91       32444 :     if (VARSIZE(tmp) < valsize - 2)
      92             :     {
      93             :         /* successful compression */
      94             :         Assert(cmid != TOAST_INVALID_COMPRESSION_ID);
      95       32444 :         TOAST_COMPRESS_SET_SIZE_AND_COMPRESS_METHOD(tmp, valsize, cmid);
      96       32444 :         return PointerGetDatum(tmp);
      97             :     }
      98             :     else
      99             :     {
     100             :         /* incompressible data */
     101           0 :         pfree(tmp);
     102           0 :         return PointerGetDatum(NULL);
     103             :     }
     104             : }
     105             : 
     106             : /* ----------
     107             :  * toast_save_datum -
     108             :  *
     109             :  *  Save one single datum into the secondary relation and return
     110             :  *  a Datum reference for it.
     111             :  *
     112             :  * rel: the main relation we're working with (not the toast rel!)
     113             :  * value: datum to be pushed to toast storage
     114             :  * oldexternal: if not NULL, toast pointer previously representing the datum
     115             :  * options: options to be passed to heap_insert() for toast rows
     116             :  * ----------
     117             :  */
     118             : Datum
     119       14182 : toast_save_datum(Relation rel, Datum value,
     120             :                  struct varlena *oldexternal, int options)
     121             : {
     122             :     Relation    toastrel;
     123             :     Relation   *toastidxs;
     124             :     HeapTuple   toasttup;
     125             :     TupleDesc   toasttupDesc;
     126             :     Datum       t_values[3];
     127             :     bool        t_isnull[3];
     128       14182 :     CommandId   mycid = GetCurrentCommandId(true);
     129             :     struct varlena *result;
     130             :     struct varatt_external toast_pointer;
     131             :     union
     132             :     {
     133             :         struct varlena hdr;
     134             :         /* this is to make the union big enough for a chunk: */
     135             :         char        data[TOAST_MAX_CHUNK_SIZE + VARHDRSZ];
     136             :         /* ensure union is aligned well enough: */
     137             :         int32       align_it;
     138             :     }           chunk_data;
     139             :     int32       chunk_size;
     140       14182 :     int32       chunk_seq = 0;
     141             :     char       *data_p;
     142             :     int32       data_todo;
     143       14182 :     Pointer     dval = DatumGetPointer(value);
     144             :     int         num_indexes;
     145             :     int         validIndex;
     146             : 
     147             :     Assert(!VARATT_IS_EXTERNAL(value));
     148             : 
     149             :     /*
     150             :      * Open the toast relation and its indexes.  We can use the index to check
     151             :      * uniqueness of the OID we assign to the toasted item, even though it has
     152             :      * additional columns besides OID.
     153             :      */
     154       14182 :     toastrel = table_open(rel->rd_rel->reltoastrelid, RowExclusiveLock);
     155       14182 :     toasttupDesc = toastrel->rd_att;
     156             : 
     157             :     /* Open all the toast indexes and look for the valid one */
     158       14182 :     validIndex = toast_open_indexes(toastrel,
     159             :                                     RowExclusiveLock,
     160             :                                     &toastidxs,
     161             :                                     &num_indexes);
     162             : 
     163             :     /*
     164             :      * Get the data pointer and length, and compute va_rawsize and va_extinfo.
     165             :      *
     166             :      * va_rawsize is the size of the equivalent fully uncompressed datum, so
     167             :      * we have to adjust for short headers.
     168             :      *
     169             :      * va_extinfo stored the actual size of the data payload in the toast
     170             :      * records and the compression method in first 2 bits if data is
     171             :      * compressed.
     172             :      */
     173       14182 :     if (VARATT_IS_SHORT(dval))
     174             :     {
     175           0 :         data_p = VARDATA_SHORT(dval);
     176           0 :         data_todo = VARSIZE_SHORT(dval) - VARHDRSZ_SHORT;
     177           0 :         toast_pointer.va_rawsize = data_todo + VARHDRSZ;    /* as if not short */
     178           0 :         toast_pointer.va_extinfo = data_todo;
     179             :     }
     180       14182 :     else if (VARATT_IS_COMPRESSED(dval))
     181             :     {
     182        7976 :         data_p = VARDATA(dval);
     183        7976 :         data_todo = VARSIZE(dval) - VARHDRSZ;
     184             :         /* rawsize in a compressed datum is just the size of the payload */
     185        7976 :         toast_pointer.va_rawsize = VARDATA_COMPRESSED_GET_EXTSIZE(dval) + VARHDRSZ;
     186             : 
     187             :         /* set external size and compression method */
     188        7976 :         VARATT_EXTERNAL_SET_SIZE_AND_COMPRESS_METHOD(toast_pointer, data_todo,
     189             :                                                      VARDATA_COMPRESSED_GET_COMPRESS_METHOD(dval));
     190             :         /* Assert that the numbers look like it's compressed */
     191             :         Assert(VARATT_EXTERNAL_IS_COMPRESSED(toast_pointer));
     192             :     }
     193             :     else
     194             :     {
     195        6206 :         data_p = VARDATA(dval);
     196        6206 :         data_todo = VARSIZE(dval) - VARHDRSZ;
     197        6206 :         toast_pointer.va_rawsize = VARSIZE(dval);
     198        6206 :         toast_pointer.va_extinfo = data_todo;
     199             :     }
     200             : 
     201             :     /*
     202             :      * Insert the correct table OID into the result TOAST pointer.
     203             :      *
     204             :      * Normally this is the actual OID of the target toast table, but during
     205             :      * table-rewriting operations such as CLUSTER, we have to insert the OID
     206             :      * of the table's real permanent toast table instead.  rd_toastoid is set
     207             :      * if we have to substitute such an OID.
     208             :      */
     209       14182 :     if (OidIsValid(rel->rd_toastoid))
     210         580 :         toast_pointer.va_toastrelid = rel->rd_toastoid;
     211             :     else
     212       13602 :         toast_pointer.va_toastrelid = RelationGetRelid(toastrel);
     213             : 
     214             :     /*
     215             :      * Choose an OID to use as the value ID for this toast value.
     216             :      *
     217             :      * Normally we just choose an unused OID within the toast table.  But
     218             :      * during table-rewriting operations where we are preserving an existing
     219             :      * toast table OID, we want to preserve toast value OIDs too.  So, if
     220             :      * rd_toastoid is set and we had a prior external value from that same
     221             :      * toast table, re-use its value ID.  If we didn't have a prior external
     222             :      * value (which is a corner case, but possible if the table's attstorage
     223             :      * options have been changed), we have to pick a value ID that doesn't
     224             :      * conflict with either new or existing toast value OIDs.
     225             :      */
     226       14182 :     if (!OidIsValid(rel->rd_toastoid))
     227             :     {
     228             :         /* normal case: just choose an unused OID */
     229       13602 :         toast_pointer.va_valueid =
     230       13602 :             GetNewOidWithIndex(toastrel,
     231       13602 :                                RelationGetRelid(toastidxs[validIndex]),
     232             :                                (AttrNumber) 1);
     233             :     }
     234             :     else
     235             :     {
     236             :         /* rewrite case: check to see if value was in old toast table */
     237         580 :         toast_pointer.va_valueid = InvalidOid;
     238         580 :         if (oldexternal != NULL)
     239             :         {
     240             :             struct varatt_external old_toast_pointer;
     241             : 
     242             :             Assert(VARATT_IS_EXTERNAL_ONDISK(oldexternal));
     243             :             /* Must copy to access aligned fields */
     244         580 :             VARATT_EXTERNAL_GET_POINTER(old_toast_pointer, oldexternal);
     245         580 :             if (old_toast_pointer.va_toastrelid == rel->rd_toastoid)
     246             :             {
     247             :                 /* This value came from the old toast table; reuse its OID */
     248         580 :                 toast_pointer.va_valueid = old_toast_pointer.va_valueid;
     249             : 
     250             :                 /*
     251             :                  * There is a corner case here: the table rewrite might have
     252             :                  * to copy both live and recently-dead versions of a row, and
     253             :                  * those versions could easily reference the same toast value.
     254             :                  * When we copy the second or later version of such a row,
     255             :                  * reusing the OID will mean we select an OID that's already
     256             :                  * in the new toast table.  Check for that, and if so, just
     257             :                  * fall through without writing the data again.
     258             :                  *
     259             :                  * While annoying and ugly-looking, this is a good thing
     260             :                  * because it ensures that we wind up with only one copy of
     261             :                  * the toast value when there is only one copy in the old
     262             :                  * toast table.  Before we detected this case, we'd have made
     263             :                  * multiple copies, wasting space; and what's worse, the
     264             :                  * copies belonging to already-deleted heap tuples would not
     265             :                  * be reclaimed by VACUUM.
     266             :                  */
     267         580 :                 if (toastrel_valueid_exists(toastrel,
     268             :                                             toast_pointer.va_valueid))
     269             :                 {
     270             :                     /* Match, so short-circuit the data storage loop below */
     271           0 :                     data_todo = 0;
     272             :                 }
     273             :             }
     274             :         }
     275         580 :         if (toast_pointer.va_valueid == InvalidOid)
     276             :         {
     277             :             /*
     278             :              * new value; must choose an OID that doesn't conflict in either
     279             :              * old or new toast table
     280             :              */
     281             :             do
     282             :             {
     283           0 :                 toast_pointer.va_valueid =
     284           0 :                     GetNewOidWithIndex(toastrel,
     285           0 :                                        RelationGetRelid(toastidxs[validIndex]),
     286             :                                        (AttrNumber) 1);
     287           0 :             } while (toastid_valueid_exists(rel->rd_toastoid,
     288           0 :                                             toast_pointer.va_valueid));
     289             :         }
     290             :     }
     291             : 
     292             :     /*
     293             :      * Initialize constant parts of the tuple data
     294             :      */
     295       14182 :     t_values[0] = ObjectIdGetDatum(toast_pointer.va_valueid);
     296       14182 :     t_values[2] = PointerGetDatum(&chunk_data);
     297       14182 :     t_isnull[0] = false;
     298       14182 :     t_isnull[1] = false;
     299       14182 :     t_isnull[2] = false;
     300             : 
     301             :     /*
     302             :      * Split up the item into chunks
     303             :      */
     304       66290 :     while (data_todo > 0)
     305             :     {
     306             :         int         i;
     307             : 
     308       52108 :         CHECK_FOR_INTERRUPTS();
     309             : 
     310             :         /*
     311             :          * Calculate the size of this chunk
     312             :          */
     313       52108 :         chunk_size = Min(TOAST_MAX_CHUNK_SIZE, data_todo);
     314             : 
     315             :         /*
     316             :          * Build a tuple and store it
     317             :          */
     318       52108 :         t_values[1] = Int32GetDatum(chunk_seq++);
     319       52108 :         SET_VARSIZE(&chunk_data, chunk_size + VARHDRSZ);
     320       52108 :         memcpy(VARDATA(&chunk_data), data_p, chunk_size);
     321       52108 :         toasttup = heap_form_tuple(toasttupDesc, t_values, t_isnull);
     322             : 
     323       52108 :         heap_insert(toastrel, toasttup, mycid, options, NULL);
     324             : 
     325             :         /*
     326             :          * Create the index entry.  We cheat a little here by not using
     327             :          * FormIndexDatum: this relies on the knowledge that the index columns
     328             :          * are the same as the initial columns of the table for all the
     329             :          * indexes.  We also cheat by not providing an IndexInfo: this is okay
     330             :          * for now because btree doesn't need one, but we might have to be
     331             :          * more honest someday.
     332             :          *
     333             :          * Note also that there had better not be any user-created index on
     334             :          * the TOAST table, since we don't bother to update anything else.
     335             :          */
     336      104216 :         for (i = 0; i < num_indexes; i++)
     337             :         {
     338             :             /* Only index relations marked as ready can be updated */
     339       52108 :             if (toastidxs[i]->rd_index->indisready)
     340       52108 :                 index_insert(toastidxs[i], t_values, t_isnull,
     341             :                              &(toasttup->t_self),
     342             :                              toastrel,
     343       52108 :                              toastidxs[i]->rd_index->indisunique ?
     344             :                              UNIQUE_CHECK_YES : UNIQUE_CHECK_NO,
     345             :                              false, NULL);
     346             :         }
     347             : 
     348             :         /*
     349             :          * Free memory
     350             :          */
     351       52108 :         heap_freetuple(toasttup);
     352             : 
     353             :         /*
     354             :          * Move on to next chunk
     355             :          */
     356       52108 :         data_todo -= chunk_size;
     357       52108 :         data_p += chunk_size;
     358             :     }
     359             : 
     360             :     /*
     361             :      * Done - close toast relation and its indexes but keep the lock until
     362             :      * commit, so as a concurrent reindex done directly on the toast relation
     363             :      * would be able to wait for this transaction.
     364             :      */
     365       14182 :     toast_close_indexes(toastidxs, num_indexes, NoLock);
     366       14182 :     table_close(toastrel, NoLock);
     367             : 
     368             :     /*
     369             :      * Create the TOAST pointer value that we'll return
     370             :      */
     371       14182 :     result = (struct varlena *) palloc(TOAST_POINTER_SIZE);
     372       14182 :     SET_VARTAG_EXTERNAL(result, VARTAG_ONDISK);
     373       14182 :     memcpy(VARDATA_EXTERNAL(result), &toast_pointer, sizeof(toast_pointer));
     374             : 
     375       14182 :     return PointerGetDatum(result);
     376             : }
     377             : 
     378             : /* ----------
     379             :  * toast_delete_datum -
     380             :  *
     381             :  *  Delete a single external stored value.
     382             :  * ----------
     383             :  */
     384             : void
     385         988 : toast_delete_datum(Relation rel, Datum value, bool is_speculative)
     386             : {
     387         988 :     struct varlena *attr = (struct varlena *) DatumGetPointer(value);
     388             :     struct varatt_external toast_pointer;
     389             :     Relation    toastrel;
     390             :     Relation   *toastidxs;
     391             :     ScanKeyData toastkey;
     392             :     SysScanDesc toastscan;
     393             :     HeapTuple   toasttup;
     394             :     int         num_indexes;
     395             :     int         validIndex;
     396             :     SnapshotData SnapshotToast;
     397             : 
     398         988 :     if (!VARATT_IS_EXTERNAL_ONDISK(attr))
     399           0 :         return;
     400             : 
     401             :     /* Must copy to access aligned fields */
     402         988 :     VARATT_EXTERNAL_GET_POINTER(toast_pointer, attr);
     403             : 
     404             :     /*
     405             :      * Open the toast relation and its indexes
     406             :      */
     407         988 :     toastrel = table_open(toast_pointer.va_toastrelid, RowExclusiveLock);
     408             : 
     409             :     /* Fetch valid relation used for process */
     410         988 :     validIndex = toast_open_indexes(toastrel,
     411             :                                     RowExclusiveLock,
     412             :                                     &toastidxs,
     413             :                                     &num_indexes);
     414             : 
     415             :     /*
     416             :      * Setup a scan key to find chunks with matching va_valueid
     417             :      */
     418         988 :     ScanKeyInit(&toastkey,
     419             :                 (AttrNumber) 1,
     420             :                 BTEqualStrategyNumber, F_OIDEQ,
     421             :                 ObjectIdGetDatum(toast_pointer.va_valueid));
     422             : 
     423             :     /*
     424             :      * Find all the chunks.  (We don't actually care whether we see them in
     425             :      * sequence or not, but since we've already locked the index we might as
     426             :      * well use systable_beginscan_ordered.)
     427             :      */
     428         988 :     init_toast_snapshot(&SnapshotToast);
     429         988 :     toastscan = systable_beginscan_ordered(toastrel, toastidxs[validIndex],
     430             :                                            &SnapshotToast, 1, &toastkey);
     431        4264 :     while ((toasttup = systable_getnext_ordered(toastscan, ForwardScanDirection)) != NULL)
     432             :     {
     433             :         /*
     434             :          * Have a chunk, delete it
     435             :          */
     436        3276 :         if (is_speculative)
     437          10 :             heap_abort_speculative(toastrel, &toasttup->t_self);
     438             :         else
     439        3266 :             simple_heap_delete(toastrel, &toasttup->t_self);
     440             :     }
     441             : 
     442             :     /*
     443             :      * End scan and close relations but keep the lock until commit, so as a
     444             :      * concurrent reindex done directly on the toast relation would be able to
     445             :      * wait for this transaction.
     446             :      */
     447         988 :     systable_endscan_ordered(toastscan);
     448         988 :     toast_close_indexes(toastidxs, num_indexes, NoLock);
     449         988 :     table_close(toastrel, NoLock);
     450             : }
     451             : 
     452             : /* ----------
     453             :  * toastrel_valueid_exists -
     454             :  *
     455             :  *  Test whether a toast value with the given ID exists in the toast relation.
     456             :  *  For safety, we consider a value to exist if there are either live or dead
     457             :  *  toast rows with that ID; see notes for GetNewOidWithIndex().
     458             :  * ----------
     459             :  */
     460             : static bool
     461         580 : toastrel_valueid_exists(Relation toastrel, Oid valueid)
     462             : {
     463         580 :     bool        result = false;
     464             :     ScanKeyData toastkey;
     465             :     SysScanDesc toastscan;
     466             :     int         num_indexes;
     467             :     int         validIndex;
     468             :     Relation   *toastidxs;
     469             : 
     470             :     /* Fetch a valid index relation */
     471         580 :     validIndex = toast_open_indexes(toastrel,
     472             :                                     RowExclusiveLock,
     473             :                                     &toastidxs,
     474             :                                     &num_indexes);
     475             : 
     476             :     /*
     477             :      * Setup a scan key to find chunks with matching va_valueid
     478             :      */
     479         580 :     ScanKeyInit(&toastkey,
     480             :                 (AttrNumber) 1,
     481             :                 BTEqualStrategyNumber, F_OIDEQ,
     482             :                 ObjectIdGetDatum(valueid));
     483             : 
     484             :     /*
     485             :      * Is there any such chunk?
     486             :      */
     487         580 :     toastscan = systable_beginscan(toastrel,
     488         580 :                                    RelationGetRelid(toastidxs[validIndex]),
     489             :                                    true, SnapshotAny, 1, &toastkey);
     490             : 
     491         580 :     if (systable_getnext(toastscan) != NULL)
     492           0 :         result = true;
     493             : 
     494         580 :     systable_endscan(toastscan);
     495             : 
     496             :     /* Clean up */
     497         580 :     toast_close_indexes(toastidxs, num_indexes, RowExclusiveLock);
     498             : 
     499         580 :     return result;
     500             : }
     501             : 
     502             : /* ----------
     503             :  * toastid_valueid_exists -
     504             :  *
     505             :  *  As above, but work from toast rel's OID not an open relation
     506             :  * ----------
     507             :  */
     508             : static bool
     509           0 : toastid_valueid_exists(Oid toastrelid, Oid valueid)
     510             : {
     511             :     bool        result;
     512             :     Relation    toastrel;
     513             : 
     514           0 :     toastrel = table_open(toastrelid, AccessShareLock);
     515             : 
     516           0 :     result = toastrel_valueid_exists(toastrel, valueid);
     517             : 
     518           0 :     table_close(toastrel, AccessShareLock);
     519             : 
     520           0 :     return result;
     521             : }
     522             : 
     523             : /* ----------
     524             :  * toast_get_valid_index
     525             :  *
     526             :  *  Get OID of valid index associated to given toast relation. A toast
     527             :  *  relation can have only one valid index at the same time.
     528             :  */
     529             : Oid
     530         750 : toast_get_valid_index(Oid toastoid, LOCKMODE lock)
     531             : {
     532             :     int         num_indexes;
     533             :     int         validIndex;
     534             :     Oid         validIndexOid;
     535             :     Relation   *toastidxs;
     536             :     Relation    toastrel;
     537             : 
     538             :     /* Open the toast relation */
     539         750 :     toastrel = table_open(toastoid, lock);
     540             : 
     541             :     /* Look for the valid index of the toast relation */
     542         750 :     validIndex = toast_open_indexes(toastrel,
     543             :                                     lock,
     544             :                                     &toastidxs,
     545             :                                     &num_indexes);
     546         750 :     validIndexOid = RelationGetRelid(toastidxs[validIndex]);
     547             : 
     548             :     /* Close the toast relation and all its indexes */
     549         750 :     toast_close_indexes(toastidxs, num_indexes, NoLock);
     550         750 :     table_close(toastrel, NoLock);
     551             : 
     552         750 :     return validIndexOid;
     553             : }
     554             : 
     555             : /* ----------
     556             :  * toast_open_indexes
     557             :  *
     558             :  *  Get an array of the indexes associated to the given toast relation
     559             :  *  and return as well the position of the valid index used by the toast
     560             :  *  relation in this array. It is the responsibility of the caller of this
     561             :  *  function to close the indexes as well as free them.
     562             :  */
     563             : int
     564       35598 : toast_open_indexes(Relation toastrel,
     565             :                    LOCKMODE lock,
     566             :                    Relation **toastidxs,
     567             :                    int *num_indexes)
     568             : {
     569       35598 :     int         i = 0;
     570       35598 :     int         res = 0;
     571       35598 :     bool        found = false;
     572             :     List       *indexlist;
     573             :     ListCell   *lc;
     574             : 
     575             :     /* Get index list of the toast relation */
     576       35598 :     indexlist = RelationGetIndexList(toastrel);
     577             :     Assert(indexlist != NIL);
     578             : 
     579       35598 :     *num_indexes = list_length(indexlist);
     580             : 
     581             :     /* Open all the index relations */
     582       35598 :     *toastidxs = (Relation *) palloc(*num_indexes * sizeof(Relation));
     583       71196 :     foreach(lc, indexlist)
     584       35598 :         (*toastidxs)[i++] = index_open(lfirst_oid(lc), lock);
     585             : 
     586             :     /* Fetch the first valid index in list */
     587       35598 :     for (i = 0; i < *num_indexes; i++)
     588             :     {
     589       35598 :         Relation    toastidx = (*toastidxs)[i];
     590             : 
     591       35598 :         if (toastidx->rd_index->indisvalid)
     592             :         {
     593       35598 :             res = i;
     594       35598 :             found = true;
     595       35598 :             break;
     596             :         }
     597             :     }
     598             : 
     599             :     /*
     600             :      * Free index list, not necessary anymore as relations are opened and a
     601             :      * valid index has been found.
     602             :      */
     603       35598 :     list_free(indexlist);
     604             : 
     605             :     /*
     606             :      * The toast relation should have one valid index, so something is going
     607             :      * wrong if there is nothing.
     608             :      */
     609       35598 :     if (!found)
     610           0 :         elog(ERROR, "no valid index found for toast relation with Oid %u",
     611             :              RelationGetRelid(toastrel));
     612             : 
     613       35598 :     return res;
     614             : }
     615             : 
     616             : /* ----------
     617             :  * toast_close_indexes
     618             :  *
     619             :  *  Close an array of indexes for a toast relation and free it. This should
     620             :  *  be called for a set of indexes opened previously with toast_open_indexes.
     621             :  */
     622             : void
     623       35592 : toast_close_indexes(Relation *toastidxs, int num_indexes, LOCKMODE lock)
     624             : {
     625             :     int         i;
     626             : 
     627             :     /* Close relations and clean up things */
     628       71184 :     for (i = 0; i < num_indexes; i++)
     629       35592 :         index_close(toastidxs[i], lock);
     630       35592 :     pfree(toastidxs);
     631       35592 : }
     632             : 
     633             : /* ----------
     634             :  * init_toast_snapshot
     635             :  *
     636             :  *  Initialize an appropriate TOAST snapshot.  We must use an MVCC snapshot
     637             :  *  to initialize the TOAST snapshot; since we don't know which one to use,
     638             :  *  just use the oldest one.
     639             :  */
     640             : void
     641       42466 : init_toast_snapshot(Snapshot toast_snapshot)
     642             : {
     643       42466 :     Snapshot    snapshot = GetOldestSnapshot();
     644             : 
     645             :     /*
     646             :      * GetOldestSnapshot returns NULL if the session has no active snapshots.
     647             :      * We can get that if, for example, a procedure fetches a toasted value
     648             :      * into a local variable, commits, and then tries to detoast the value.
     649             :      * Such coding is unsafe, because once we commit there is nothing to
     650             :      * prevent the toast data from being deleted.  Detoasting *must* happen in
     651             :      * the same transaction that originally fetched the toast pointer.  Hence,
     652             :      * rather than trying to band-aid over the problem, throw an error.  (This
     653             :      * is not very much protection, because in many scenarios the procedure
     654             :      * would have already created a new transaction snapshot, preventing us
     655             :      * from detecting the problem.  But it's better than nothing, and for sure
     656             :      * we shouldn't expend code on masking the problem more.)
     657             :      */
     658       42466 :     if (snapshot == NULL)
     659           0 :         elog(ERROR, "cannot fetch toast data without an active snapshot");
     660             : 
     661             :     /*
     662             :      * Catalog snapshots can be returned by GetOldestSnapshot() even if not
     663             :      * registered or active. That easily hides bugs around not having a
     664             :      * snapshot set up - most of the time there is a valid catalog snapshot.
     665             :      * So additionally insist that the current snapshot is registered or
     666             :      * active.
     667             :      */
     668             :     Assert(HaveRegisteredOrActiveSnapshot());
     669             : 
     670       42466 :     InitToastSnapshot(*toast_snapshot, snapshot->lsn, snapshot->whenTaken);
     671       42466 : }

Generated by: LCOV version 1.14