SQLite

         && &pBuf[-4]>=pBufStart                               /* (6) */
        ){
          sqlite3_file *fd = sqlite3PagerFile(pBt->pPager);
          u8 aSave[4];
          u8 *aWrite = &pBuf[-4];
          assert( aWrite>=pBufStart );                         /* due to (6) */
          memcpy(aSave, aWrite, 4);
          rc = sqlite3PagerUsePage(pBt->pPager, nextPage);
          if( rc!=SQLITE_OK ) break;
          rc = sqlite3OsRead(fd, aWrite, a+4, (i64)pBt->pageSize*(nextPage-1));
          nextPage = get4byte(aWrite);
          memcpy(aWrite, aSave, 4);
        }else
#endif

        {

static void pagerUnlockIfUnused(Pager *pPager){
  if( sqlite3PcacheRefCount(pPager->pPCache)==0 ){
    assert( pPager->nMmapOut==0 ); /* because page1 is never memory mapped */
    pagerUnlockAndRollback(pPager);
  }
}

#ifndef SQLITE_OMIT_CONCURRENT
/*
** If this pager is currently in a concurrent transaction (pAllRead!=0),
** then set the bit in the pAllRead vector to indicate that the transaction
** read from page pgno. Return SQLITE_OK if successful, or an SQLite error
** code (i.e. SQLITE_NOMEM) if an error occurs.
*/
int sqlite3PagerUsePage(Pager *pPager, Pgno pgno){
  int rc = SQLITE_OK;
  if( pPager->pAllRead && pgno<=pPager->dbOrigSize ){
    PAGERTRACE(("USING page %d\n", pgno));
    rc = sqlite3BitvecSet(pPager->pAllRead, pgno);
  }
  return rc;
}
#endif

/*
** The page getter methods each try to acquire a reference to a
** page with page number pgno. If the requested reference is
** successfully obtained, it is copied to *ppPage and SQLITE_OK returned.
**
** There are different implementations of the getter method depending
** on the current state of the pager.

  sqlite3_pcache_page *pBase;

  assert( pPager->errCode==SQLITE_OK );
  assert( pPager->eState>=PAGER_READER );
  assert( assert_pager_state(pPager) );
  assert( pPager->hasHeldSharedLock==1 );


  /* If this is an CONCURRENT transaction and the page being read was
  ** present in the database file when the transaction was opened,
  ** mark it as read in the pAllRead vector.  */
  if( sqlite3PagerUsePage(pPager, pgno)!=SQLITE_OK ){
    pPg = 0;



    goto pager_acquire_err;
  }


  if( pgno==0 ) return SQLITE_CORRUPT_BKPT;
  pBase = sqlite3PcacheFetch(pPager->pPCache, pgno, 3);
  if( pBase==0 ){
    pPg = 0;
    rc = sqlite3PcacheFetchStress(pPager->pPCache, pgno, &pBase);
    if( rc!=SQLITE_OK ) goto pager_acquire_err;

/* Functions used to truncate the database file. */
void sqlite3PagerTruncateImage(Pager*,Pgno);

void sqlite3PagerRekey(DbPage*, Pgno, u16);

#ifndef SQLITE_OMIT_CONCURRENT
int sqlite3PagerUsePage(Pager*, Pgno);
void sqlite3PagerEndConcurrent(Pager*);
int sqlite3PagerBeginConcurrent(Pager*);
void sqlite3PagerDropExclusiveLock(Pager*);
int sqlite3PagerUpgradeSnapshot(Pager *pPager, DbPage*);
void sqlite3PagerSetDbsize(Pager *pPager, Pgno);
int sqlite3PagerIsWal(Pager*);
#else
# define sqlite3PagerEndConcurrent(x)
# define sqlite3PagerUsePage(x, y) SQLITE_OK
#endif

#if defined(SQLITE_DEBUG) || !defined(SQLITE_OMIT_CONCURRENT)
int sqlite3PagerIswriteable(DbPage*);
#endif

int sqlite3PagerWalInfo(Pager*, u32 *pnPrior, u32 *pnFrame);

#-------------------------------------------------------------------------
reset_db
sqlite3 db2 test.db

set big1 [string repeat ab 10000]
set big2 "[string repeat ab  9999]xy"



do_execsql_test 1.6.0 {
  CREATE TABLE x1(x, y);
  INSERT INTO x1 VALUES(1, $big1);
  PRAGMA journal_mode = wal;
} {wal}

do_execsql_test -db db2 1.6.1.1 {

  COMMIT;
} {1 {database is locked}}
do_test_conflict_msg 1.6.1.5 {
  conflict at page 21 (read/write page; part of db table x1; content=0000000061626162...)
}
catchsql ROLLBACK

#--------------------------------------------------------------------------
reset_db
sqlite3 db2 test.db

set big1 [string repeat ab 10000]
set big2 "[string repeat ab  9999]xy"

do_execsql_test 1.7.0 {
  CREATE TABLE ww(a);
  CREATE TABLE y1(x, y);
  INSERT INTO y1 VALUES(1, $big1);
  PRAGMA journal_mode = wal;
} {wal}

do_execsql_test -db db2 1.7.1 {
  BEGIN;
    UPDATE y1 SET y=$big2;
    SELECT * FROM ww;
}

do_execsql_test 1.7.2 {
  BEGIN CONCURRENT;
    INSERT INTO ww SELECT y FROM y1;
}

do_execsql_test -db db2 1.7.3 COMMIT

do_catchsql_test 1.7.4 {
  COMMIT;
} {1 {database is locked}}

db close
db2 close
sqlite3_shutdown
test_sqlite3_log 
sqlite3_initialize
finish_test