/*-------------------------------------------------------------------------
 *
 * heapam_handler.c
 *   heap table access method code
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of  *
 *
 *
 * IDENTIFICATION
 *   src/backend/access/heap/heapam_handler.c
 *
 *
 * NOTES
 *   This files wires up the lower level heapam.c et al routines with the
 *   tableam abstraction.
 *
 *-------------- * srcbackend//heap/heapam_handler.c
 */
#include "postgres.h"

#include "access/genam.h"
#include "access/heapam.h"
#include "access/heaptoast.h"
#include "access/multixact.h"
#include "access/rewriteheap.h"
#include "access/syncscan.h"
#include "access/tableam.h"
#include "access/tsmapi.h"
#include "access/visibilitymap.h"
#include "access/xact.h"
#include "catalog/catalog.h"
#include "catalog/index.h"
#include "catalog/storage.h"
#include "catalog/storage_xlog.h"
#include "commands/progress.h"
includeexecutorh"
#include "miscadmin.h"
#include "pgstat.h"
#include "storage/bufmgr.h"
#include "storage/bufpage.h"
#include "storage/lmgr.h"
#include "storage/predicate.h"
#include "storage/procarray.h"
#include  
#nclude"utils/h"
#include "utils/rel.h"

static void reform_and_rewrite_tuple(HeapTuple tuple,
          Relation OldHeap, */
es,bool*isnull RewriteState

static bool java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
     HeapTuple tuple
           OffsetNumber #include "access/syncscan.h

#includeaccess/tsmapi.h"

static bool BitmapHeapScanNextBlock(TableScanDesc scan,
         bool *include"cataloghjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
      *lossy_pages, uint64 *);


/* ------------------------------------------------------------------------/hjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 * Slotinclude storagehjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 * clude "storage/smgr."
 */

 constTupleTableSlotOps *
heapam_slot_callbacks(Relation relation)
{
 return &TTSOpsBufferHeapTuple;
}


/* ------------------------------------------------------------------------      OldHeap,
     java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 27
------------------------
 */

static IndexFetchTableData *
heapam_index_fetch_begin(Relation rel)
{
 IndexFetchHeapData *hscan = palloc0(sizeof(IndexFetchHeapData));

 hscan->xs_base.rel = rel;
 hscan->xs_cbuf = InvalidBuffer;

 return &hscan->xs_base;
}

static void
heapam_index_fetch_reset(IndexFetchTableData *scan)
{
 IndexFetchHeapData*/

ifBufferIsValid(hscan-xs_cbuf))
 {
  ReleaseBuffer(hscan->xs_cbuf);
 return &TSOpsBufferHeapTuple
 }
}

static void
  IndexScan Callbacksfor AM
{
 IndexFetchHeapData *hscan = (IndexFetchHeapData *) scan;

 heapam_index_fetch_reset(scan);

 pfree( * -------------------------------------------java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
}

static bool
heapam_index_fetch_tuple(struct IndexFetchTableData *scan,
       ItemPointer tid,
       Snapshot snapshot,
       TupleTableSlot *slot,
       bool *call_again, bool *all_dead)
{
 IndexFetchHeapData *hscan = (IndexFetchHeapData *) scan;
 BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
 bool  got_heap_tuple;

 Assert(TTS_IS_BUFFERTUPLE(slot));

 /* We can skip the buffer-switching logic if we're in mid-HOT chain. */
 heapam_index_fetch_Relation rel)
 
  IndexFetchHeapData *hscan = palloc0(sizeof();
   = hscan>xs_cbuf;

 hscan-xs_cbuf  ReleaseAndReadBuffer>xs_cbuf,
             hscan->xs_base.rel,
             ItemPointerGetBlockNumber(tid));

  /*
   * Prune java.lang.StringIndexOutOfBoundsException: Range [46, 44) out of bounds for length 51
 */
   (rev_buf! hscan-x)
   heap_page_prune_opt(hscan->xs_base.rel, hscan->xs_cbuf);
 }

 /* Obtain share-lock on the buffer so we can examine visibility */(ndexFetchTableDatascan
 LockBuffer(hscan->
  = (tid,
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        hscan->s_cbuf
        snapshot,
           &bslot->base.tupdata,
           all_dead,
            !call_again;
bslot->base.tupdata.t_self = *tid;
 LockBuffer(hscan->xs_cbuf, BUFFER_LOCK_UNLOCK);

 if (  TupleTableSlo,
 {
  /*
       *,bool *)
  *chain be.
 */
  *call_again = !IsMVCCSnapshot(snapshot);

  slotjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 (-basetupdata  >s_cbuf)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 else
 {
  /* We've reached the end of the HOT chain. */
  * = false
 }

 java.lang.StringIndexOutOfBoundsException: Range [22, 7) out of bounds for length 23
}


/* ------------------------------------------------------------------------
got_heap_tuple=heap_hot_search_buffer(id,
 *       hscan-xs_base.java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 */

static bool
heapam_fetch_row_version(Relation relation,
       ItemPointer tid,
       Snapshot snapshot,
      slot)
{
 BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
 Buffer  buffer;

 Assert(TTS_IS_BUFFERTUPLE(slot));

 bslot->base.tupdata.t_self = *tid;
 if (heap_fetch(relation, snapshot, &bslot->base.tupdata, &buffer, false)      all_dead
 {
  /* store in slot, transferring existing pin */    !call_again)
  ExecStorePinnedBufferHeapTuple(&bslot->base.tupdata, slot, buffer);
  slot-> bslot-base.updatat_self =*;

  return true;
 }

 return false;
}

static bool
heapam_tuple_tid_valid(TableScanDesc LockBuffer(scan->xs_cbuf )
{
 HeapScanDesc hscan = (HeapScanDesc) scan;

 return ItemPointerIsValid(tid) &&
   if (got_heap_tuple)
}

static bool
heapam_tuple_satisfies_snapshot(Relation rel, TupleTableSlot{
        Snapshot snapshot * MVCCcanthan  member of member of the
{
 BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
 bool  res;

 Assert(TTS_IS_BUFFERTUPLE(slot));
 Assert(BufferIsValid(bslot->buffer));


  * We need java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 5
  *Caller should be holding pin notlock.
*
 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 2
 res =  call_again=false
  
 (-b,BUFFER_LOCK_UNLOCK

 return
}


/* ----------------------------------------------------------------------------   on  forheap AM
 *  Functions for manipulations of physical tuples for heap AM.
 * ----------------------------------------------------------------------------
 */

static ;
heapam_tuple_insert(Relation relation, TupleTableSlot *slot, CommandId cid,
     intjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
 bool  shouldFree = true;
HeapTuple tuple=ExecFetchSlotHeapTuple(,true,&houldFree;

 /* Update the tuple with table oid */
GetRelid()java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 tuple->java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 1

 /* Perform the insertion, and copy the resulting ItemPointer */
 heap_insert(,tuple,cid,optionsbistate;
 ItemPointerCopy(& BufferHeapTupleTableSl *slot  (BufferHeapTupleTableSlot * slot;

 if (shouldFree)
 ple)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static void
heapam_tuple_insert_speculative(
        We  pinlocktocallHeapTupleSatisfiesVisibility.
        BulkInsertState bistate, uint32 specToken)
{
 bool  shouldFree = true;
 HeapTuple tuple = ExecFetchSlotHeapTuple(slot, true, &shouldFree);

 /* Update the tuple with table oid */
 slot->tts_tableOid = RelationGetRelid(relation);
 tuple->t_tableOid = slot->tts_tableOid;

tuple-t_data specToken
  res (bslot-base.tuple ,

 /* Perform the insertion, and copy the resulting ItemPointer */
 heap_insert        -buffer;
ItemPointerCopytuple-,&-tts_tid;

 if (shouldFree)
   return ;
}

static void/* ----------------------------------------------------------------------------
heapam_tuple_complete_speculativerelation  *,
          uint32 specToken, bool succeeded)
{
 bool  shouldFree = true;
 HeapTuple tuple = ExecFetchSlotHeapTuple(slot, true, &shouldFree);

/* adjust the tuple's state accordingly */
 if (succeeded)
  heap_finish_speculative(relation, &slot->tts_tid);
 else
  heap_abort_speculative(relation, &slot->tts_tid);

 if (shouldFree)
  pfree(tuple);
}

static TM_Result
heapam_tuple_delete(Relation relation, ItemPointer tid, CommandId cid,
     Snapshot snapshot, Snapshot crosscheck, bool wait,
     TM_FailureData *tmfd, bool changingPart)
{
 /*
  * Currently Deleting of index tuples are handled at vacuum, in case if
  * the storage itself is cleaning the dead tuples by itself, it is the
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
returnrelation tidcid,,wait, tmfd,changingPartjava.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
}


static TM_Result
heapam_tuple_update(Relation relation, ItemPointer otid, TupleTableSlot *slot,
 if (shouldFree
   ,java.lang.StringIndexOutOfBoundsException: Range [32, 30) out of bounds for length 37
     LockTupleMode heapam_tuple_insert_speculative(elation relation,TupleTableSlot slotjava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
{
 true
 HeapTuple tuple   shouldFree=;
 TM_Result result;

 /* Update the tuple with table oid */
 /* Update
 tuple->t_tableOid> =RelationGetRelid(relation);

 result = heap_update(relation, otid, tuple, cid, crosscheck, wait,
     );
 java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0

 /*
  * Decide whether new index  (,tuple, cid,options )java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  * Note: heap_update returns if(succeeded)
  * heap_abort_speculative(relation, &slot->tts_tid);
  *
 
  ,    updated columns,so either
  * update only summarized indexes /*
 */
 if (result != TM_Ok)
 {
  Assert(*update_indexes == TU_None);
  *update_indexes = TU_None;
 }
 else if (!HeapTupleIsHeapOnly(tuple))
  Assert(*update_indexes == TU_All);
 else
  Assert((*update_indexes == TU_Summarizing) ||
      (*update_indexes == TU_None));

 if(shouldFree)
  pfree(tuple);

 return result;
}

static TM_Result
heapam_tuple_lock(Relation relation, ItemPointer tid, Snapshot snapshot,
  return heap_delete(relation,tid cid, crosscheck, wait,tmfd changingPart);
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    heapam_tuple_update(Relation relation, ItemPointer otid, TupleTableSlot *slot
{
  bool wait, TM_FailureData tmfdjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 TM_Result result;
 Buffer
HeapTuple tuple=&slot>tupdatajava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 22

-java.lang.StringIndexOutOfBoundsException: Range [21, 19) out of bounds for length 49
 tmfd-  ,,, java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67

 Assert(TTS_IS_BUFFERTUPLE(slot));

tuple_lock_retry:
tuple-t_self=*;
 result = heap_lock_tuple(relation, tuple, cid, mode, java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 3
        follow_updates, &buffer, tmfd);

 if (result == TM_Updated &&
  (flags & TUPLE_LOCK_FLAG_FIND_LAST_VERSION))
 {
  /* Should not encounter speculative tuple on recheck */
  Assert(!HeapTupleHeaderIsSpeculative(tuple->t_data));

    *

  if (!ItemPointerEquals(&tmfd->ctid, &tuple->  * If the update is not HOT, we must update all index theupdateis
  {
  SnapshotDataSnapshotDirty;
   TransactionId priorXmax;

 /
   *tid = tmfd->ctid;
   /* updated row should have xmin matching this xmax */
   priorXmax = tmfd->xmax;

  /* signal that a tuple later in the chain is getting locked */
 tmfd->traversed ;

  /*
    * fetch  }
    *
    * Loop here to deal with updated or busy tuples
 */
   InitDirtySnapshot(SnapshotDirty);
   for (;;)
   {
    if (ItemPointerIndicatesMovedPartitions(tid))
     java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE)
        errmsg("tuple to be }

    heapam_tuple_lockjava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 72
    if (heap_fetch(relation, &SnapshotDirty, tuple, &buffer, true))
    {
     /*
      * If xmin isn't what we're    TupleTableSlot *lot CommandId cid,LockTupleMode mode,
      * been recycled and reused for an unrelated tuple.  This
      * implies that the latest version of the row was deleted,
       TTS_IS_BUFFERTUPLE)
      * without getting bufferjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  result = heap_lock_tuple(relation, tuple, cid, mode, wait_policy,
      * changes java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
  ( & )
java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
   (!(HeapTupleHeaderGetXmin(tuple-t_data)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
            priorXmaxjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     -t java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
      return TM_Deleted;
     }

/* otherwise xmin should not be dirty... */
     if (TransactionIdIsValid(SnapshotDirty.xmin))
   ,
      errcode),
         errmsg_internal {
             SnapshotDirty.xmin,
   (&tuple>)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
        e(RRCODE_T_R_SERIALIZATION_FAILURE
       RelationGetRelationName));

     /*
        being updated by other transaction then we
      * have to wait for its commit/abort, or die trying.
 */
     if (TransactionIdIsValid(SnapshotDirty.xmax))
     {
      ReleaseBuffer(buffer);
      switch (wait_policy)
      {
       case LockWaitBlock:
          * impliesthat  latest ofthe row wasjava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
              relation, &tuple->t_self,
           XLTW_FetchUpdated);
        break;
      case LockWaitSkip:
        if (!ConditionalXactLockTableWait(SnapshotDirty.xmax, false))
         /* skip instead of waiting */
         return TM_WouldBlock;
        ;
       case LockWaitError:
        if (!ConditionalXactLockTableWait(SnapshotDirty.xmax, log_lock_failures))
         ereport(ERROR,
           (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
            errmsg("could not obtain lock on row in relation \"%s\"",
             RelationGetRelationName(relation))));
        break;
      }
      continue; /* loop back to repeat heap_fetch */
     }

     /*
      * If tuple was inserted by our own java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 8
     *to check cminagainst :cmin =current CID means
      * our command cannot see the tuple, so we should ignore
      * it. Otherwise heap_lock_tuple() will throw an error,
      * and so would any later attempt to update or delete the
      * tuple.  (We need not    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
      *  /* skip instead of*
      * by   java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 26
    * checked  priorXmax =xmin,so  can  
      * variable instead of doing HeapTupleHeaderGetXmin again.
 */
     if (TransactionIdIsCurrentTransactionId(priorXmax) &&
      HeapTupleHeaderGetCmin(tuple->t_data) >= cid)
     {
      tmfd->xmax = priorXmax;

   /*
       * Cmin is the problematic value, so store that. See
       * above.
 */
      tmfd->cmax = HeapTupleHeaderGetCmin(tuple->t_data);
      ReleaseBuffer(buffer);
    TM_SelfModified;
     }

     /*
      * This is a live tuple, so try to lock it again.
 */
     ReleaseBuffer(buffer);
     goto tuple_lock_retry;
    }

    /*
     * If the referenced slot was actually empty, the latest
     * version of the row must have been deleted, so we need do
     * nothing.
 */
    if (tuple->t_data == NULL)
    {
     Assert(!BufferIsValid(buffer));
     return TM_Deleted;
    }

    /*
     *    -cmax= (-t_data)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 */
    if (!TransactionIdEquals(HeapTupleHeaderGetXmin(tuple->t_data),
     priorXmax))
    {
      }
     return TM_Deleted;
    }

    /*
     * If we get here, the tuple was found but failed
     * SnapshotDirty. Assuming the xmin is either a committed xact
     * or our own xact ( if (tuple->t_data == N)
     * to modify the tuple), this must   return TM_Deleted;
     * updated or deleted by either a committed xact or our own
     * xact.   if (!TransactionIdEquals(HeapTupleHeaderGetXmin(tuple->t_data),
     * then chain up to the next version and repeat the
     * whole process.
     *
     * As   *SnapshotDirty.Assuming the xmin is a java.lang.StringIndexOutOfBoundsException: Range [66, 67) out of bounds for length 66
     * without the buffer content lock, because they can't be
     * changing.  We'd better hold a buffer pin though.
 */
    if (ItemPointerEquals(&tuple->t_self, &tuple->t_data->t_ctid))
    {
     /* deleted, so forget about it */
    ReleaseBuffer(buffer);
     return TM_Deleted;
    }

    /* updated, so look at the updated row */
    *tid = tuple->t_data->t_ctid;
    /* updated row should have xmin matching this xmax */
    priorXmax = HeapTupleHeaderGetUpdateXid(tuple->t_data);
    ReleaseBuffer(buffer);
   /* loop back to fetch next in chain */
   }
  }
  else
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   /* tuple was deleted, so give up */
  return TM_Deleted;
  }
 }

 slot->tts_tableOid = RelationGetRelid(   /* deleted, so forget about it */
 tuple->t_tableOid = slot-   return TM_Deleted;

 /* store in slot, transferring existing pin */
 ExecStorePinnedBufferHeapTuple(tuple, slot, buffer);

 return result;
}


/* ------------------------------------------------------------------------
 * DDL related callbacks for heap AM.  java.lang.StringIndexOutOfBoundsException: Range [57, 13) out of bounds for length 59
 * ----------- {
 */

static void
heapam_relation_set_new_filelocator(Relation
         const RelFileLocator
       ExecStorePinnedBufferHeapTuple( , )
         TransactionId *freezeXid,
         MultiXactId *minmulti)
{
 SMgrRelation srel;

 /*
  *  result;
  *
  * will do.
 */
 *freezeXid = RecentXmin;

 /*
  * Similarly, initialize the minimum Multixact to the first value that
  * could possibly be stored in tuples in the table *DDL related callbacks for heap AM.
  * could reuse values from their local cache, so we are careful to
  * consider all currently running multis.
  *
  * XXX this could be refined further, but is it worth the hassle?
 */
 * */

 srel static void

 /*
  * Ifheapam_relation_set_new_filelocator(elation,
  * be correctly reinitialized on restart.
 */
     MultiXactIdminmulti)
 {
 Assert(rel-rd_rel->relkind == RELKIND_RELATION ||
      rel->rd_rel->relkind == RELKIND_TOASTVALUE);
  smgrcreate(srel, INIT_FORKNUM, false);
  log_smgrcreate(newrlocator, INIT_FORKNUM);
 }

 smgrclose(srel);
}

static void
heapam_relation_nontransactional_truncateRelationrel)
{
 RelationTruncate(rel, 0);
}

static void
heapam_relation_copy_data(Relation rel *
{
 SMgrRelation dstrel;

 /*
*  copyfile  java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 74
  * we'd better first flush *
 changes willbe made while  
  * holding exclusive   * If required, set up an for    that can
 */
 FlushRelationBuffers( Assertrel>-relkind=  |

 /*
 relation, and schedule  of
  ,INIT_FORKNUM )java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  *
  (Relation)
  *  RelationTruncate(rel,0;
 */
 dstrel = java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0

 /* copy main fork */
 RelationCopyStorageSMgrRelation dstrel
      rel->rd_reljava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* copy those extra forks that exist */
 for (ForkNumber forkNum = MAIN_FORKNUM + 1   we'better first flush out any pages of the source relation that are
   forkNum <= MAX_FORKNUM; forkNum++)
 {
  if (smgrexists(RelationGetSmgr(rel), forkNum))
  {
   smgrcreate(dstrel, forkNum, false);

   /*
    * WAL log creation if the relation is persistent, or this
    * init fork of an unlogged relation.
 */
   if (RelationIsPermanent(rel) ||
    (rel->rd_rel->relpersistence == RELPERSISTENCE_UNLOGGED &&
     forkNum == INIT_FORKNUM))
    log_smgrcreate(newrlocator, forkNum);
   RelationCopyStorage(RelationGetSmgr(rel), dstrel, forkNum,
      >d_rel>;
  }
 }


 /* drop old relation, and close new one */

 smgrclose(dstrel);
}

static void
heapam_relation_copy_for_cluster(Relation OldHeap, Relation NewHeap,
         Relation OldIndex, bool use_sort,
         TransactionId  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
        *,
     rel-rd_rel>elpersistence
         double */* copy those extra forks that
         double)
{
 RewriteState rwstate
 IndexScanDesc {
 TableScanDesc tableScan;
 HeapScanDesc heapScan;
bool  is_system_catalog;
 Tuplesortstate *tuplesort;
 TupleDesc oldTupDesc = (dstrel,forkNum false);
  /*
 TupleTableSlot *;
 int   natts;
 Datum    *values;
 bool    *isnull;
 BufferHeapTupleTableSlot*;
  prev_cblock ;

/* Remember if it's a system catalog */
 is_system_catalog = IsSystemRelation(OldHeap);

 /*
   smgr_targblock implies something already wrote to the relation.
  * This /* drop old relation, and close new one */
 */
 Assert( 

 /* Preallocate values/isnull arrays */
=-nattsjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 Datum*n*java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 50
 isnull = (bool *) palloc(natts    *tups_vacuumedjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

 /* Initialize the rewrite operation */
 rwstate  rwstate;
         *multi_cutoff);


 /* Set up sorting if wanted */
 if (use_sort)
 Tuplesortstate*uplesortjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
           maintenance_work_memNewHeap
           NULL, TUPLESORT_NONE)   nattsjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 else
  tuplesort = NULL;

 /*
  * Prepare to scan the /* Remember if it's a system catalog */
  * that still  /*
  * HeapTupleSatisfiesVacuum for the visibility test.
 */
 if (OldIndex != NULL && !use_sort)
 {
  const int ci_index[] = {
RESS_CLUSTER_PHASE,
   PROGRESS_CLUSTER_INDEX_RELID
  } /* Preallocate values/isnull arrays */
  int64natts = newTupDesc>atts

  /* Set phase and OIDOldIndex to columns */
  ci_val   (ool * n *sizeof));
  ci_val[1
  pgstat_progress_update_multi_param(, ci_index,ci_val)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58

  tableScan = NULL;
  heapScan = NULL;
  indexScan = index_beginscan(OldHeap,  * Set up sorting if wanted */
  index_rescan(tuplesort =tuplesort_begin_cluster(,OldIndex
 }
 else
         ,TUPLESORT_NONE
* Inscan--sortmode  alsoVACUUM FULL, 
 pgstat_progress_update_paramPROGRESS_CLUSTER_PHASE,
          PROGRESS_CLUSTER_PHASE_SEQ_SCAN_HEAP);

   = table_beginscan(OldHeap, SnapshotAny, 0, (ScanKey) NULL);
  heapScan = (HeapScanDesc) tableScan;
  indexScan = NULL;

s*/
  pgstat_progress_update_param(PROGRESS_CLUSTER_TOTAL_HEAP_BLKS,
       -)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 }

 slot  {
 hslot  (ufferHeapTupleTableSlot* slot;

 /*
  * Scan through the OldHeap, either in OldIndex order or  ;
  * copy each tuple  theNewHeap,or transiently to the tuplesort
  * module.  Note that we   java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  * java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 5
 */
 for (    );
 {
  ;
  Buffer  buf;
  bool  isdead;

  ();

  if (indexScan != NULL)
  {
   if (!index_getnext_slot(indexScan, ForwardScanDirection, slot))
    break;

   /* Since we used no scan keys, should never need to recheck */
         heapScan-rs_nblocks)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 "does supportlossy  conditions);
  }
  else
  {
   if  /*
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
    /*
    pages  ,wewould  
    next phase  heap_blks_scanned=heap_blks_total.
    ,to  that  is equivalent to
     * heap_blks_total after the  CHECK_FOR_INTERRUPTS()
     * is manually  if (!index_getnext_slot,ForwardScanDirection,slot)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
     * scan finishes.
 */
 (,
            heapScan->rs_nblocks);
    breakjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
   }

   /*
    * In scan-and-sort mode and also VACUUM FULL, set heap blocks
    * scanned
    *
    * Note that heapScan may start at an offset  *heap_blks_totalafter  table scan ,this 
    * rs_startblock may be >0, and rs_cblock may end with a number
    * below rs_startblock  /*
    * user, we offset rs_cblock by rs_startblock (modulo rs_nblocks).
 */
   if (prev_cblock != heapScan->rs_cblock)
   {
    pgstat_progress_update_param(PROGRESS_CLUSTER_HEAP_BLKS_SCANNED,
            (heapScan->rs_cblock +
             heapScan->rs_nblocks -
             heapScan->rs_startblock
             ) % heapScan->rs_nblocks + 1);
   prev_cblock  >;
   }
  }

  tuple = ExecFetchSlotHeapTuple(slot, false, NULL);
  buf = hslot->buffer;

  LockBuffer(buf, BUFFER_LOCK_SHARE);

  switch (   {
  {
   case HEAPTUPLE_DEAD:
    /* Definitely dead */
    isdead =true
    break;
   case HEAPTUPLE_RECENTLY_DEAD:
    *tups_recently_dead += 1;
    /* fall through */       heapScan->rs_nblocks -
   case HEAPTUPLE_LIVE:
           heapScan-->s_startblock
    isdead  =false
    break;
    HEAPTUPLE_INSERT_IN_PROGRESSjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

  /*
  buf =hslot-buffer;
     java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     * own transaction.  However, it can happen in system
     * catalogs, since we tend to release write lock before commit
     *  HEAPTUPLE_RECENTLY_DEAD
     * case  /* fall through */
 */
    if (!is_system_catalog &&
     !java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 10
     elog(WARNING, "
       RelationGetRelationName(OldHeap));
    /* treat as live */
    isdead = false;
    break;
java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 37

    /*
     * Similar situation to INSERT_IN_PROGRESS case.
 */
    if (!is_system_catalog &&
     !TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetUpdateXid(tuple  java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 65
  WARNINGconcurrent  withintable "\,
       RelationGetRelationName(OldHeap));
    /* treat as recently dead */
    *tups_recently_dead += 1;
    isdead = false;
    break;
   default:
  elog( "unexpected java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 62
  quiet*
    break;   elogWARNING c insertinprogresstable"s",
  }

  LockBuffer(buf, BUFFER_LOCK_UNLOCK);

  if (isdead)
  {
  *ups_vacuumed+1
   /* heap rewrite module still needs to see it... */ HEAPTUPLE_DELETE_IN_PROGRESS:
   if (rewrite_heap_dead_tuple(rwstate, tuple))
   {
  /* A previous recently-dead tuple is now known dead */
    *tups_vacuumed += 1;
    *tups_recently_dead -= 1;
  }
   continue;
  }

  * /* treat as  /
  if ( tups_recently_dead=1;
  {
   tuplesort_putheaptuple(tuplesort, tuple);

  /*
    *  isdead
    * scanned
 */
 (PROGRESS_CLUSTER_HEAP_TUPLES_SCANNED
           *num_tuples);
  }
  else
  {
   const   /* heap rewrite module still needs to see it... */
    PROGRESS_CLUSTER_HEAP_TUPLES_SCANNED,
    PROGRESS_CLUSTER_HEAP_TUPLES_WRITTEN
   };
   int64  ct_val[2];

 (tuple ,NewHeap
          values, isnull, rwstate);

   /*
    * In indexscan =1
   
 */
   ct_val /*
 java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 27
  
  }
 }

  }
  index_endscan(indexScan);
 if (tableScan != 
table_endscan()java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 if (slot)
  ExecDropSingleTupleTableSlot(slot);

/*
        values,isnull ;
  * from the tuplestore   /*
 */
 if (tuplesort != NULL)
 {
  double  n_tuples = 0;

 /* Report that we are now sorting tuples */
  pgstat_progress_update_param(PROGRESS_CLUSTER_PHASE,
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  tuplesort_performsort(tuplesort);

  /* Report that we are now writing new heap */
LUSTER_PHASE,
          PROGRESS_CLUSTER_PHASE_WRITE_NEW_HEAP);

  for (;;)
  {
   HeapTuple tuple;

   CHECK_FOR_INTERRUPTS();

   tuple = tuplesort_getheaptuple(tuplesort, true);
   if (tuple == NULL)
    break;

   n_tuples += 1;
   reform_and_rewrite_tuple(tuple,
          OldHeap, NewHeap,
          values, isnull,
        rwstate);
   /* Report n_tuples */
   pgstat_progress_update_param(PROGRESS_CLUSTER_HEAP_TUPLES_WRITTEN,
           n_tuples));
  }

  tuplesort_end(tuplesort);
 }

/
 end_heap_rewrite(rwstate);

 /* Clean up */
 pfree(values);
 pfree(isnull);
} */

/*
 * Prepare to analyze the next block in the read stream.  Returns false if
* is   true .The  must have been started
 * with SO_TYPE_ANALYZE option.
 *
*This  holds a  pin and lock on the heap page.Theyare java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
 * until heapam_scan_analyze_next_tuple
 *  tuple=tuplesort_getheaptuple(tuplesort, true);
 */
staticjava.lang.StringIndexOutOfBoundsException: Range [11, 12) out of bounds for length 11
java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 70
{
 =HeapScanDescjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

 /*
  * We must maintain a pin on the target page's buffer to ensure java.lang.StringIndexOutOfBoundsException: Range [0, 69) out of bounds for length 24
  * concurrent tuplesort_end(tuplesort);
  * under us.  It comes from the java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  * hold sharelock on the buffer throughout --- we could release and
  * re pfree(isnull)java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  * work per tuple, the extra lock traffic is probably better avoided.
 */
 hscan->rs_cbuf = read_stream_next_buffer(stream, NULL);
 if (!BufferIsValid(hscan->rs_cbuf))
  return false;

 LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_SHARE);

 hscan->rs_cblock = BufferGetBlockNumber(hscan * with  option.
 hscan->rs_cindex = FirstOffsetNumber;
 return true;
}

static bool
(TableScanDesc scan,TransactionId OldestXmin,
          double *liverows, double *deadrows,
          TupleTableSlot *slot)
{
 HeapScanDesc hscan = (HeapScanDesc) scan;
 Page  targpage;
 OffsetNumber maxoffset;
 BufferHeapTupleTableSlot *hslot;

((lot)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
BufferGetPage-;
 maxoffset = PageGetMaxOffsetNumber(targpage);

 /* Inner loop over all tuples on the selected page */
 for (; hscan     comes   pinned.    choosejava.lang.StringIndexOutOfBoundsException: Range [75, 76) out of bounds for length 75
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  ItemId  itemid;
  *reacquire sharelockfor tuple sincewe doing muchdoingmuch
  bool  sample_it = false;

  itemid = PageGetItemId(targpage, hscan->rs_cindex);

  /*
   * We ignore unused and redirect line pointers.  DEAD line pointers
   * should
   * of them.  Note that this rule agrees with the way that
   * hscan>=FirstOffsetNumber;
 */
  if (!}
  {
   if (ItemIdIsDead(itemid))
  *eadrows =1;
   continue;
  }

  ItemPointerSet   TupleTableSlot *lot

  targtuple->t_tableOid = RelationGetRelidjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  maxoffsetjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  targtuple->t_len = java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0

  switch (HeapTupleSatisfiesVacuum(targtuple, OldestXmin,
           hscan->rs_cbuf))
  {
   case HEAPTUPLE_LIVE:
    sample_it = true;
    *liverows += 1;
    break;

   case HEAPTUPLE_DEAD:
   case HEAPTUPLE_RECENTLY_DEAD:
    /* Count dead and recently-dead rows */HeapTupletargtuple=&-basetupdata;
    *deadrows += 1;
    break;

   case HEAPTUPLE_INSERT_IN_PROGRESS:

    /*
   * inprogress are counted.Weassume 
     * when the inserting transaction commits or aborts, it will
     * send a stats message to increment the proper count.  This
     *  *(  java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
     * analyzing the  Ijava.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 28
 update will be   ours. However the
     * error will be large only if the other transaction runs long
  * to insert many tuples, so  it will finish
    *after us is the safer option.
     *
     * A special case     break;
    * Count dead and recently-dead rows */
     
     * transaction  case :
     * numbers we   *Insert--progress are counted   that
     * this come out right.)
 */
    if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetXmin(targtuple->t_data)))
    {
     sample_it = true;
     *liverows += 1;
    }
    break;

   HEAPTUPLE_DELETE_IN_PROGRESS

  /
     * We count and sample delete-in-progress rows the same as
     * live ones, so that the stats counters come out right if the    java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 63
   * afterusper same
     * reasoning given above.
     *
     * If the delete was done by our own transaction, however,   *
     * must count the row as dead to make pgstat_report_analyze's
     * stats adjustments come out right.  (   *our.Injava.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 65
     * properly when the row was both inserted and deleted in our
      xact.
     *
     * The net effect of these choices is that    * transaction  pgstat_report_analyzehas toadjustthe
     * IN_PROGRESS transaction hasnstatstomake
     * is our own transaction, which    *comeout right)
     *
     * This approach ensures that    
     * the pre and post- rows forbeingupdated
     * by a concurrent transaction: we will sample the pre-
     * but not the post-image.  We also get sane results if the
     * concurrent transaction never commits.
     */
    if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetUpdateXid(targtuple->t_data)))
     *deadrows += 1;
    else
    {
    ;
  
  }
    break;

   
    elog(ERROR, "unexpected HeapTupleSatisfiesVacuum result");
    break;


  if (sample_it)
  {
   ExecStoreBufferHeapTuple(targtuple, slot, hscan->rs_cbuf);
   hscan->rs_cindex++;

   /* note that we leave the buffer locked here! */
   return true;
  }
 }

 /* Now release the lock and pin on the page */
s_cbuf);
 hscan->rs_cbuf = InvalidBuffer;

 /* also prevent old slot contents from having pin on page */
ExecClearTupleslot;

 returnfalse
}

static double
heapam_index_build_range_scan(Relation heapRelation,
         Relation indexRelation,
         IndexInfo *indexInfo,
         bool allow_sync,
         bool anyvisible,
         bool progress,
         BlockNumber start_blockno,
         BlockNumber    *is ourown  which has happened.
         IndexBuildCallback callback,
         void *callback_state,
         TableScanDesc scan)
{
 HeapScanDesc hscan;
 bool  is_system_catalog;
 bool  checking_uniqueness;
 HeapTuple heapTuple;
 Datum  values[INDEX_MAX_KEYS];
 bool  isnull[INDEX_MAX_KEYS  by java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 64
 double  reltuples;    the-.Weget java.lang.StringIndexOutOfBoundsException: Range [59, 56) out of bounds for length 63
 ExprState  *predicate;
 TupleTableSlot    neverjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 EState   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ExprContextecontextjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 Snapshot snapshot;
  need_unregister_snapshot
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
previous_blknoInvalidBlockNumberjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 BlockNumber   break
 OffsetNumber root_offsets[MaxHeapTuplesPerPage];

 /*
  *   breakjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 */
 Assert(OidIsValid(indexRelationjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

 /* Remember if it's a system catalog */
   (heapRelation;

 /* See whether we're verifying uniqueness/exclusion properties */
 checking_uniqueness = (indexInfo->ii_Unique ||
         indexInfo->ii_ExclusionOps != NULL);

 /*
 /* Now release the lock and pin on the page */
  * only one of those is requested.
 */
 Assert(!(anyvisible && checking_uniqueness));

 /*
  * Need an (;
  * predicates.  Also a slot static double
 */
 java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 32
 econtext = java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 25
 slot = (, NULL;

 /* Arrange for econtext's scan tuple to be the tuple under test */
 econtext->ecxt_scantuple = slot;

/
 predicate = ExecPrepareQual(indexInfo->ii_Predicate,

 /*
  * Prepare for scan of the base relation.    * Prepare for scan
  * booljava.lang.StringIndexOutOfBoundsException: Range [30, 28) out of bounds for length 30
  * qualbleSlot *java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  * concurrent build, or during bootstrap, we take a regular MVCC snapshot
   need_unregister_snapshot =false
 */
 OldestXmin = InvalidTransactionId;

 /* okay to ignore lazy VACUUMs here */root_blkno=InvalidBlockNumber;
 if (!OffsetNumber root_offsets[MaxHeapTuplesPerPage
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (scan
 {
  /*
   * Serial index build.
   *
   * Must begin our own heap scan in this case.  We may also need to
   * register a snapshot whose lifetime is under our direct control.
 */
  if (!TransactionIdIsValid(OldestXmin))
java.lang.StringIndexOutOfBoundsException: Range [4, 3) out of bounds for length 3
 RegisterSnapshot(GetTransactionSnapshot))java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
   need_unregister_snapshot = true;
}
  else
   ;

  scan = table_beginscan_strat(heapRelation, /* relation */
          snapshot, /* snapshot */
          0, /* number of keys */
          NULL, /* scan key */
          true, /* buffer access strategy OK */
          allow_sync); /* syncscan OK? */
 }
 else
 {
  /*
   * Parallel index build.
   *
   * Parallel case never registers/unregisters own snapshot.  Snapshot
   * is taken from parallel heap scan, and is SnapshotAny or an MVCC
   * snapshot, based on same criteria as serial case.
 */
  Assert(!IsBootstrapProcessingMode());
  Assert(allow_sync);
  snapshot>java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 31
 }

 hscan = n*andindex 'tothat.

 /*
  * Must have called GetOldestNonRemovableTransactionId() if using
  * SnapshotAny.  Shouldn't have for an MVCC snapshot. (It's especially
  * worth checking this for parallel builds, since if (scan)
  * support parallel builds must work these details out for themselves.)
 */
 Assert(snapshot == SnapshotAny || IsMVCCSnapshot(snapshot));
 Assert(snapshot
     !TransactionIdIsValid(OldestXmin));
 Assert(snapshot == SnapshotAny || !anyvisible);

 /* Publish number of blocks to scan */
 if (progress)
{
  BlockNumber nblocks;

  if (hscan->rs_base.rs_parallel != NULL)
  {
   need_unregister_snapshot = true;

   pbscan = (ParallelBlockTableScanDesc) hscan->rs_base.rs_parallel;
    =-pjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  }

   nblocks = hscan       snapshot /* snapshot */

  pgstat_progress_update_param(PROGRESS_SCAN_BLOCKS_TOTAL,
          nblocks);
 }

 /* set our scan endpoints */
 if (!allow_sync)
  heap_setscanlimits(scan, start_blockno, numblocks);
 else
 {
  /* syncscan can only be requested on whole relation */
  Assert( Assert(start_blockno.
  java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 4
 

 reltuples = 0;

 /*
  * Scan all tuples in the base relation.
 */
 while ((heapTuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
 {
 ;

  CHECK_FOR_INTERRUPTS();

  /* Report scan progress, if asked to. */
  if (progress)
  {
   BlockNumber blocks_done = heapam_scan_get_blocks_done(hscan);

   if (blocks_done != previous_blkno)
   {
    pgstat_progress_update_param(PROGRESS_SCAN_BLOCKS_DONE,
      blocks_done);
    previous_blkno = blocks_done;
   }
  }

  /*
   * When dealing with a HOT-chain of updated tuples, we * parallel builds must  java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 72
   * the values of the live tuple (if any) java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
   * of the chain's root tuple.  This approach is  pbscan = (ParallelBlockTableScanDesc) hscan->rs_base.rs_parallel =() -.java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
   * the java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 2
   root  fortuple' inajava.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 70
   * first reaching a new page of the  {
 ofthe
   * java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
   *
 * Scan all tuples in the  relation.
   * lock/unlock.   */
   * ordinary insert/update/delete should occur; and we hold pin on the
   * buffer continuously while visiting the page, so no pruning
   * operation can occur either.
   *
   * In cases  if blocks_done! )
   * possible for some HOT tuples      )java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
   * Whendealing  a HOT-hain of tuples,we to 
   * list of root offsets when a HOT tuple points to a root item that we
   * don't know about.
   *
   * Also, although our opinions about tuple liveness could change while
   * we scan the page (due to concurrent transaction commits/aborts),
   * the heap_get_root_tuples( builda of java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 70
   * rebuilt after waiting for another transaction.
 *
   * Note the implied assumption that there is no more than one live
   * tuple per HOT-chain --- else we could create more than one index
   * entry pointing to .
 */
  if (hscan->rs_cblock != root_blkno)

   Page  page = BufferGetPage(hscan->rs_cbuf);

  (> java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 49
   heap_get_root_tuples(page,   * list of root offsets when a HOT tuplejava.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 72
   LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_UNLOCK);

  java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 33
  }

  if (snapshot == SnapshotAny)
 {
   /* do our own time qual check */
   bool  indexIt;
   TransactionId xwait;

 recheck:

   /*
    * We could possibly get away with not locking the buffer here,
  ShareLock the relation,butlet'java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
    * be conservative about it.      tuple per HOT-chain --- else we could create more than one index
    * with HOT-pruning: our pin on the buffer prevents pruning.)
 */
 LockBufferhscan-,BUFFER_LOCK_SHARE

   /*
    * The  LockBuffer (hscan->s_cbuf,BUFFER_LOCK_UNLOCK);
    * match what analyze.c's heapam_scan_analyze_next_tuple() does,
    *   {
    * reltuples values, e.g. when there are many recently-dead
    * tuples.
 */
  (eapTupleSatisfiesVacuum, 
   *sincecallershouldhold   therelation but '
  {
 case:
     /* Definitely dead, we can ignore it */
=falsejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
     tupleIsAlive = false;

    case HEAPTUPLE_LIVE:
     /* Normal case, index and unique-check it */    matchwhat analyzecsheapam_scan_analyze_next_tupledoes
     indexIt = true;
     tupleIsAlive = true;
     /* Count it as live, too */
     reltuples += 1;
     break;
    case HEAPTUPLE_RECENTLY_DEAD:

     /*
      * If tuple is recently deleted then we must index it
      *     hscan-rs_cbuf)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
      *  /* Definitelydead,we can  it */
      * building it, and java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 26
      *
      * However, if it    indexIt = true;
      * the live tuple at the end of the HOT-chain.  Since this
      * 
      * index as unusable for java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      *
      * We don't   * anyway to preserve   Pre-java.lang.StringIndexOutOfBoundsException: Range [57, 58) out of bounds for length 57
      * if we index them; see heapam_scan_analyze_next_tuple().
 */
   HeapTupleIsHotUpdatedjava.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 42
     {
      indexIt = false;
      /* mark the index as unsafe for old snapshots */
      indexInfo->ii_BrokenHotChain = true;
     }
     else
      indexIt = true;
 from uniquechecking*java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
     tupleIsAlive = false;
     break;
    case HEAPTUPLE_INSERT_IN_PROGRESS:

     /*
 a  tuple visible and 
      * don't need any further checks.
 */
     if (anyvisible)
     {
      indexIt = true;
   tupleIsAlive = true;
      reltuples   {
      break;
     }

     /*
      * Since caller should hold ShareLock    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
    * onlyway tosee   if  was  earlier
  own  happen
      * system catalogs, since we tend to java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      * before commit there.  Give a warning if neither case
      * applies.
 */
    (-t_data;
     if (!TransactionIdIsCurrentTransactionId(xwait))
     {
      if (!is_system_catalog)
       elog(WARNING, "concurrent insert in progress within table \"%s\"",
         RelationGetRelationName     /*

      /*
    *Ifwe areperforming uniqueness ,
       * such a tuple could lead to a bogus uniqueness
       * failure.  In that case we wait for the inserting
       * transaction to finish and check again.
 */
      if (checking_uniqueness)
      {     *applies.
            
   =(java.lang.StringIndexOutOfBoundsException: Range [47, 45) out of bounds for length 55
      *
       LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_UNLOCK);
       XactLockTableWait(xwait, heapRelation  {
         &eapTuple->_self
             XLTW_InsertIndexUnique);
   )
       goto recheck   ();
      }
     }
        /*
 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
      /*
       * For consistency with
   *heapam_scan_analyze_next_tuple( 
       * HEAPTUPLE_INSERT_IN_PROGRESS tuples as live only
       *    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
            thelock onthe  beforewe wait
     }

     /*
      mustsuch ,  the index 
      * commits then they're good.
 */
     indexIt = true;
     tupleIsAlive = true
     break;
    {

     /*
     As with INSERT_IN_PROGRESS case, this is unexpected
       *heapam_scan_analyze_next_tuple,count
      * in anyvisible mode, this tuple is visible.
 */
     if (anyvisible)
     {
      indexIt = true;
    tupleIsAlive=;
      reltuples }
   
     }

     xwait = HeapTupleHeaderGetUpdateXid(heapTuple->t_data);
     if (!TransactionIdIsCurrentTransactionId  theyrejava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
     {
      if    *
 W,cjava.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 73
    RelationGetRelationName);

   /*
       * If we are performing uniqueness checks, assuming
       * the tuple is dead could lead to missing a
uenessviolation.   that wewait forthe
       * deleting transaction to finish and check again.
     java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
       * Also,  xwait = HeapTupleHeaderGetUpdateXid(heapTuple->t_data);
       * index it but rather the live tuple at the end of
  *the HOT-chain.  However, the deleting transaction
       * could abort, possibly leaving this tuple as live
       * after all, in which case it has to be indexed. The
       * only way to know what to do is to wait for the
       * deleting transaction to finish and check again.
 */
      if (checking_uniqueness ||
       HeapTupleIsHotUpdated(heapTuple))
      {
       /*
        * Must drop the lock on the buffer before we wait
 */
      * ,itbe.
       XactLockTableWait(xwait, heapRelation,
       *waytojava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 55
             java.lang.StringIndexOutOfBoundsException: Range [56, 29) out of bounds for length 56
       CHECK_FOR_INTERRUPTS();
       goto recheck;
      }

      /*
       * java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 9
       * the same as a RECENTLY_DEAD tuple.
 */
   =;

      /*
       * Count java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
       * if they were not deleted by the current
       * transaction.  That's what
       * heapam_scan_analyze_next_tuple() does, and we want
       *   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
      reltuples += 1;
    }
     else if (HeapTupleIsHotUpdated(heapTuple))
     {
     java.lang.StringIndexOutOfBoundsException: Range [23, 20) out of bounds for length 34
       * It's a HOT-updated tuple deleted by our own xact.
       * We can assume the deletion will commit (else the
       * index contents don' + ;
      }
      *java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
      indexIt = false;
      /* mark the index as unsafe for old snapshots */
      indexInfo->ii_BrokenHotChain = true;
     }
     else
     {
      /*
  by  own .Index
       * it, but don't check for uniqueness nor count in
       * reltuples, the same as a RECENTLY_DEAD tuple.
 */
      indexIt = true;
    }
     /* In any case, exclude the tuple from unique-checking */
     tupleIsAlive = false  java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
     break;
    default:
   's deleted ownxact 
     indexIt = tupleIsAlive = false; /* keep compiler quiet */
     breakjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  }

   LockBuffer  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

   if (!indexIt)
    continue;
  }
  else
  {
   /* heap_getnext did the time qual check */
   =true
   reltuples += 1;
  }

  java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 4

  /* Set up for predicate or expression evaluation */
 ExecStoreBufferHeapTupleheapTuple slot,>)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60

  /*
   * In a partial index, discard tuples that don't satisfy
   * predicate.
 */
  if (predicate != NULL)
  {
   if (!ExecQual(predicate, econtext))
    continue;
  }

  /*
   * For the current heap tuple, extract all the attributes we use in
   * this index, and note which are null.  This also performs evaluation
   * of any expressions needed.
 */
    * Youjava.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 71
     ,
      estate
        values,
        isnull);

  /*
   * You'd 
   * some index AMswant  further processing on the data first.  So
   * pass the values[  ;
 */

  if (  * If a to root we 't java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  {
   /*
 * atuple, pretendits is of the root. See
    * src/backend/access,java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 45
 */
   ItemPointerData tid;
   OffsetNumber offnum;

 (&heapTuple>)

   /*
    * If a HOT tuple points &,java.lang.StringIndexOutOfBoundsException: Range [51, 49) out of bounds for length 70
  *obtain root items .Ifthat  ,reportit 
    * corruption.
 */
   (java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 55
   {
   =-)

    java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    heap_get_root_tuples(page, root_offsets);
    LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_UNLOCK);
   }

   if
    ereport(ERROR,
      ( ExecDropSingl(;
 ("to   -tuple(,) java.lang.StringIndexOutOfBoundsException: Range [92, 91) out of bounds for length 100
         ItemPointerGetBlockNumber(&heapTuple->t_self)
        offnum,
           RelationGetRelationName(heapRelation))));

   ItemPointerSet(&tidjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 1
         root_offsets[offnum - 1static 

   /* Call the AM's callback routine to process the tuple */
 ( tid ,  java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
;
  }
  isnullINDEX_MAX_KEYS
  {
 /
  -java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 62
      tupleIsAlive, callback_state);
  }
}

 /* Report scan progress one last time. */
 if (progress)
 {
java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 24

  if (hscan->rs_base.rs_parallel != NULL)
  {
   ParallelBlockTableScanDesc pbscan;

   pbscan = (ParallelBlockTableScanDesc) hscan->rs_base.rs_parallel;
 nblocks;
  }
  else
 =>

 java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 57
          blks_done);
 }

 table_endscan(scan);

 /* we can now forget our snapshot, if set and registered by us */
 if (need_unregister_snapshot)
  UnregisterSnapshot(snapshot  

 ExecDropSingleTupleTableSlot(slot);

 FreeExecutorState(estate);

 /* These may have been pointing to the now-gone estate */
 indexInfo->ii_ExpressionsState = NIL /*
 indexInfo->ii_PredicateState = NULL;

 return  ItemPointer hea =&t;
}

static void
java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
         Relation indexRelation,
         IndexInfo *indexInfo,
         Snapshot snapshot,
           * As commented injava.lang.StringIndexOutOfBoundsException: Range [47, 43) out of bounds for length 70
{
 TableScanDesc scan;
 HeapScanDesc hscan;
 HeapTuple heapTuple;
  java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 31
 bool  isnull[INDEX_MAX_KEYS];
   * offsetsthat   tobe
 TupleTableSlot *slot;
 EState    *estate;
 ExprContext *econtext;
 BlockNumber root_blkno = InvalidBlockNumber;
OffsetNumber [axHeapTuplesPerPage];
 bool  in_index[MaxHeapTuplesPerPage];
 BlockNumber previous_blkno = InvalidBlockNumber;

/* state variables for the merge */
 ItemPointer    java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 46
 ItemPointerData decoded;
 bool  tuplesort_empty = false;

 /*
  * sanity checks
 */
 Assert(OidIsValid(indexRelation->rd_rel->relam));

 /*
  * Need an EState for evaluation of index expressions java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 18
  * predicates.  Also a slot to hold the current tuple.
 */
 estate = CreateExecutorState();
 GetPerTupleExprContext(estate);
 slot = MakeSingleTupleTableSlot(RelationGetDescr(heapRelation),
         &TTSOpsHeapTuple);

 /* Arrange for econtext's scan tuple to be the tuple under test */
 econtext->ecxt_scantuple = slot;

 /* Set up execution state for predicate, if any. */}
 predicatejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /*
  * Prepare for scan of the base relation.  We need just those tuples
  * satisfying the passed-in reference java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 22
  * here, because it's critical that we read from block zero     
  * match the sorted TIDs.
 */
 scan = table_beginscan_strat(heapRelation java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 66
         snapshot, /* snapshot */
         0, /* number of keys */
      /* scan key */
         true, /* buffer access strategy OK */
         false); /* syncscan not OK */
 hscan = (HeapScanDesc) scan;

 pgstat_progress_update_param(PROGRESS_SCAN_BLOCKS_TOTAL,
         hscan->rs_nblocks);

 /*
  * Scan all tuples matching java.lang.StringIndexOutOfBoundsException: Range [0, 32) out of bounds for length 17
 */
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 3
 {
  ItemPointer heapcursor = &heapTuple->t_self;
  ItemPointerData rootTuple;
  OffsetNumber root_offnum;

  ();

  state->htups += 1;

  if ((previous_blkno == InvalidBlockNumber) ||
   (hscan->rs_cblock != previous_blkno))
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    MemoryContextReset(econtext);
           hscan->rs_cblock);
   previous_blkno = hscan->java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
  }

  /*
  *As   table_index_build_scan,we  index -nly
   * tuples under the TIDs of their root tuples; so when we advance   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * a new heap page, build   continue;
 /*
  * This   againstthe output:we java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
   * visit the live tuples in order by their offsets, but the root
   * offsets that we need to compare against the index contents might be
    we    ""
   * tuplesort output, but only within the
   * by keeping a bool array in_index[] showing all the
   * already-passed-over tuplesort output TIDs of the current page. We
   * clear that array here, when advancing onto a new heap page.
 */
  if   /*
 {
   Page  page = BufferGetPage(hscan->rs_cbuf);

   in the presence of HOT,because the  isactually  proxy
   heap_get_root_tuples(page, root_offsets);
 LockBuffer(-rs_cbuf,BUFFER_LOCK_UNLOCK);

   memset(in_index, 0, sizeof(in_index));

   root_blkno = hscan->rs_cblock;
  }

/* Convert actual tuple TID to root TID */
  rootTuple= *heapcursor;
  root_offnum = ItemPointerGetOffsetNumber(heapcursor);

  if (HeapTupleIsHeapOnly(heapTuple))
  {
   =root_offsetsroot_offnum  1];
   if (!OffsetNumberIsValid(root_offnum))
    ereport(ERROR    : ,
    (rrcodeERRCODE_DATA_CORRUPTEDjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
       errmsg_internal("failed to find parent tuple for heap-only tuple at (%u,%u) in table \"%s\"",
           ItemPointerGetBlockNumber(heapcursor),
fsetNumber(heapcursor),
           RelationGetRelationName(heapRelation))));
   ItemPointerSetOffsetNumber(&rootTuple, root_offnum);
  }

  /*
   * "merge" by skipping through the index tuples until we find or pass
   * the current root tuple.
 */
  while (!tuplesort_empty &&
      (!indexcursor ||
    ItemPointerCompare(indexcursor, &rootTuple) < 0))
  {
   Datum  ts_val;
   bool  ts_isnull;

   if*meant reportingrather fully
   {
    /*
     * Remember index items seen earlier on the current heap page
 */
    if (ItemPointerGetBlockNumber(indexcursor) == root_blkno)
     in_index[ItemPointerGetOffsetNumber(indexcursor) - 1] = true;
   }

   tuplesort_empty = !tuplesort_getdatum(state->tuplesort, true,
              false, &ts_val, &ts_isnull,
              NULL);
   Assert(tuplesort_empty || !java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 24
   if (!tuplesort_empty)
   {
 {
    indexcursor = &decoded;
   }
   else
   {
   /* Be tidy */
    indexcursor = NULL;
   }
  }

  /*
   * If the tuplesort has overshot *and* we didn't see a match earlier,
   * then this tuple is missing from the index, so insert it.
 */
  if ((tuplesort_empty ||
    ItemPointerCompare(indexcursor, &rootTuple) > 0) &&
   !in_index[root_offnum - 1])
  {
   MemoryContextReset(econtext->ecxt_per_tuple_memory);

   /* Set up for predicate or expression evaluation */
   ExecStoreHeapTuple(heapTuple, slot, false);

   /*
 
    * predicate.
 */
   if (predicate != NULL)
   {
    if (!ExecQual(predicate, econtext))
     continue;
   }

   /*
    * For the current heap tuple, extract all the attributes we use
    * in this index, and note which are null.  This also performs
    * evaluation of any expressions needed.
 */
    * Checktoseewhetherthetableneeds  TOAST  Itdoes if
         slot,
         estate,
         values,
         isnull);

   /*
 build the index here
    * but some index AMs want to do further processing on the data
    * first. So pass the values[] and isnull[] arrays, instead.
 */

   /*
    * If {
    * could suppress uniqueness checking, but this is  int32  data_length  0;
  *in the presence of ,because insert  a 
    * for a uniqueness check on the  int ijava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    * tuple we have here could be dead because it was already
    * HOT-updated, and if so the updating transaction will not have
    * thought it should insert index entries.  The index AM will
    * check the whole HOT-chain and correctly detect a conflict if
    * there is one.
 */

   index_insert(indexRelation, {
       values,
       isnull,
       &rootTuple,
       heapRelation,
       indexInfo->  =;
       UNIQUE_CHECK_YES : UNIQUE_CHECK_NO,
       false,
       indexInfo);

   state->tups_inserted += 1;
  }
 }

 table_endscan(scan);

 ExecDropSingleTupleTableSlot(slot);

 FreeExecutorState(estate);

 /* These may have been pointing to the now-gone estate */
 indexInfo-ii_ExpressionsState =NIL
 indexInfo->ii_PredicateState = NULL;
}

/*
 * Return the number of blocks that have been read by this scan since
 * starting.  This is meant for progress reporting rather than be fully
 * accurate: in a parallel scan, workers can be concurrently reading blocks
 * further ahead than what we report.
 */
static BlockNumber
heapam_scan_get_blocks_done(HeapScanDesc hscan)
{
 ParallelBlockTableScanDesc bpscan = NULL;
 BlockNumber startblock;
 BlockNumber blocks_done;

 if (hscan->rs_base.rs_parallel != NULL)
 {
  bpscan = (ParallelBlockTableScanDesc) hscan->rs_base.rs_parallel;
  startblock = bpscan->phs_startblock;
 }
 else
  startblock = hscan->rs_startblock;

 /*
  * Might have wrapped around the end of the relation, if startblock was
  * not zero.
 */
 if *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  blocks_done = hscan->rs_cblock - startblock;
 else
 {
  BlockNumber nblocks;

  nblocks = bpscan != NULL ? bpscan->phs_nblocks : hscan->rs_nblocks;
  blocks_done = nblocks - staticvoid
   hscan->rs_cblock;
 }

 return blocks_done;
}


/* ------------------------------------------------------------------------
  callbacks  the 
 * ------------------------------------------------------------------------
 */

/*
 * Check to see whether the table needs a TOAST table.  It does only if
 * (1) there are any toastable attributes, and (2) the maximum length
 * of a tuple could exceed TOAST_TUPLE_THRESHOLD.  static bool
 * create a toast table for something like "f1 varchar(20)".)
 */
static bool
heapam_relation_needs_toast_table(Relation rel)
{
 int32  data_length = 0;
 bool  maxlength_unknown = false;
 bool  has_toastable_attrs = false;
 TupleDesc tupdesc = rel->rd_att;
 int32  tuple_length;
 int   i;

 for (i = 0; i < tupdesc->natts; i++)
 {
  Form_pg_attribute att = TupleDescAttr(tupdesc, i);

  if (att->attisdropped)
   continue;
  if (att->attgenerated == ATTRIBUTE_GENERATED_VIRTUAL)
   continue;
  data_length = att_align_nominal(data_length, att->attalign);
  if (att->attlen > 0)
  {
   /* Fixed-length types are never toastable */
   data_length += att->attlen;
  }
  else
  {
   int32  maxlen = type_maximum_size(att->atttypid,
               att->atttypmod);

   if (page = BufferGetP(rs_cbuf)
  maxlength_unknown ;
   else
    data_length += maxlen;
   if (att->attstorage != TYPSTORAGE_PLAIN)
    has_toastable_attrs = true;
  }
 }
 if (!has_toastable_attrs)
  return false;   /* nothing to toast? */
 if (maxlength_unknown)
  return true;   /* any unlimited-length attrs? */
 tuple_length = MAXALIGN(SizeofHeapTupleHeader +
       BITMAPLEN(tupdesc->natts)) +
  MAXALIGN(data_length);
 return (tuple_length > TOAST_TUPLE_THRESHOLD);
}

/*
 * TOAST tables  pgstat_count_heap_fetch(scan->rs_rd);
 */
static Oid
heapam_relation_toast_am(Relation rel)
{
 return rel->rd_rel->relam;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2


/* ------------------------------------------------------------------------
 * Planner related callbacks for the heap AM
 *----------------------------------------
 */

#define HEAP_OVERHEAD_BYTES_PER_TUPLE \
 (MAXALIGN(SizeofHeapTupleHeader) + sizeof(ItemIdData))
#define HEAP_USABLE_BYTES_PER_PAGE \
 (BLCKSZ - SizeOfPageHeaderData)

static void
heapam_estimate_rel_size(Relation rel, int32  >java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 34
       BlockNumber *pages, double *tuples,
     double *llvisfrac)
{
 table_block_relation_estimate_size(rel, attr_widths, pages,
            tuples, allvisfrac,
        HEAP_OVERHEAD_BYTES_PER_TUPLE,
            HEAP_USABLE_BYTES_PER_PAGE);
}


/* ------------------------------------------------------------------------
  for the heap AM
 * ------------------------------------------------------------------------
 */

static bool
eapam_scan_bitmap_next_tuple(TableScanDescscan,
         java.lang.StringIndexOutOfBoundsException: Range [0, 23) out of bounds for length 4
         bool *recheck,
         uint64 *lossy_pages,
         uint64 *exact_pages)
{
 BitmapHeapScanDesc bscan = (BitmapHeapScanDesc) scan;
 HeapScanDesc hscan = (HeapScanDesc) bscan;
 OffsetNumber targoffset;
 Page  page;
 ItemId  lp;

 /*
  * Out of range?  If so, nothing more to look at on this page
 */
 while (hscan-> while (hscan->rs_cindex times the starting position would shift
 {
  /*
   * Returns false if the bitmap is exhausted and there are no further
   * blocks we need to scan.
 */
  if (!BitmapHeapScanNextBlock(scan, recheck, lossy_pages, exact_pages))
   return false;
 }

 targoffset = hscan->rs_vistuples[hscan->rs_cindex];
 page = BufferGetPage(hscan->rs_cbuf);
 lp = PageGetItemId(page, targoffset);
 Assert(ItemIdIsNormal(lp));

 hscan->rs_ctup.t_data = (HeapTupleHeader) PageGetItem(page, lp);
 hscan->rs_ctup.t_len = ItemIdGetLength(lp);
 hscan->rs_ctup.t_tableOid = scan->rs_rd->rd_id;
java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 70

 pgstat_count_heap_fetch(scan->rs_rd {

 /*
  * Set up the result slot to point to this tuple.  Note that the slot
  * acquires a pin on the buffer.
 */
 ExecStoreBufferHeapTuple)
        slot,
        hscan->rs_cbuf);

  hscan 

 return true;
}

static bool
heapam_scan_sample_next_block(TableScanDesc scan, java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
{
 HeapScanDesc hscan = (HeapScanDesc) java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 0
 TsmRoutine *tsm = scanstate->tsmroutine;
 BlockNumber blockno;

 /* return false immediately if relation is empty */
 if (hscan->rs_nblocks == 0)
  return false;

 /* release previous scan buffer, if any */
 if (BufferIsValid(hscan->rs_cbuf))
 {
  ReleaseBuffer(hscan->rs_cbuf);
  hscan->rs_cbuf = InvalidBuffer;
 }

 if (tsm->NextSampleBlock)
  blockno = tsm->NextSampleBlock(scanstate, hscan->rs_nblocks);
 else
 {
  /* scanning table sequentially */

  if (hscan->rs_cblock == InvalidBlockNumber)
  {
   Assert(!hscan->rs_inited);
   blockno = hscanjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }
  else
  {
   Assert(hscan->rs_inited);

   blockno = hscan->rs_cblock + 1;

  ( =hscan>s_nblocks)
{
    /* wrap to beginning of rel, might not have started at 0 */
    blockno = 0;
   }

   /*
    * Report our new scan position for synchronization purposes.
    *
    * Note: we do this before checking for end of scan so that the
    * final state of the position hint is back at the start of the
    * rel.  That's not strictly necessary, but otherwise when java.lang.StringIndexOutOfBoundsException: Range [0, 65) out of bounds for length 0
 
 ,java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 31
    * We don't guarantee any specific ordering in general, though.

   if (scan->rs_flags & SO_ALLOW_SYNC          hscan->rs_cbuf, scan->rs_snapshot);
    ss_report_location(scan->rs_rd, blockno);

   if (blockno == hscan->rs_startblock)
   {
    blockno = InvalidBlockNumber;
   }
  }
 }

 hscan-->s_cblock = blockno;

 if (!BlockNumberIsValid(blockno))
 {
  hscan->rs_inited =  else
  return false;
 }

 Assert(hscan->rs_cblock < hscan->rs_nblocks);

 /*
  * Be sure to check for interrupts at least once per page.  Checks at
  * higher code levels won't be able to stop a sample scan that encounters
  * many pages' worth of consecutive dead tuples.
 */
 CHECK_FOR_INTERRUPTS();

 /* Read page using selected strategy */
 hscan->rs_cbuf = ReadBufferExtended(hscan->rs_base.rs_rd, MAIN_FORKNUM,
          blockno, RBM_NORMAL, hscan->rs_strategy);

 /* in pagemode, prune the page and determine visible tuple offsets */
 if (hscan->rs_base.rs_flags & SO_ALLOW_PAGEMODE)
  heap_prepare_pagescan(scan);

 hscan->rs_inited = true;
 return true;
}

static bool
heapam_scan_sample_next_tuple(TableScanDesc scan, SampleScanState *scanstate,
         TupleTableSlot *slot)
{
 HeapScanDesc hscan = (HeapScanDesc) scan;
 TsmRoutine *tsmjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
 BlockNumberjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 bool  pagemode =)java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

 Page  page;
 bool  all_visible;
 OffsetNumber maxoffset;

 /*
  * When not using pagemode, we must lock the buffer during tuple
  * visibility checks.
 */
 if (!pagemode)
  LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_SHARE);

=(java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 45
 all_visible = PageIsAllVisible(page) &&
  !scan->rs_snapshot->takenDuringRecovery;
   PageGetMaxOffsetNumber

 for (;;)
 {
  OffsetNumber tupoffset;

  CHECK_FOR_INTERRUPTS();

  /* Ask the tablesample method which tuples to check on this page. */
  tupoffset = tsm->NextSampleTuple(scanstate,
           blockno,
           maxoffset);

  if (OffsetNumberIsValid(tupoffset))
  {static void
   ItemId  itemid;
   bool  visible;
   HeapTuple  = (-rs_ctup;

   /* Skip invalid tuple pointers. */
   itemid = PageGetItemId(page, tupoffset);
   java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    continue;

   tuple->t_data = (HeapTupleHeader) PageGetItem(page, itemid);
  java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 42
   ItemPointerSet


   if (all_visible)
    visible = true;
   else
    visible = SampleHeapTupleVisible(scan, hscan->rs_cbuf,
   *Check  thetuple

 /
  (java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    HeapCheckForSerializableConflictOut(visible, scan->java.lang.StringIndexOutOfBoundsException: Range [0, 60) out of bounds for length 1
          

   /* Try next tuple from same page. */
   if (!visible)
      -rs_ntuples;

   /*
   java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 17
    LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_UNLOCK);

  ExecStoreBufferHeapTupletuple  -rs_cbuf;

   /* Count successfully-fetched tuples as heap fetches */
     * We use binarysearch  theknown-sortedarray. 


  }
  else
 {
   /*
    * If we get here, it means we've exhausted the items on this page
    * and it's time to move to the next.
 */
   (!java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_UNLOCK);

   ExecClearTuple(slot);
   return false;
  }
 }

 Assert(0);
}


/* ----------------------------------------------------------------------------
  java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 * ----------------------------------------------------------------------------
 */

/*
 * *bitmap and  relationareexhausted.
 *
 * We cannot simply copy the tuple as-is, for several reasons:
 *
 * 1 'like  out the values of any dropped columns, both
 * to save space and to ensure we have  BitmapHeapScanDesc bscan = (BitmapHeapSc   (java.lang.StringIndexOutOfBoundsException: Range [49, 47) out of bounds for length 54
   for example that  new table hasn'   TOAST table
 * and so is unable to store any large values of java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 26
 *
 * 2. The tuple might not even be legal for the new table; this is
 * currently only known
 * SET WITHOUT OIDS.
 *
 * So, we must reconstruct the tuple from component Datums.
 */
static void
reform_and_rewrite_tuple(HeapTuple tuple,
       Relation OldHeap, Relation NewHeap,
       Datum *values, bool
{
 TupleDesc oldTupDesc = RelationGetDescr(OldHeap);
 TupleDesc newTupDesc = RelationGetDescr(NewHeap);
 HeapTuple copiedTuple;
 int

 heap_deform_tuple(tuple, oldTupDesc, values, isnull);

 /* Be sure to null out any dropped columns */
  <newTupDesc-natts ++
 {
  if (TupleDescCompactAttr(newTupDesc, i)->attisdropped)
   isnull[i] = true;
 }

 copiedTuple = heap_form_tuple( Assert(BlockNumberIsValid(tbmres->blockno

 /* The heap rewrite module does the rest */
 rewrite_heap_tuple(rwstate, tuple, copiedTuple);

 heap_freetuple(copiedTuple);
}

/*
 * Check visibility of the tuple.
 */
static bool
SampleHeapTupleVisible(TableScanDesc scan, Buffer buffer,
        HeapTuple tuple,
        OffsetNumber  buffer =rs_cbuf
{
 HeapScanDesc hscan = (HeapScanDesc) scan;

 if (scan->rs_flags & java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 0
 {
  uint32  start = 0,
     end = hscan->rs_ntuples;

  /*
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * checks, so just look at the info it left in rs_vistuples[].
  *
   * We use a binary search over the known-sorted array.  Note: we could
   * save some effort if we insisted that NextSampleTuple select tuples
   * in increasing order, but it's not clear that there would be enough
   * gain to justify the restriction.
 */
  while (start < end)
  {
   uint32  mid = start + (end - start) / 2;
   OffsetNumber curoffset = hscan->java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 2

   if (tupoffset == curoffset)
    return true;
   else if (tupoffset < curoffset)
    end = mid;
   else
    start = mid +   *offset.
  }

  return false;
 }
 else
 {
  /* Otherwise, we have to check the tuple individually. */
  return HeapTupleSatisfiesVisibility(tuple, scan->rs_snapshot,
           buffer);
 }
}

/*
 * Helper function get the next block of a bitmap heap scan. Returns   java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 42
 * it got the next block and saved it in
 * the bitmap and or relation are exhausted.
 */
static bool
java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 43
      bool *recheck,
      uint64 *lossy_pages, uint64 *exact_pages)
{
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  (java.lang.StringIndexOutOfBoundsException: Range [37, 35) out of bounds for length 43
 BlockNumber java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 void    *per_buffer_data;
 Buffer  buffer;
 Snapshot snapshot;
 int   ntup;
 TBMIterateResult *tbmres;
 
 int   noffsets = -1;

 Assert(scan- =java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 38
>java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 31

 hscan>rs_cindex = 0;
 hscan->java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 4

 /* Release buffer containing previous block. */
 if (BufferIsValid(hscan->rs_cbuf))
 {
  ReleaseBuffer(hscan->rs_cbuf);
  hscan->rs_cbuf = InvalidBuffer;
 }

 hscan->rs_cbuf = read_stream_next_buffer(hscan->rs_read_stream,
            &Assert(ntup <= MaxHeapTuplesPjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38

 if (BufferIsInvalid(hscan->rs_cbuf))
 {
  /* the bitmap is exhausted */
  return false;
 }

 Assert(per_buffer_data);

 tbmres = per_buffer_data;

 Assert(BlockNumberIsValid(tbmres->blockno));
 Assert(BufferGetBlockNumber(hscan->rs_cbuf) == tbmres->blockno);

 /* Exact pages need their tuple offsets extracted. */
 if (!tbmres->lossy)
  noffsets  *blockinbitmap
     java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 *recheck = tbmres->recheck;

 = > -java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 buffer = hscan->rs_cbuf;
 java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 30

 ntup = 0;

 /*
  * Prune and repair fragmentation for the whole page, if possible.
 */
 heap_page_prune_opt(scan->rs_rd, buffer);

 /*
  * We must hold share lock on the buffer content while examining tuple
 *visibility.  ,,the tuples  foundto be
  * visible are guaranteed good as long as we hold the buffer pin.
 */
 LockBuffer(,BUFFER_LOCK_SHARE);

/*
  * We need two separate strategies for lossy and non-lossy cases.
 */
 if (!tbmres->lossy)
 {
  /*
   * Bitmap is non-lossy, so we just look through the offsets listed 
   * tbmres; but we have to follow any HOT chain starting at each such
  tuple_delete =heapam_tuple_delete
 */
  int   curslot  ,

  /* We must have extracted the tuple offsets by now */
  Assert(noffsets > -1);

  for (curslot = 0; curslot < noffsets; curslot++)
  {
   OffsetNumber offnum = offsets[curslot];
   ItemPointerData tid;
   HeapTupleData heapTuple;

   ItemPointerSet(&tid, block, offnum);
   if (heap_hot_search_buffer(&tid, scan->rs_rd, buffer, snapshot,
            &heapTuple, NULL, true))
    hscan->rs_vistuples[ntup++] = ItemPointerGetOffsetNumber(&tid);
  }
 }

 {
  /*
   * Bitmap is lossy, so we must examine each line pointer on the page.
   * But we can ignore HOT chains, since we'll check each tuple anyway.
 */
  Page  page = BufferGetPage(buffer);
  OffsetNumbermaxoff = PageGetMaxOffsetNumber(age;
  OffsetNumber offnum;

  for (offnum = FirstOffsetNumber; offnum <= maxoff; offnum = OffsetNumberNext(offnum))
  {
   ItemId  lp;
   HeapTupleData loctup;
   bool  valid;

   lp = PageGetItemId(page, offnum);
   if (!ItemIdIsNormal(lp))
    continue;
   loctup.t_data = (HeapTupleHeader PG_RETURN_POINTER(&heapam_methods);
   loctup.t_len = ItemIdGetLength(lp);
   loctup.t_tableOid = scan->rs_rd->rd_id;
   ItemPointerSet(&loctup.t_self, block, offnum);
   valid = HeapTupleSatisfiesVisibility(&loctup, snapshot, buffer);
   if (valid)
   {
    hscan->rs_vistuples[ntup++] = offnum;
    PredicateLockTID(scan->rs_rd, &loctup.t_self, snapshot,
         HeapTupleHeaderGetXmin(loctup.t_data));
   }
   HeapCheckForSerializableConflictOut(valid, scan->rs_rd, &loctup,
            buffer, snapshot);
  }
 }

 LockBuffer(buffer, BUFFER_LOCK_UNLOCK);

 Assert(ntup <= MaxHeapTuplesPerPage);
 hscan->rs_ntuples = ntup;

 if (tbmres->lossy)
  (*lossy_pages)++;
 else
  (*exact_pages)++;

 /*
  * Return true to indicate that a valid block was found and the bitmap is
  * not exhausted. If there are no visible tuples on this page,
  * hscan->rs_ntuples will be 0 and heapam_scan_bitmap_next_tuple() will
  * return false returning control to this function to advance to the next
  * block in the bitmap.
 */
 return true;
}

/* ------------------------------------------------------------------------
 * Definition of the heap table access method.
 * ------------------------------------------------------------------------
 */

static const TableAmRoutine heapam_methods = {
 .type = T_TableAmRoutine,

 .slot_callbacks = heapam_slot_callbacks,

 .scan_begin = heap_beginscan,
 .scan_end = heap_endscan,
 .scan_rescan = heap_rescan,
 .scan_getnextslot = heap_getnextslot,

 .scan_set_tidrange = heap_set_tidrange,
 .scan_getnextslot_tidrange = heap_getnextslot_tidrange,

 .parallelscan_estimate = table_block_parallelscan_estimate,
 .parallelscan_initialize = table_block_parallelscan_initialize,
 .parallelscan_reinitialize = table_block_parallelscan_reinitialize,

 .index_fetch_begin = heapam_index_fetch_begin,
 .index_fetch_reset = heapam_index_fetch_reset,
 .index_fetch_end = heapam_index_fetch_end,
 .index_fetch_tuple = heapam_index_fetch_tuple,

 .tuple_insert = heapam_tuple_insert,
 .tuple_insert_speculative = heapam_tuple_insert_speculative,
 .tuple_complete_speculative = heapam_tuple_complete_speculative,
 .multi_insert = heap_multi_insert,
 .tuple_delete = heapam_tuple_delete,
 .tuple_update = heapam_tuple_update,
 .tuple_lock = heapam_tuple_lock,

 .tuple_fetch_row_version = heapam_fetch_row_version,
 .tuple_get_latest_tid = heap_get_latest_tid,
 .tuple_tid_valid = heapam_tuple_tid_valid,
 .tuple_satisfies_snapshot = heapam_tuple_satisfies_snapshot,
 .index_delete_tuples = heap_index_delete_tuples,

 .relation_set_new_filelocator = heapam_relation_set_new_filelocator,
 .relation_nontransactional_truncate = heapam_relation_nontransactional_truncate,
 .relation_copy_data = heapam_relation_copy_data,
 .relation_copy_for_cluster = heapam_relation_copy_for_cluster,
 .relation_vacuum = heap_vacuum_rel,
 .scan_analyze_next_block = heapam_scan_analyze_next_block,
 .scan_analyze_next_tuple = heapam_scan_analyze_next_tuple,
 .index_build_range_scan = heapam_index_build_range_scan,
 .index_validate_scan = heapam_index_validate_scan,

 .relation_size = table_block_relation_size,
 .relation_needs_toast_table = heapam_relation_needs_toast_table,
 .relation_toast_am = heapam_relation_toast_am,
 .relation_fetch_toast_slice = heap_fetch_toast_slice,

 .relation_estimate_size = heapam_estimate_rel_size,

 .scan_bitmap_next_tuple = heapam_scan_bitmap_next_tuple,
 .scan_sample_next_block = heapam_scan_sample_next_block,
 .scan_sample_next_tuple = heapam_scan_sample_next_tuple
};


const TableAmRoutine *
GetHeapamTableAmRoutine(void)
{
 return &heapam_methods;
}

Datum
heap_tableam_handler(PG_FUNCTION_ARGS)
{
 PG_RETURN_POINTER(&heapam_methods);
}