LCOV - code coverage report
Current view: top level - src/backend/executor - execIndexing.c (source / functions) Hit Total Coverage
Test: PostgreSQL 16beta1 Lines: 236 254 92.9 %
Date: 2023-06-06 08:12:15 Functions: 9 9 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * execIndexing.c
       4             :  *    routines for inserting index tuples and enforcing unique and
       5             :  *    exclusion constraints.
       6             :  *
       7             :  * ExecInsertIndexTuples() is the main entry point.  It's called after
       8             :  * inserting a tuple to the heap, and it inserts corresponding index tuples
       9             :  * into all indexes.  At the same time, it enforces any unique and
      10             :  * exclusion constraints:
      11             :  *
      12             :  * Unique Indexes
      13             :  * --------------
      14             :  *
      15             :  * Enforcing a unique constraint is straightforward.  When the index AM
      16             :  * inserts the tuple to the index, it also checks that there are no
      17             :  * conflicting tuples in the index already.  It does so atomically, so that
      18             :  * even if two backends try to insert the same key concurrently, only one
      19             :  * of them will succeed.  All the logic to ensure atomicity, and to wait
      20             :  * for in-progress transactions to finish, is handled by the index AM.
      21             :  *
      22             :  * If a unique constraint is deferred, we request the index AM to not
      23             :  * throw an error if a conflict is found.  Instead, we make note that there
      24             :  * was a conflict and return the list of indexes with conflicts to the
      25             :  * caller.  The caller must re-check them later, by calling index_insert()
      26             :  * with the UNIQUE_CHECK_EXISTING option.
      27             :  *
      28             :  * Exclusion Constraints
      29             :  * ---------------------
      30             :  *
      31             :  * Exclusion constraints are different from unique indexes in that when the
      32             :  * tuple is inserted to the index, the index AM does not check for
      33             :  * duplicate keys at the same time.  After the insertion, we perform a
      34             :  * separate scan on the index to check for conflicting tuples, and if one
      35             :  * is found, we throw an error and the transaction is aborted.  If the
      36             :  * conflicting tuple's inserter or deleter is in-progress, we wait for it
      37             :  * to finish first.
      38             :  *
      39             :  * There is a chance of deadlock, if two backends insert a tuple at the
      40             :  * same time, and then perform the scan to check for conflicts.  They will
      41             :  * find each other's tuple, and both try to wait for each other.  The
      42             :  * deadlock detector will detect that, and abort one of the transactions.
      43             :  * That's fairly harmless, as one of them was bound to abort with a
      44             :  * "duplicate key error" anyway, although you get a different error
      45             :  * message.
      46             :  *
      47             :  * If an exclusion constraint is deferred, we still perform the conflict
      48             :  * checking scan immediately after inserting the index tuple.  But instead
      49             :  * of throwing an error if a conflict is found, we return that information
      50             :  * to the caller.  The caller must re-check them later by calling
      51             :  * check_exclusion_constraint().
      52             :  *
      53             :  * Speculative insertion
      54             :  * ---------------------
      55             :  *
      56             :  * Speculative insertion is a two-phase mechanism used to implement
      57             :  * INSERT ... ON CONFLICT DO UPDATE/NOTHING.  The tuple is first inserted
      58             :  * to the heap and update the indexes as usual, but if a constraint is
      59             :  * violated, we can still back out the insertion without aborting the whole
      60             :  * transaction.  In an INSERT ... ON CONFLICT statement, if a conflict is
      61             :  * detected, the inserted tuple is backed out and the ON CONFLICT action is
      62             :  * executed instead.
      63             :  *
      64             :  * Insertion to a unique index works as usual: the index AM checks for
      65             :  * duplicate keys atomically with the insertion.  But instead of throwing
      66             :  * an error on a conflict, the speculatively inserted heap tuple is backed
      67             :  * out.
      68             :  *
      69             :  * Exclusion constraints are slightly more complicated.  As mentioned
      70             :  * earlier, there is a risk of deadlock when two backends insert the same
      71             :  * key concurrently.  That was not a problem for regular insertions, when
      72             :  * one of the transactions has to be aborted anyway, but with a speculative
      73             :  * insertion we cannot let a deadlock happen, because we only want to back
      74             :  * out the speculatively inserted tuple on conflict, not abort the whole
      75             :  * transaction.
      76             :  *
      77             :  * When a backend detects that the speculative insertion conflicts with
      78             :  * another in-progress tuple, it has two options:
      79             :  *
      80             :  * 1. back out the speculatively inserted tuple, then wait for the other
      81             :  *    transaction, and retry. Or,
      82             :  * 2. wait for the other transaction, with the speculatively inserted tuple
      83             :  *    still in place.
      84             :  *
      85             :  * If two backends insert at the same time, and both try to wait for each
      86             :  * other, they will deadlock.  So option 2 is not acceptable.  Option 1
      87             :  * avoids the deadlock, but it is prone to a livelock instead.  Both
      88             :  * transactions will wake up immediately as the other transaction backs
      89             :  * out.  Then they both retry, and conflict with each other again, lather,
      90             :  * rinse, repeat.
      91             :  *
      92             :  * To avoid the livelock, one of the backends must back out first, and then
      93             :  * wait, while the other one waits without backing out.  It doesn't matter
      94             :  * which one backs out, so we employ an arbitrary rule that the transaction
      95             :  * with the higher XID backs out.
      96             :  *
      97             :  *
      98             :  * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
      99             :  * Portions Copyright (c) 1994, Regents of the University of California
     100             :  *
     101             :  *
     102             :  * IDENTIFICATION
     103             :  *    src/backend/executor/execIndexing.c
     104             :  *
     105             :  *-------------------------------------------------------------------------
     106             :  */
     107             : #include "postgres.h"
     108             : 
     109             : #include "access/genam.h"
     110             : #include "access/relscan.h"
     111             : #include "access/tableam.h"
     112             : #include "access/xact.h"
     113             : #include "catalog/index.h"
     114             : #include "executor/executor.h"
     115             : #include "nodes/nodeFuncs.h"
     116             : #include "storage/lmgr.h"
     117             : #include "utils/snapmgr.h"
     118             : 
     119             : /* waitMode argument to check_exclusion_or_unique_constraint() */
     120             : typedef enum
     121             : {
     122             :     CEOUC_WAIT,
     123             :     CEOUC_NOWAIT,
     124             :     CEOUC_LIVELOCK_PREVENTING_WAIT
     125             : } CEOUC_WAIT_MODE;
     126             : 
     127             : static bool check_exclusion_or_unique_constraint(Relation heap, Relation index,
     128             :                                                  IndexInfo *indexInfo,
     129             :                                                  ItemPointer tupleid,
     130             :                                                  Datum *values, bool *isnull,
     131             :                                                  EState *estate, bool newIndex,
     132             :                                                  CEOUC_WAIT_MODE waitMode,
     133             :                                                  bool violationOK,
     134             :                                                  ItemPointer conflictTid);
     135             : 
     136             : static bool index_recheck_constraint(Relation index, Oid *constr_procs,
     137             :                                      Datum *existing_values, bool *existing_isnull,
     138             :                                      Datum *new_values);
     139             : static bool index_unchanged_by_update(ResultRelInfo *resultRelInfo,
     140             :                                       EState *estate, IndexInfo *indexInfo,
     141             :                                       Relation indexRelation);
     142             : static bool index_expression_changed_walker(Node *node,
     143             :                                             Bitmapset *allUpdatedCols);
     144             : 
     145             : /* ----------------------------------------------------------------
     146             :  *      ExecOpenIndices
     147             :  *
     148             :  *      Find the indices associated with a result relation, open them,
     149             :  *      and save information about them in the result ResultRelInfo.
     150             :  *
     151             :  *      At entry, caller has already opened and locked
     152             :  *      resultRelInfo->ri_RelationDesc.
     153             :  * ----------------------------------------------------------------
     154             :  */
     155             : void
     156     4287152 : ExecOpenIndices(ResultRelInfo *resultRelInfo, bool speculative)
     157             : {
     158     4287152 :     Relation    resultRelation = resultRelInfo->ri_RelationDesc;
     159             :     List       *indexoidlist;
     160             :     ListCell   *l;
     161             :     int         len,
     162             :                 i;
     163             :     RelationPtr relationDescs;
     164             :     IndexInfo **indexInfoArray;
     165             : 
     166     4287152 :     resultRelInfo->ri_NumIndices = 0;
     167             : 
     168             :     /* fast path if no indexes */
     169     4287152 :     if (!RelationGetForm(resultRelation)->relhasindex)
     170      482370 :         return;
     171             : 
     172             :     /*
     173             :      * Get cached list of index OIDs
     174             :      */
     175     3804782 :     indexoidlist = RelationGetIndexList(resultRelation);
     176     3804782 :     len = list_length(indexoidlist);
     177     3804782 :     if (len == 0)
     178       40686 :         return;
     179             : 
     180             :     /*
     181             :      * allocate space for result arrays
     182             :      */
     183     3764096 :     relationDescs = (RelationPtr) palloc(len * sizeof(Relation));
     184     3764096 :     indexInfoArray = (IndexInfo **) palloc(len * sizeof(IndexInfo *));
     185             : 
     186     3764096 :     resultRelInfo->ri_NumIndices = len;
     187     3764096 :     resultRelInfo->ri_IndexRelationDescs = relationDescs;
     188     3764096 :     resultRelInfo->ri_IndexRelationInfo = indexInfoArray;
     189             : 
     190             :     /*
     191             :      * For each index, open the index relation and save pg_index info. We
     192             :      * acquire RowExclusiveLock, signifying we will update the index.
     193             :      *
     194             :      * Note: we do this even if the index is not indisready; it's not worth
     195             :      * the trouble to optimize for the case where it isn't.
     196             :      */
     197     3764096 :     i = 0;
     198    11053456 :     foreach(l, indexoidlist)
     199             :     {
     200     7289360 :         Oid         indexOid = lfirst_oid(l);
     201             :         Relation    indexDesc;
     202             :         IndexInfo  *ii;
     203             : 
     204     7289360 :         indexDesc = index_open(indexOid, RowExclusiveLock);
     205             : 
     206             :         /* extract index key information from the index's pg_index info */
     207     7289360 :         ii = BuildIndexInfo(indexDesc);
     208             : 
     209             :         /*
     210             :          * If the indexes are to be used for speculative insertion, add extra
     211             :          * information required by unique index entries.
     212             :          */
     213     7289360 :         if (speculative && ii->ii_Unique)
     214        1206 :             BuildSpeculativeIndexInfo(indexDesc, ii);
     215             : 
     216     7289360 :         relationDescs[i] = indexDesc;
     217     7289360 :         indexInfoArray[i] = ii;
     218     7289360 :         i++;
     219             :     }
     220             : 
     221     3764096 :     list_free(indexoidlist);
     222             : }
     223             : 
     224             : /* ----------------------------------------------------------------
     225             :  *      ExecCloseIndices
     226             :  *
     227             :  *      Close the index relations stored in resultRelInfo
     228             :  * ----------------------------------------------------------------
     229             :  */
     230             : void
     231     4390238 : ExecCloseIndices(ResultRelInfo *resultRelInfo)
     232             : {
     233             :     int         i;
     234             :     int         numIndices;
     235             :     RelationPtr indexDescs;
     236             : 
     237     4390238 :     numIndices = resultRelInfo->ri_NumIndices;
     238     4390238 :     indexDescs = resultRelInfo->ri_IndexRelationDescs;
     239             : 
     240    11678092 :     for (i = 0; i < numIndices; i++)
     241             :     {
     242     7287854 :         if (indexDescs[i] == NULL)
     243           0 :             continue;           /* shouldn't happen? */
     244             : 
     245             :         /* Drop lock acquired by ExecOpenIndices */
     246     7287854 :         index_close(indexDescs[i], RowExclusiveLock);
     247             :     }
     248             : 
     249             :     /*
     250             :      * XXX should free indexInfo array here too?  Currently we assume that
     251             :      * such stuff will be cleaned up automatically in FreeExecutorState.
     252             :      */
     253     4390238 : }
     254             : 
     255             : /* ----------------------------------------------------------------
     256             :  *      ExecInsertIndexTuples
     257             :  *
     258             :  *      This routine takes care of inserting index tuples
     259             :  *      into all the relations indexing the result relation
     260             :  *      when a heap tuple is inserted into the result relation.
     261             :  *
     262             :  *      When 'update' is true and 'onlySummarizing' is false,
     263             :  *      executor is performing an UPDATE that could not use an
     264             :  *      optimization like heapam's HOT (in more general terms a
     265             :  *      call to table_tuple_update() took place and set
     266             :  *      'update_indexes' to TUUI_All).  Receiving this hint makes
     267             :  *      us consider if we should pass down the 'indexUnchanged'
     268             :  *      hint in turn.  That's something that we figure out for
     269             :  *      each index_insert() call iff 'update' is true.
     270             :  *      (When 'update' is false we already know not to pass the
     271             :  *      hint to any index.)
     272             :  *
     273             :  *      If onlySummarizing is set, an equivalent optimization to
     274             :  *      HOT has been applied and any updated columns are indexed
     275             :  *      only by summarizing indexes (or in more general terms a
     276             :  *      call to table_tuple_update() took place and set
     277             :  *      'update_indexes' to TUUI_Summarizing). We can (and must)
     278             :  *      therefore only update the indexes that have
     279             :  *      'amsummarizing' = true.
     280             :  *
     281             :  *      Unique and exclusion constraints are enforced at the same
     282             :  *      time.  This returns a list of index OIDs for any unique or
     283             :  *      exclusion constraints that are deferred and that had
     284             :  *      potential (unconfirmed) conflicts.  (if noDupErr == true,
     285             :  *      the same is done for non-deferred constraints, but report
     286             :  *      if conflict was speculative or deferred conflict to caller)
     287             :  *
     288             :  *      If 'arbiterIndexes' is nonempty, noDupErr applies only to
     289             :  *      those indexes.  NIL means noDupErr applies to all indexes.
     290             :  * ----------------------------------------------------------------
     291             :  */
     292             : List *
     293     3815006 : ExecInsertIndexTuples(ResultRelInfo *resultRelInfo,
     294             :                       TupleTableSlot *slot,
     295             :                       EState *estate,
     296             :                       bool update,
     297             :                       bool noDupErr,
     298             :                       bool *specConflict,
     299             :                       List *arbiterIndexes,
     300             :                       bool onlySummarizing)
     301             : {
     302     3815006 :     ItemPointer tupleid = &slot->tts_tid;
     303     3815006 :     List       *result = NIL;
     304             :     int         i;
     305             :     int         numIndices;
     306             :     RelationPtr relationDescs;
     307             :     Relation    heapRelation;
     308             :     IndexInfo **indexInfoArray;
     309             :     ExprContext *econtext;
     310             :     Datum       values[INDEX_MAX_KEYS];
     311             :     bool        isnull[INDEX_MAX_KEYS];
     312             : 
     313             :     Assert(ItemPointerIsValid(tupleid));
     314             : 
     315             :     /*
     316             :      * Get information from the result relation info structure.
     317             :      */
     318     3815006 :     numIndices = resultRelInfo->ri_NumIndices;
     319     3815006 :     relationDescs = resultRelInfo->ri_IndexRelationDescs;
     320     3815006 :     indexInfoArray = resultRelInfo->ri_IndexRelationInfo;
     321     3815006 :     heapRelation = resultRelInfo->ri_RelationDesc;
     322             : 
     323             :     /* Sanity check: slot must belong to the same rel as the resultRelInfo. */
     324             :     Assert(slot->tts_tableOid == RelationGetRelid(heapRelation));
     325             : 
     326             :     /*
     327             :      * We will use the EState's per-tuple context for evaluating predicates
     328             :      * and index expressions (creating it if it's not already there).
     329             :      */
     330     3815006 :     econtext = GetPerTupleExprContext(estate);
     331             : 
     332             :     /* Arrange for econtext's scan tuple to be the tuple under test */
     333     3815006 :     econtext->ecxt_scantuple = slot;
     334             : 
     335             :     /*
     336             :      * for each index, form and insert the index tuple
     337             :      */
     338     8095876 :     for (i = 0; i < numIndices; i++)
     339             :     {
     340     4281442 :         Relation    indexRelation = relationDescs[i];
     341             :         IndexInfo  *indexInfo;
     342             :         bool        applyNoDupErr;
     343             :         IndexUniqueCheck checkUnique;
     344             :         bool        indexUnchanged;
     345             :         bool        satisfiesConstraint;
     346             : 
     347     4281442 :         if (indexRelation == NULL)
     348           0 :             continue;
     349             : 
     350     4281442 :         indexInfo = indexInfoArray[i];
     351             : 
     352             :         /* If the index is marked as read-only, ignore it */
     353     4281442 :         if (!indexInfo->ii_ReadyForInserts)
     354         260 :             continue;
     355             : 
     356             :         /*
     357             :          * Skip processing of non-summarizing indexes if we only update
     358             :          * summarizing indexes
     359             :          */
     360     4281182 :         if (onlySummarizing && !indexInfo->ii_Summarizing)
     361           6 :             continue;
     362             : 
     363             :         /* Check for partial index */
     364     4281176 :         if (indexInfo->ii_Predicate != NIL)
     365             :         {
     366             :             ExprState  *predicate;
     367             : 
     368             :             /*
     369             :              * If predicate state not set up yet, create it (in the estate's
     370             :              * per-query context)
     371             :              */
     372      401090 :             predicate = indexInfo->ii_PredicateState;
     373      401090 :             if (predicate == NULL)
     374             :             {
     375         260 :                 predicate = ExecPrepareQual(indexInfo->ii_Predicate, estate);
     376         260 :                 indexInfo->ii_PredicateState = predicate;
     377             :             }
     378             : 
     379             :             /* Skip this index-update if the predicate isn't satisfied */
     380      401090 :             if (!ExecQual(predicate, econtext))
     381      400548 :                 continue;
     382             :         }
     383             : 
     384             :         /*
     385             :          * FormIndexDatum fills in its values and isnull parameters with the
     386             :          * appropriate values for the column(s) of the index.
     387             :          */
     388     3880628 :         FormIndexDatum(indexInfo,
     389             :                        slot,
     390             :                        estate,
     391             :                        values,
     392             :                        isnull);
     393             : 
     394             :         /* Check whether to apply noDupErr to this index */
     395     3884618 :         applyNoDupErr = noDupErr &&
     396        3990 :             (arbiterIndexes == NIL ||
     397        3990 :              list_member_oid(arbiterIndexes,
     398        3990 :                              indexRelation->rd_index->indexrelid));
     399             : 
     400             :         /*
     401             :          * The index AM does the actual insertion, plus uniqueness checking.
     402             :          *
     403             :          * For an immediate-mode unique index, we just tell the index AM to
     404             :          * throw error if not unique.
     405             :          *
     406             :          * For a deferrable unique index, we tell the index AM to just detect
     407             :          * possible non-uniqueness, and we add the index OID to the result
     408             :          * list if further checking is needed.
     409             :          *
     410             :          * For a speculative insertion (used by INSERT ... ON CONFLICT), do
     411             :          * the same as for a deferrable unique index.
     412             :          */
     413     3880628 :         if (!indexRelation->rd_index->indisunique)
     414     1861762 :             checkUnique = UNIQUE_CHECK_NO;
     415     2018866 :         else if (applyNoDupErr)
     416        4032 :             checkUnique = UNIQUE_CHECK_PARTIAL;
     417     2014834 :         else if (indexRelation->rd_index->indimmediate)
     418     2014684 :             checkUnique = UNIQUE_CHECK_YES;
     419             :         else
     420         150 :             checkUnique = UNIQUE_CHECK_PARTIAL;
     421             : 
     422             :         /*
     423             :          * There's definitely going to be an index_insert() call for this
     424             :          * index.  If we're being called as part of an UPDATE statement,
     425             :          * consider if the 'indexUnchanged' = true hint should be passed.
     426             :          */
     427     3880628 :         indexUnchanged = update && index_unchanged_by_update(resultRelInfo,
     428             :                                                              estate,
     429             :                                                              indexInfo,
     430             :                                                              indexRelation);
     431             : 
     432             :         satisfiesConstraint =
     433     3880628 :             index_insert(indexRelation, /* index relation */
     434             :                          values,    /* array of index Datums */
     435             :                          isnull,    /* null flags */
     436             :                          tupleid,   /* tid of heap tuple */
     437             :                          heapRelation,  /* heap relation */
     438             :                          checkUnique,   /* type of uniqueness check to do */
     439             :                          indexUnchanged,    /* UPDATE without logical change? */
     440             :                          indexInfo);    /* index AM may need this */
     441             : 
     442             :         /*
     443             :          * If the index has an associated exclusion constraint, check that.
     444             :          * This is simpler than the process for uniqueness checks since we
     445             :          * always insert first and then check.  If the constraint is deferred,
     446             :          * we check now anyway, but don't throw error on violation or wait for
     447             :          * a conclusive outcome from a concurrent insertion; instead we'll
     448             :          * queue a recheck event.  Similarly, noDupErr callers (speculative
     449             :          * inserters) will recheck later, and wait for a conclusive outcome
     450             :          * then.
     451             :          *
     452             :          * An index for an exclusion constraint can't also be UNIQUE (not an
     453             :          * essential property, we just don't allow it in the grammar), so no
     454             :          * need to preserve the prior state of satisfiesConstraint.
     455             :          */
     456     3880106 :         if (indexInfo->ii_ExclusionOps != NULL)
     457             :         {
     458             :             bool        violationOK;
     459             :             CEOUC_WAIT_MODE waitMode;
     460             : 
     461         306 :             if (applyNoDupErr)
     462             :             {
     463           0 :                 violationOK = true;
     464           0 :                 waitMode = CEOUC_LIVELOCK_PREVENTING_WAIT;
     465             :             }
     466         306 :             else if (!indexRelation->rd_index->indimmediate)
     467             :             {
     468          42 :                 violationOK = true;
     469          42 :                 waitMode = CEOUC_NOWAIT;
     470             :             }
     471             :             else
     472             :             {
     473         264 :                 violationOK = false;
     474         264 :                 waitMode = CEOUC_WAIT;
     475             :             }
     476             : 
     477             :             satisfiesConstraint =
     478         306 :                 check_exclusion_or_unique_constraint(heapRelation,
     479             :                                                      indexRelation, indexInfo,
     480             :                                                      tupleid, values, isnull,
     481             :                                                      estate, false,
     482             :                                                      waitMode, violationOK, NULL);
     483             :         }
     484             : 
     485     3880056 :         if ((checkUnique == UNIQUE_CHECK_PARTIAL ||
     486     3875874 :              indexInfo->ii_ExclusionOps != NULL) &&
     487        4438 :             !satisfiesConstraint)
     488             :         {
     489             :             /*
     490             :              * The tuple potentially violates the uniqueness or exclusion
     491             :              * constraint, so make a note of the index so that we can re-check
     492             :              * it later.  Speculative inserters are told if there was a
     493             :              * speculative conflict, since that always requires a restart.
     494             :              */
     495         132 :             result = lappend_oid(result, RelationGetRelid(indexRelation));
     496         132 :             if (indexRelation->rd_index->indimmediate && specConflict)
     497          10 :                 *specConflict = true;
     498             :         }
     499             :     }
     500             : 
     501     3814434 :     return result;
     502             : }
     503             : 
     504             : /* ----------------------------------------------------------------
     505             :  *      ExecCheckIndexConstraints
     506             :  *
     507             :  *      This routine checks if a tuple violates any unique or
     508             :  *      exclusion constraints.  Returns true if there is no conflict.
     509             :  *      Otherwise returns false, and the TID of the conflicting
     510             :  *      tuple is returned in *conflictTid.
     511             :  *
     512             :  *      If 'arbiterIndexes' is given, only those indexes are checked.
     513             :  *      NIL means all indexes.
     514             :  *
     515             :  *      Note that this doesn't lock the values in any way, so it's
     516             :  *      possible that a conflicting tuple is inserted immediately
     517             :  *      after this returns.  But this can be used for a pre-check
     518             :  *      before insertion.
     519             :  * ----------------------------------------------------------------
     520             :  */
     521             : bool
     522        9390 : ExecCheckIndexConstraints(ResultRelInfo *resultRelInfo, TupleTableSlot *slot,
     523             :                           EState *estate, ItemPointer conflictTid,
     524             :                           List *arbiterIndexes)
     525             : {
     526             :     int         i;
     527             :     int         numIndices;
     528             :     RelationPtr relationDescs;
     529             :     Relation    heapRelation;
     530             :     IndexInfo **indexInfoArray;
     531             :     ExprContext *econtext;
     532             :     Datum       values[INDEX_MAX_KEYS];
     533             :     bool        isnull[INDEX_MAX_KEYS];
     534             :     ItemPointerData invalidItemPtr;
     535        9390 :     bool        checkedIndex = false;
     536             : 
     537        9390 :     ItemPointerSetInvalid(conflictTid);
     538        9390 :     ItemPointerSetInvalid(&invalidItemPtr);
     539             : 
     540             :     /*
     541             :      * Get information from the result relation info structure.
     542             :      */
     543        9390 :     numIndices = resultRelInfo->ri_NumIndices;
     544        9390 :     relationDescs = resultRelInfo->ri_IndexRelationDescs;
     545        9390 :     indexInfoArray = resultRelInfo->ri_IndexRelationInfo;
     546        9390 :     heapRelation = resultRelInfo->ri_RelationDesc;
     547             : 
     548             :     /*
     549             :      * We will use the EState's per-tuple context for evaluating predicates
     550             :      * and index expressions (creating it if it's not already there).
     551             :      */
     552        9390 :     econtext = GetPerTupleExprContext(estate);
     553             : 
     554             :     /* Arrange for econtext's scan tuple to be the tuple under test */
     555        9390 :     econtext->ecxt_scantuple = slot;
     556             : 
     557             :     /*
     558             :      * For each index, form index tuple and check if it satisfies the
     559             :      * constraint.
     560             :      */
     561       13504 :     for (i = 0; i < numIndices; i++)
     562             :     {
     563        9478 :         Relation    indexRelation = relationDescs[i];
     564             :         IndexInfo  *indexInfo;
     565             :         bool        satisfiesConstraint;
     566             : 
     567        9478 :         if (indexRelation == NULL)
     568           0 :             continue;
     569             : 
     570        9478 :         indexInfo = indexInfoArray[i];
     571             : 
     572        9478 :         if (!indexInfo->ii_Unique && !indexInfo->ii_ExclusionOps)
     573           4 :             continue;
     574             : 
     575             :         /* If the index is marked as read-only, ignore it */
     576        9474 :         if (!indexInfo->ii_ReadyForInserts)
     577           0 :             continue;
     578             : 
     579             :         /* When specific arbiter indexes requested, only examine them */
     580        9474 :         if (arbiterIndexes != NIL &&
     581        9294 :             !list_member_oid(arbiterIndexes,
     582        9294 :                              indexRelation->rd_index->indexrelid))
     583          78 :             continue;
     584             : 
     585        9396 :         if (!indexRelation->rd_index->indimmediate)
     586           6 :             ereport(ERROR,
     587             :                     (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
     588             :                      errmsg("ON CONFLICT does not support deferrable unique constraints/exclusion constraints as arbiters"),
     589             :                      errtableconstraint(heapRelation,
     590             :                                         RelationGetRelationName(indexRelation))));
     591             : 
     592        9390 :         checkedIndex = true;
     593             : 
     594             :         /* Check for partial index */
     595        9390 :         if (indexInfo->ii_Predicate != NIL)
     596             :         {
     597             :             ExprState  *predicate;
     598             : 
     599             :             /*
     600             :              * If predicate state not set up yet, create it (in the estate's
     601             :              * per-query context)
     602             :              */
     603          30 :             predicate = indexInfo->ii_PredicateState;
     604          30 :             if (predicate == NULL)
     605             :             {
     606          30 :                 predicate = ExecPrepareQual(indexInfo->ii_Predicate, estate);
     607          30 :                 indexInfo->ii_PredicateState = predicate;
     608             :             }
     609             : 
     610             :             /* Skip this index-update if the predicate isn't satisfied */
     611          30 :             if (!ExecQual(predicate, econtext))
     612           0 :                 continue;
     613             :         }
     614             : 
     615             :         /*
     616             :          * FormIndexDatum fills in its values and isnull parameters with the
     617             :          * appropriate values for the column(s) of the index.
     618             :          */
     619        9390 :         FormIndexDatum(indexInfo,
     620             :                        slot,
     621             :                        estate,
     622             :                        values,
     623             :                        isnull);
     624             : 
     625             :         satisfiesConstraint =
     626        9390 :             check_exclusion_or_unique_constraint(heapRelation, indexRelation,
     627             :                                                  indexInfo, &invalidItemPtr,
     628             :                                                  values, isnull, estate, false,
     629             :                                                  CEOUC_WAIT, true,
     630             :                                                  conflictTid);
     631        9390 :         if (!satisfiesConstraint)
     632        5358 :             return false;
     633             :     }
     634             : 
     635        4026 :     if (arbiterIndexes != NIL && !checkedIndex)
     636           0 :         elog(ERROR, "unexpected failure to find arbiter index");
     637             : 
     638        4026 :     return true;
     639             : }
     640             : 
     641             : /*
     642             :  * Check for violation of an exclusion or unique constraint
     643             :  *
     644             :  * heap: the table containing the new tuple
     645             :  * index: the index supporting the constraint
     646             :  * indexInfo: info about the index, including the exclusion properties
     647             :  * tupleid: heap TID of the new tuple we have just inserted (invalid if we
     648             :  *      haven't inserted a new tuple yet)
     649             :  * values, isnull: the *index* column values computed for the new tuple
     650             :  * estate: an EState we can do evaluation in
     651             :  * newIndex: if true, we are trying to build a new index (this affects
     652             :  *      only the wording of error messages)
     653             :  * waitMode: whether to wait for concurrent inserters/deleters
     654             :  * violationOK: if true, don't throw error for violation
     655             :  * conflictTid: if not-NULL, the TID of the conflicting tuple is returned here
     656             :  *
     657             :  * Returns true if OK, false if actual or potential violation
     658             :  *
     659             :  * 'waitMode' determines what happens if a conflict is detected with a tuple
     660             :  * that was inserted or deleted by a transaction that's still running.
     661             :  * CEOUC_WAIT means that we wait for the transaction to commit, before
     662             :  * throwing an error or returning.  CEOUC_NOWAIT means that we report the
     663             :  * violation immediately; so the violation is only potential, and the caller
     664             :  * must recheck sometime later.  This behavior is convenient for deferred
     665             :  * exclusion checks; we need not bother queuing a deferred event if there is
     666             :  * definitely no conflict at insertion time.
     667             :  *
     668             :  * CEOUC_LIVELOCK_PREVENTING_WAIT is like CEOUC_NOWAIT, but we will sometimes
     669             :  * wait anyway, to prevent livelocking if two transactions try inserting at
     670             :  * the same time.  This is used with speculative insertions, for INSERT ON
     671             :  * CONFLICT statements. (See notes in file header)
     672             :  *
     673             :  * If violationOK is true, we just report the potential or actual violation to
     674             :  * the caller by returning 'false'.  Otherwise we throw a descriptive error
     675             :  * message here.  When violationOK is false, a false result is impossible.
     676             :  *
     677             :  * Note: The indexam is normally responsible for checking unique constraints,
     678             :  * so this normally only needs to be used for exclusion constraints.  But this
     679             :  * function is also called when doing a "pre-check" for conflicts on a unique
     680             :  * constraint, when doing speculative insertion.  Caller may use the returned
     681             :  * conflict TID to take further steps.
     682             :  */
     683             : static bool
     684        9766 : check_exclusion_or_unique_constraint(Relation heap, Relation index,
     685             :                                      IndexInfo *indexInfo,
     686             :                                      ItemPointer tupleid,
     687             :                                      Datum *values, bool *isnull,
     688             :                                      EState *estate, bool newIndex,
     689             :                                      CEOUC_WAIT_MODE waitMode,
     690             :                                      bool violationOK,
     691             :                                      ItemPointer conflictTid)
     692             : {
     693             :     Oid        *constr_procs;
     694             :     uint16     *constr_strats;
     695        9766 :     Oid        *index_collations = index->rd_indcollation;
     696        9766 :     int         indnkeyatts = IndexRelationGetNumberOfKeyAttributes(index);
     697             :     IndexScanDesc index_scan;
     698             :     ScanKeyData scankeys[INDEX_MAX_KEYS];
     699             :     SnapshotData DirtySnapshot;
     700             :     int         i;
     701             :     bool        conflict;
     702             :     bool        found_self;
     703             :     ExprContext *econtext;
     704             :     TupleTableSlot *existing_slot;
     705             :     TupleTableSlot *save_scantuple;
     706             : 
     707        9766 :     if (indexInfo->ii_ExclusionOps)
     708             :     {
     709         388 :         constr_procs = indexInfo->ii_ExclusionProcs;
     710         388 :         constr_strats = indexInfo->ii_ExclusionStrats;
     711             :     }
     712             :     else
     713             :     {
     714        9378 :         constr_procs = indexInfo->ii_UniqueProcs;
     715        9378 :         constr_strats = indexInfo->ii_UniqueStrats;
     716             :     }
     717             : 
     718             :     /*
     719             :      * If any of the input values are NULL, and the index uses the default
     720             :      * nulls-are-distinct mode, the constraint check is assumed to pass (i.e.,
     721             :      * we assume the operators are strict).  Otherwise, we interpret the
     722             :      * constraint as specifying IS NULL for each column whose input value is
     723             :      * NULL.
     724             :      */
     725        9766 :     if (!indexInfo->ii_NullsNotDistinct)
     726             :     {
     727       19696 :         for (i = 0; i < indnkeyatts; i++)
     728             :         {
     729        9936 :             if (isnull[i])
     730           0 :                 return true;
     731             :         }
     732             :     }
     733             : 
     734             :     /*
     735             :      * Search the tuples that are in the index for any violations, including
     736             :      * tuples that aren't visible yet.
     737             :      */
     738        9766 :     InitDirtySnapshot(DirtySnapshot);
     739             : 
     740       19708 :     for (i = 0; i < indnkeyatts; i++)
     741             :     {
     742        9942 :         ScanKeyEntryInitialize(&scankeys[i],
     743        9942 :                                isnull[i] ? SK_ISNULL | SK_SEARCHNULL : 0,
     744        9942 :                                i + 1,
     745        9942 :                                constr_strats[i],
     746             :                                InvalidOid,
     747        9942 :                                index_collations[i],
     748        9942 :                                constr_procs[i],
     749        9942 :                                values[i]);
     750             :     }
     751             : 
     752             :     /*
     753             :      * Need a TupleTableSlot to put existing tuples in.
     754             :      *
     755             :      * To use FormIndexDatum, we have to make the econtext's scantuple point
     756             :      * to this slot.  Be sure to save and restore caller's value for
     757             :      * scantuple.
     758             :      */
     759        9766 :     existing_slot = table_slot_create(heap, NULL);
     760             : 
     761        9766 :     econtext = GetPerTupleExprContext(estate);
     762        9766 :     save_scantuple = econtext->ecxt_scantuple;
     763        9766 :     econtext->ecxt_scantuple = existing_slot;
     764             : 
     765             :     /*
     766             :      * May have to restart scan from this point if a potential conflict is
     767             :      * found.
     768             :      */
     769        9836 : retry:
     770        9836 :     conflict = false;
     771        9836 :     found_self = false;
     772        9836 :     index_scan = index_beginscan(heap, index, &DirtySnapshot, indnkeyatts, 0);
     773        9836 :     index_rescan(index_scan, scankeys, indnkeyatts, NULL, 0);
     774             : 
     775       10168 :     while (index_getnext_slot(index_scan, ForwardScanDirection, existing_slot))
     776             :     {
     777             :         TransactionId xwait;
     778             :         XLTW_Oper   reason_wait;
     779             :         Datum       existing_values[INDEX_MAX_KEYS];
     780             :         bool        existing_isnull[INDEX_MAX_KEYS];
     781             :         char       *error_new;
     782             :         char       *error_existing;
     783             : 
     784             :         /*
     785             :          * Ignore the entry for the tuple we're trying to check.
     786             :          */
     787        6300 :         if (ItemPointerIsValid(tupleid) &&
     788         436 :             ItemPointerEquals(tupleid, &existing_slot->tts_tid))
     789             :         {
     790         278 :             if (found_self)     /* should not happen */
     791           0 :                 elog(ERROR, "found self tuple multiple times in index \"%s\"",
     792             :                      RelationGetRelationName(index));
     793         278 :             found_self = true;
     794         332 :             continue;
     795             :         }
     796             : 
     797             :         /*
     798             :          * Extract the index column values and isnull flags from the existing
     799             :          * tuple.
     800             :          */
     801        5586 :         FormIndexDatum(indexInfo, existing_slot, estate,
     802             :                        existing_values, existing_isnull);
     803             : 
     804             :         /* If lossy indexscan, must recheck the condition */
     805        5586 :         if (index_scan->xs_recheck)
     806             :         {
     807          72 :             if (!index_recheck_constraint(index,
     808             :                                           constr_procs,
     809             :                                           existing_values,
     810             :                                           existing_isnull,
     811             :                                           values))
     812          54 :                 continue;       /* tuple doesn't actually match, so no
     813             :                                  * conflict */
     814             :         }
     815             : 
     816             :         /*
     817             :          * At this point we have either a conflict or a potential conflict.
     818             :          *
     819             :          * If an in-progress transaction is affecting the visibility of this
     820             :          * tuple, we need to wait for it to complete and then recheck (unless
     821             :          * the caller requested not to).  For simplicity we do rechecking by
     822             :          * just restarting the whole scan --- this case probably doesn't
     823             :          * happen often enough to be worth trying harder, and anyway we don't
     824             :          * want to hold any index internal locks while waiting.
     825             :          */
     826       11064 :         xwait = TransactionIdIsValid(DirtySnapshot.xmin) ?
     827        5532 :             DirtySnapshot.xmin : DirtySnapshot.xmax;
     828             : 
     829        5532 :         if (TransactionIdIsValid(xwait) &&
     830           0 :             (waitMode == CEOUC_WAIT ||
     831           0 :              (waitMode == CEOUC_LIVELOCK_PREVENTING_WAIT &&
     832           0 :               DirtySnapshot.speculativeToken &&
     833           0 :               TransactionIdPrecedes(GetCurrentTransactionId(), xwait))))
     834             :         {
     835         140 :             reason_wait = indexInfo->ii_ExclusionOps ?
     836          70 :                 XLTW_RecheckExclusionConstr : XLTW_InsertIndex;
     837          70 :             index_endscan(index_scan);
     838          70 :             if (DirtySnapshot.speculativeToken)
     839           2 :                 SpeculativeInsertionWait(DirtySnapshot.xmin,
     840             :                                          DirtySnapshot.speculativeToken);
     841             :             else
     842          68 :                 XactLockTableWait(xwait, heap,
     843             :                                   &existing_slot->tts_tid, reason_wait);
     844          70 :             goto retry;
     845             :         }
     846             : 
     847             :         /*
     848             :          * We have a definite conflict (or a potential one, but the caller
     849             :          * didn't want to wait).  Return it to caller, or report it.
     850             :          */
     851        5462 :         if (violationOK)
     852             :         {
     853        5382 :             conflict = true;
     854        5382 :             if (conflictTid)
     855        5358 :                 *conflictTid = existing_slot->tts_tid;
     856        5382 :             break;
     857             :         }
     858             : 
     859          80 :         error_new = BuildIndexValueDescription(index, values, isnull);
     860          80 :         error_existing = BuildIndexValueDescription(index, existing_values,
     861             :                                                     existing_isnull);
     862          80 :         if (newIndex)
     863          12 :             ereport(ERROR,
     864             :                     (errcode(ERRCODE_EXCLUSION_VIOLATION),
     865             :                      errmsg("could not create exclusion constraint \"%s\"",
     866             :                             RelationGetRelationName(index)),
     867             :                      error_new && error_existing ?
     868             :                      errdetail("Key %s conflicts with key %s.",
     869             :                                error_new, error_existing) :
     870             :                      errdetail("Key conflicts exist."),
     871             :                      errtableconstraint(heap,
     872             :                                         RelationGetRelationName(index))));
     873             :         else
     874          68 :             ereport(ERROR,
     875             :                     (errcode(ERRCODE_EXCLUSION_VIOLATION),
     876             :                      errmsg("conflicting key value violates exclusion constraint \"%s\"",
     877             :                             RelationGetRelationName(index)),
     878             :                      error_new && error_existing ?
     879             :                      errdetail("Key %s conflicts with existing key %s.",
     880             :                                error_new, error_existing) :
     881             :                      errdetail("Key conflicts with existing key."),
     882             :                      errtableconstraint(heap,
     883             :                                         RelationGetRelationName(index))));
     884             :     }
     885             : 
     886        9686 :     index_endscan(index_scan);
     887             : 
     888             :     /*
     889             :      * Ordinarily, at this point the search should have found the originally
     890             :      * inserted tuple (if any), unless we exited the loop early because of
     891             :      * conflict.  However, it is possible to define exclusion constraints for
     892             :      * which that wouldn't be true --- for instance, if the operator is <>. So
     893             :      * we no longer complain if found_self is still false.
     894             :      */
     895             : 
     896        9686 :     econtext->ecxt_scantuple = save_scantuple;
     897             : 
     898        9686 :     ExecDropSingleTupleTableSlot(existing_slot);
     899             : 
     900        9686 :     return !conflict;
     901             : }
     902             : 
     903             : /*
     904             :  * Check for violation of an exclusion constraint
     905             :  *
     906             :  * This is a dumbed down version of check_exclusion_or_unique_constraint
     907             :  * for external callers. They don't need all the special modes.
     908             :  */
     909             : void
     910          70 : check_exclusion_constraint(Relation heap, Relation index,
     911             :                            IndexInfo *indexInfo,
     912             :                            ItemPointer tupleid,
     913             :                            Datum *values, bool *isnull,
     914             :                            EState *estate, bool newIndex)
     915             : {
     916          70 :     (void) check_exclusion_or_unique_constraint(heap, index, indexInfo, tupleid,
     917             :                                                 values, isnull,
     918             :                                                 estate, newIndex,
     919             :                                                 CEOUC_WAIT, false, NULL);
     920          40 : }
     921             : 
     922             : /*
     923             :  * Check existing tuple's index values to see if it really matches the
     924             :  * exclusion condition against the new_values.  Returns true if conflict.
     925             :  */
     926             : static bool
     927          72 : index_recheck_constraint(Relation index, Oid *constr_procs,
     928             :                          Datum *existing_values, bool *existing_isnull,
     929             :                          Datum *new_values)
     930             : {
     931          72 :     int         indnkeyatts = IndexRelationGetNumberOfKeyAttributes(index);
     932             :     int         i;
     933             : 
     934         144 :     for (i = 0; i < indnkeyatts; i++)
     935             :     {
     936             :         /* Assume the exclusion operators are strict */
     937         126 :         if (existing_isnull[i])
     938           0 :             return false;
     939             : 
     940         126 :         if (!DatumGetBool(OidFunctionCall2Coll(constr_procs[i],
     941         126 :                                                index->rd_indcollation[i],
     942         126 :                                                existing_values[i],
     943         126 :                                                new_values[i])))
     944          54 :             return false;
     945             :     }
     946             : 
     947          18 :     return true;
     948             : }
     949             : 
     950             : /*
     951             :  * Check if ExecInsertIndexTuples() should pass indexUnchanged hint.
     952             :  *
     953             :  * When the executor performs an UPDATE that requires a new round of index
     954             :  * tuples, determine if we should pass 'indexUnchanged' = true hint for one
     955             :  * single index.
     956             :  */
     957             : static bool
     958      504452 : index_unchanged_by_update(ResultRelInfo *resultRelInfo, EState *estate,
     959             :                           IndexInfo *indexInfo, Relation indexRelation)
     960             : {
     961             :     Bitmapset  *updatedCols;
     962             :     Bitmapset  *extraUpdatedCols;
     963             :     Bitmapset  *allUpdatedCols;
     964      504452 :     bool        hasexpression = false;
     965             :     List       *idxExprs;
     966             : 
     967             :     /*
     968             :      * Check cache first
     969             :      */
     970      504452 :     if (indexInfo->ii_CheckedUnchanged)
     971      459874 :         return indexInfo->ii_IndexUnchanged;
     972       44578 :     indexInfo->ii_CheckedUnchanged = true;
     973             : 
     974             :     /*
     975             :      * Check for indexed attribute overlap with updated columns.
     976             :      *
     977             :      * Only do this for key columns.  A change to a non-key column within an
     978             :      * INCLUDE index should not be counted here.  Non-key column values are
     979             :      * opaque payload state to the index AM, a little like an extra table TID.
     980             :      *
     981             :      * Note that row-level BEFORE triggers won't affect our behavior, since
     982             :      * they don't affect the updatedCols bitmaps generally.  It doesn't seem
     983             :      * worth the trouble of checking which attributes were changed directly.
     984             :      */
     985       44578 :     updatedCols = ExecGetUpdatedCols(resultRelInfo, estate);
     986       44578 :     extraUpdatedCols = ExecGetExtraUpdatedCols(resultRelInfo, estate);
     987       49814 :     for (int attr = 0; attr < indexInfo->ii_NumIndexKeyAttrs; attr++)
     988             :     {
     989       46654 :         int         keycol = indexInfo->ii_IndexAttrNumbers[attr];
     990             : 
     991       46654 :         if (keycol <= 0)
     992             :         {
     993             :             /*
     994             :              * Skip expressions for now, but remember to deal with them later
     995             :              * on
     996             :              */
     997          30 :             hasexpression = true;
     998          30 :             continue;
     999             :         }
    1000             : 
    1001       46624 :         if (bms_is_member(keycol - FirstLowInvalidHeapAttributeNumber,
    1002        5206 :                           updatedCols) ||
    1003        5206 :             bms_is_member(keycol - FirstLowInvalidHeapAttributeNumber,
    1004             :                           extraUpdatedCols))
    1005             :         {
    1006             :             /* Changed key column -- don't hint for this index */
    1007       41418 :             indexInfo->ii_IndexUnchanged = false;
    1008       41418 :             return false;
    1009             :         }
    1010             :     }
    1011             : 
    1012             :     /*
    1013             :      * When we get this far and index has no expressions, return true so that
    1014             :      * index_insert() call will go on to pass 'indexUnchanged' = true hint.
    1015             :      *
    1016             :      * The _absence_ of an indexed key attribute that overlaps with updated
    1017             :      * attributes (in addition to the total absence of indexed expressions)
    1018             :      * shows that the index as a whole is logically unchanged by UPDATE.
    1019             :      */
    1020        3160 :     if (!hasexpression)
    1021             :     {
    1022        3136 :         indexInfo->ii_IndexUnchanged = true;
    1023        3136 :         return true;
    1024             :     }
    1025             : 
    1026             :     /*
    1027             :      * Need to pass only one bms to expression_tree_walker helper function.
    1028             :      * Avoid allocating memory in common case where there are no extra cols.
    1029             :      */
    1030          24 :     if (!extraUpdatedCols)
    1031          24 :         allUpdatedCols = updatedCols;
    1032             :     else
    1033           0 :         allUpdatedCols = bms_union(updatedCols, extraUpdatedCols);
    1034             : 
    1035             :     /*
    1036             :      * We have to work slightly harder in the event of indexed expressions,
    1037             :      * but the principle is the same as before: try to find columns (Vars,
    1038             :      * actually) that overlap with known-updated columns.
    1039             :      *
    1040             :      * If we find any matching Vars, don't pass hint for index.  Otherwise
    1041             :      * pass hint.
    1042             :      */
    1043          24 :     idxExprs = RelationGetIndexExpressions(indexRelation);
    1044          24 :     hasexpression = index_expression_changed_walker((Node *) idxExprs,
    1045             :                                                     allUpdatedCols);
    1046          24 :     list_free(idxExprs);
    1047          24 :     if (extraUpdatedCols)
    1048           0 :         bms_free(allUpdatedCols);
    1049             : 
    1050          24 :     if (hasexpression)
    1051             :     {
    1052          18 :         indexInfo->ii_IndexUnchanged = false;
    1053          18 :         return false;
    1054             :     }
    1055             : 
    1056             :     /*
    1057             :      * Deliberately don't consider index predicates.  We should even give the
    1058             :      * hint when result rel's "updated tuple" has no corresponding index
    1059             :      * tuple, which is possible with a partial index (provided the usual
    1060             :      * conditions are met).
    1061             :      */
    1062           6 :     indexInfo->ii_IndexUnchanged = true;
    1063           6 :     return true;
    1064             : }
    1065             : 
    1066             : /*
    1067             :  * Indexed expression helper for index_unchanged_by_update().
    1068             :  *
    1069             :  * Returns true when Var that appears within allUpdatedCols located.
    1070             :  */
    1071             : static bool
    1072          76 : index_expression_changed_walker(Node *node, Bitmapset *allUpdatedCols)
    1073             : {
    1074          76 :     if (node == NULL)
    1075           0 :         return false;
    1076             : 
    1077          76 :     if (IsA(node, Var))
    1078             :     {
    1079          24 :         Var        *var = (Var *) node;
    1080             : 
    1081          24 :         if (bms_is_member(var->varattno - FirstLowInvalidHeapAttributeNumber,
    1082             :                           allUpdatedCols))
    1083             :         {
    1084             :             /* Var was updated -- indicates that we should not hint */
    1085          18 :             return true;
    1086             :         }
    1087             : 
    1088             :         /* Still haven't found a reason to not pass the hint */
    1089           6 :         return false;
    1090             :     }
    1091             : 
    1092          52 :     return expression_tree_walker(node, index_expression_changed_walker,
    1093             :                                   (void *) allUpdatedCols);
    1094             : }

Generated by: LCOV version 1.14