SQLite

  memset(p, 0, offsetof(BtCursor, BTCURSOR_FIRST_UNINIT));
}

void sqlite3BtreeScanDeref(CursorScan *pScan){
  if( pScan ){
    pScan->nRef--;
    if( pScan->nRef==0 ){
      sqlite3_free(pScan->aMax);
      sqlite3_free(pScan->aMin);
      sqlite3_free(pScan->aLimit);
      sqlite3_free(pScan);
    }
  }
}

/*
** Close a cursor.  The read lock on the database file is released

  }else if( rc==SQLITE_EMPTY ){
    assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 );
    *pRes = 1;
    rc = SQLITE_OK;
  }
  return rc;
}

#include "vdbeInt.h"

const char *sqlite3_begin_concurrent_report(sqlite3 *db){
  sqlite3DbFree(db, db->zBCReport);
  db->zBCReport = 0;
  if( db->pCScanList ){
    CursorScan *p;
    StrAccum accum;

      );
    }
    db->zBCReport = sqlite3StrAccumFinish(&accum);
  }
  return db->zBCReport;
}

static u32 btreeScanSerialType(Mem *pMem){
  if( pMem->flags & MEM_Int ) return 6;
  if( pMem->flags & MEM_Real ) return 7;
  if( pMem->flags & MEM_Str ) return (pMem->n * 2)+12;
  if( pMem->flags & MEM_Blob ) return (pMem->n * 2)+13;
  return 0;
}

static void btreeScanSet(
  CursorScan *pNew, 
  UnpackedRecord *pKey, 
  i64 iKey,
  i64 *piKey,
  u8 **paKey
){
  if( pKey==0 ){
    assert( *paKey==0 );
    *piKey = iKey;
  }else{
    /* Figure out how much space is required */
    int ii;
    u8 *aRec = 0;
    int nByte = 0;
    int nHdr = 0;
    int nSize = 0;

    sqlite3_free(*paKey);
    *paKey = 0;

    for(ii=0; ii<pKey->nField; ii++){
      Mem *pMem = &pKey->aMem[ii];
      u32 serial_type = btreeScanSerialType(pMem);
      nByte += sqlite3VdbeSerialTypeLen(serial_type);
      nHdr += sqlite3VarintLen(serial_type);
    }

    nSize = sqlite3VarintLen(nHdr);
    if( sqlite3VarintLen(nSize+nHdr)>nSize ) nSize++;

    aRec = (u8*)sqlite3_malloc(nSize+nHdr+nByte);
    if( aRec==0 ){
      pNew->flags |= CURSORSCAN_OOM;
    }else{
      int iOff = 0;
      iOff += sqlite3PutVarint(&aRec[iOff], nSize);
      for(ii=0; ii<pKey->nField; ii++){
        u32 serial_type = btreeScanSerialType(&pKey->aMem[ii]);
        iOff += sqlite3PutVarint(&aRec[iOff], serial_type);
      }
      for(ii=0; ii<pKey->nField; ii++){
        Mem *pMem = &pKey->aMem[ii];
        u32 serial_type = btreeScanSerialType(pMem);
        iOff += sqlite3VdbeSerialPut(&aRec[iOff], pMem, serial_type);
      }
      assert( iOff==(nSize+nHdr+nByte) );
      *paKey = aRec;
      *piKey = iOff;
    }

  }
}

static void btreeScanSetKey(BtCursor *pCsr, i64 *piKey, u8 **paKey){
  if( pCsr->curIntKey ){
    *piKey = sqlite3BtreeIntegerKey(pCsr);
  }else{
    int rc;
    u32 nKey = sqlite3BtreePayloadSize(pCsr);
    u8 *aKey = sqlite3_malloc(nKey);
    if( aKey==0 ){
      rc = SQLITE_NOMEM;
    }else{
      rc = sqlite3BtreePayload(pCsr, 0, nKey, aKey);
    }
    if( rc ){
      sqlite3_free(aKey);
      pCsr->pCScan->flags |= CURSORSCAN_OOM;
    }else{
      sqlite3_free(*paKey);
      *piKey = nKey;
      *paKey = aKey;
    }
  }
}

static void btreeScanNext(BtCursor *pCsr, int bPrev){
  CursorScan *pCScan = pCsr->pCScan;
  if( pCScan ){
    if( bPrev ){
      if( sqlite3BtreeEof(pCsr) ){
        pCScan->flags &= ~(CURSORSCAN_MINVALID|CURSORSCAN_MININCL);
      }else{
        pCScan->iMin = sqlite3BtreeIntegerKey(pCsr);
        btreeScanSetKey(pCsr, &pCScan->iMin, &pCScan->aMin);
      }
    }else{
      if( sqlite3BtreeEof(pCsr) ){
        pCScan->flags &= ~(CURSORSCAN_MAXVALID|CURSORSCAN_MAXINCL);
      }else{
        btreeScanSetKey(pCsr, &pCScan->iMax, &pCScan->aMax);
        pCScan->flags |= CURSORSCAN_MAXVALID|CURSORSCAN_MAXINCL;
      }
    }
  }
}

int sqlite3BtreeScanLimit(
  BtCursor *pCsr, 
  UnpackedRecord *pKey, 
  i64 iKey, 
  int opcode
){
  CursorScan *pScan = pCsr->pCScan;
  if( pScan ){
    btreeScanSet(pScan, pKey, iKey, &pScan->iLimit, &pScan->aLimit);
    pScan->flags |= CURSORSCAN_LIMITVALID;
    switch( opcode ){
      case OP_Lt:
        pScan->flags |= CURSORSCAN_LIMITINCL;
      case OP_Le:
        break;

int sqlite3BtreeScanStart(
  BtCursor *pCsr, 
  UnpackedRecord *pKey, 
  i64 iKey,
  int opcode
){
  Btree *pBtree = pCsr->pBtree;

  if( pBtree->db->bConcurrent 
   && sqlite3PagerIsWal(pBtree->pBt->pPager) 
  ){
    sqlite3 *db = pCsr->pBtree->db;
    CursorScan *pNew;
    pNew = (CursorScan*)sqlite3MallocZero(sizeof(CursorScan));
    if( pNew==0 ) return SQLITE_NOMEM;
    pNew->tnum = (int)pCsr->pgnoRoot;
    if( pKey==0 ) pNew->flags = CURSORSCAN_INTKEY;


    if( pCsr->pCScan ){
      sqlite3BtreeScanDeref(pCsr->pCScan);
    }
    pCsr->pCScan = pNew;
    pNew->pNext = db->pCScanList;
    db->pCScanList = pNew;

        btreeScanNext(pCsr, 1);
        break;

      case OP_SeekLE:
        pNew->flags |= CURSORSCAN_MAXINCL;
      case OP_SeekLT:
        pNew->flags |= CURSORSCAN_MAXVALID;
        pNew->iMax = iKey;
        btreeScanNext(pCsr, 1);
        break;

      case OP_SeekGE:
        pNew->flags |= CURSORSCAN_MININCL;
      case OP_SeekGT:
        pNew->flags |= CURSORSCAN_MINVALID;
        btreeScanSet(pNew, pKey, iKey, &pNew->iMin, &pNew->aMin);
        btreeScanNext(pCsr, 0);
        break;

      case OP_SeekRowid:
      case OP_DeferredSeek:
        pNew->iMin = pNew->iMax = iKey;
        pNew->flags |= (CURSORSCAN_MININCL|CURSORSCAN_MAXINCL);
        pNew->flags |= CURSORSCAN_MINVALID|CURSORSCAN_MAXVALID;
        break;
    }
  }
  return SQLITE_OK;
}

void sqlite3BtreeScanDerefList(CursorScan *pList){
  CursorScan *p;
  CursorScan *pNext;
  for(p=pList; p; p=pNext){
    pNext = p->pNext;
    sqlite3BtreeScanDeref(p);
  }
}


/* Move the cursor so that it points to an entry near the key 
** specified by pIdxKey or intKey.   Return a success code.
**
** For INTKEY tables, the intKey parameter is used.  pIdxKey 
** must be NULL.  For index tables, pIdxKey is used and intKey
** is ignored.

#define CURSORSCAN_REVERSE    0x0008
#define CURSORSCAN_MININCL    0x0010
#define CURSORSCAN_MAXINCL    0x0020

#define CURSORSCAN_LIMITVALID 0x0040
#define CURSORSCAN_LIMITINCL  0x0080
#define CURSORSCAN_LIMITMAX   0x0100

#define CURSORSCAN_OOM        0x0200

typedef struct CursorScan CursorScan;
struct CursorScan {
  int tnum;                     /* Root page of scanned b-tree */
  int flags;
  i64 iMin;
  i64 iMax;
  i64 iLimit;
  u8 *aMin;
  u8 *aMax;
  u8 *aLimit;
  int nRef;                     /* Number of pointers to this structure */
  CursorScan *pNext;            /* Next CursorScan object in list */
};


/*
** Each database connection is an instance of the following structure.

    r.aMem = &aMem[pOp->p3];
#ifdef SQLITE_DEBUG
    { int i; for(i=0; i<r.nField; i++) assert( memIsValid(&r.aMem[i]) ); }
#endif
    r.eqSeen = 0;
    rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, &r, 0, 0, &res);
    sqlite3BtreeScanStart(pC->uc.pCursor, &r, 0, pOp->opcode);
    if( rc!=SQLITE_OK ){
      goto abort_due_to_error;
    }
    if( eqOnly && r.eqSeen==0 ){
      assert( res!=0 );
      goto seek_not_found;
    }

# This case does not work. The result should be [101..200], but as there
# are no rows matching (k>=101) the system never sees the (k<=200) 
# constraint. Hence "..EOF".
do_concreport_test 1.13 {
  SELECT v FROM t1 WHERE k >= 101 AND k <= 200
} {} {
  2:[101..EOF)
}

do_concreport_test 1.14 {
  SELECT v FROM t1 WHERE +v=5
} {5} {
  2:(EOF..EOF)
}

#--------------------------------------------------------------------------
reset_db
do_execsql_test 2.0 {
  PRAGMA journal_mode = wal;
  CREATE TABLE t2(k PRIMARY KEY, v);
  INSERT INTO t2 VALUES('a',  1);
  INSERT INTO t2 VALUES('b',  2);
  INSERT INTO t2 VALUES('c',  3);
  INSERT INTO t2 VALUES('d',  4);
  INSERT INTO t2 VALUES('e',  5);
  INSERT INTO t2 VALUES('f',  6);
  INSERT INTO t2 VALUES('g',  7);
  INSERT INTO t2 VALUES('h',  8);
  INSERT INTO t2 VALUES('i',  9);
  INSERT INTO t2 VALUES('j', 10);
  INSERT INTO t2 VALUES('k', 11);
}

explain_i {
  SELECT * FROM t2 WHERE k = 'e'
}
breakpoint
do_concreport_test 2.1 {
  SELECT * FROM t2 WHERE k = 'e'
} {e 5} {
  2:
}

finish_test