SQLite

    }
    3 {
      CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
      CREATE INDEX i1 ON t1(b);
      CREATE INDEX i2 ON t1(c, b);
      CREATE INDEX i3 ON t1(c, b, c);
    }






  } {
    reset_db
    execsql $schema
    execsql {
      INSERT INTO t1 VALUES(2, 'hello', 'world');
      INSERT INTO t1 VALUES(4, 'hello', 'planet');
      INSERT INTO t1 VALUES(6, 'hello', 'xyz');

  foreach {tn schema} {
    1 {
      CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c, d);
    }
    2 {
      CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c, d);
      CREATE INDEX i1 ON t1(d);









      CREATE INDEX i2 ON t1(d, c);
      CREATE INDEX i3 ON t1(d, c, b);
      CREATE INDEX i4 ON t1(b);
      CREATE INDEX i5 ON t1(c);
      CREATE INDEX i6 ON t1(c, b);
    }
  } {

** Return 1 if database is read-only or 0 if read/write.  Return -1 if
** no such database exists.
*/
int sqlite3_db_readonly(sqlite3 *db, const char *zDbName){
  Btree *pBt = sqlite3DbNameToBtree(db, zDbName);
  return pBt ? sqlite3BtreeIsReadonly(pBt) : -1;
}

int sqlite3_transaction_save(sqlite3 *db, void **ppState, int *pnState){
  Pager *pPager = sqlite3BtreePager(db->aDb[0].pBt);
  return sqlite3PagerSaveState(pPager, ppState, pnState);
}

int sqlite3_transaction_restore(sqlite3 *db, const void *pState, int nState){
  Pager *pPager = sqlite3BtreePager(db->aDb[0].pBt);
  return sqlite3PagerRestoreState(pPager, pState, nState);
}

    if( rc==SQLITE_OK ){
      rc = sqlite3WalClose(pPager->pWal, pPager->ckptSyncFlags,
                           pPager->pageSize, (u8*)pPager->pTmpSpace);
      pPager->pWal = 0;
      pagerFixMaplimit(pPager);
    }
  }
  return rc;
}

int sqlite3PagerSaveState(Pager *pPager, void **ppState, int *pnState){
  int rc = SQLITE_OK;
  *ppState = 0;
  *pnState = 0;
  if( pPager->pWal==0 || pPager->eState<PAGER_WRITER_LOCKED ){
    rc = SQLITE_ERROR;
  }else{
    /* Flush all dirty pages to the wal. */
    PgHdr *pList = sqlite3PcacheDirtyList(pPager->pPCache);
    rc = sqlite3WalFrames(pPager->pWal, 
        pPager->pageSize, pList, 0, 0, pPager->walSyncFlags
    );
    if( rc==SQLITE_OK ){
      rc = sqlite3WalSaveState(pPager->pWal, ppState, pnState);
    }
  }
  return rc;
}

int sqlite3PagerRestoreState(Pager *pPager, const void *pState, int nState){
  int rc = SQLITE_OK;
  if( pPager->pWal==0 
   || pPager->eState<PAGER_WRITER_LOCKED 
   || sqlite3PcacheDirtyList(pPager->pPCache)
  ){
    rc = SQLITE_ERROR;
  }else{
    sqlite3PcacheTruncate(pPager->pPCache, 1);
    rc = sqlite3WalRestoreState(pPager->pWal, pState, nState);
    pPager->eState = PAGER_WRITER_CACHEMOD;
  }

  return rc;
}

#endif /* !SQLITE_OMIT_WAL */

#ifdef SQLITE_ENABLE_ZIPVFS
/*

  void disable_simulated_io_errors(void);
  void enable_simulated_io_errors(void);
#else
# define disable_simulated_io_errors()
# define enable_simulated_io_errors()
#endif

int sqlite3PagerSaveState(Pager *pPager, void **ppState, int *pnState);
int sqlite3PagerRestoreState(Pager *pPager, const void *pState, int nState);

int sqlite3PagerSetOtaMode(Pager *pPager, int bOta);

#endif /* _PAGER_H_ */

  { /* zName:     */ "writable_schema",
    /* ePragTyp:  */ PragTyp_FLAG,
    /* ePragFlag: */ 0,
    /* iArg:      */ SQLITE_WriteSchema|SQLITE_RecoveryMode },
#endif
};
/* Number of pragmas: 59 on by default, 72 total. */
/* Number of pragmas: 58 on by default, 71 total. */
/* End of the automatically generated pragma table.
***************************************************************************/

/*
** Interpret the given string as a safety level.  Return 0 for OFF,
** 1 for ON or NORMAL and 2 for FULL.  Return 1 for an empty or 
** unrecognized string argument.  The FULL option is disallowed

  const char **pzTail       /* OUT: End of parsed string */
){
  int rc;
  rc = sqlite3LockAndPrepare(db,zSql,nBytes,1,0,ppStmt,pzTail);
  assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );  /* VERIFY: F13021 */
  return rc;
}


#ifndef SQLITE_OMIT_UTF16
/*
** Compile the UTF-16 encoded SQL statement zSql into a statement handle.
*/
static int sqlite3Prepare16(
  sqlite3 *db,              /* Database handle. */ 

  int bDelete,                    /* Zero for insert, non-zero for delete */
  const char *zIndex,             /* Index to write to */
  sqlite3_stmt**,                 /* OUT: New statement handle */
  const char ***pazColl,          /* OUT: Collation sequences for each column */
  int **paiCol, int *pnCol        /* OUT: See above */
);

/*
** This function is used to save the state of an ongoing WAL mode write 
** transaction on the "main" database of the supplied database handle.
**
** If successful, SQLITE_OK is returned and output variable (*ppState)
** is set to point to a buffer containing the transaction state data. 
** (*pnState) is set to the size of that buffer in bytes. Otherwise, if
** an error occurs, an SQLite error code is returned and both output
** variables are zeroed.
**
** A transaction state may be saved if: 
**
**   * the transaction does not contain any schema modifications.
**   * there are no open sub-transactions.
*/
int sqlite3_transaction_save(sqlite3 *db, void **ppState, int *pnState);

int sqlite3_transaction_restore(sqlite3 *db, const void *pState, int nState);

/*
** Undo the hack that converts floating point types to integer for
** builds on processors without floating point support.
*/
#ifdef SQLITE_OMIT_FLOATING_POINT
# undef double
#endif

  return TCL_OK;
 sql_error:
  Tcl_AppendResult(interp, "sql error: ", sqlite3_errmsg(db), 0);
  return TCL_ERROR;
}


/*
** tclcmd: sqlite3_transaction_save DB
*/
static int testTransactionSave(
  void * clientData,
  Tcl_Interp *interp,
  int objc,
  Tcl_Obj *CONST objv[]
){
  void *pState;
  int nState;
  sqlite3 *db;
  int rc;

  if( objc!=2 ){
    Tcl_WrongNumArgs(interp, 1, objv, "DB");
    return TCL_ERROR;
  }
  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;

  rc = sqlite3_transaction_save(db, &pState, &nState);
  if( rc==SQLITE_OK ){
    Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(pState, nState));
  }else{
    Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
    return TCL_ERROR;
  }

  sqlite3_free(pState);
  return TCL_OK;
}

/*
** tclcmd: sqlite3_transaction_restore DB BLOB
*/
static int testTransactionRestore(
  void * clientData,
  Tcl_Interp *interp,
  int objc,
  Tcl_Obj *CONST objv[]
){
  void *pState;
  int nState;
  sqlite3 *db;
  int rc;

  if( objc!=3 ){
    Tcl_WrongNumArgs(interp, 1, objv, "DB BLOB");
    return TCL_ERROR;
  }
  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
  pState = (void*)Tcl_GetByteArrayFromObj(objv[2], &nState);

  rc = sqlite3_transaction_restore(db, pState, nState);
  if( rc==SQLITE_OK ){
    Tcl_ResetResult(interp);
  }else{
    Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
    return TCL_ERROR;
  }

  return TCL_OK;
}

#ifdef SQLITE_USER_AUTHENTICATION
#include "sqlite3userauth.h"
/*
** tclcmd:  sqlite3_user_authenticate DB USERNAME PASSWORD
*/
static int test_user_authenticate(
  ClientData clientData, /* Unused */

     { "sqlite3_test_control", test_test_control },
#if SQLITE_OS_UNIX
     { "getrusage", test_getrusage },
#endif
     { "load_static_extension", tclLoadStaticExtensionCmd },
     { "sorter_test_fakeheap", sorter_test_fakeheap },
     { "sorter_test_sort4_helper", sorter_test_sort4_helper },
     { "sqlite3_transaction_save",    testTransactionSave },
     { "sqlite3_transaction_restore", testTransactionRestore },
#ifdef SQLITE_USER_AUTHENTICATION
     { "sqlite3_user_authenticate", test_user_authenticate, 0 },
     { "sqlite3_user_add",          test_user_add,          0 },
     { "sqlite3_user_change",       test_user_change,       0 },
     { "sqlite3_user_delete",       test_user_delete,       0 },
#endif
  };

#endif /* SQLITE_ENABLE_EXPENSIVE_ASSERT */
  }


  return rc;
}

static int walFileReadHdr(Wal *pWal, int *pbValid){
  u8 aBuf[WAL_HDRSIZE];           /* Buffer to load WAL header into */
  int rc;                         /* Return code */
  u32 magic;                      /* Magic value read from WAL header */
  int szPage;                     /* Page size according to the log */
  u32 version;                    /* Magic value read from WAL header */

  *pbValid = 0;

  /* Read in the WAL header. */
  rc = sqlite3OsRead(pWal->pWalFd, aBuf, WAL_HDRSIZE, 0);
  if( rc!=SQLITE_OK ){
    return rc;
  }

  /* If the database page size is not a power of two, or is greater than
  ** SQLITE_MAX_PAGE_SIZE, conclude that the WAL file contains no valid 
  ** data. Similarly, if the 'magic' value is invalid, ignore the whole
  ** WAL file.
  */
  magic = sqlite3Get4byte(&aBuf[0]);
  szPage = sqlite3Get4byte(&aBuf[8]);
  if( (magic&0xFFFFFFFE)!=WAL_MAGIC 
      || szPage&(szPage-1) 
      || szPage>SQLITE_MAX_PAGE_SIZE 
      || szPage<512 
  ){
    return SQLITE_OK;
  }

  pWal->hdr.bigEndCksum = (u8)(magic&0x00000001);
  pWal->szPage = szPage;
  pWal->nCkpt = sqlite3Get4byte(&aBuf[12]);
  memcpy(&pWal->hdr.aSalt, &aBuf[16], 8);

  /* Verify that the WAL header checksum is correct */
  walChecksumBytes(pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN, 
      aBuf, WAL_HDRSIZE-2*4, 0, pWal->hdr.aFrameCksum
  );
  if( pWal->hdr.aFrameCksum[0]!=sqlite3Get4byte(&aBuf[24])
      || pWal->hdr.aFrameCksum[1]!=sqlite3Get4byte(&aBuf[28])
  ){
    return SQLITE_OK;
  }

  /* Verify that the version number on the WAL format is one that
  ** are able to understand */
  version = sqlite3Get4byte(&aBuf[4]);
  if( version!=WAL_MAX_VERSION ){
    return SQLITE_CANTOPEN_BKPT;
  }

  *pbValid = 1;
  return SQLITE_OK;
}


/*
** Recover the wal-index by reading the write-ahead log file. 
**
** This routine first tries to establish an exclusive lock on the
** wal-index to prevent other threads/processes from doing anything
** with the WAL or wal-index while recovery is running.  The

  rc = sqlite3OsFileSize(pWal->pWalFd, &nSize);
  if( rc!=SQLITE_OK ){
    goto recovery_error;
  }

  if( nSize>WAL_HDRSIZE ){

    u8 *aFrame = 0;               /* Malloc'd buffer to load entire frame */
    int szFrame;                  /* Number of bytes in buffer aFrame[] */
    u8 *aData;                    /* Pointer to data part of aFrame buffer */
    int iFrame;                   /* Index of last frame read */
    i64 iOffset;                  /* Next offset to read from log file */
    int szPage;                   /* Page size according to the log */


    int isValid;                  /* True if this frame is valid */

    rc = walFileReadHdr(pWal, &isValid);

    if( rc!=SQLITE_OK ) goto recovery_error;















    if( isValid==0 ) goto finished;


    szPage = pWal->szPage;





















    /* Malloc a buffer to read frames into. */
    szFrame = szPage + WAL_FRAME_HDRSIZE;
    aFrame = (u8 *)sqlite3_malloc(szFrame);
    if( !aFrame ){
      rc = SQLITE_NOMEM;
      goto recovery_error;

  if( rx ){
    sqlite3_log(rx, "cannot limit WAL size: %s", pWal->zWalName);
  }
}

/*
** Close a connection to a log file.



*/
int sqlite3WalClose(
  Wal *pWal,                      /* Wal to close */
  int sync_flags,                 /* Flags to pass to OsSync() (or 0) */
  int nBuf,
  u8 *zBuf                        /* Buffer of at least nBuf bytes */
){

** heap-memory for the wal-index. Otherwise, if the argument is NULL or the
** WAL module is using shared-memory, return false. 
*/
int sqlite3WalHeapMemory(Wal *pWal){
  return (pWal && pWal->exclusiveMode==WAL_HEAPMEMORY_MODE );
}

/*
** Save current transaction state.
**
** The transaction state consists of a series of 32-bit big-endian integers:
**
**     * initial number of frames in WAL file.
**     * initial checksum values (2 integers).
**     * current number of frames.
**     * current checksum values (2 integers).
*/
int sqlite3WalSaveState(Wal *pWal, void **ppState, int *pnState){
  int rc = SQLITE_OK;

  *ppState = 0;
  *pnState = 0;
  if( pWal->writeLock==0 ){
    /* Must be in a write transaction to call this function. */
    rc = SQLITE_ERROR;
  }else{
    WalIndexHdr *pOrig = (WalIndexHdr*)walIndexHdr(pWal);
    int nBuf = 6 * 4;             /* Bytes of space to allocate */
    u8 *aBuf;

    aBuf = sqlite3_malloc(nBuf);
    if( aBuf==0 ){
      rc = SQLITE_NOMEM;
    }else{
      sqlite3Put4byte(&aBuf[0], pOrig->mxFrame);
      sqlite3Put4byte(&aBuf[4], pOrig->aFrameCksum[0]);
      sqlite3Put4byte(&aBuf[8], pOrig->aFrameCksum[1]);
      sqlite3Put4byte(&aBuf[12], pWal->hdr.mxFrame);
      sqlite3Put4byte(&aBuf[16], pWal->hdr.aFrameCksum[0]);
      sqlite3Put4byte(&aBuf[20], pWal->hdr.aFrameCksum[1]);
      *ppState = (void*)aBuf;
      *pnState = nBuf;
    }
  }

  return rc;
}

static int walUndoNoop(void *pUndoCtx, Pgno pgno){
  UNUSED_PARAMETER(pUndoCtx);
  UNUSED_PARAMETER(pgno);
  return SQLITE_OK;
}

/*
** If possible, restore the state of the curent transaction to that 
** described by the second and third arguments.
*/
int sqlite3WalRestoreState(Wal *pWal, const void *pState, int nState){
  int rc = SQLITE_OK;

  if( pWal->writeLock==0 ){
    /* Must have opened a write transaction to call this */
    rc = SQLITE_ERROR;
  }else{
    u8 *aBuf = (u8*)pState;
    int szFrame;                    /* Size of each frame in WAL file */
    u8 *aFrame = 0;                 /* Buffer to read data into */
    u8 *aData;                      /* Data part of aFrame[] buffer */
    u32 mxFrame;                    /* Maximum frame following restoration */
    int i;                          /* Iterator variable */

    WalIndexHdr *pOrig = (WalIndexHdr*)walIndexHdr(pWal);

    /* Check that no dirty pages have been written to the WAL file since
    ** the current transaction was opened.  */
    if( pOrig->mxFrame!=pWal->hdr.mxFrame 
     || pOrig->aFrameCksum[0]!=pWal->hdr.aFrameCksum[0] 
     || pOrig->aFrameCksum[1]!=pWal->hdr.aFrameCksum[1] 
    ){
      rc = SQLITE_ERROR;
    }

    /* Check that the WAL file is in the same state that it was when the
    ** transaction was saved. If not, return SQLITE_MISMATCH - cannot 
    ** resume this transaction  */
    if( rc==SQLITE_OK && (
          pWal->hdr.mxFrame!=sqlite3Get4byte(&aBuf[0])
       || pWal->hdr.aFrameCksum[0]!=sqlite3Get4byte(&aBuf[4])
       || pWal->hdr.aFrameCksum[1]!=sqlite3Get4byte(&aBuf[8])
    )){
      rc = SQLITE_MISMATCH;
    }

    if( rc==SQLITE_OK && pWal->readLock==0 ){
      int cnt = 0;
      walUnlockShared(pWal, WAL_READ_LOCK(0));
      pWal->readLock = -1;
      do{
        int notUsed;
        rc = walTryBeginRead(pWal, &notUsed, 1, ++cnt);
      }while( rc==WAL_RETRY );
      
      if( rc==SQLITE_OK ){
        int bValid;
        rc = walFileReadHdr(pWal, &bValid);
        if( rc==SQLITE_OK && bValid==0 ) rc = SQLITE_MISMATCH;
        pWal->hdr.szPage = (u16)((pWal->szPage&0xff00) | (pWal->szPage>>16));
      }
    }

    /* Malloc a buffer to read frames into. */
    if( rc==SQLITE_OK ){
      szFrame = pWal->szPage + WAL_FRAME_HDRSIZE;
      aFrame = (u8*)sqlite3_malloc(szFrame);
      if( !aFrame ){
        rc = SQLITE_NOMEM;
      }else{
        aData = &aFrame[WAL_FRAME_HDRSIZE];
      }
    }

    mxFrame = sqlite3Get4byte(&aBuf[12]);
    for(i=pWal->hdr.mxFrame+1; rc==SQLITE_OK && i<=mxFrame; i++){
      sqlite3_int64 iOff = walFrameOffset(i, pWal->szPage);
      rc = sqlite3OsRead(pWal->pWalFd, aFrame, szFrame, iOff);
      if( rc==SQLITE_OK ){
        u32 iPg;
        u32 dummy;
        if( 0==walDecodeFrame(pWal, &iPg, &dummy, aData, aFrame) ){
          rc = SQLITE_MISMATCH;
        }else{
          rc = walIndexAppend(pWal, i, iPg);
          if( iPg>pWal->hdr.nPage ) pWal->hdr.nPage = iPg;
        }
        pWal->hdr.mxFrame = i;
      }
    }
    sqlite3_free(aFrame);

    if( rc==SQLITE_OK ){
      assert( pWal->hdr.mxFrame==mxFrame );
      if( pWal->hdr.aFrameCksum[0]!=sqlite3Get4byte(&aBuf[16])
       || pWal->hdr.aFrameCksum[1]!=sqlite3Get4byte(&aBuf[20])
      ){
        rc = SQLITE_MISMATCH;
      }
    }


    if( rc!=SQLITE_OK ){
      sqlite3WalUndo(pWal, walUndoNoop, 0);
    }
  }

  return rc;
}

#ifdef SQLITE_ENABLE_ZIPVFS
/*
** If the argument is not NULL, it points to a Wal object that holds a
** read-lock. This function returns the database page-size if it is known,
** or zero if it is not (or if pWal is NULL).
*/
int sqlite3WalFramesize(Wal *pWal){
  assert( pWal==0 || pWal->readLock>=0 );
  return (pWal ? pWal->szPage : 0);
}
#endif

#endif /* #ifndef SQLITE_OMIT_WAL */

/* Return true if the argument is non-NULL and the WAL module is using
** heap-memory for the wal-index. Otherwise, if the argument is NULL or the
** WAL module is using shared-memory, return false. 
*/
int sqlite3WalHeapMemory(Wal *pWal);

int sqlite3WalSaveState(Wal *pWal, void **ppState, int *pnState);
int sqlite3WalRestoreState(Wal *pWal, const void *pState, int nState);

#ifdef SQLITE_ENABLE_ZIPVFS
/* If the WAL file is not empty, return the number of bytes of content
** stored in each frame (i.e. the db page-size when the WAL was created).
*/
int sqlite3WalFramesize(Wal *pWal);
#endif