/******************************************************************************

** This file is an amalgamation of many separate C source files from SQLite

** single large file, the entire code can be compiled as a single translation

** unit.  This allows many compilers to do optimizations that would not be

** possible if the files were compiled separately.  Performance improvements

** [sqlite3_libversion_number()], [sqlite3_sourceid()],

** [sqlite_version()] and [sqlite_source_id()].

*/

/*

** CAPI3REF: Run-Time Library Version Numbers

#define SQLITE_CORRUPT_VTAB            (SQLITE_CORRUPT | (1<<8))

#define SQLITE_READONLY_RECOVERY       (SQLITE_READONLY | (1<<8))

#define SQLITE_READONLY_CANTLOCK       (SQLITE_READONLY | (2<<8))

/*

** CAPI3REF: Flags For File Open Operations

** into an integer that the pArg argument points to. This capability

** is used during testing and only needs to be supported when SQLITE_TEST

** is defined.

** The [SQLITE_FCNTL_SIZE_HINT] opcode is used by SQLite to give the VFS

** layer a hint of how large the database file will grow to be during the

** current transaction.  This hint is not guaranteed to be accurate but it

** file space based on this hint in order to help writes to the database

** file run faster.

**

** The [SQLITE_FCNTL_CHUNK_SIZE] opcode is used to request that the VFS

** extends and truncates the database file in chunks of a size specified

** by the user. The fourth argument to [sqlite3_file_control()] should 

** chunks (say 1MB at a time), may reduce file-system fragmentation and

** improve performance on some systems.

**

** The [SQLITE_FCNTL_FILE_POINTER] opcode is used to obtain a pointer

** to the [sqlite3_file] object associated with a particular database

** connection.  See the [sqlite3_file_control()] documentation for

** additional information.

**

** ^(The [SQLITE_FCNTL_SYNC_OMITTED] opcode is generated internally by

** SQLite and sent to all VFSes in place of a call to the xSync method

** when the database connection has [PRAGMA synchronous] set to OFF.)^

** opcode as doing so may disrupt the operation of the specialized VFSes

** that do require it.  

**

** ^The [SQLITE_FCNTL_WIN32_AV_RETRY] opcode is used to configure automatic

** retry counts and intervals for certain disk I/O operations for the

** windows [VFS] in order to provide robustness in the presence of

** into the array entry, allowing the current retry settings to be

** interrogated.  The zDbName parameter is ignored.

**

** ^The [SQLITE_FCNTL_PERSIST_WAL] opcode is used to set or query the

** persistent [WAL | Write AHead Log] setting.  By default, the auxiliary

** write ahead log and shared memory files used for transaction control

** WAL mode.  If the integer is -1, then it is overwritten with the current

** WAL persistence setting.

**

** ^The [SQLITE_FCNTL_POWERSAFE_OVERWRITE] opcode is used to set or query the

** persistent "powersafe-overwrite" or "PSOW" setting.  The PSOW setting

** determines the [SQLITE_IOCAP_POWERSAFE_OVERWRITE] bit of the

** mode.  If the integer is -1, then it is overwritten with the current

** zero-damage mode setting.

**

** ^The [SQLITE_FCNTL_OVERWRITE] opcode is invoked by SQLite after opening

** a write transaction to indicate that, unless it is rolled back for some

** reason, the entire database file will be overwritten by the current 

** transaction. This is used by VACUUM operations.

**

** ^The [SQLITE_FCNTL_VFSNAME] opcode can be used to obtain the names of

** all [VFSes] in the VFS stack.  The names are of all VFS shims and the

** final bottom-level VFS are written into memory obtained from 

** do anything.  Callers should initialize the char* variable to a NULL

** pointer in case this file-control is not implemented.  This file-control

** is intended for diagnostic use only.

*/

#define SQLITE_FCNTL_LOCKSTATE               1

#define SQLITE_GET_LOCKPROXYFILE             2

#define SQLITE_FCNTL_OVERWRITE              11

#define SQLITE_FCNTL_VFSNAME                12

#define SQLITE_FCNTL_POWERSAFE_OVERWRITE    13

/*

** CAPI3REF: Mutex Handle

**

** The sqlite3_uri_boolean(F,P,B) routine assumes that P is a boolean

** parameter and returns true (1) or false (0) according to the value

**

** The sqlite3_uri_int64(F,P,D) routine converts the value of P into a

** 64-bit signed integer and returns that integer, or D if P does not

SQLITE_API const char *sqlite3_db_filename(sqlite3 *db, const char *zDbName);

/*

** CAPI3REF: Find the next prepared statement

**

** ^This interface returns a pointer to the next [prepared statement] after

/*

** CAPI3REF: String Comparison

**

*/

SQLITE_API int sqlite3_strnicmp(const char *, const char *, int);

/*

/*

** The following value as a destructor means to use sqlite3DbFree().

*/

/*

** When SQLITE_OMIT_WSD is defined, it means that the target platform does

** pager.h.

*/

#define BTREE_OMIT_JOURNAL  1  /* Do not create or use a rollback journal */

SQLITE_PRIVATE int sqlite3BtreeClose(Btree*);

SQLITE_PRIVATE int sqlite3BtreeSetCacheSize(Btree*,int);

SQLITE_PRIVATE int sqlite3BtreeCommitPhaseOne(Btree*, const char *zMaster);

SQLITE_PRIVATE int sqlite3BtreeCommitPhaseTwo(Btree*, int);

SQLITE_PRIVATE int sqlite3BtreeCommit(Btree*);

SQLITE_PRIVATE int sqlite3BtreeBeginStmt(Btree*,int);

SQLITE_PRIVATE int sqlite3BtreeCreateTable(Btree*, int*, int flags);

SQLITE_PRIVATE int sqlite3BtreeIsInTrans(Btree*);

** NOTE: These values must match the corresponding BTREE_ values in btree.h.

*/

#define PAGER_OMIT_JOURNAL  0x0001    /* Do not use a rollback journal */

/*

** Valid values for the second argument to sqlite3PagerLockingMode().

SQLITE_PRIVATE int sqlite3PagerWalCallback(Pager *pPager);

SQLITE_PRIVATE int sqlite3PagerOpenWal(Pager *pPager, int *pisOpen);

SQLITE_PRIVATE int sqlite3PagerCloseWal(Pager *pPager);

/* Functions used to query pager state and configuration. */

SQLITE_PRIVATE u8 sqlite3PagerIsreadonly(Pager*);

  void *pData;                   /* Page data */

  void *pExtra;                  /* Extra content */

  PgHdr *pDirty;                 /* Transient list of dirty pages */

  Pager *pPager;                 /* The pager this page is part of */

#ifdef SQLITE_CHECK_PAGES

  u32 pageHash;                  /* Hash of page content */

#endif

/*

** Determine if we are dealing with Windows NT.

*/

# define SQLITE_OS_WINNT 1

#endif

/*

/*

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

*/

struct sqlite3 {

  sqlite3_vfs *pVfs;            /* OS Interface */

  Db *aDb;                      /* All backends */

  int flags;                    /* Miscellaneous flags. See below */

  unsigned int openFlags;       /* Flags passed to sqlite3_vfs.xOpen() */

  int errCode;                  /* Most recent error code (SQLITE_*) */

  int errMask;                  /* & result codes with this before returning */

  signed char nextAutovac;      /* Autovac setting after VACUUM if >=0 */

  u8 suppressErr;               /* Do not issue error messages if true */

  u8 vtabOnConflict;            /* Value to return for s3_vtab_on_conflict() */

  int nextPagesize;             /* Pagesize after VACUUM if >0 */

  u32 magic;                    /* Magic number for detect library misuse */

  int nChange;                  /* Value returned by sqlite3_changes() */

  int nTotalChange;             /* Value returned by sqlite3_total_changes() */

  int aLimit[SQLITE_N_LIMIT];   /* Limits */

  struct sqlite3InitInfo {      /* Information used during initialization */

    int newTnum;                /* Rootpage of table being initialized */

    u8 busy;                    /* TRUE if currently initializing */

    u8 orphanTrigger;           /* Last statement is orphaned TEMP trigger */

  } init;

  int activeVdbeCnt;            /* Number of VDBEs currently executing */

  int writeVdbeCnt;             /* Number of active VDBEs that are writing */

  int vdbeExecCnt;              /* Number of nested calls to VdbeExec() */

  void (*xTrace)(void*,const char*);        /* Trace function */

  void *pTraceArg;                          /* Argument to the trace function */

  void (*xProfile)(void*,const char*,u64);  /* Profiling function */

  int nProgressOps;             /* Number of opcodes for progress callback */

#endif

#ifndef SQLITE_OMIT_VIRTUALTABLE

  Hash aModule;                 /* populated by sqlite3_create_module() */

  VtabCtx *pVtabCtx;            /* Context for active vtab connect/create */

  VTable **aVTrans;             /* Virtual tables with open transactions */

  VTable *pDisconnect;    /* Disconnect these in next sqlite3_prepare() */

#endif

  FuncDefHash aFunc;            /* Hash table of connection functions */

  Hash aCollSeq;                /* All collating sequences */

  BusyHandler busyHandler;      /* Busy callback */

  Db aDbStatic[2];              /* Static space for the 2 default backends */

  Savepoint *pSavepoint;        /* List of active savepoints */

  int nSavepoint;               /* Number of non-transaction savepoints */

  int nStatement;               /* Number of nested statement-transactions  */

  i64 nDeferredCons;            /* Net deferred constraints this transaction. */

  int *pnBytesFreed;            /* If not NULL, increment this in DbFree() */

#define SQLITE_SqlTrace       0x00004000  /* Debug print SQL as it executes */

#define SQLITE_VdbeListing    0x00008000  /* Debug listings of VDBE programs */

#define SQLITE_WriteSchema    0x00010000  /* OK to update SQLITE_MASTER */

#define SQLITE_IgnoreChecks   0x00040000  /* Do not enforce check constraints */

#define SQLITE_ReadUncommitted 0x0080000  /* For shared-cache mode */

#define SQLITE_LegacyFileFmt  0x00100000  /* Create new databases in format 1 */

#define SQLITE_FUNC_CASE     0x02 /* Case-sensitive LIKE-type function */

#define SQLITE_FUNC_EPHEM    0x04 /* Ephemeral.  Delete with VDBE */

#define SQLITE_FUNC_NEEDCOLL 0x08 /* sqlite3GetFuncCollSeq() might be called */

#define SQLITE_FUNC_COUNT    0x20 /* Built-in count(*) aggregate */

#define SQLITE_FUNC_COALESCE 0x40 /* Built-in coalesce() or ifnull() function */

#define TF_HasPrimaryKey   0x04    /* Table has a primary key */

#define TF_Autoincrement   0x08    /* Integer primary key is autoincrement */

#define TF_Virtual         0x10    /* Is a virtual table */

/*

*/

struct Index {

  char *zName;     /* Name of this index */

  int *aiColumn;   /* Which columns are used by this index.  1st is 0 */

  tRowcnt *aiRowEst; /* Result of ANALYZE: Est. rows selected by each column */

  Table *pTable;   /* The SQL table being indexed */

  char *zColAff;   /* String defining the affinity of each column */

  Index *pNext;    /* The next index associated with the same table */

  Schema *pSchema; /* Schema containing this index */

  u8 *aSortOrder;  /* Array of size Index.nColumn. True==DESC, False==ASC */

  char **azColl;   /* Array of collation sequence names for index */

#ifdef SQLITE_ENABLE_STAT3

  int nSample;             /* Number of elements in aSample[] */

  tRowcnt avgEq;           /* Average nEq value for key values not in aSample */

                          ** than the source table */

  int sortingIdx;         /* Cursor number of the sorting index */

  int sortingIdxPTab;     /* Cursor number of pseudo-table */

  int nSortingColumn;     /* Number of columns in the sorting index */

  struct AggInfo_col {    /* For each column used in source tables */

    Table *pTab;             /* Source table */

    int iTable;              /* Cursor number of the source table */

    Expr *pExpr;             /* The original expression */

  } *aCol;

  int nColumn;            /* Number of used entries in aCol[] */

  int nAccumulator;       /* Number of columns that show through to the output.

                          ** Additional columns are used only as parameters to

                          ** aggregate functions */

    int iDistinct;           /* Ephemeral table used to enforce DISTINCT */

  } *aFunc;

  int nFunc;              /* Number of entries in aFunc[] */

};

/*

*/

struct ExprList {

  int nExpr;             /* Number of expressions on the list */

  int iECursor;          /* VDBE Cursor associated with this ExprList */

    Expr *pExpr;           /* The list of expressions */

    char *zName;           /* Token associated with this expression */

    char *zSpan;           /* Original text of the expression */

    u8 done;               /* A flag to indicate when processing is finished */

    u16 iOrderByCol;       /* For ORDER BY, column number in result set */

    u16 iAlias;            /* Index into Parse.aAlias[] for zName */

};

/*

    int idx;          /* Index in some Table.aCol[] of a column named zName */

  } *a;

  int nId;         /* Number of identifiers on the list */

};

/*

  u8 op;                 /* One of: TK_UNION TK_ALL TK_INTERSECT TK_EXCEPT */

  char affinity;         /* MakeRecord with this affinity for SRT_Set */

  u16 selFlags;          /* Various SF_* values */

  SrcList *pSrc;         /* The FROM clause */

  Expr *pWhere;          /* The WHERE clause */

  ExprList *pGroupBy;    /* The GROUP BY clause */

  Select *pRightmost;    /* Right-most select in a compound select statement */

  Expr *pLimit;          /* LIMIT expression. NULL means not used. */

  Expr *pOffset;         /* OFFSET expression. NULL means not used. */

};

/*

#define SF_Expanded        0x10  /* sqlite3SelectExpand() called on this */

#define SF_HasTypeInfo     0x20  /* FROM subqueries have Table metadata */

#define SF_UseSorter       0x40  /* Sort using a sorter */

/*

*/

struct TriggerPrg {

  Trigger *pTrigger;      /* Trigger this program was coded from */

  SubProgram *pProgram;   /* Program implementing pTrigger/orconf */

  u32 aColmask[2];        /* Masks of old.*, new.* columns accessed */

};

/*

*/

struct Parse {

  sqlite3 *db;         /* The main database structure */

  char *zErrMsg;       /* An error message */

  Vdbe *pVdbe;         /* An engine for executing database bytecode */

  u8 colNamesSet;      /* TRUE after OP_ColumnName has been issued to pVdbe */

  u8 checkSchema;      /* Causes schema cookie check after an error */

  u8 nested;           /* Number of nested calls to the parser/code generator */

  u8 nTempReg;         /* Number of temporary registers in aTempReg[] */

  u8 nTempInUse;       /* Number of aTempReg[] currently checked out */

  int aTempReg[8];     /* Holding area for temporary registers */

  int nRangeReg;       /* Size of the temporary register block */

  int iRangeReg;       /* First register in temporary register block */

  int ckBase;          /* Base register of data during check constraints */

  int iCacheLevel;     /* ColCache valid when aColCache[].iLevel<=iCacheLevel */

  int iCacheCnt;       /* Counter used to generate aColCache[].lru values */

  struct yColCache {

    int iTable;           /* Table cursor number */

    int iColumn;          /* Table column number */

  } aColCache[SQLITE_N_COLCACHE];  /* One for each column cache entry */

  yDbMask writeMask;   /* Start a write transaction on these databases */

  yDbMask cookieMask;  /* Bitmask of schema verified databases */

  int cookieGoto;      /* Address of OP_Goto to cookie verifier subroutine */

  int cookieValue[SQLITE_MAX_ATTACHED+2];  /* Values of cookies to verify */

#ifndef SQLITE_OMIT_SHARED_CACHE

  int nTableLock;        /* Number of locks in aTableLock */

  TableLock *aTableLock; /* Required table locks for shared-cache mode */

#endif

  AutoincInfo *pAinc;  /* Information about AUTOINCREMENT counters */

  /* Information used while coding trigger programs. */

  Parse *pToplevel;    /* Parse structure for main program (or NULL) */

  Table *pTriggerTab;  /* Table triggers are being coded for */

  u32 oldmask;         /* Mask of old.* columns referenced */

  u32 newmask;         /* Mask of new.* columns referenced */

  u8 eTriggerOp;       /* TK_UPDATE, TK_INSERT or TK_DELETE */

  u8 eOrconf;          /* Default ON CONFLICT policy for trigger steps */

  u8 disableTriggers;  /* True to disable triggers */

  /* Above is constant between recursions.  Below is reset before and after

  ** each recursion */

#ifndef SQLITE_OMIT_VIRTUALTABLE

#endif

#ifndef SQLITE_OMIT_EXPLAIN

#endif

};

#ifdef SQLITE_OMIT_VIRTUALTABLE

  #define IN_DECLARE_VTAB 0

#else

*/

typedef struct {

  sqlite3 *db;        /* The database being initialized */

  char **pzErrMsg;    /* Error message stored here */

  int rc;             /* Result code stored here */

} InitData;

/*

** Internal function prototypes

*/

SQLITE_PRIVATE int sqlite3Strlen30(const char*);

#define sqlite3StrNICmp sqlite3_strnicmp

SQLITE_PRIVATE void sqlite3EndTable(Parse*,Token*,Token*,Select*);

SQLITE_PRIVATE int sqlite3ParseUri(const char*,const char*,unsigned int*,

                    sqlite3_vfs**,char**,char **);

SQLITE_PRIVATE int sqlite3CodeOnce(Parse *);

SQLITE_PRIVATE Bitvec *sqlite3BitvecCreate(u32);

# define sqlite3AutoincrementEnd(X)

#endif

SQLITE_PRIVATE void sqlite3Insert(Parse*, SrcList*, ExprList*, Select*, IdList*, int);

SQLITE_PRIVATE IdList *sqlite3IdListAppend(sqlite3*, IdList*, Token*);

SQLITE_PRIVATE int sqlite3IdListIndex(IdList*,const char*);

SQLITE_PRIVATE SrcList *sqlite3SrcListEnlarge(sqlite3*, SrcList*, int, int);

SQLITE_PRIVATE void sqlite3PrngSaveState(void);

SQLITE_PRIVATE void sqlite3PrngRestoreState(void);

SQLITE_PRIVATE void sqlite3PrngResetState(void);

SQLITE_PRIVATE void sqlite3CodeVerifySchema(Parse*, int);

SQLITE_PRIVATE void sqlite3CodeVerifyNamedSchema(Parse*, const char *zDb);

SQLITE_PRIVATE void sqlite3BeginTransaction(Parse*, int);

#else

# define sqlite3FileSuffix3(X,Y)

#endif

SQLITE_PRIVATE const void *sqlite3ValueText(sqlite3_value*, u8);

SQLITE_PRIVATE int sqlite3ValueBytes(sqlite3_value*, u8);

#  define sqlite3VtabInSync(db) ((db)->nVTrans>0 && (db)->aVTrans==0)

#endif

SQLITE_PRIVATE void sqlite3VtabMakeWritable(Parse*,Table*);

SQLITE_PRIVATE void sqlite3VtabFinishParse(Parse*, Token*);

SQLITE_PRIVATE void sqlite3VtabArgInit(Parse*);

SQLITE_PRIVATE void sqlite3VtabArgExtend(Parse*, Token*);

typedef struct VdbeFrame VdbeFrame;

struct VdbeFrame {

  Vdbe *v;                /* VM this frame belongs to */

  Op *aOp;                /* Program instructions for parent frame */

  Mem *aMem;              /* Array of memory cells for parent frame */

  u8 *aOnceFlag;          /* Array of OP_Once flags for parent frame */

  VdbeCursor **apCsr;     /* Array of Vdbe cursors for parent frame */

  void *token;            /* Copy of SubProgram.token */

  int nChildMem;          /* Number of memory cells for child frame */

  int nChildCsr;          /* Number of cursors for child frame */

  int nChange;            /* Statement changes (Vdbe.nChanges)     */

};

#define VdbeFrameMem(p) ((Mem *)&((u8 *)p)[ROUND8(sizeof(VdbeFrame))])

  VdbeFunc *pVdbeFunc;  /* Auxilary data, if created. */

  Mem s;                /* The return value is stored here */

  Mem *pMem;            /* Memory cell used to store aggregate context */

  CollSeq *pColl;       /* Collating sequence */

};

/*

  int nOp;                /* Number of instructions in the program */

  int nOpAlloc;           /* Number of slots allocated for aOp[] */

  int nLabel;             /* Number of labels used */

  int *aLabel;            /* Space to hold the labels */

  u16 nResColumn;         /* Number of columns in one row of the result set */

  u16 nCursor;            /* Number of slots in apCsr[] */

** to obtain the memory it needs.

**

** This file contains implementations of the low-level memory allocation

*/

/*

#ifdef SQLITE_SYSTEM_MALLOC

/*

*/

#endif

/*

*/

#include <sys/sysctl.h>

#include <malloc/malloc.h>

#else /* if not __APPLE__ */

/*

*/

#define SQLITE_MALLOC(x)    malloc(x)

#define SQLITE_FREE(x)      free(x)

#define SQLITE_REALLOC(x,y) realloc((x),(y))

#ifdef HAVE_MALLOC_USABLE_SIZE

#else

#endif

#endif /* __APPLE__ or not __APPLE__ */

** Initialize this module.

*/

static int sqlite3MemInit(void *NotUsed){

  int cpuCount;

  size_t len;

  if( _sqliteZone_ ){

** Some systems have stricmp().  Others have strcasecmp().  Because

** there is no consistency, we will define our own.

**

*/

  register unsigned char *a, *b;

  a = (unsigned char *)zLeft;

  b = (unsigned char *)zRight;

  unixInodeInfo *pInode;              /* Info about locks on this inode */

  int h;                              /* The file descriptor */

  unsigned char eFileLock;            /* The type of lock held on this fd */

  int lastErrno;                      /* The unix errno from last I/O error */

  void *lockingContext;               /* Locking style specific state */

  UnixUnusedFd *pUnused;              /* Pre-allocated UnixUnusedFd */

#define UNIXFILE_DELETE      0x20     /* Delete on close */

#define UNIXFILE_URI         0x40     /* Filename might have query parameters */

#define UNIXFILE_NOLOCK      0x80     /* Do no file locking */

/*

** Include code that is common to all os_*.c files

  { "rmdir",        (sqlite3_syscall_ptr)rmdir,           0 },

#define osRmdir     ((int(*)(const char*))aSyscall[19].pCurrent)

}; /* End of the overrideable system calls */

/*

}

/*

*/

  int rc;

  return rc;

}

    /* Call fstat() to figure out the permissions on the database file. If

    ** a new *-shm file is created, an attempt will be made to create it

    */

    if( osFstat(pDbFd->h, &sStat) && pInode->bProcessLock==0 ){

      rc = SQLITE_IOERR_FSTAT;

      }

      pShmNode->h = robust_open(zShmFilename, openFlags, (sStat.st_mode&0777));

      if( pShmNode->h<0 ){

      }

      /* Check to see if another process is holding the dead-man switch.

** written to *pMode. If an IO error occurs, an SQLite error code is 

** returned and the value of *pMode is not modified.

**

** this function queries the file-system for the permissions on the 

** corresponding database file and sets *pMode to this value. Whenever 

** possible, WAL and journal files are created using the same permissions 

static int findCreateFileMode(

  const char *zPath,              /* Path of file (possibly) being created */

  int flags,                      /* Flags passed as 4th argument to xOpen() */

){

  int rc = SQLITE_OK;             /* Return Code */

  if( flags & (SQLITE_OPEN_WAL|SQLITE_OPEN_MAIN_JOURNAL) ){

    char zDb[MAX_PATHNAME+1];     /* Database file path */

    int nDb;                      /* Number of valid bytes in zDb */

    if( 0==osStat(zDb, &sStat) ){

      *pMode = sStat.st_mode & 0777;

    }else{

      rc = SQLITE_IOERR_FSTAT;

    }

  if( fd<0 ){

    mode_t openMode;              /* Permissions to create file with */

    if( rc!=SQLITE_OK ){

      assert( !p->pUnused );

      assert( eType==SQLITE_OPEN_WAL || eType==SQLITE_OPEN_MAIN_JOURNAL );

      rc = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zName);

      goto open_finished;

    }

  }

  assert( fd>=0 );

  if( pOutFlags ){

  memset(zBuf, 0, nBuf);

#if !defined(SQLITE_TEST)

  {

    fd = robust_open("/dev/urandom", O_RDONLY, 0);

    if( fd<0 ){

      time_t t;

      assert( sizeof(t)+sizeof(pid)<=(size_t)nBuf );

      nBuf = sizeof(t) + sizeof(pid);

    }else{

      robust_close(0, fd, __LINE__);

    }

  }

    }

  }

  if( fd<0 ){

    terrno = errno;

    if( fd<0 && errno==ENOENT && islockfile ){

      if( proxyCreateLockPath(path) == SQLITE_OK ){

      }

    }

  }

  if( fd<0 ){

    openFlags = O_RDONLY;

    terrno = errno;

  }

  if( fd<0 ){

    goto end_breaklock;

  }

  /* write it out to the temporary break file */

  if( fd<0 ){

    sqlite3_snprintf(sizeof(errmsg), errmsg, "create failed (%d)", errno);

    goto end_breaklock;

          robust_close(pFile, pFile->h, __LINE__);

        }

        pFile->h = -1;

        OSTRACE(("TRANSPROXY: OPEN  %d\n", fd));

        if( fd>=0 ){

          pFile->h = fd;

  /* Double-check that the aSyscall[] array has been constructed

  ** correctly.  See ticket [bb3a86e890c8e96ab] */

  /* Register all VFSes defined in the aVfs[] array */

  for(i=0; i<(sizeof(aVfs)/sizeof(sqlite3_vfs)); i++){

  unsigned int nMin;                  /* Minimum number of pages reserved */

  unsigned int nMax;                  /* Configured "cache_size" value */

  unsigned int n90pct;                /* nMax*9/10 */

  /* Hash table of all pages. The following variables may only be accessed

  ** when the accessor is holding the PGroup mutex.

  unsigned int nPage;                 /* Total number of pages in apHash */

  unsigned int nHash;                 /* Number of slots in apHash[] */

  PgHdr1 **apHash;                    /* Hash table for fast lookup by key */

};

/*

  void *pStart, *pEnd;           /* Bounds of pagecache malloc range */

  /* Above requires no mutex.  Use mutex below for variable that follow. */

  sqlite3_mutex *mutex;          /* Mutex for accessing the following: */

  PgFreeslot *pFree;             /* Free page blocks */

  /* The following value requires a mutex to change.  We skip the mutex on

  ** reading because (1) most platforms read a 32-bit integer atomically and

  ** (2) even if an incorrect value is read, no great harm is done since this

# define sqlite3WalCallback(z)                   0

# define sqlite3WalExclusiveMode(y,z)            0

# define sqlite3WalHeapMemory(z)                 0

#else

#define WAL_SAVEPOINT_NDATA 4

*/

SQLITE_PRIVATE int sqlite3WalHeapMemory(Wal *pWal);

#endif /* ifndef SQLITE_OMIT_WAL */

#endif /* _WAL_H_ */

  u8 exclusiveMode;           /* Boolean. True if locking_mode==EXCLUSIVE */

  u8 journalMode;             /* One of the PAGER_JOURNALMODE_* values */

  u8 useJournal;              /* Use a rollback journal on this file */

  u8 noSync;                  /* Do not sync the journal if true */

  u8 fullSync;                /* Do extra syncs of the journal for robustness */

  u8 ckptSyncFlags;           /* SYNC_NORMAL or SYNC_FULL for checkpoint */

    case PAGER_READER:

      assert( pPager->errCode==SQLITE_OK );

      assert( p->eLock!=UNKNOWN_LOCK );

      break;

    case PAGER_WRITER_LOCKED:

  ** contains no valid committed transactions.

  */

  assert( pPager->eState==PAGER_OPEN );

  nPage = sqlite3WalDbsize(pPager->pWal);

  /* If the database size was not available from the WAL sub-system,

static int pagerOpenWalIfPresent(Pager *pPager){

  int rc = SQLITE_OK;

  assert( pPager->eState==PAGER_OPEN );

  if( !pPager->tempFile ){

    int isWal;                    /* True if WAL file exists */

**

** The flags argument is used to specify properties that affect the

** operation of the pager. It should be passed some bitwise combination

**

** The vfsFlags parameter is a bitmask to pass to the flags parameter

** of the xOpen() method of the supplied VFS when opening files. 

  char *zPathname = 0;     /* Full path to database file */

  int nPathname = 0;       /* Number of bytes in zPathname */

  int useJournal = (flags & PAGER_OMIT_JOURNAL)==0; /* False to omit journal */

  int pcacheSize = sqlite3PcacheSize();       /* Bytes to allocate for PCache */

  u32 szPageDflt = SQLITE_DEFAULT_PAGE_SIZE;  /* Default page size */

  const char *zUri = 0;    /* URI args to copy */

  IOTRACE(("OPEN %p %s\n", pPager, pPager->zFilename))

  pPager->useJournal = (u8)useJournal;

  /* pPager->stmtOpen = 0; */

  /* pPager->stmtInUse = 0; */

  /* pPager->nRef = 0; */

    int bHotJournal = 1;          /* True if there exists a hot journal-file */

    assert( !MEMDB );

    }

    /* If a journal file exists, and there is no RESERVED lock on the

  int rc = SQLITE_OK;

  assert( pPager->pWal==0 && pPager->tempFile==0 );

  /* If the pager is already in exclusive-mode, the WAL module will use 

  ** heap-memory for the wal-index instead of the VFS shared-memory 

  return rc;

}

#ifdef SQLITE_HAS_CODEC

/*

** This function is called by the wal module when writing page content

    iOffset = walFrameOffset(iRead, sz) + WAL_FRAME_HDRSIZE;

    *pInWal = 1;

    /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL */

  }

  *pInWal = 0;

  return (pWal && pWal->exclusiveMode==WAL_HEAPMEMORY_MODE );

}

#endif /* #ifndef SQLITE_OMIT_WAL */

/************** End of wal.c *************************************************/

  u16 nFree;           /* Number of free bytes on the page */

  u16 nCell;           /* Number of cells on this page, local and ovfl */

  u16 maskPage;        /* Mask for page offset */

  BtShared *pBt;       /* Pointer to BtShared that this page is part of */

  u8 *aData;           /* Pointer to disk image of the page data */

  u8 *aDataEnd;        /* One byte past the end of usable data */

  BtShared *pBt;            /* The BtShared this cursor points to */

  BtCursor *pNext, *pPrev;  /* Forms a linked list of all cursors */

  struct KeyInfo *pKeyInfo; /* Argument passed to comparison function */

  Pgno pgnoRoot;            /* The root page of this tree */

  sqlite3_int64 cachedRowid; /* Next rowid cache.  0 means not valid */

  CellInfo info;            /* A parse of the cell we are pointing at */

  u8 validNKey;             /* True if info.nKey is valid */

  u8 eState;                /* One of the CURSOR_XXX constants (see below) */

#ifndef SQLITE_OMIT_INCRBLOB

  u8 isIncrblobHandle;      /* True if this cursor is an incr. io handle */

#endif

  i16 iPage;                            /* Index of current page in apPage */

struct IntegrityCk {

  BtShared *pBt;    /* The tree being checked out */

  Pager *pPager;    /* The associated pager.  Also accessible by pBt->pPager */

  int *anRef;       /* Number of times each page is referenced */

  int mxErr;        /* Stop accumulating errors when this reaches zero */

  int nErr;         /* Number of messages written to zErrMsg so far */

  int mallocFailed; /* A memory allocation error has occurred */

  assert( sqlite3_mutex_held(pPage->pBt->mutex) );

  for(i=pPage->nOverflow-1; i>=0; i--){

    int k;

    if( k<=iCell ){

      if( k==iCell ){

      }

      iCell--;

    }

** If zFilename is ":memory:" then an in-memory database is created

** that is automatically destroyed when it is closed.

**

**

** If the database is already opened in the same database connection

** and we are in shared cache mode, then the open will fail with an

  /* A BTREE_SINGLE database is always a temporary and/or ephemeral */

  assert( (flags & BTREE_SINGLE)==0 || isTempDb );

  if( isMemdb ){

    flags |= BTREE_MEMORY;

  }

  ** The call to sqlite3BtreeRollback() drops any table-locks held by

  ** this handle.

  */

  sqlite3BtreeLeave(p);

  /* If there are still other outstanding references to the shared-btree

*/

SQLITE_PRIVATE void sqlite3BtreeTripAllCursors(Btree *pBtree, int errCode){

  BtCursor *p;

  sqlite3BtreeEnter(pBtree);

  for(p=pBtree->pBt->pCursor; p; p=p->pNext){

    int i;

** This will release the write lock on the database file.  If there

** are no active cursors, it also releases the read lock.

*/

  int rc;

  BtShared *pBt = p->pBt;

  MemPage *pPage1;

  sqlite3BtreeEnter(p);

  }

  btreeIntegrity(p);

  if( p->inTrans==TRANS_WRITE ){

** If the cell content will fit on the page, then put it there.  If it

** will not fit, then make a copy of the cell content into pTemp if

** pTemp is not null.  Regardless of pTemp, allocate a new entry

** in pTemp or the original pCell) and also record its index. 

** Allocating a new entry in pPage->aCell[] implies that 

** pPage->nOverflow is incremented.

  assert( i>=0 && i<=pPage->nCell+pPage->nOverflow );

  assert( pPage->nCell<=MX_CELL(pPage->pBt) && MX_CELL(pPage->pBt)<=10921 );

  assert( sqlite3_mutex_held(pPage->pBt->mutex) );

  /* The cell should normally be sized correctly.  However, when moving a

  ** malformed cell from a leaf page to an interior page, if the cell size

      put4byte(pCell, iChild);

    }

    j = pPage->nOverflow++;

  }else{

    int rc = sqlite3PagerWrite(pPage->pDbPage);

    if( rc!=SQLITE_OK ){

  if( rc==SQLITE_OK ){

    u8 *pOut = &pSpace[4];

    u16 szCell = cellSizePtr(pPage, pCell);

    u8 *pStop;

** map entries are also updated so that the parent page is page pTo.

**

** If pFrom is currently carrying any overflow cells (entries in the

**

** Before returning, page pTo is reinitialized using btreeInitPage().

**

  ** is called (indirectly) from sqlite3BtreeDelete().

  */

  assert( pParent->nOverflow==0 || pParent->nOverflow==1 );

  if( !aOvflSpace ){

    return SQLITE_NOMEM;

    nMaxCells += 1+apOld[i]->nCell+apOld[i]->nOverflow;

    if( (i--)==0 ) break;

      pgno = get4byte(apDiv[i]);

      szNew[i] = cellSizePtr(pParent, apDiv[i]);

      pParent->nOverflow = 0;

    MemPage *pOld = apCopy[0];

    int nOverflow = pOld->nOverflow;

    int iNextOld = pOld->nCell + nOverflow;

    j = 0;                             /* Current 'old' sibling page */

    k = 0;                             /* Current 'new' sibling page */

    for(i=0; i<nCell; i++){

        iNextOld = i + !leafData + pOld->nCell + pOld->nOverflow;

        if( pOld->nOverflow ){

          nOverflow = pOld->nOverflow;

        }

        isDivider = !leafData;  

      }

      assert(nOverflow>0 || iOverflow<i );

      if( i==iOverflow ){

        isDivider = 1;

        if( (--nOverflow)>0 ){

  TRACE(("BALANCE: copy root %d into %d\n", pRoot->pgno, pChild->pgno));

  /* Copy the overflow cells from pRoot to pChild */

  pChild->nOverflow = pRoot->nOverflow;

  /* Zero the contents of pRoot. Then install pChild as the right-child. */

#ifndef SQLITE_OMIT_QUICKBALANCE

        if( pPage->hasData

         && pPage->nOverflow==1

         && pParent->pgno!=1

         && pParent->nCell==iIdx

        ){

  }

  /* If a transaction is still open on the Btree, roll it back. */

  /* Set the error code of the destination database handle. */

  rc = (p->rc==SQLITE_DONE) ? SQLITE_OK : p->rc;

    memcpy(pMem->zMalloc, pMem->z, pMem->n);

  }

  if( pMem->flags&MEM_Dyn && pMem->xDel ){

    pMem->xDel((void *)(pMem->z));

  }

    sqlite3VdbeMemRelease(p);

  }else if( p->flags&MEM_Dyn && p->xDel ){

    assert( (p->flags&MEM_RowSet)==0 );

    p->xDel((void *)p->z);

    p->xDel = 0;

  }else if( p->flags&MEM_RowSet ){

  ** true and could be omitted.  But we leave it in because other

  ** architectures might behave differently.

  */

    pMem->flags |= MEM_Int;

  }

}

** Zero is returned if a malloc() fails.

*/

SQLITE_PRIVATE int sqlite3VdbeMakeLabel(Vdbe *p){

  assert( p->magic==VDBE_MAGIC_INIT );

  }

  if( p->aLabel ){

    p->aLabel[i] = -1;

#endif

/*