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

Generated by: LCOV version 1.14