#include "access/genam.h"
#include "access/parallel.h"
#include "nodes/execnodes.h"

Include dependency graph for nodeIndexscan.h:

This graph shows which files directly or indirectly include this file:

Functions
IndexScanState *	ExecInitIndexScan (IndexScan node, EState estate, int eflags)

void	ExecEndIndexScan (IndexScanState *node)

void	ExecIndexMarkPos (IndexScanState *node)

void	ExecIndexRestrPos (IndexScanState *node)

void	ExecReScanIndexScan (IndexScanState *node)

void	ExecIndexScanEstimate (IndexScanState node, ParallelContext pcxt)

void	ExecIndexScanInitializeDSM (IndexScanState node, ParallelContext pcxt)

void	ExecIndexScanReInitializeDSM (IndexScanState node, ParallelContext pcxt)

void	ExecIndexScanInitializeWorker (IndexScanState node, ParallelWorkerContext pwcxt)

void	ExecIndexBuildScanKeys (PlanState planstate, Relation index, List quals, bool isorderby, ScanKey scanKeys, int numScanKeys, IndexRuntimeKeyInfo *runtimeKeys, int numRuntimeKeys, IndexArrayKeyInfo *arrayKeys, int numArrayKeys)

void	ExecIndexEvalRuntimeKeys (ExprContext econtext, IndexRuntimeKeyInfo runtimeKeys, int numRuntimeKeys)

bool	ExecIndexEvalArrayKeys (ExprContext econtext, IndexArrayKeyInfo arrayKeys, int numArrayKeys)

bool	ExecIndexAdvanceArrayKeys (IndexArrayKeyInfo *arrayKeys, int numArrayKeys)

Function Documentation

◆ ExecEndIndexScan()

void ExecEndIndexScan ( IndexScanState * node )

Definition at line 785 of file nodeIndexscan.c.

 {
     Relation    indexRelationDesc;
     IndexScanDesc indexScanDesc;
  
     /*
      * extract information from the node
      */
     indexRelationDesc = node->iss_RelationDesc;
     indexScanDesc = node->iss_ScanDesc;
  
     /*
      * close the index relation (no-op if we didn't open it)
      */
     if (indexScanDesc)
         index_endscan(indexScanDesc);
     if (indexRelationDesc)
         index_close(indexRelationDesc, NoLock);
 }

References index_close(), index_endscan(), IndexScanState::iss_RelationDesc, IndexScanState::iss_ScanDesc, and NoLock.

Referenced by ExecEndNode().

◆ ExecIndexAdvanceArrayKeys()

bool ExecIndexAdvanceArrayKeys	(	IndexArrayKeyInfo *	arrayKeys,
		int	numArrayKeys
	)

Definition at line 740 of file nodeIndexscan.c.

 {
     bool        found = false;
     int         j;
  
     /*
      * Note we advance the rightmost array key most quickly, since it will
      * correspond to the lowest-order index column among the available
      * qualifications.  This is hypothesized to result in better locality of
      * access in the index.
      */
     for (j = numArrayKeys - 1; j >= 0; j--)
     {
         ScanKey     scan_key = arrayKeys[j].scan_key;
         int         next_elem = arrayKeys[j].next_elem;
         int         num_elems = arrayKeys[j].num_elems;
         Datum      *elem_values = arrayKeys[j].elem_values;
         bool       *elem_nulls = arrayKeys[j].elem_nulls;
  
         if (next_elem >= num_elems)
         {
             next_elem = 0;
             found = false;      /* need to advance next array key */
         }
         else
             found = true;
         scan_key->sk_argument = elem_values[next_elem];
         if (elem_nulls[next_elem])
             scan_key->sk_flags |= SK_ISNULL;
         else
             scan_key->sk_flags &= ~SK_ISNULL;
         arrayKeys[j].next_elem = next_elem + 1;
         if (found)
             break;
     }
  
     return found;
 }

References IndexArrayKeyInfo::elem_nulls, IndexArrayKeyInfo::elem_values, j, IndexArrayKeyInfo::next_elem, IndexArrayKeyInfo::num_elems, IndexArrayKeyInfo::scan_key, ScanKeyData::sk_argument, ScanKeyData::sk_flags, and SK_ISNULL.

Referenced by MultiExecBitmapIndexScan().

◆ ExecIndexBuildScanKeys()

void ExecIndexBuildScanKeys	(	PlanState *	planstate,
		Relation	index,
		List *	quals,
		bool	isorderby,
		ScanKey *	scanKeys,
		int *	numScanKeys,
		IndexRuntimeKeyInfo **	runtimeKeys,
		int *	numRuntimeKeys,
		IndexArrayKeyInfo **	arrayKeys,
		int *	numArrayKeys
	)

Definition at line 1135 of file nodeIndexscan.c.

 {
     ListCell   *qual_cell;
     ScanKey     scan_keys;
     IndexRuntimeKeyInfo *runtime_keys;
     IndexArrayKeyInfo *array_keys;
     int         n_scan_keys;
     int         n_runtime_keys;
     int         max_runtime_keys;
     int         n_array_keys;
     int         j;
  
     /* Allocate array for ScanKey structs: one per qual */
     n_scan_keys = list_length(quals);
     scan_keys = (ScanKey) palloc(n_scan_keys * sizeof(ScanKeyData));
  
     /*
      * runtime_keys array is dynamically resized as needed.  We handle it this
      * way so that the same runtime keys array can be shared between
      * indexquals and indexorderbys, which will be processed in separate calls
      * of this function.  Caller must be sure to pass in NULL/0 for first
      * call.
      */
     runtime_keys = *runtimeKeys;
     n_runtime_keys = max_runtime_keys = *numRuntimeKeys;
  
     /* Allocate array_keys as large as it could possibly need to be */
     array_keys = (IndexArrayKeyInfo *)
         palloc0(n_scan_keys * sizeof(IndexArrayKeyInfo));
     n_array_keys = 0;
  
     /*
      * for each opclause in the given qual, convert the opclause into a single
      * scan key
      */
     j = 0;
     foreach(qual_cell, quals)
     {
         Expr       *clause = (Expr *) lfirst(qual_cell);
         ScanKey     this_scan_key = &scan_keys[j++];
         Oid         opno;       /* operator's OID */
         RegProcedure opfuncid;  /* operator proc id used in scan */
         Oid         opfamily;   /* opfamily of index column */
         int         op_strategy;    /* operator's strategy number */
         Oid         op_lefttype;    /* operator's declared input types */
         Oid         op_righttype;
         Expr       *leftop;     /* expr on lhs of operator */
         Expr       *rightop;    /* expr on rhs ... */
         AttrNumber  varattno;   /* att number used in scan */
         int         indnkeyatts;
  
         indnkeyatts = IndexRelationGetNumberOfKeyAttributes(index);
         if (IsA(clause, OpExpr))
         {
             /* indexkey op const or indexkey op expression */
             int         flags = 0;
             Datum       scanvalue;
  
             opno = ((OpExpr *) clause)->opno;
             opfuncid = ((OpExpr *) clause)->opfuncid;
  
             /*
              * leftop should be the index key Var, possibly relabeled
              */
             leftop = (Expr *) get_leftop(clause);
  
             if (leftop && IsA(leftop, RelabelType))
                 leftop = ((RelabelType *) leftop)->arg;
  
             Assert(leftop != NULL);
  
             if (!(IsA(leftop, Var) &&
                   ((Var *) leftop)->varno == INDEX_VAR))
                 elog(ERROR, "indexqual doesn't have key on left side");
  
             varattno = ((Var *) leftop)->varattno;
             if (varattno < 1 || varattno > indnkeyatts)
                 elog(ERROR, "bogus index qualification");
  
             /*
              * We have to look up the operator's strategy number.  This
              * provides a cross-check that the operator does match the index.
              */
             opfamily = index->rd_opfamily[varattno - 1];
  
             get_op_opfamily_properties(opno, opfamily, isorderby,
                                        &op_strategy,
                                        &op_lefttype,
                                        &op_righttype);
  
             if (isorderby)
                 flags |= SK_ORDER_BY;
  
             /*
              * rightop is the constant or variable comparison value
              */
             rightop = (Expr *) get_rightop(clause);
  
             if (rightop && IsA(rightop, RelabelType))
                 rightop = ((RelabelType *) rightop)->arg;
  
             Assert(rightop != NULL);
  
             if (IsA(rightop, Const))
             {
                 /* OK, simple constant comparison value */
                 scanvalue = ((Const *) rightop)->constvalue;
                 if (((Const *) rightop)->constisnull)
                     flags |= SK_ISNULL;
             }
             else
             {
                 /* Need to treat this one as a runtime key */
                 if (n_runtime_keys >= max_runtime_keys)
                 {
                     if (max_runtime_keys == 0)
                     {
                         max_runtime_keys = 8;
                         runtime_keys = (IndexRuntimeKeyInfo *)
                             palloc(max_runtime_keys * sizeof(IndexRuntimeKeyInfo));
                     }
                     else
                     {
                         max_runtime_keys *= 2;
                         runtime_keys = (IndexRuntimeKeyInfo *)
                             repalloc(runtime_keys, max_runtime_keys * sizeof(IndexRuntimeKeyInfo));
                     }
                 }
                 runtime_keys[n_runtime_keys].scan_key = this_scan_key;
                 runtime_keys[n_runtime_keys].key_expr =
                     ExecInitExpr(rightop, planstate);
                 runtime_keys[n_runtime_keys].key_toastable =
                     TypeIsToastable(op_righttype);
                 n_runtime_keys++;
                 scanvalue = (Datum) 0;
             }
  
             /*
              * initialize the scan key's fields appropriately
              */
             ScanKeyEntryInitialize(this_scan_key,
                                    flags,
                                    varattno,    /* attribute number to scan */
                                    op_strategy, /* op's strategy */
                                    op_righttype,    /* strategy subtype */
                                    ((OpExpr *) clause)->inputcollid,    /* collation */
                                    opfuncid,    /* reg proc to use */
                                    scanvalue);  /* constant */
         }
         else if (IsA(clause, RowCompareExpr))
         {
             /* (indexkey, indexkey, ...) op (expression, expression, ...) */
             RowCompareExpr *rc = (RowCompareExpr *) clause;
             ScanKey     first_sub_key;
             int         n_sub_key;
             ListCell   *largs_cell;
             ListCell   *rargs_cell;
             ListCell   *opnos_cell;
             ListCell   *collids_cell;
  
             Assert(!isorderby);
  
             first_sub_key = (ScanKey)
                 palloc(list_length(rc->opnos) * sizeof(ScanKeyData));
             n_sub_key = 0;
  
             /* Scan RowCompare columns and generate subsidiary ScanKey items */
             forfour(largs_cell, rc->largs, rargs_cell, rc->rargs,
                     opnos_cell, rc->opnos, collids_cell, rc->inputcollids)
             {
                 ScanKey     this_sub_key = &first_sub_key[n_sub_key];
                 int         flags = SK_ROW_MEMBER;
                 Datum       scanvalue;
                 Oid         inputcollation;
  
                 leftop = (Expr *) lfirst(largs_cell);
                 rightop = (Expr *) lfirst(rargs_cell);
                 opno = lfirst_oid(opnos_cell);
                 inputcollation = lfirst_oid(collids_cell);
  
                 /*
                  * leftop should be the index key Var, possibly relabeled
                  */
                 if (leftop && IsA(leftop, RelabelType))
                     leftop = ((RelabelType *) leftop)->arg;
  
                 Assert(leftop != NULL);
  
                 if (!(IsA(leftop, Var) &&
                       ((Var *) leftop)->varno == INDEX_VAR))
                     elog(ERROR, "indexqual doesn't have key on left side");
  
                 varattno = ((Var *) leftop)->varattno;
  
                 /*
                  * We have to look up the operator's associated btree support
                  * function
                  */
                 if (index->rd_rel->relam != BTREE_AM_OID ||
                     varattno < 1 || varattno > indnkeyatts)
                     elog(ERROR, "bogus RowCompare index qualification");
                 opfamily = index->rd_opfamily[varattno - 1];
  
                 get_op_opfamily_properties(opno, opfamily, isorderby,
                                            &op_strategy,
                                            &op_lefttype,
                                            &op_righttype);
  
                 if (op_strategy != rc->rctype)
                     elog(ERROR, "RowCompare index qualification contains wrong operator");
  
                 opfuncid = get_opfamily_proc(opfamily,
                                              op_lefttype,
                                              op_righttype,
                                              BTORDER_PROC);
                 if (!RegProcedureIsValid(opfuncid))
                     elog(ERROR, "missing support function %d(%u,%u) in opfamily %u",
                          BTORDER_PROC, op_lefttype, op_righttype, opfamily);
  
                 /*
                  * rightop is the constant or variable comparison value
                  */
                 if (rightop && IsA(rightop, RelabelType))
                     rightop = ((RelabelType *) rightop)->arg;
  
                 Assert(rightop != NULL);
  
                 if (IsA(rightop, Const))
                 {
                     /* OK, simple constant comparison value */
                     scanvalue = ((Const *) rightop)->constvalue;
                     if (((Const *) rightop)->constisnull)
                         flags |= SK_ISNULL;
                 }
                 else
                 {
                     /* Need to treat this one as a runtime key */
                     if (n_runtime_keys >= max_runtime_keys)
                     {
                         if (max_runtime_keys == 0)
                         {
                             max_runtime_keys = 8;
                             runtime_keys = (IndexRuntimeKeyInfo *)
                                 palloc(max_runtime_keys * sizeof(IndexRuntimeKeyInfo));
                         }
                         else
                         {
                             max_runtime_keys *= 2;
                             runtime_keys = (IndexRuntimeKeyInfo *)
                                 repalloc(runtime_keys, max_runtime_keys * sizeof(IndexRuntimeKeyInfo));
                         }
                     }
                     runtime_keys[n_runtime_keys].scan_key = this_sub_key;
                     runtime_keys[n_runtime_keys].key_expr =
                         ExecInitExpr(rightop, planstate);
                     runtime_keys[n_runtime_keys].key_toastable =
                         TypeIsToastable(op_righttype);
                     n_runtime_keys++;
                     scanvalue = (Datum) 0;
                 }
  
                 /*
                  * initialize the subsidiary scan key's fields appropriately
                  */
                 ScanKeyEntryInitialize(this_sub_key,
                                        flags,
                                        varattno,    /* attribute number */
                                        op_strategy, /* op's strategy */
                                        op_righttype,    /* strategy subtype */
                                        inputcollation,  /* collation */
                                        opfuncid,    /* reg proc to use */
                                        scanvalue);  /* constant */
                 n_sub_key++;
             }
  
             /* Mark the last subsidiary scankey correctly */
             first_sub_key[n_sub_key - 1].sk_flags |= SK_ROW_END;
  
             /*
              * We don't use ScanKeyEntryInitialize for the header because it
              * isn't going to contain a valid sk_func pointer.
              */
             MemSet(this_scan_key, 0, sizeof(ScanKeyData));
             this_scan_key->sk_flags = SK_ROW_HEADER;
             this_scan_key->sk_attno = first_sub_key->sk_attno;
             this_scan_key->sk_strategy = rc->rctype;
             /* sk_subtype, sk_collation, sk_func not used in a header */
             this_scan_key->sk_argument = PointerGetDatum(first_sub_key);
         }
         else if (IsA(clause, ScalarArrayOpExpr))
         {
             /* indexkey op ANY (array-expression) */
             ScalarArrayOpExpr *saop = (ScalarArrayOpExpr *) clause;
             int         flags = 0;
             Datum       scanvalue;
  
             Assert(!isorderby);
  
             Assert(saop->useOr);
             opno = saop->opno;
             opfuncid = saop->opfuncid;
  
             /*
              * leftop should be the index key Var, possibly relabeled
              */
             leftop = (Expr *) linitial(saop->args);
  
             if (leftop && IsA(leftop, RelabelType))
                 leftop = ((RelabelType *) leftop)->arg;
  
             Assert(leftop != NULL);
  
             if (!(IsA(leftop, Var) &&
                   ((Var *) leftop)->varno == INDEX_VAR))
                 elog(ERROR, "indexqual doesn't have key on left side");
  
             varattno = ((Var *) leftop)->varattno;
             if (varattno < 1 || varattno > indnkeyatts)
                 elog(ERROR, "bogus index qualification");
  
             /*
              * We have to look up the operator's strategy number.  This
              * provides a cross-check that the operator does match the index.
              */
             opfamily = index->rd_opfamily[varattno - 1];
  
             get_op_opfamily_properties(opno, opfamily, isorderby,
                                        &op_strategy,
                                        &op_lefttype,
                                        &op_righttype);
  
             /*
              * rightop is the constant or variable array value
              */
             rightop = (Expr *) lsecond(saop->args);
  
             if (rightop && IsA(rightop, RelabelType))
                 rightop = ((RelabelType *) rightop)->arg;
  
             Assert(rightop != NULL);
  
             if (index->rd_indam->amsearcharray)
             {
                 /* Index AM will handle this like a simple operator */
                 flags |= SK_SEARCHARRAY;
                 if (IsA(rightop, Const))
                 {
                     /* OK, simple constant comparison value */
                     scanvalue = ((Const *) rightop)->constvalue;
                     if (((Const *) rightop)->constisnull)
                         flags |= SK_ISNULL;
                 }
                 else
                 {
                     /* Need to treat this one as a runtime key */
                     if (n_runtime_keys >= max_runtime_keys)
                     {
                         if (max_runtime_keys == 0)
                         {
                             max_runtime_keys = 8;
                             runtime_keys = (IndexRuntimeKeyInfo *)
                                 palloc(max_runtime_keys * sizeof(IndexRuntimeKeyInfo));
                         }
                         else
                         {
                             max_runtime_keys *= 2;
                             runtime_keys = (IndexRuntimeKeyInfo *)
                                 repalloc(runtime_keys, max_runtime_keys * sizeof(IndexRuntimeKeyInfo));
                         }
                     }
                     runtime_keys[n_runtime_keys].scan_key = this_scan_key;
                     runtime_keys[n_runtime_keys].key_expr =
                         ExecInitExpr(rightop, planstate);
  
                     /*
                      * Careful here: the runtime expression is not of
                      * op_righttype, but rather is an array of same; so
                      * TypeIsToastable() isn't helpful.  However, we can
                      * assume that all array types are toastable.
                      */
                     runtime_keys[n_runtime_keys].key_toastable = true;
                     n_runtime_keys++;
                     scanvalue = (Datum) 0;
                 }
             }
             else
             {
                 /* Executor has to expand the array value */
                 array_keys[n_array_keys].scan_key = this_scan_key;
                 array_keys[n_array_keys].array_expr =
                     ExecInitExpr(rightop, planstate);
                 /* the remaining fields were zeroed by palloc0 */
                 n_array_keys++;
                 scanvalue = (Datum) 0;
             }
  
             /*
              * initialize the scan key's fields appropriately
              */
             ScanKeyEntryInitialize(this_scan_key,
                                    flags,
                                    varattno,    /* attribute number to scan */
                                    op_strategy, /* op's strategy */
                                    op_righttype,    /* strategy subtype */
                                    saop->inputcollid,   /* collation */
                                    opfuncid,    /* reg proc to use */
                                    scanvalue);  /* constant */
         }
         else if (IsA(clause, NullTest))
         {
             /* indexkey IS NULL or indexkey IS NOT NULL */
             NullTest   *ntest = (NullTest *) clause;
             int         flags;
  
             Assert(!isorderby);
  
             /*
              * argument should be the index key Var, possibly relabeled
              */
             leftop = ntest->arg;
  
             if (leftop && IsA(leftop, RelabelType))
                 leftop = ((RelabelType *) leftop)->arg;
  
             Assert(leftop != NULL);
  
             if (!(IsA(leftop, Var) &&
                   ((Var *) leftop)->varno == INDEX_VAR))
                 elog(ERROR, "NullTest indexqual has wrong key");
  
             varattno = ((Var *) leftop)->varattno;
  
             /*
              * initialize the scan key's fields appropriately
              */
             switch (ntest->nulltesttype)
             {
                 case IS_NULL:
                     flags = SK_ISNULL | SK_SEARCHNULL;
                     break;
                 case IS_NOT_NULL:
                     flags = SK_ISNULL | SK_SEARCHNOTNULL;
                     break;
                 default:
                     elog(ERROR, "unrecognized nulltesttype: %d",
                          (int) ntest->nulltesttype);
                     flags = 0;  /* keep compiler quiet */
                     break;
             }
  
             ScanKeyEntryInitialize(this_scan_key,
                                    flags,
                                    varattno,    /* attribute number to scan */
                                    InvalidStrategy, /* no strategy */
                                    InvalidOid,  /* no strategy subtype */
                                    InvalidOid,  /* no collation */
                                    InvalidOid,  /* no reg proc for this */
                                    (Datum) 0);  /* constant */
         }
         else
             elog(ERROR, "unsupported indexqual type: %d",
                  (int) nodeTag(clause));
     }
  
     Assert(n_runtime_keys <= max_runtime_keys);
  
     /* Get rid of any unused arrays */
     if (n_array_keys == 0)
     {
         pfree(array_keys);
         array_keys = NULL;
     }
  
     /*
      * Return info to our caller.
      */
     *scanKeys = scan_keys;
     *numScanKeys = n_scan_keys;
     *runtimeKeys = runtime_keys;
     *numRuntimeKeys = n_runtime_keys;
     if (arrayKeys)
     {
         *arrayKeys = array_keys;
         *numArrayKeys = n_array_keys;
     }
     else if (n_array_keys != 0)
         elog(ERROR, "ScalarArrayOpExpr index qual found where not allowed");
 }

References arg, NullTest::arg, ScalarArrayOpExpr::args, IndexArrayKeyInfo::array_expr, Assert, BTORDER_PROC, elog, ERROR, ExecInitExpr(), forfour, get_leftop(), get_op_opfamily_properties(), get_opfamily_proc(), get_rightop(), INDEX_VAR, IndexRelationGetNumberOfKeyAttributes, InvalidOid, InvalidStrategy, IS_NOT_NULL, IS_NULL, IsA, j, IndexRuntimeKeyInfo::key_expr, IndexRuntimeKeyInfo::key_toastable, RowCompareExpr::largs, lfirst, lfirst_oid, linitial, list_length(), lsecond, MemSet, nodeTag, NullTest::nulltesttype, ScalarArrayOpExpr::opno, palloc(), palloc0(), pfree(), PointerGetDatum(), RowCompareExpr::rargs, RowCompareExpr::rctype, RegProcedureIsValid, repalloc(), IndexRuntimeKeyInfo::scan_key, IndexArrayKeyInfo::scan_key, ScanKeyEntryInitialize(), ScanKeyData::sk_argument, ScanKeyData::sk_attno, ScanKeyData::sk_flags, SK_ISNULL, SK_ORDER_BY, SK_ROW_END, SK_ROW_HEADER, SK_ROW_MEMBER, SK_SEARCHARRAY, SK_SEARCHNOTNULL, SK_SEARCHNULL, ScanKeyData::sk_strategy, TypeIsToastable, and ScalarArrayOpExpr::useOr.

Referenced by ExecInitBitmapIndexScan(), ExecInitIndexOnlyScan(), and ExecInitIndexScan().

◆ ExecIndexEvalArrayKeys()

bool ExecIndexEvalArrayKeys	(	ExprContext *	econtext,
		IndexArrayKeyInfo *	arrayKeys,
		int	numArrayKeys
	)

Definition at line 661 of file nodeIndexscan.c.

 {
     bool        result = true;
     int         j;
     MemoryContext oldContext;
  
     /* We want to keep the arrays in per-tuple memory */
     oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
  
     for (j = 0; j < numArrayKeys; j++)
     {
         ScanKey     scan_key = arrayKeys[j].scan_key;
         ExprState  *array_expr = arrayKeys[j].array_expr;
         Datum       arraydatum;
         bool        isNull;
         ArrayType  *arrayval;
         int16       elmlen;
         bool        elmbyval;
         char        elmalign;
         int         num_elems;
         Datum      *elem_values;
         bool       *elem_nulls;
  
         /*
          * Compute and deconstruct the array expression. (Notes in
          * ExecIndexEvalRuntimeKeys() apply here too.)
          */
         arraydatum = ExecEvalExpr(array_expr,
                                   econtext,
                                   &isNull);
         if (isNull)
         {
             result = false;
             break;              /* no point in evaluating more */
         }
         arrayval = DatumGetArrayTypeP(arraydatum);
         /* We could cache this data, but not clear it's worth it */
         get_typlenbyvalalign(ARR_ELEMTYPE(arrayval),
                              &elmlen, &elmbyval, &elmalign);
         deconstruct_array(arrayval,
                           ARR_ELEMTYPE(arrayval),
                           elmlen, elmbyval, elmalign,
                           &elem_values, &elem_nulls, &num_elems);
         if (num_elems <= 0)
         {
             result = false;
             break;              /* no point in evaluating more */
         }
  
         /*
          * Note: we expect the previous array data, if any, to be
          * automatically freed by resetting the per-tuple context; hence no
          * pfree's here.
          */
         arrayKeys[j].elem_values = elem_values;
         arrayKeys[j].elem_nulls = elem_nulls;
         arrayKeys[j].num_elems = num_elems;
         scan_key->sk_argument = elem_values[0];
         if (elem_nulls[0])
             scan_key->sk_flags |= SK_ISNULL;
         else
             scan_key->sk_flags &= ~SK_ISNULL;
         arrayKeys[j].next_elem = 1;
     }
  
     MemoryContextSwitchTo(oldContext);
  
     return result;
 }

References ARR_ELEMTYPE, IndexArrayKeyInfo::array_expr, DatumGetArrayTypeP, deconstruct_array(), ExprContext::ecxt_per_tuple_memory, IndexArrayKeyInfo::elem_nulls, IndexArrayKeyInfo::elem_values, ExecEvalExpr(), get_typlenbyvalalign(), j, MemoryContextSwitchTo(), IndexArrayKeyInfo::next_elem, IndexArrayKeyInfo::num_elems, IndexArrayKeyInfo::scan_key, ScanKeyData::sk_argument, ScanKeyData::sk_flags, and SK_ISNULL.

Referenced by ExecReScanBitmapIndexScan().

◆ ExecIndexEvalRuntimeKeys()

void ExecIndexEvalRuntimeKeys	(	ExprContext *	econtext,
		IndexRuntimeKeyInfo *	runtimeKeys,
		int	numRuntimeKeys
	)

Definition at line 599 of file nodeIndexscan.c.

 {
     int         j;
     MemoryContext oldContext;
  
     /* We want to keep the key values in per-tuple memory */
     oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
  
     for (j = 0; j < numRuntimeKeys; j++)
     {
         ScanKey     scan_key = runtimeKeys[j].scan_key;
         ExprState  *key_expr = runtimeKeys[j].key_expr;
         Datum       scanvalue;
         bool        isNull;
  
         /*
          * For each run-time key, extract the run-time expression and evaluate
          * it with respect to the current context.  We then stick the result
          * into the proper scan key.
          *
          * Note: the result of the eval could be a pass-by-ref value that's
          * stored in some outer scan's tuple, not in
          * econtext->ecxt_per_tuple_memory.  We assume that the outer tuple
          * will stay put throughout our scan.  If this is wrong, we could copy
          * the result into our context explicitly, but I think that's not
          * necessary.
          *
          * It's also entirely possible that the result of the eval is a
          * toasted value.  In this case we should forcibly detoast it, to
          * avoid repeat detoastings each time the value is examined by an
          * index support function.
          */
         scanvalue = ExecEvalExpr(key_expr,
                                  econtext,
                                  &isNull);
         if (isNull)
         {
             scan_key->sk_argument = scanvalue;
             scan_key->sk_flags |= SK_ISNULL;
         }
         else
         {
             if (runtimeKeys[j].key_toastable)
                 scanvalue = PointerGetDatum(PG_DETOAST_DATUM(scanvalue));
             scan_key->sk_argument = scanvalue;
             scan_key->sk_flags &= ~SK_ISNULL;
         }
     }
  
     MemoryContextSwitchTo(oldContext);
 }

References ExprContext::ecxt_per_tuple_memory, ExecEvalExpr(), j, IndexRuntimeKeyInfo::key_expr, MemoryContextSwitchTo(), PG_DETOAST_DATUM, PointerGetDatum(), IndexRuntimeKeyInfo::scan_key, ScanKeyData::sk_argument, ScanKeyData::sk_flags, and SK_ISNULL.

Referenced by ExecReScanBitmapIndexScan(), ExecReScanIndexOnlyScan(), and ExecReScanIndexScan().

◆ ExecIndexMarkPos()

void ExecIndexMarkPos ( IndexScanState * node )

Definition at line 813 of file nodeIndexscan.c.

 {
     EState     *estate = node->ss.ps.state;
     EPQState   *epqstate = estate->es_epq_active;
  
     if (epqstate != NULL)
     {
         /*
          * We are inside an EvalPlanQual recheck.  If a test tuple exists for
          * this relation, then we shouldn't access the index at all.  We would
          * instead need to save, and later restore, the state of the
          * relsubs_done flag, so that re-fetching the test tuple is possible.
          * However, given the assumption that no caller sets a mark at the
          * start of the scan, we can only get here with relsubs_done[i]
          * already set, and so no state need be saved.
          */
         Index       scanrelid = ((Scan *) node->ss.ps.plan)->scanrelid;
  
         Assert(scanrelid > 0);
         if (epqstate->relsubs_slot[scanrelid - 1] != NULL ||
             epqstate->relsubs_rowmark[scanrelid - 1] != NULL)
         {
             /* Verify the claim above */
             if (!epqstate->relsubs_done[scanrelid - 1])
                 elog(ERROR, "unexpected ExecIndexMarkPos call in EPQ recheck");
             return;
         }
     }
  
     index_markpos(node->iss_ScanDesc);
 }

References Assert, elog, ERROR, EState::es_epq_active, index_markpos(), IndexScanState::iss_ScanDesc, PlanState::plan, ScanState::ps, EPQState::relsubs_done, EPQState::relsubs_rowmark, EPQState::relsubs_slot, IndexScanState::ss, and PlanState::state.

Referenced by ExecMarkPos().

◆ ExecIndexRestrPos()

void ExecIndexRestrPos ( IndexScanState * node )

Definition at line 850 of file nodeIndexscan.c.

 {
     EState     *estate = node->ss.ps.state;
     EPQState   *epqstate = estate->es_epq_active;
  
     if (estate->es_epq_active != NULL)
     {
         /* See comments in ExecIndexMarkPos */
         Index       scanrelid = ((Scan *) node->ss.ps.plan)->scanrelid;
  
         Assert(scanrelid > 0);
         if (epqstate->relsubs_slot[scanrelid - 1] != NULL ||
             epqstate->relsubs_rowmark[scanrelid - 1] != NULL)
         {
             /* Verify the claim above */
             if (!epqstate->relsubs_done[scanrelid - 1])
                 elog(ERROR, "unexpected ExecIndexRestrPos call in EPQ recheck");
             return;
         }
     }
  
     index_restrpos(node->iss_ScanDesc);
 }

References Assert, elog, ERROR, EState::es_epq_active, index_restrpos(), IndexScanState::iss_ScanDesc, PlanState::plan, ScanState::ps, EPQState::relsubs_done, EPQState::relsubs_rowmark, EPQState::relsubs_slot, IndexScanState::ss, and PlanState::state.

Referenced by ExecRestrPos().

◆ ExecIndexScanEstimate()

void ExecIndexScanEstimate	(	IndexScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 1641 of file nodeIndexscan.c.

 {
     EState     *estate = node->ss.ps.state;
  
     node->iss_PscanLen = index_parallelscan_estimate(node->iss_RelationDesc,
                                                      node->iss_NumScanKeys,
                                                      node->iss_NumOrderByKeys,
                                                      estate->es_snapshot);
     shm_toc_estimate_chunk(&pcxt->estimator, node->iss_PscanLen);
     shm_toc_estimate_keys(&pcxt->estimator, 1);
 }

References EState::es_snapshot, ParallelContext::estimator, index_parallelscan_estimate(), IndexScanState::iss_NumOrderByKeys, IndexScanState::iss_NumScanKeys, IndexScanState::iss_PscanLen, IndexScanState::iss_RelationDesc, ScanState::ps, shm_toc_estimate_chunk, shm_toc_estimate_keys, IndexScanState::ss, and PlanState::state.

Referenced by ExecParallelEstimate().

◆ ExecIndexScanInitializeDSM()

void ExecIndexScanInitializeDSM	(	IndexScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 1661 of file nodeIndexscan.c.

 {
     EState     *estate = node->ss.ps.state;
     ParallelIndexScanDesc piscan;
  
     piscan = shm_toc_allocate(pcxt->toc, node->iss_PscanLen);
     index_parallelscan_initialize(node->ss.ss_currentRelation,
                                   node->iss_RelationDesc,
                                   estate->es_snapshot,
                                   piscan);
     shm_toc_insert(pcxt->toc, node->ss.ps.plan->plan_node_id, piscan);
     node->iss_ScanDesc =
         index_beginscan_parallel(node->ss.ss_currentRelation,
                                  node->iss_RelationDesc,
                                  node->iss_NumScanKeys,
                                  node->iss_NumOrderByKeys,
                                  piscan);
  
     /*
      * If no run-time keys to calculate or they are ready, go ahead and pass
      * the scankeys to the index AM.
      */
     if (node->iss_NumRuntimeKeys == 0 || node->iss_RuntimeKeysReady)
         index_rescan(node->iss_ScanDesc,
                      node->iss_ScanKeys, node->iss_NumScanKeys,
                      node->iss_OrderByKeys, node->iss_NumOrderByKeys);
 }

Referenced by ExecParallelInitializeDSM().

◆ ExecIndexScanInitializeWorker()

void ExecIndexScanInitializeWorker	(	IndexScanState *	node,
		ParallelWorkerContext *	pwcxt
	)

Definition at line 1710 of file nodeIndexscan.c.

 {
     ParallelIndexScanDesc piscan;
  
     piscan = shm_toc_lookup(pwcxt->toc, node->ss.ps.plan->plan_node_id, false);
     node->iss_ScanDesc =
         index_beginscan_parallel(node->ss.ss_currentRelation,
                                  node->iss_RelationDesc,
                                  node->iss_NumScanKeys,
                                  node->iss_NumOrderByKeys,
                                  piscan);
  
     /*
      * If no run-time keys to calculate or they are ready, go ahead and pass
      * the scankeys to the index AM.
      */
     if (node->iss_NumRuntimeKeys == 0 || node->iss_RuntimeKeysReady)
         index_rescan(node->iss_ScanDesc,
                      node->iss_ScanKeys, node->iss_NumScanKeys,
                      node->iss_OrderByKeys, node->iss_NumOrderByKeys);
 }

References index_beginscan_parallel(), index_rescan(), IndexScanState::iss_NumOrderByKeys, IndexScanState::iss_NumRuntimeKeys, IndexScanState::iss_NumScanKeys, IndexScanState::iss_OrderByKeys, IndexScanState::iss_RelationDesc, IndexScanState::iss_RuntimeKeysReady, IndexScanState::iss_ScanDesc, IndexScanState::iss_ScanKeys, PlanState::plan, Plan::plan_node_id, ScanState::ps, shm_toc_lookup(), IndexScanState::ss, ScanState::ss_currentRelation, and ParallelWorkerContext::toc.

Referenced by ExecParallelInitializeWorker().

◆ ExecIndexScanReInitializeDSM()

void ExecIndexScanReInitializeDSM	(	IndexScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 1697 of file nodeIndexscan.c.

 {
     index_parallelrescan(node->iss_ScanDesc);
 }

References index_parallelrescan(), and IndexScanState::iss_ScanDesc.

Referenced by ExecParallelReInitializeDSM().

◆ ExecInitIndexScan()

IndexScanState* ExecInitIndexScan	(	IndexScan *	node,
		EState *	estate,
		int	eflags
	)

Definition at line 886 of file nodeIndexscan.c.

 {
     IndexScanState *indexstate;
     Relation    currentRelation;
     LOCKMODE    lockmode;
  
     /*
      * create state structure
      */
     indexstate = makeNode(IndexScanState);
     indexstate->ss.ps.plan = (Plan *) node;
     indexstate->ss.ps.state = estate;
     indexstate->ss.ps.ExecProcNode = ExecIndexScan;
  
     /*
      * Miscellaneous initialization
      *
      * create expression context for node
      */
     ExecAssignExprContext(estate, &indexstate->ss.ps);
  
     /*
      * open the scan relation
      */
     currentRelation = ExecOpenScanRelation(estate, node->scan.scanrelid, eflags);
  
     indexstate->ss.ss_currentRelation = currentRelation;
     indexstate->ss.ss_currentScanDesc = NULL;   /* no heap scan here */
  
     /*
      * get the scan type from the relation descriptor.
      */
     ExecInitScanTupleSlot(estate, &indexstate->ss,
                           RelationGetDescr(currentRelation),
                           table_slot_callbacks(currentRelation));
  
     /*
      * Initialize result type and projection.
      */
     ExecInitResultTypeTL(&indexstate->ss.ps);
     ExecAssignScanProjectionInfo(&indexstate->ss);
  
     /*
      * initialize child expressions
      *
      * Note: we don't initialize all of the indexqual expression, only the
      * sub-parts corresponding to runtime keys (see below).  Likewise for
      * indexorderby, if any.  But the indexqualorig expression is always
      * initialized even though it will only be used in some uncommon cases ---
      * would be nice to improve that.  (Problem is that any SubPlans present
      * in the expression must be found now...)
      */
     indexstate->ss.ps.qual =
         ExecInitQual(node->scan.plan.qual, (PlanState *) indexstate);
     indexstate->indexqualorig =
         ExecInitQual(node->indexqualorig, (PlanState *) indexstate);
     indexstate->indexorderbyorig =
         ExecInitExprList(node->indexorderbyorig, (PlanState *) indexstate);
  
     /*
      * If we are just doing EXPLAIN (ie, aren't going to run the plan), stop
      * here.  This allows an index-advisor plugin to EXPLAIN a plan containing
      * references to nonexistent indexes.
      */
     if (eflags & EXEC_FLAG_EXPLAIN_ONLY)
         return indexstate;
  
     /* Open the index relation. */
     lockmode = exec_rt_fetch(node->scan.scanrelid, estate)->rellockmode;
     indexstate->iss_RelationDesc = index_open(node->indexid, lockmode);
  
     /*
      * Initialize index-specific scan state
      */
     indexstate->iss_RuntimeKeysReady = false;
     indexstate->iss_RuntimeKeys = NULL;
     indexstate->iss_NumRuntimeKeys = 0;
  
     /*
      * build the index scan keys from the index qualification
      */
     ExecIndexBuildScanKeys((PlanState *) indexstate,
                            indexstate->iss_RelationDesc,
                            node->indexqual,
                            false,
                            &indexstate->iss_ScanKeys,
                            &indexstate->iss_NumScanKeys,
                            &indexstate->iss_RuntimeKeys,
                            &indexstate->iss_NumRuntimeKeys,
                            NULL,    /* no ArrayKeys */
                            NULL);
  
     /*
      * any ORDER BY exprs have to be turned into scankeys in the same way
      */
     ExecIndexBuildScanKeys((PlanState *) indexstate,
                            indexstate->iss_RelationDesc,
                            node->indexorderby,
                            true,
                            &indexstate->iss_OrderByKeys,
                            &indexstate->iss_NumOrderByKeys,
                            &indexstate->iss_RuntimeKeys,
                            &indexstate->iss_NumRuntimeKeys,
                            NULL,    /* no ArrayKeys */
                            NULL);
  
     /* Initialize sort support, if we need to re-check ORDER BY exprs */
     if (indexstate->iss_NumOrderByKeys > 0)
     {
         int         numOrderByKeys = indexstate->iss_NumOrderByKeys;
         int         i;
         ListCell   *lco;
         ListCell   *lcx;
  
         /*
          * Prepare sort support, and look up the data type for each ORDER BY
          * expression.
          */
         Assert(numOrderByKeys == list_length(node->indexorderbyops));
         Assert(numOrderByKeys == list_length(node->indexorderbyorig));
         indexstate->iss_SortSupport = (SortSupportData *)
             palloc0(numOrderByKeys * sizeof(SortSupportData));
         indexstate->iss_OrderByTypByVals = (bool *)
             palloc(numOrderByKeys * sizeof(bool));
         indexstate->iss_OrderByTypLens = (int16 *)
             palloc(numOrderByKeys * sizeof(int16));
         i = 0;
         forboth(lco, node->indexorderbyops, lcx, node->indexorderbyorig)
         {
             Oid         orderbyop = lfirst_oid(lco);
             Node       *orderbyexpr = (Node *) lfirst(lcx);
             Oid         orderbyType = exprType(orderbyexpr);
             Oid         orderbyColl = exprCollation(orderbyexpr);
             SortSupport orderbysort = &indexstate->iss_SortSupport[i];
  
             /* Initialize sort support */
             orderbysort->ssup_cxt = CurrentMemoryContext;
             orderbysort->ssup_collation = orderbyColl;
             /* See cmp_orderbyvals() comments on NULLS LAST */
             orderbysort->ssup_nulls_first = false;
             /* ssup_attno is unused here and elsewhere */
             orderbysort->ssup_attno = 0;
             /* No abbreviation */
             orderbysort->abbreviate = false;
             PrepareSortSupportFromOrderingOp(orderbyop, orderbysort);
  
             get_typlenbyval(orderbyType,
                             &indexstate->iss_OrderByTypLens[i],
                             &indexstate->iss_OrderByTypByVals[i]);
             i++;
         }
  
         /* allocate arrays to hold the re-calculated distances */
         indexstate->iss_OrderByValues = (Datum *)
             palloc(numOrderByKeys * sizeof(Datum));
         indexstate->iss_OrderByNulls = (bool *)
             palloc(numOrderByKeys * sizeof(bool));
  
         /* and initialize the reorder queue */
         indexstate->iss_ReorderQueue = pairingheap_allocate(reorderqueue_cmp,
                                                             indexstate);
     }
  
     /*
      * If we have runtime keys, we need an ExprContext to evaluate them. The
      * node's standard context won't do because we want to reset that context
      * for every tuple.  So, build another context just like the other one...
      * -tgl 7/11/00
      */
     if (indexstate->iss_NumRuntimeKeys != 0)
     {
         ExprContext *stdecontext = indexstate->ss.ps.ps_ExprContext;
  
         ExecAssignExprContext(estate, &indexstate->ss.ps);
         indexstate->iss_RuntimeContext = indexstate->ss.ps.ps_ExprContext;
         indexstate->ss.ps.ps_ExprContext = stdecontext;
     }
     else
     {
         indexstate->iss_RuntimeContext = NULL;
     }
  
     /*
      * all done.
      */
     return indexstate;
 }

Referenced by ExecInitNode().

◆ ExecReScanIndexScan()

void ExecReScanIndexScan ( IndexScanState * node )

Definition at line 551 of file nodeIndexscan.c.

 {
     /*
      * If we are doing runtime key calculations (ie, any of the index key
      * values weren't simple Consts), compute the new key values.  But first,
      * reset the context so we don't leak memory as each outer tuple is
      * scanned.  Note this assumes that we will recalculate *all* runtime keys
      * on each call.
      */
     if (node->iss_NumRuntimeKeys != 0)
     {
         ExprContext *econtext = node->iss_RuntimeContext;
  
         ResetExprContext(econtext);
         ExecIndexEvalRuntimeKeys(econtext,
                                  node->iss_RuntimeKeys,
                                  node->iss_NumRuntimeKeys);
     }
     node->iss_RuntimeKeysReady = true;
  
     /* flush the reorder queue */
     if (node->iss_ReorderQueue)
     {
         HeapTuple   tuple;
  
         while (!pairingheap_is_empty(node->iss_ReorderQueue))
         {
             tuple = reorderqueue_pop(node);
             heap_freetuple(tuple);
         }
     }
  
     /* reset index scan */
     if (node->iss_ScanDesc)
         index_rescan(node->iss_ScanDesc,
                      node->iss_ScanKeys, node->iss_NumScanKeys,
                      node->iss_OrderByKeys, node->iss_NumOrderByKeys);
     node->iss_ReachedEnd = false;
  
     ExecScanReScan(&node->ss);
 }

Referenced by ExecReScan().

Functions