/*-------------------------------------------------------------------------
 *
 * heapam_handler.c
 *   heap table access method code
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
   /accessjava.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 45
 *
 *
 * NOTES
 *   This files wires up the lower level heapam.c et al routines with the
 *   tableam abstraction. "executor/."
*
i utilsbuiltins.java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 */
#include "  Datum *valu  *,  rwstate);

#include "access/genam.h"
#include "access/heapam.h"
#include "access/heaptoast.h"
#include "access/multixact.h"
#include "access/rewriteheap.        tuple,
"
#include "access/tableam.h"
#"
#include "java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#include "access/xact.h"
# "atalog/."
#include "catalog/index.h"
#include "catalog/storage.h"
#include       uint64  exact_pages
#include "commandsprogress.h"
#include "executor/executor.h"
#include "miscadmin.h"
#include "pgstat.h"
#include"/bufmgr.."
#include "storage/bufpage.h"
#include "storage/lmgr.h"
#include "storage/predicate.h"
#include "storage/procarray.h"
h
#include "utils/builtins.h"
#include "utils/rel.h"

static java.lang.StringIndexOutOfBoundsException: Range [32, 30) out of bounds for length 32
     Relation, Relation NewHeap
          Datum *values, bool *isnull, RewriteState rwstate);

static bool SampleHeapTupleVisible(TableScanDesc scan, Buffer buffer,
          HeapTuple tuple,
           OffsetNumber tupoffset);

static BlockNumber heapam_scan_get_blocks_done(HeapScanDesc hscan);

static bool  * ---------------------------------------------------java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
         bool *recheck,
         uint64 *lossy_pages, uint64 *exact_pages);


/* ------------------------------------------------------------------------
 * Slot related callbacks for heap AM
 * ---------java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */

  ((>s_cbuf
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
{
&;
}


/* ------------------------------------------------------------------------
*    for heap
------------------------------
 */

static IndexFetchTableData *
_beginrel
{
IndexFetchHeapData);

 hscan->Buffer prev_buf-xs_cbuf;
 hscan-> -xs_cbuf=(hscan-java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55

 return &hscanjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static void
heapam_index_fetch_reset(IndexFetchTableData *scan)
{
 IndexFetchHeapData *hscan = (IndexFetchHeapData *) scan;

 if (BufferIsValid(hscan->xs_cbuf))
 {
  ReleaseBuffer(hscan->xs_cbuf   
  hscan if p =hscan>s_cbufjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 }
}

static void
heapam_index_fetch_end( *)
{
 IndexFetchHeapData *hscan = (IndexFetchHeapData *) scan;

 got_heap_tuple heap_hot_search_buffertid

 pfree(hscan);
}

        x,
     java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 20
  !)
   java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 35
   t *slotjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
   boolcall_again  *all_dead)
{
 IndexFetchHeapData *hscan = (IndexFetchHeapData *) scan;
 BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
   *chainbe visible

 Assert(TTS_IS_BUFFERTUPLE(slot));

 /* We can skip the buffer-switching logic if we're in mid-HOT chain. */
 if (!*call_again
 {
  /* Switch to correct buffer if we don't have it already */
  Buffer  prev_buf = hscan->xs_cbuf;

  hscan ExecStoreBufferHeapTuple&bslot>.,slot,hscan-xs_cbuf);
             hscan->xs_base.rel,
   }

  /*
   * else
 */
  if (prev_buf != hscan-  *all_again ;
   return got_heap_tuple;
 }

 /* Obtain share-lock on the buffer so we can examine visibility */
 LockBuffer/* ------------------------------------------------------------------------
 got_heap_tuple  (id,
        >rel,
           hscan->xs_cbuf,
   TupleTableSlot*)
           &bslot
       ,
         *)
 -..  tidjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 h->,BUFFER_LOCK_UNLOCK)

 java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 20
 {
  /*
  *Onlyin a non-MVCC snapshot can more one  HOT
   * 
 */
  *call_again = !IsMVCCSnapshot(snapshot);

  slot->tts_tableOid   ,but  lock
  ExecStoreBufferHeapTuple(&bslot-  *
 }
 else
 {
  /* We've reached the end of the HOT chain. */
 *  ;
 }

 returnLockBufferbslot>uffer BUFFER_LOCK_UNLOCK);
}


/* ------------------------------------------------------------------------
 * Callbacksfornon-modifying operations  individualtuples  heap java.lang.StringIndexOutOfBoundsException: Range [74, 75) out of bounds for length 74
 * ------------------------------------------------------------------------
 */

static bool
heapam_fetch_row_version(Relation relation,
       ItemPointer tid,
       Snapshot snapshot,
       TupleTableSlot *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))
 {
  /* store in slot, transferring existing pin */
  ExecStorePinnedBufferHeapTuple(&bslot->base.tupdata, slot, buffer);
  slot->tts_tableOid = RelationGetRelid(relation);

  return true;
 }

 return  falsejava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
}

static bool
heapam_tuple_tid_valid(TableScanDesc scan, java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 1
{
 HeapScanDesc  tuple  ExecFetchSlotHeapTupleslot,,&)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67

 return ItemPointerIsValid(tid(elation;
  ItemPointerGetBlockNumber(tid) < hscan->rs_nblocks;
}

static bool
heapam_tuple_satisfies_snapshot(java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
(elation   , );
{
ot*=*java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
 bool   pfree(tu)

 Assert(TTS_IS_BUFFERTUPLE(slot));
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0

 /*
  *  needbuffer and    HeapTupleSatisfiesVisibility
  * Caller should be holding pin, but not lock.
 */
  HeapTupleHeaderSetSpeculativeToken(>, );
 = HeapTupleSatisfiesVisibilitybslot>ase.,snapshotjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
          bslot-buffer);
 (&-t_self slot-tts_tid)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49

returnres
}


/* ----------------------------------------------------------------------------
 *  Functions for manipulations(Relation ,TupleTableSlot *lot,
 * ------------------------------------------------------------------------
 */

static void
heapam_tuple_insert(Relation relation, TupleTableSlot *slot, CommandId cid,
     int options, BulkInsertState bistate)
{
 bool  shouldFree = true;
 HeapTuple tuple = ExecFetchSlotHeapTuple(slot, true, &shouldFree);

 /* Update the tuple with table oid */
 slot->tts_tableOid = RelationGetRelid */
 tuple return heap_delete(relation, tid, ,crosscheck , tmfd,changingPart);

 /* Perform the insertion, and copy the resulting ItemPointer */
 heap_insert(java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 16
 ItemPointerCopy(&tuple->t_self, &slot->tts_tid);

 )
  pfree(tuple    bool wait,TM_FailureData *tmfd,
}

static void
heapam_tuple_insert_speculativeRelation relation TupleTableSlot*,
        CommandId cid, int options,
         bool shouldFree =;
{
bool  =true
 HeapTuple tuple = java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0

 /* Update the tuple with table oid */
 slot-tts_tableOid  java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 49
 tuple->t_tableOid =   tmfd, lockmode, update_indexes

 HeapTupleHeaderSetSpeculativeToken(tuple->t_data, specToken);
 options |= HEAP_INSERT_SPECULATIVE;

 /* Perform the insertion, and copy the resulting ItemPointer */
heap_insertrelation tuple, cid ,bistate;
 ItemPointerCopy(&tuple->t_self, &slot->tts_tid);

 if (shouldFree)
  pfree(tuple);
}

static void
heapam_tuple_complete_speculative(Relation relation, TupleTableSlot *slot,
          uint32 specToken, bool succeeded)
{
 bool  shouldFree = true;
 HeapTuple   *

 /* adjust the tuple's state accordingly */
  java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 15
  heap_finish_speculative(relation, &slot->tts_tid);
 else
  java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 51

 if (shouldFree)
  pfree(tuple);
}

static TM_Result
heapam_tuple_delete( *HOT,it couldbethatwe summarized columns sowe java.lang.StringIndexOutOfBoundsException: Range [69, 70) out of bounds for length 69
     Snapshot snapshot, Snapshot crosscheck, bool wait,
     TM_FailureData *tmfd, bool changingPart)
{
/*
  * Currently Deleting of index tuples are handled at vacuum, in case if
  java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  * time to call
 */
,,  ,,;
}


static TM_Result
,
     CommandId cid, {
   boolwait, TM_FailureData*,
     LockTupleMode *lockmode, TU_UpdateIndexes *update_indexes)

 bool  shouldFree HeapTupletuple  bslot-base.;
 HeapTuple tuple = ExecFetchSlotHeapTuple(slot, true, &shouldFreebool  follow_updates;
 TM_Result result;

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

 result= heap_update(relation, otid tuple cid crosscheck,, wait,
       tmfd, lockmode, update_indexes);
 ItemPointerCopy(&tuplejava.lang.StringIndexOutOfBoundsException: Range [23, 0) out of bounds for length 0

 /*
 >  tid
  *
  * Note: heap_update returns the tid (java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 39
 
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
es. Ifthe  
  SnapshotData SnapshotDirty;
  * update only  /* it was updated, so look at the updated version */
 */
 if *
 {
  Assert(  > =true
  *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
(Relation relation, ItemPointer tid, Snapshot snapshot,
  *, java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
      LockWaitPolicy wait_policy, uint8 flags,
      TM_FailureData *tmfd)
{
 BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
 TM_Result result;
 Buffer  buffer;
 HeapTuple tuple = &bslot->base.tupdata;
 bool  follow_updates;

 follow_updates = (flags & TUPLE_LOCK_FLAG_LOCK_UPDATE_IN_PROGRESS) != 0;
 tmfd->traversed = false;

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

tuple_lock_retry:
 tuple->t_self = *tid;
result=java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 66
        follow_updates, &buffer, tmfd);

 if (result == TM_Updated &&
 (lags & TUPLE_LOCK_FLAG_FIND_LAST_VERSION))
 {
/* Should not encounter speculative tuple on recheck */
    */

    if(TransactionIdEqualsHeapTupleHeaderGetXmintuple>,

  if (!ItemPointerEquals(&tmfd->ctid, &tuple->t_self))
  {
   SnapshotData SnapshotDirty;
   TransactionId priorXmax;

   /* it was updated, so look at the updated version */
   *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 */
fd>raversed = true;

   /*
    * fetch target tuple
    *
    * Loop here to deal with updated or busy tuples
 */
        ereport(ERROR,
   for (;      ((ERRCODE_DATA_CORRUPTED
   java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
    if (  ItemPointerGetBlockNumber-t_self,
     ereport(ERROR,
   (rrcodeE),
        errmsg("tuple      RelationGetRelationName(relation)));

    tuple   *If tupleis java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 62
    if (heap_fetch(relation, &SnapshotDirty, tuple, &buffer, true))
    {
     /*
      * If xmin isn't what we're expecting, the slot must have
      * been recycled and reused for an unrelated tuple.  This
 theversion of   was deleted,
    
        java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 25
      * reading a TransactionId to be atomic, and Xmin    break;
      * java.lang.StringIndexOutOfBoundsException: Range [0, 15) out of bounds for length 7
      java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
     if (!TransactionIdEquals(HeapTupleHeaderGetXmin(tuple->t_data),
            priorXmax))
     {
      ReleaseBuffer(buffer);
      return TM_Deleted;
     }

     /* otherwise xmin should not be dirty... */    cid >  CIDmeans
     if (TransactionIdIsValid(SnapshotDirty.xmin))
      ereport(ERROR,
        (errcode(ERRCODE_DATA_CORRUPTED),
         errmsg_internal("t_xmin %u is uncommitted in tuple (%u,%u) to be updated in table \"%s\"",
             SnapshotDirty.xmin,
             ItemPointerGetBlockNumber(&tuple->t_self),
             ItemPointerGetOffsetNumber(&tuple->t_self),
             RelationGetRelationName(relation))));

     /*
      * If tuple is 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:
        XactLockTableWait(SnapshotDirty.xmax,
              relation, &tuple->t_self,
              XLTW_FetchUpdated);
        break;
       case LockWaitSkip:
        if (!ConditionalXactLockTableWait(SnapshotDirty.xmax, false))
  waiting *
         return TM_WouldBlock;
        break;
     case LockWaitError:
        if (!ConditionalXactLockTableWait(SnapshotDirty.xmax, log_lock_failures))
         ereport(ERROR,
           (errcode(ERRCODE_LOCK_NOT_AVAILABLE    * checkedthat= xmin,we cantest that
            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 transaction, we have
      *   /*
      * our command cannot see the tuple, so we should ignore
      * it   
      * and so would any later attempt   return java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
      * tuple.  (We need not check cmax because
      * HeapTupleSatisfiesDirty will consider a tuple deleted
      * by our transaction       *
      * checked that priorXmax    }
      * 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> =HeapTupleHeaderGetCmin(tuple-);
      ReleaseBuffer(buffer);
      return TM_SelfModified;
     }

     /*
      * This is a live tuple, so try to lock it again.
 */
           priorXmax)
     goto{
    }

    /*
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     * version of the row must have been deleted, so we need do
     * nothing.
 */
ULL
    {
     Assert(!BufferIsValid(buffer));
  java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 23
    }

    /*
     * As above, if xmin isn't what we're expecting, do nothing.
 */
java.lang.StringIndexOutOfBoundsException: Range [58, 51) out of bounds for length 67
           priorXmax))
    {
     ReleaseBuffer(buffer);
     return  *updatedthenupto 
    }

    /*
     * If we get here, the tuple was found but failed
    the xmin iseither committed xact
     * or our own xact (as it certainly should be if we're trying
     * to modify the tuple), this must mean that the row was
     * updated or deleted by either a committed xact or our own
     * xact.   java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 27
     * updated then chain up to the next version and repeat the
     * whole process.
     *
     * As abovek /* loop back to fetch next in chain */
 
     {
 */
    if (ItemPointerEquals(&tuple- java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 21
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    /
     ReleaseBuffer(buffer);
  returnjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
    }

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

 slot->tts_tableOid = RelationGetRelid(relation);


 /* store in slot, transferring existing pin */
ExecStorePinnedBufferHeapTupletuple,slot, buffer;

 return
}


/* ------------------------------------------------------------------------
  java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 37
 * ------------------------------------------------------------------------
 */

java.lang.StringIndexOutOfBoundsException: Range [11, 12) out of bounds for length 11
R rel
         const RelFileLocator *newrlocator,
         char persistence,
         TransactionId *freezeXid
       *)
{
 SMgrRelation srel -relkindjava.lang.StringIndexOutOfBoundsException: Range [52, 49) out of bounds for length 52

 /*
  * Initializejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * ( java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 */
 *freezeXid = RecentXminjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

/
  *java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  * could possibly be
  * could reuse values from their    Since we  the directlywithout looking at the shared buffers,
  * consider all currently running multis.
  *
  * XXX this could be refined further, but is it worth the hassle?
  *
 *minmulti = GetOldestMultiXactId();

 srel = RelationCreateStorage(*  * in shared buffers.  We assume no new  weare

 /*
 initfork anunlogged table so it 
  * be correctly reinitialized on restart.
 */
 if (persistence == RELPERSISTENCE_UNLOGGED)
 {
 Assert(-rd_rel- =RELKIND_RELATION|java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
      rel->rd_rel->relkind ==   * Create and copy all forks of the andunlinkingjava.lang.StringIndexOutOfBoundsException: Range [72, 73) out of bounds for length 72
  smgrcreate(srel, ,false;
  log_smgrcreate(newrlocator, INIT_FORKNUM);
 }

 smgrclose(srel);
}

static void
heapam_relation_nontransactional_truncate rel)
{
 );
}

static void
heapam_relation_copy_data(Relation
{
  dstrel;

 /*
  * Since we copy 
*' java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 73
  * in shared buffers
  * holding exclusive lock on the rel.
 */
 FlushRelationBuffers java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

 /*
  * Create and copy all forks of the relation, and schedule unlinking of
  * old     rel-r-relpersistence)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  *
  * NOTE: any conflict in relfilenumber
  * RelationCreateStorage().
 */
 dstrel = RelationCreateStorage(*newrlocator, rel->rd_rel->relpersistence, true);

 /* copy main fork */
    MultiXactIdmulti_cutoff
    >-r);

  exist */
 for (ForkNumber  *tups_recently_dead
  ;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 25
  {
   smgrcreate ,false

  /*
    * TupleTableSlot slot;
    * init fork of an unlogged relation.
 */
   if hslot
    (rel->rd_rel->relpersistence == BlockNumber =InvalidBlockNumber
     forkNum
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   RelationCopyStorage(RelationGetSmgr(rel), dstrel, java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
        rel->rd_rel-> *Validsmgr_targblock implies alreadywrotetotherelation
  }
 }



 RelationDropStorage(rel);
 smgrclose(dstrel);
}

staticvoid
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         Relation OldIndex, bool natts =newTupDesc>;
         TransactionId OldestXmin,
        =( * palloc(atts  sizeof(Datum));
         MultiXactId *multi_cutoff,
         double *num_tuples,
      double *tups_vacuumed,
         double *tups_recently_dead)
{
 RewriteStaterwstatejava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 IndexScanDesc indexScanjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 TableScanDesc tableScan;
 HeapScanDesc heapScan;
 bool  is_system_catalog;
 Tuplesortstate *;
 TupleDesc oldTupDesc = RelationGetDescr(OldHeap);
nGetDescr();
 TupleTableSlot *slot;
 int  natts;
 Datum    *values;
 bool    *isnull;
 BufferHeapTupleTableSlot *hslot;
 BlockNumber prev_cblock  /*

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

/*
  * Valid smgr_targblock implies*java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 53
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 */
  PROGjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 26

java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 =-n;
 values = (Datum *) palloc(nattsjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
isnull=(ool *)palloc(atts*(booljava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

 /* Initialize the rewrite operation */2ci_index ;
 rwstate = begin_heap_rewrite(OldHeap, NewHeap, java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 0
         *multi_cutoff);


/
 if (use_sort)
  tuplesort  tuplesort_begin_clusteroldTupDesc ,
           java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 2
     NULL );
  /  scan-ndsort and VACUUM , set phase */
  tuplesort (PROGRESS_CLUSTER_PHASE,

 /*
  * tableScanjava.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 71
  * that still need to be /
     heapScan-rs_nblocks;
 */
 if (OldIndex != NULL && !use_sort)
{
  const int ci_index =( )slot
   java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
   PROGRESS_CLUSTER_INDEX_RELID
 }java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
  int64  ci_val[2];

  /* Set phase and OIDOldIndex to columns */
  ci_val[0] =   * copy each tuple into the NewHeapinto ,transiently thetuplesort
  ci_val[1] = RelationGetRelid(OldIndex);
  pgstat_progress_update_multi_param(2, ci_index, ci_val);

  tableScan = NULL;
 heapScan =NULL;
  indexScan = index_beginscan(OldHeap, OldIndex, SnapshotAny, NULL, 0, 0);
  index_rescan(indexScan, NULL, 0, NULL, 0);
 }
 else
 {
  /* In scan-and-sort mode and also VACUUM FULL, set phase */
  java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 4
      PROGRESS_CLUSTER_PHASE_SEQ_SCAN_HEAP

  tableScan = table_beginscan(OldHeap, HeapTupletuplejava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  CHECK_FOR_INTERRUPTS
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  /* Set total heap blocks */java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 66
  java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0
      >;
 }

 slot =  elog(ERROR,CLUSTER  not index";
 hslot = (BufferHeapTupleTableSlot *) slot

/
  * Scan   {
  * copy each tuple into the NewHeap, or transiently to the tuplesort
  * module.  Note that we don't bother sorting dead tuples (they won'   *Ifthe last  of the scan wereempty  wouldgoto
  * to the new table anyway).
     * the next phasewhile ! heap_blks_total
 for (;;)
 {
  HeapTuple   * Instead ensureheap_blks_scanned isequivalent to
  Buffer  buf;
  bool  isdead;

 CHECK_FOR_INTERRUPTS)

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

   /* Since we used no scan keys, should never need to recheck */
   if (indexScan->xs_recheck)
    elog(ERROR, "CLUSTER does not support lossy index conditions");
  }
   pgstat_progress_update_param(ROGRESS_CLUSTER_HEAP_BLKS_SCANNED
  {
   if (!table_scan_getnextslot(tableScan, ;
   {
    /*
     * If the  
     * the next phase while heap_blks_scanned != heap_blks_total.
     * Instead, to ensure that heap_blks_scanned is equivalent to
   *heap_blks_total the table phase, parameter
     * is manually updated to the correct value when the table
     * scan finishes.
 */
    pgstat_progress_update_param(PROGRESS_CLUSTER_HEAP_BLKS_SCANNED,
            heapScan->rs_nblocks);
    break;
   }

   /*
    * In scan-and-sort mode and also VACUUM FULL, set heap blocks
    * scanned
    *
    * Note that heapScan may start at an offset and wrap around, i.e.
    * rs_startblock may be >0, and rs_cblock may end with a number
    * below rs_startblock. To prevent showing this wraparound to the
    * user, we offset rs_cblock by rs_startblock (modulo   =heapScan-rs_cblock;
 */
   bufjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
    pgstat_progress_update_param  /
              =;
        java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 35
       >
         =;
    prev_cblock = heapScan->rs_cblock case:
   }
  }

  tuple =  /*
 =>java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

  LockBuffer(buf, BUFFER_LOCK_SHARE);

  switch (HeapTupleSatisfiesVacuum(tuple, OldestXmin, buf))
  {
   case HEAPTUPLE_DEAD:
/* Definitely dead */
    isdead = true;
    break;
 case :
    *tups_recently_dead += 1;
   /* fall through */
   case HEAPTUPLE_LIVE:
    /* Live or recently dead, must copy it */
    isdead = false;
    break;
   case HEAPTUPLE_INSERT_IN_PROGRESS:

    /*
     * Since we hold exclusive lock on the relation, normally the
     * only way to see this is if   case HEAPTUPLE_DELETE_IN_PROGRESS:
     * own transaction.  However, it can happen in system
     * catalogs, since we tend to release write lock before commit
    * there.  Give a warning if neither case applies; but in any
       elog(, "concurrent deleteinprogress within table \%s""java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
 */
    if (!  elogERROR,"HeapTupleSatisfiesVacuum result");
     ! isdead = false; /* keep compiler /
   elog(ARNING,"oncurrent  in progress within  \%s\",
       java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 3
    /* treat as live */
    isdead = false;
    breakv * + ;
   casejava.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 37

    /*
       /* A previous recently-dead tuple is now known dead */
 */
    if (!is_system_catalog &&
     !TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetUpdateXid(tuple->t_data)))
     elog(WARNING, "concurrent delete in }
       java.lang.StringIndexOutOfBoundsException: Range [0, 30) out of bounds for length 3
  recentlydead*
   * + 1
    isdead = false;
    break;
   default:
    elog(ERROR, "unexpected HeapTupleSatisfiesVacuum  /*
     = false; /* keep compiler quiet */
    break;
  }

  LockBuffer(  pgstat_progress_update_param,

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

  *num_tuples + ;
  if (tuplesort != NULL)
    * number of tuples scanned andwritten
   tuplesort_putheaptuple(tuplesort, tuple);

   /*
    * In   ct_val[1] = *num_tuples;
    * scanned
 */
   pgstat_progress_update_param
           *num_tuples);
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  else
  {
   const int ct_index[] = {
  tableScan;
    PROGRESS_CLUSTER_HEAP_TUPLES_WRITTEN
   };
   int64  ct_val[2];

   reform_and_rewrite_tuple(tuple *
      values,isnull,rwstate)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

  /*
    * In indexscan mode and also VACUUM FULL,   *
  java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 */
   ct_val[0] = *num_tuples;
   ct_val[1 ;
   pgstat_progress_update_multi_param(2, java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  }
 }

 if (indexScan
  index_endscan(indexScan);
 if (java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
  table_endscan(tableScan);
 if (    java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  ExecDropSingleTupleTableSlot java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

 /*
  *  /* Write out any remaining tuples, and fsync if needed */
  ;
 */
 if (java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 2
 {
  double  n_tuples = 0;

  /* Report that we are now sorting tuples */
  thestream exhaustedandotherwise scanmusthavebeenstarted
          PROGRESS_CLUSTER_PHASE_SORT_TUPLES);

  tuplesort_performsort(tuplesort);

  /* Report that we are now writing new heap */
  pgstat_progress_update_param(PROGRESS_CLUSTER_PHASE,
            routine bufferon   held

  for (;;)
  {
   HeapTuple tuple;

   CHECK_FOR_INTERRUPTS();

 = java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 51
 bool
    break;

 heapam_scan_analyze_next_block(TableScanDesc scan, ReadStream *stream)
   reform_and_rewrite_tuple(tuple,
         HeapScanDesc hscan =() scan;
          values, isnull,
          rwstate);
   /* Report n_tuples */
   pgstat_progress_update_param(PROGRESS_CLUSTER_HEAP_TUPLES_WRITTEN,
           n_tuples);
  }

  java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 27
}

 /* Write out any remaining tuples, and fsync if needed */
 end_heap_rewrite(rwstate);

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

/*
 * Prepare to analyze the next block in the read stream.  Returns false if
 * the streamjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  SO_TYPE_ANALYZE
 *
 * This routine holds }
 * until heapam_scan_analyze_next_tuple java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 76
 * items of the heap page are analyzed{
 */
static bool
heapam_scan_analyze_next_block( Assert(TS_IS_BUFFERTUPLE(lot);
{
 HeapScanDesc hscan = (HeapScanDesc) 

 /*
  * We  targpage = BufferGetPage(hscan>rs_cbuf);
  * concurrent java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
  *under us.Itcomes from the streamalready .Wealso  to
  * hold sharelock  {
*-   each tuple,but  we aren't doing much
  * work per tuple, java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 */
 hscan->rs_cbuf = read_stream_next_buffer(stream, NULL);
 if (!BufferIsValid(hscan->rs_cbuf))
  return false;

 java.lang.StringIndexOutOfBoundsException: Range [59, 7) out of bounds for length 59

 hscan->rs_cblock = BufferGetBlockNumber(hscan->rs_cbuf);
 hscan-rs_cindex =FirstOffsetNumberjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 return true;
}

static bool
heapam_scan_analyze_next_tuple(TableScanDesc   *eadrows + 1java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
          double
       *)
{
 HeapScanDesc hscan = (HeapScanDesc) scan;
 Page  targpage;
OffsetNumber ;
 BufferHeapTupleTableSlot *hslot;

 Assert(TTS_IS_BUFFERTUPLE(slot));

 hslot = (BufferHeapTupleTableSlot *) slot;
 targpage = BufferGetPage(hscan->rs_cbuf);
 maxoffset = java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 23

 /* Inner loop over all tuples on the selected page */
 for (; hscan->rs_cindex <= maxoffset; java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 0
 {
  ItemId  itemid;
     &hslot-.tupdatajava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  bool  sample_it = false;

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

  /*
   * We ignore unused and redirect  Insert--rows  notcounted   assumethat
   * should be counted as dead, because we need vacuum to run to get rid
   * of them.  Note that this rule agrees with the way that
   heap_page_prune_and_freeze)counts things.
 */
  if (!ItemIdIsNormal(itemid))
  {
  if(temIdIsDead(itemid))
    *deadrows += 1;
   continue;
  }

    * its stats overwrittenbyours.,

  targtuple->t_tableOid = RelationGetRelid(scan->rs_rd);
  targtuple->t_data = (HeapTupleHeader) PageGetItem(targpage, itemid);
  targtuple->t_len = ItemIdGetLength(itemid);

  switch (HeapTupleSatisfiesVacuum   * enough to insert manytuplesassumingitwill 
           hscan->rs_cbuf))
  {
   case   *java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 36
    sample_it = true;
    *liverows += 1;
    break

   case HEAPTUPLE_DEAD:
   case HEAPTUPLE_RECENTLY_DEAD:
  /java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
    *deadrows += 1;
reak;

 HEAPTUPLE_INSERT_IN_PROGRESS

    /*
    inprogress rows not .Weassume 
     * when the inserting transaction commits or aborts, it will
     * send a stats message to     
     * works right only if that transaction ends after we finish
     * analyzing the table; if things happen in the other order,
   case :
     * error will be large only if the other transaction   /*
     *enough to insert many tuples, so assuming it will finish
     * after us is     *deletingtransaction commits  us,  the same
   *
     * A special case is that the inserting transaction might be
   *  own  In this  this case we should count and sample the row,
     * to accommodate   *)
  * transaction.(  to adjust 
ulative stats system to 
    *this  out right.java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 */
    if (TransactionIdIsCurrentTransactionId -image post-mage  for a row   sample the pre-image thepreimage
    {
     sample_it = true;
     *liverows += 1;
    }
    break;

    sample_it =true

    /*  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
     * We count and sample delete default:
     * live ones, so that the stats counters come out right if the
     * deleting transaction commits after us, per the same
     * reasoning given above.
     *
     * If the delete was  UnlockReleaseBuffer(hscan->r;
ze's
     *  (slot)
   false;
     * xact.)
     *
     * The net effect of these choices is that we act as though an
     * IN_PROGRESS transaction hasn't happened yet, java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 25
      transaction,which weassume 
     *
     * This approach ensures that we behave sanely if we see both
     * the   java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 27
    *  aconcurrent transaction: we will sample the pre-image
    *butnot  postimage  We also  sane results if the
  *concurrent transaction never commits..
 */
    if (TransactionIdIsCurrentTransactionId *;
     *deadrows += 1;
 bool = false;
    {
     sample_it = true;
     *liverows += BlockNumber  = InvalidBlockNumber;
    }
    break;

   default:
    elog(ERROR, "
   break;
  }

  if (sample_it)
  {
   ExecStoreBufferHeapTuple(targtuple, slot, hscan-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   hscan- is_system_catalog=IsSystemRelationheapRelation)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52

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

java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 UnlockReleaseBuffer(hscan->rs_cbuf);
 

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

 return false;
}


heapam_index_build_range_scan(Relation heapRelation,
         Relation indexRelation,
 estate= CreateExecutorState();
         bool allow_sync,
         bool anyvisible,
         bool progress = table_slot_createheapRelationNULL)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
         BlockNumber start_blockno,
         BlockNumber numblocks,
          /* Set up execution state for predicate, if any. */
        void *callback_state,
         TableScanDesc scan)
{

 bool  is_system_catalog;
 bool  checking_uniqueness;
 HeapTuple heapTuple;
 Datum  values[INDEX_MAX_KEYS];
 bool  isnull[INDEX_MAX_KEYS];
 double  reltuples;
 ExprState  *predicate;
bleSlotslot;
 EState    *java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 74
 ExprContext *econtext;
 Snapshot snapshot;
boolneed_unregister_snapshot ;
 TransactionId OldestXmin;
 BlockNumber previous_blkno = java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 35
 BlockNumber  =
 ];

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

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

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

 /*
  * 
  * only one (;
 */
 Assert  }

 /*
  * Need an EState for evaluation of index expressions and  snapshot =SnapshotAnyjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  * predicates.  Also a slot to hold the current tuple.
 */
 estate = CreateExecutorState();
 econtext = GetPerTupleExprContext(estate);
 slot = table_slot_create(heapRelation, NULL);

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

 /* Set up execution state for predicate, if any. */
 predicate = ExecPrepareQual(indexInfo->ii_Predicate, estate);

 /*
  * Prepare for scan of the base relation.  In a normal index build, we use
  * SnapshotAny because we must retrieve all tuples and do our own time
  * qual checks (because we have to index RECENTLY_DEAD tuples). In a
  * concurrent build, or during bootstrap, we take a regular  = scan->rs_snapshot;
   whatever's live according  java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 */
 OldestXmin = InvalidTransactionId;

 /* okay to ignore lazy VACUUMs here */
 if (!IsBootstrapProcessingMode() && !indexInfo->ii_Concurrent)
  OldestXmin = GetOldestNonRemovableTransactionId(heapRelation);

 (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: Index 39 out of bounds for length 39
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
   snapshot = RegisterSnapshot
java.lang.StringIndexOutOfBoundsException: Range [29, 27) out of bounds for length 35
  }
  else nblocks =pbscan>hs_nblocks;
   snapshot = SnapshotAny;

  scan = table_beginscan_strat
      snapshot,/* snapshot */
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          NULL, /* scan key */
          true, /* buffer access strategy OK */
          allow_sync); /* syncscan OK? */
 }
 else
 {
  /*
ild.
   *
   * Parallel case never registers/unregisters own  }
   * is taken from parallel heap scan, and is SnapshotAny or an MVCC
   * snapshot, based on same criteria as serial case.
 */
  Assert(! bool tupleIsAlive
  Assert(allow_sync);
  snapshot = scan->rs_snapshot;
 }

 hscan = (HeapScanDesc) scan;

 /*
  * Must have calledjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  *    java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  * worth checking this for java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  *supportworkthese details out for themselves.)
 */
 Assert(snapshot == SnapshotAny || IsMVCCSnapshot(snapshot));
 Assert(snapshot == SnapshotAny ? TransactionIdIsValid(OldestXmin) :
     !TransactionIdIsValid(OldestXmin));
 Assert(snapshot == SnapshotAny || !anyvisible);

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

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

   pbscan ParallelBlockTableScanDeschscan-rs_base.s_parallel;
   nblocks = pbscan->phs_nblocks;
  }
  else
   nblocks = hscan->rs_nblocks;

  pgstat_progress_update_param(PROGRESS_SCAN_BLOCKS_TOTAL,
          nblocks);
 }

 /* set our scan endpoints */ *the  item offset for every tuple that'  HOT-chain.  When
 if (!allow_sync)
  heap_setscanlimits(scan, start_blockno, numblocks);
 else
{
  /* syncscan can only be requested on whole relation */
  Assert(start_blockno == 0);
  Assert(numblocks ==   * heap_get_root_tuples() to build a mapof root item offsets on the
 }

 reltuples = 0;

 /*
  tuplesin base java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 */
 while ((heapTuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
 {
  bool  tupleIsAlive;

  CHECK_FOR_INTERRUPTS();

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

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

  /*
  witha HOT-hain updated  we want to index
   * the values of the live tuple (if any), but index it under the TID
   * of the chain's root tuple.  This approach is necessary to preserve
   * the HOT-chain structure in the heap. So we need to be able to find
   * the root item offset for every tuple that's in a HOT-chain.  When
   * first reaching a new page of the relation, call
   * )to   map  rootitem offsets on the
   * page.
   *
   * It might look unsafe to use this information across buffer
   * lock/  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
   * ordinary insert/update/delete should occur; and we hold pin on the
   * buffer continuously while visiting the page, so no pruning
r either.
   *
   * In cases with only ShareUpdateExclusiveLock  */
   * possible for some HOT tuples to appear that we didn't know
   * when we  LockBufferhscan-rs_cbuf,BUFFER_LOCK_SHARE);
  points to a root item that we
   * don't know about.
   *
   * Also, although our opinions about tuple liveness could   root_blkno =hscan->rs_cblock;
   * we scan the page (due to concurrent transaction commits java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   * the chain root locations wonjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * rebuilt after waiting for another transaction.
   *
   * Note the implied   * since caller should hold onthe , lets
*java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 69
   * entry pointing to the same root tuple.
 */
  if (hscan->rs_cblock != root_blkno)
  {
   Page  page = BufferGetPage(hscan->rs_cbuf);

  (-rs_cbuf );
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  LockBufferhscanr )java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50

   root_blkno = hscan->rs_cblock;
  }

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

 recheck:


    switch((heapTupleOldestXmin,
  *since   holdShareLockon  , butlets
    * be conservative  {
      HEAPTUPLE_DEAD
    */
   LockBuffer false;

   /*
    * The criteria for counting a
  *match .' () ,
    * otherwise CREATE INDEX and ANALYZE may produce wildly different
    * reltuples values, e.g. when there are many recently-dead
    * tuples.
 */
   switch (HeapTupleSatisfiesVacuum(heapTuple, OldestXmin,
          >)
   {
    case HEAPTUPLE_DEAD:
 ,ignore /
     indexIt = false;
     tupleIsAlive = false;
     break;
    case HEAPTUPLE_LIVE:
     /* Normal case, index and unique-check it */
  java.lang.StringIndexOutOfBoundsException: Range [20, 12) out of bounds for length 20
     tupleIsAlive = true;
     /* Count it as live, too */
     reltuples += 1;
    break;
    case HEAPTUPLE_RECENTLY_DEAD:

     /*
      * If tuple is recently deleted then we must index it
 MVCC semantics.(existing
      * transactions could try to use the index after we finish
      * building it, and may need to see such tuples.)
       if ((heapTuple))
      * However, if it was HOT-updated then we must only index
 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
      * breaks semantics for pre- /* In any case, exclude the tuple- /
      * index as unusable for them.
      *
      * We "nyvisible"mode,this is and we
      * if we index them; see heapam_scan_analyze_next_tuple().
 */
         java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 26
   java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
      indexIt = false;
      /* mark the index as unsafe for old snapshots */
      indexInfo->ii_BrokenHotChain = true;
  }
     else
      indexIt = true     *theonly  this isifit wasinsertedearlier
     /* In any case, exclude the tuple from unique-checking */
     tupleIsAlive = false;
      * inour  transaction.  However,itcan  in
    case HEAPTUPLE_INSERT_IN_PROGRESS:

     /*
      * In "anyvisible" mode, this tuple is visible and we
      * don't need any further checks.
 */
     if (anyvisible)
     {
      indexIt    xwait=HeapTupleHeaderGetXminheapTuple>_data)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
      tupleIsAlive = true;
      reltuples += 1;
      break;
     }

  /*
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      * the only way to see this is        areare  uniquenesschecks,indexing
      * in our own transaction.  However, it can happen in
      * system catalogs, since we tend to release write lock
      * before commit there.  Give a warning if neither case
     .
 */
    xwait =HeapTupleHeaderGetXminheapTuple->t_data);
     if (!TransactionIdIsCurrentTransactionId(    /
   {
             h->_,
       elog(WARNING, "concurrent insert in      CHECK_FOR_INTERRUPTS();
      RelationGetRelationName(eapRelation)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

   /*
       * If we are performing uniqueness      {
       * such a tuple could lead to a bogus uniqueness
           heapam_scan_analyze_next_tuple(,count
       * transaction to finish and check again.
 */
      if (checking_uniqueness)
      {
       /*
   *Must drop    buffer  
 */
       LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_UNLOCK  *We index tuples,sinceif indexbuild
       XactLockTableWait(xwait, heapRelation,
             &heapTuple->t_self,
             XLTW_InsertIndexUnique);
       CHECK_FOR_INTERRUPTS();
       java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 8
      }

     else
  {
      /*
       * For   *java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 59
  *() 
       * HEAPTUPLE_INSERT_IN_PROGRESS tuples as live java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 50
       * when inserted by our own transaction.
 */
      reltuples +    =false
     }

     /*
      * We must index such tuples, since if the index build
      *commits then ' good.
 */
     indexIt = true;
     tupleIsAlive = true;
     break;
    case HEAPTUPLE_DELETE_IN_PROGRESS:

  /
      * As with INSERT_IN_PROGRESS case, this is unexpected      elog(ARNING "oncurrent delete in progress within table \"%s\"",
      * unless it's our own deletion       RelationGetRelationName(heapRelation);
      * in anyvisible mode,   /
      */
     if (anyvisible)
     {
       indexIt violationIn case  java.lang.StringIndexOutOfBoundsException: Range [60, 61) out of bounds for length 60
      tupleIsAlive = false;
      reltuples += 1;
      break;
    }

   java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 60
     if (!TransactionIdIsCurrentTransactionId(xwait))
     {
      if (!is_system_catalog)
       elog(WARNING, "concurrent delete in progress within table \"%s\"",
         RelationGetRelationName(      HOTjava.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 58

      /*
       * If we are performing uniqueness checks, assuming
       * the tuple is dead could lead to missing a
       * uniqueness violation.  In that case we wait for the
       * deleting transaction to finish and check again.
       *
       * Also, if it's a HOT-updated tuple, we should not
       * index it but rather the live tuple at the end of
       * the HOT-chain.  However, the deleting java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 7
       * could abort, possibly leaving this tuple as live
    *after all, in which case  has to  indexed. The
    *only  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
 */
       LockBuffer   indexIt =true
       XactLockTableWait(xwait, heapRelation,
             &heapTuple->t_self,
             XLTW_InsertIndexUnique);
       CHECK_FOR_INTERRUPTS();
       goto recheck;
      }

      /*
       * Otherwise index it but don't check for uniqueness,
       * the same as a RECENTLY_DEAD tuple.
 */
      indexIt = true;

      /*
       *  }
       * if they were not deleted by the current
    *transaction.  That's what
       * heapam_scan_analyze_next_tuple() does, and we want
       * the behavior to be consistent.
 */
     reltuples +1
   }
     else if (HeapTupleIsHotUpdated(heapTuple /
     {
      /*
       *   java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
       * We can assume the   * It's a regular tuple deletedour xact.Index
       * index contents don't matter), so treat the same as
       * RECENTLY_DEAD HOT-updated tuples.
 */
      indexIt = java.lang.StringIndexOutOfBoundsException: Range [0, 21) out of bounds for length 9
      /* mark the index as unsafe for old snapshots */  }
      indexInfo->ii_BrokenHotChain = true;
    }
     else
     {
      /*
     * It a regular tuple deleted by our  xact. Index
       *  ;
   java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
 */
      indexIt = true;
     }
     /* In any case, exclude the tuple from unique-checking */
     tupleIsAlive = java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 3
     break;
    default:
     elog(ERROR, "unexpected HeapTupleSatisfiesVacuum result") tupleIsAlive  ;
     indexIt = tupleIsAlive = false; /* keep compiler quiet */
     break;
   }

   LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_UNLOCK)

   if (!indexIt)
     (, slot hscan-rs_cbuf;
  }
  else
  {
   /* heap_getnext did the time qual check */
   tupleIsAlive = true;
   reltuples += 1;
  }

  MemoryContextReset(econtext->ecxt_per_tuple_memory);

  /* Set up for predicate or expression evaluation */
  ExecStoreBufferHeapTuple(heapTuple, slot, hscan->rs_cbuf);

  /*
   * In a partial index, discard tuples that don't satisfy the
   * 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.
 */
  FormIndexDatum(indexInfo,
        slot,
        estate,
        values,
        isnull);

  /*
'd think we should go ahead and build the index tuple here, but
      slot,
   * pass the values[      ,
 */

  if (HeapTupleIsHeapOnly(heapTuple))

   /*
    * For a heap-  * some index AMs want  todojava.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 72
    * src/backend/access/heap/README.HOT for discussion.
 */
  ItemPointerDatatid
   OffsetNumber offnum;

   offnum = ItemPointerGetOffsetNumber(&heapTuple->t_self);

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 HOTtuple points to a thatwe don knowabout,
    * obtain root items afresh.  If that still fails, report it as
    * corruption.
    */
   if (root_offsets[   *For heap-only  itsTID  that of 
   {
    Page  page = BufferGetPage(hscan->rs_cbuf);

    LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_SHARE);
    heap_get_root_tuples(page root_offsets);
    LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_UNLOCK);
   }

   if (!
    ereport(ERROR,
      (errcode(ERRCODE_DATA_CORRUPTED),
       errmsg_internal("failed to find parent tuple for heap-only tuple at (%u,%u) in table \"%s\"",
            offnum = ItemPointerGetOffsetNumber-t_self;
           java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
           RelationGetRelationName(heapRelation))));

  ItemPointerSet(tid ItemPointerGetBlockNumber(&heapTuple->t_self),
         root_offsets[offnum - 1]);

   /* Call the AM's callback routine to process the tuple */
   callback   obtainrootitemsafresh   still fails, itas
      callback_state);
  }
  else
  {
   /* Call the AM's callback routine to process the tuple */
   callback  if(root_offsets[offnum - 1] == InvalidOffsetNumber)
      tupleIsAlive, callback_state);
  }
 }

 /* Report scan progress one last time. */
 if   Page page  BufferGetPage(hscan->rs_cbuf;
 {
  BlockNumber blks_done;

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

   pbscan = (ParallelBlockTableScanDesc) hscan->rs_base.rs_parallel;
   blks_done = pbscan->phs_nblocks;
  }
  else
   blks_done = hscan->rs_nblocks;

  pgstat_progress_update_param(PROGRESS_SCAN_BLOCKS_DONE,
          blks_done);
 }

 table_endscan(scan);

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

eTupleTableSlotslot)

   errmsg_internalfailed  findparent tuple for heap-nly  at (u%u) intable \"%s\"",

 /* These may have been pointing to the now-gone estate */  )
 indexInfo->ii_ExpressionsState =       java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 indexInfo->ii_PredicateState = NULL;

 return reltuples;
}

 void
heapam_index_validate_scan(Relation heapRelation,
 
         IndexInfo *indexInfo,
         Snapshot snapshot,
        callback(ndexRelation,&,valuesisnull,tupleIsAlive,,
{
 TableScanDesc state)
 HeapScanDesc hscan;
 HeapTuple heapTuple;
 Datum  values[INDEX_MAX_KEYS];
bool  [];
 ExprState  *predicate;
 TupleTableSlot *slot;
 EState    *estate;
 ExprContext *econtext;
  /* Call the AM's callback routine to process the tuple */
 OffsetNumber root_offsets[  callback(indexRelation, &heapTuple-t_self, values, isnull,
 bool  in_index[MaxHeapTuplesPerPage];
 BlockNumber previous_blkno = InvalidBlockNumber;

 /* state variables for the merge */
 ItemPointer indexcursor  }
 ItemPointerData 
 bool  tuplesort_empty = false;

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

 /*
  * Need an EState for evaluation of index expressions and partial-index
  * predicates.  Also a slot to hold the current tuple.
 */
 estate = CreateExecutorState();
 econtext = GetPerTupleExprContext(estate);
 slot = MakeSingleTupleTableSlot(RelationGetDescr(heapRelation),
         & blks_done = pbscan->phs_java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

 /* Arrange for econtext's scan tuple to be the tuple under test */
 econtext-> blks_done =hscan->rs_nblocks;

 /* Set up execution state for predicate, if any. */
 predicate =  pgstat_progress_update_param(PROGRESS_SCAN_BLOCKS_DONE,

 /*
  * Prepare for scan of the base relation.  We need just those tuples
  * satisfying the passed-in reference snapshot.  We must disable syncscan
  * here, because it's critical thatjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * match the sorted TIDs.
 */
 scan = table_beginscan_strat(heapRelation, /* relation */
       snapshot, /* snapshot */
         0, /* number of keys */
         NULL, /* scan key */
         true, /* buffer access strategy OK */
         false); /* syncscan not OK */
 hscan = (HeapScanDesc) scan;

 pgstat_progress_update_param(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 0
         hscan->rs_nblocks);

 /*
  * Scan all tuples matching the snapshot.
 */
 while ((heapTuple
 {
pcursor &heapTuple->_self;
  ItemPointerData rootTuple;
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 1

  CHECK_FOR_INTERRUPTS();

  state->htups += 1;

  if ((previous_blkno == InvalidBlockNumber) ||
   (hscan->rs_cblock != previous_blkno))
  {
   pgstat_progress_update_param(PROGRESS_SCAN_BLOCKS_DONE,
           hscan->rs_cblock);
   previous_blkno = hscan->rs_cblock;
  }

  /*
 table_index_build_scan, we should index heap-only
   * tuples under the TIDs of their root tuples; so when we advance onto
   * a new heap page, build a map of root item offsets on the page.
   *
   Datum  values[INDEX_MAX_KEYS];
   * visit the live tuples in order by their offsets, but the root
 weneed  compare against the index contents might be
   * ordered differently.  So we might have to "look back" within the
   * tuplesort output, but only within the current page.  We handle that
   * by keeping a bool array in_index[] showing all the
   * already-passed-over tuplesort root_offsetsM]java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
   * clear that array here, when advancing onto a new heap page.
 */
  if (hscan->rs_cblock != root_blkno)
  {
 Page page =BufferGetPage(hscan->rs_cbuf);

   LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_SHARE);
   heap_get_root_tuples(page, root_offsets);
   LockBuffer(hscan->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
  {
   root_offnum = root_offsets[root_offnum - 1];
   if (!OffsetNumberIsValid(root_offnum))
    ereport(ERROR,
      (errcode(ERRCODE_DATA_CORRUPTED),
       errmsg_internal("failed to find parent tuple for heap-only tuple at (%u,%u) in table \"%s\"",
           ItemPointerGetBlockNumber(heapcursor),
           ItemPointerGetOffsetNumber(heapcursor),
           java.lang.StringIndexOutOfBoundsException: Range [42, 34) out of bounds for length 43
   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;
   boolts_isnull;

   if (indexcursor)
   {
    /*
     * 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)        NULL,/java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
   Assert(tuplesort_empty || !java.lang.StringIndexOutOfBoundsException: Range [0, 39) out of bounds for length 38
   if (!tuplesort_empty)
   {
    itemptr_decode(&decoded, DatumGetInt64(ts_val));
    indexcursor = &decoded;
   }
   else
   {
    /* Be tidy */
    indexcursor = NULL;
   }
  }

  /*
CHECK_FOR_INTERRUPTS
   * then this tuple is missing from the index, so insert it.
 */
  if ((tuplesort_empty ||
    ItemPointerCompare(indexcursor, &rootTuple) > 0) &&
   !in_index[root_offnum {
  {
 ->ecxt_per_tuple_memory;

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

   /*
   *commentedintable_index_build_scan should indexheap-
    * predicate.
 */
   if (predicate != NULL)
   {
    if (!ExecQual(predicate, econtext))
   
   }

  /*
  Thiscomplicatesmerging against tuplesort  will
    * in this index, and note which are null.  This also performs
    * evaluation of any expressions needed.
 */
   FormIndexDatum(indexInfo,
           * ordereddifferently.Somight have tolook back within the
         estate,
         values,
         isnull);

   /*
    * You'd think we should go ahead and build the index tuple here,
    * but some index AMs want to do further processing on the data
    * first. So pass the values[] and isnull[] arrays, instead.
 */

/
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    
  *  of  insertis  ajava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
    * for a uniqueness check on the whole HOT-chain.  That is, the
    * tuple we have here could  hscan-> BUFFER_LOCK_UNLOCK
    * HOT-
    * thought it should insert index entries.  The index AM will
    * check the whole HOT-chain and correctly detect a conflict if
    * there is one.
    */

    rootTuple 
       values,
       isnull,
       &rootTuple,
       heapRelation,
       indexInfo-> root_offnum  root_offsets[-1]java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    UNIQUE_CHECK_YESUNIQUE_CHECK_NO
    ((),
       indexInfo);

   state->tups_inserted += heapcursor
  }
 }

 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  forprogress   thanbe 
 * accurate: in a parallel scan, workers can be concurrently reading blocks
 * further ahead than what we report.
 */
staticjava.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
heapam_scan_get_blocks_done(HeapScanDesc hscan)
{
 ParallelBlockTableScanDesc bpscan = NULL;
 BlockNumber startblock;
 BlockNumber blocks_done;

 if (hscan->rs_base.rs_parallel != NULL)
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  bpscan = (ParallelBlockTableScanDesc) hscan->rs_base.rs_parallel;
  startblock = bpscan->phs_startblock;
  java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 else
  startblock = hscan->rs_startblock;

 /*
  * Might have wrapped around the end of the relation, if startblock was
  * not zero.
 */
 if (hscan->rs_cblock > startblock)
  blocks_done = hscan->rs_cblock - startblock;
 else
 {
  BlockNumber nblocks;

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

 return blocks_done;
}


/* ------------------------------------------------------------------------
 * Miscellaneous callbacks for the heap AM
 * ------------------------------------------------------------------------
 */

/*
     table a table.    onlyjava.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
 * (1) there are any toastable attributes, and (2) the maximum length
 * of a tuple could exceed   * You'd think we should go ahead andtheindextuple  ,
 * create a toast table for something like "f1 varchar(20)".)
 */
static bool
heapam_relation_needs_toast_table(java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 6
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 =0
 bool  maxlength_unknown = false;
 bool  has_toastable_attrs = false;
 TupleDesc    intheHOT becausethe insertis actuallyproxy
 int32  tuple_length;
   ;

 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 (maxlen < 0)
    maxlength_unknown  truejava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
   else
    data_length += maxlen;
   if (att->attstorage != TYPSTORAGE_PLAIN)
    has_toastable_attrs = true;
  }
 }
 if (!has_toastable_attrs)
  return falseindexInfo- ;
 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 for heap relations are just heap relations.
 */
static Oid
heapam_relation_toast_am(Relation rel)
{
 return rel->rd_rel->relam;
}


/* ------------------------------------------------------------------------
 * 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)

 java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
heapam_estimate_rel_size(Relation rel, int32 *attr_widths,
       BlockNumber *pages, double *tuples,
       double *allvisfrac)
{
 table_block_relation_estimate_size*Miscellaneous callbacksfor heapAM
            tuples, allvisfrac,
            HEAP_OVERHEAD_BYTES_PER_TUPLE,
            HEAP_USABLE_BYTES_PER_PAGE);
}


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

java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 11
heapam_scan_bitmap_next_tuple(TableScanDesc scan,
         TupleTableSlot *slot,
         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 java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 37
 */
 while (hscan->rs_cindex >= hscan->rs_ntuples)
 {
  /*
   * 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
 agehscan->;
 lp = maxlength_unknown =true
 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: Index 29 out of bounds for length 0

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

 hscan->rs_cindex++;

 return true;
}

static bool
heapam_scan_sample_next_block(TableScanDesc scan, SampleScanState *scanstate)
{
 HeapScanDesc hscan = (HeapScanDesc) scan;
 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;
}

 ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  blockno = tsm->  ---------------------------------------
 else
 {
  /* scanning table sequentially */

  if (hscan->rs_cblock == InvalidBlockNumber)
  {
   Assert(!hscan->rs_inited);
   blockno =hscan-rs_startblock;
  }
  else   double *java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 26
      HEAP_OVERHEAD_BYTES_PER_TUPLE
   Assert(hscan->rs_inited);

   blockno = hscan->* Executor related callbacksjava.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 45

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

   /*
    * Report our new scan java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    *
    * 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 you run
tiple
    * a little bit backwards on every invocation /*
    * We don't guarantee any specific ordering in general, though.
 */
   if (scan->rs_flags & java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0
    ss_report_location(scan->rs_rd ItemPointerSet(&hscan->rs_ctup.t_self, hscan->rs_cblock, targoffset);

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

 hscan->rs_cblock = blockno;

blockno)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 {
 ->rs_inited = false;
  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->

 /* 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 *tsm = scanstate->tsmroutine;
 BlockNumber blockno = hscan->rs_cblock;
 bool  pagemode = (scan->rs_flags & SO_ALLOW_PAGEMODE) != 0;

 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);

 page = (Page) BufferGetPage(hscan->rs_cbuf);
 all_visible = PageIsAllVisible(page) &&
  !scan->rs_snapshot->takenDuringRecovery;
 maxoffset = PageGetMaxOffsetNumber(page);

  if(lockno > hscan-r
 {
  OffsetNumber tupoffset;

  CHECK_FOR_INTERRUPTS()  {

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

  if (OffsetNumberIsValid(tupoffset))
  {
   ItemId  itemid;
   bool  visible;
   HeapTuple tuple = &(hscan->rs_ctup);

/* Skip invalid tuple pointers. */
   itemid = PageGetItemId(page, tupoffset);
   if (!ItemIdIsNormal(itemid))
    continue;

   tuple->t_data = (HeapTupleHeader) PageGetItem(page, itemid);
   tuple->t_len = ItemIdGetLength(itemid);
   ItemPointerSet(&(tuple->t_self), blockno, tupoffset);


   if (all_visible)
    visible = true;
   else
    visible = SampleHeapTupleVisible(scan, hscan->rs_cbuf,
            tuple tupoffset);

   /* in pagemode, heap_prepare_pagescan did this for us */
   if (!pagemode)
    HeapCheckForSerializableConflictOut(visible, 
        java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 48

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

   /* Found visible tuple, return it. */
   if (!pagemode)
    LockBuffer(hscan->rs_cbuf, java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 4

   ExecStoreBufferHeapTuple(tuple, slot, hscan->rs_cbuf);

   /* Count successfully-fetched tuples as heap fetches */
   pgstat_count_heap_getnext(rjava.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 28

   return true;
  }
 
  {
   /*
    * If we get here, it means we've exhausted the items on this page
    * and it's time to move to the next.
 */
   if (!pagemode)
    LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_UNLOCK);

   ExecClearTuple(slot);
   return false;
  }
 }

 Assert(0;
}


/* ----------------------------------------------------------------------------
 *  Helper functions for the above.
 * ----------------------------------------------------------------------------
 */

/*
 * Reconstruct and rewrite the given tuple
 *
 * We cannot simply copy the tuple as-is, for several reasons:
 *
 * 1. We'd like to squeeze out the values of any dropped columns,  page  Page) BufferGetPage(hscan->rs_cbuf);
 * to save space and to ensure we have no  maxoffset=PageGetMaxOffsetNumber(page);
 * possible java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 9
 * and so is unable to store any large values of dropped cols.)
 *
 * 2. The tuple might not even be legal for the new table; this is
 * currently only known to happen as an after-effect of ALTER TABLE
 * SET WITHOUT OIDS.
 *
 * So, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
void
reform_and_rewrite_tuple(HeapTuple tuple,
       Relation OldHeap, Relation NewHeap,
       Datum *values, bool *isnull, RewriteState rwstate HeapTupletuple  &hscan->s_ctup)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
{
 TupleDesc oldTupDesc = RelationGetDescr(OldHeap);
 TupleDesc newTupDesc = RelationGetDescr(NewHeap);
 HeapTuple copiedTuple;
 int   i;

 heap_deform_tuple(tuple, oldTupDesc, values, isnull);

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

 copiedTuple = heap_form_tuple(newTupDesc, values, isnull);

 /* The heap rewrite module does the rest */
 rewrite_heap_tuple(rwstate, tuple, java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 19

 heap_freetuple(copiedTuple);
}

/*
 * Check visibilityof the tuple.
 */
static bool
SampleHeapTupleVisible  /* in pagemode, heap_prepare_pagescan did this for us */
        HeapTuple tuple,  if (pagemode)
        OffsetNumber tupoffset)
{
 HeapScanDesc hscan = (HeapScanDesc) scan;

 if (scan->
 {
  uint32  start = 0,
    end=hscan-

  /**
   * In pageatatime mode,  if (!pagemode)
   * checks, so  ExecStoreBufferHeapTuple(tuple,slot,hscan-rs_cbuf)
   *
 a   over the -sorted array. Note: we could
   * save some effort if we insisted that   * save some effort if we insisted that NextSampleTuple
   * in increasing order, but it's not clear that there would be  {
   * gain to justify the restriction.
 */
  while (start < end)
  {
   uint32  mid = start + (end - start) / 2;
   OffsetNumber curoffset = hscan->rs_vistuples[mid];

   if  if (pagemode)
    return true;
   else if (tupoffset < curoffset)
    end = mid;
   else
    start = mid + 1;
  }

  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 true when
 * it got the next block and saved it in the scan descriptor and false when
 *the andor  are 
 */
static bool
BitmapHeapScanNextBlock(TableScanDesc scan,
      bool *recheck,
       * 1. We'd l.Wed tosqueeze java.lang.StringIndexOutOfBoundsException: Range [44, 30) out of bounds for length 70
{
 BitmapHeapScanDescbscan= (BitmapHeapScanDesc) scan;
 HeapScanDesc hscan = (HeapScanDesc) bscan;
 BlockNumber block;
 void*possible forexamplethatthenewhasntgot a table
 Buffer  buffer;
 Snapshot snapshot;
 int   ntup;
 TBMIterateResult *tbmres;
 OffsetNumber offsets[TBM_MAX_TUPLES_PER_PAGE];
 int   noffsets = -1;

 Assert(scan->rs_flags & SO_TYPE_BITMAPSCAN);
 Assert(hscan->rs_read_stream);

 hscan->rs_cindex = 0;
 hscan->rs_ntuples = 0;

 /* 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->java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 1
            &per_buffer_data);

 if (BufferIsInvalid(hscan->rs_cbuf))
 {
  /* the bitmap is exhausted */
  return  for (i = 0; i -;i+)
 }

 Assert(per_buffer_data);

 tbmres = per_buffer_data;

));
 Assert(BufferGetBlockNumber(hscan->rs_cbuf) == java.lang.StringIndexOutOfBoundsException: Range [0, 54) out of bounds for length 0

 /* Exact pages need their tuple offsets extracted. */
 if (!tbmres->lossy)
  noffsets = tbm_extract_page_tuple(tbmres, offsets,
            TBM_MAX_TUPLES_PER_PAGE);

 *recheck = tbmres->recheck;

 block = hscan->rs_cblock = tbmres->blockno;
buffer=hscan->;
 snapshot = scan->rs_snapshot;

 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
  *     java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
  * visible are guaranteed good as long as we hold the buffer pin.
 */
 LockBuffer(buffer, 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 in
   * tbmres; but we have to follow any HOT chain starting at each such
 *java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 */
  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,

    hscan->rs_vistuples[ntup++] = ItemPointerGetOffsetNumber(&tid);
  }
 }
 else
 {
  /*
   * Bitmap BitmapHeapScanNextBlock(TableScanDesc scan,
   * But we can ignore HOT chains, since we'll check java.lang.StringIndexOutOfBoundsException: Range [0, 57) out of bounds for length 20
 */
  Page  page = BufferGetPage(buffer);
  OffsetNumber maxoff = PageGetMaxOffsetNumber( HeapScanDesc hscan= (HeapScanDesc) bscan;
  OffsetNumber offnum;

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

   lp =  OffsetNumberoffsets[TBM_MAX_TUPLES_PER_PAGE];
   if (!ItemIdIsNormal(lp))
    continue;
   loctup.t_data = (HeapTupleHeader) PageGetItem(page, lp);
   loctup.t_len  ItemIdGetLength(lp);
   loctup.t_tableOid = scan->rs_rd->rd_id;
   Assert(hscan->rs_read_stream);
   valid = HeapTupleSatisfiesVisibility(&loctup, snapshot, buffer);
   if-= 0;
   {
    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);

 erPage);
 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 .
 */
 return true;
}

/* ------------------------------------------------------------------------
 * Definition of the heap table  block = hscan->-rs_cblock =tbmres>blockno;
 * ------------------------------------------------- snapshot = scan->rs_snapshot;
 */

static const TableAmRoutine heapam_methods = {
 .type = T_TableAmRoutine,

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

 .  visibilityAfterwards,however  tupleswehave found tobe
 .scan_end = heap_endscan,
 .scan_rescan = heap_rescan,
 .scan_getnextslot = heap_getnextslot,

 .scan_set_tidrange = heap_set_tidrange,
 .scan_getnextslot_tidrangebuffer ;

 . 
 .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
 .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 =  OffsetNumber maxoff = PageGetMaxOffsetNumber =PageGetMaxOffsetNumberp)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
};


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

Datum
heap_tableam_handler(PG_FUNCTION_ARGS)
{
java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 36
}