U++

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

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

# define _LARGEFILE_SOURCE 1

#endif

# define GCC_VERSION (__GNUC__*1000000+__GNUC_MINOR__*1000+__GNUC_PATCHLEVEL__)

#else

# define GCC_VERSION 0

#endif

/* Needed for various definitions... */

#if defined(__GNUC__) && !defined(_GNU_SOURCE)

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

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

*/

/*

** CAPI3REF: Run-Time Library Version Numbers

*/

#ifdef SQLITE_INT64_TYPE

  typedef SQLITE_INT64_TYPE sqlite_int64;

#elif defined(_MSC_VER) || defined(__BORLANDC__)

  typedef __int64 sqlite_int64;

  typedef unsigned __int64 sqlite_uint64;

** file that were written at the application level might have changed

** and that adjacent bytes, even bytes within the same sector are

** guaranteed to be unchanged.  The SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN

** SQLITE_IOCAP_IMMUTABLE flag indicates that the file is on

** read-only media and cannot be changed even by processes with

** elevated privileges.

** <li> [SQLITE_IOCAP_ATOMIC64K]

** <li> [SQLITE_IOCAP_SAFE_APPEND]

** <li> [SQLITE_IOCAP_SEQUENTIAL]

** </ul>

**

** The SQLITE_IOCAP_ATOMIC property means that all writes of

** ^The update hook is not invoked when [WITHOUT ROWID] tables are modified.

**

** ^In the current implementation, the update hook

** [ON CONFLICT | ON CONFLICT REPLACE] clause.  ^Nor is the update hook

** invoked when rows are deleted using the [truncate optimization].

** The exceptions defined in this paragraph might change in a future

** [database connection] error code and message accessible via 

** [sqlite3_errcode()] and [sqlite3_errmsg()] and related functions. 

**

**

** ^(If the row that a BLOB handle points to is modified by an

** [UPDATE], [DELETE], or by [ON CONFLICT] side-effects

**

** To avoid a resource leak, every open [BLOB handle] should eventually

** be released by a call to [sqlite3_blob_close()].

*/

SQLITE_API int sqlite3_blob_open(

  sqlite3*,

** CAPI3REF: Move a BLOB Handle to a New Row

** METHOD: sqlite3_blob

**

** to a different row of the same database table. ^The new row is identified

** by the rowid value passed as the second argument. Only the row can be

** changed. ^The database, table and column on which the blob handle is open

** faster than closing the existing handle and opening a new one.

**

** ^(The new row must meet the same criteria as for [sqlite3_blob_open()] -

**

** ^The [sqlite3_preupdate_hook()] interface registers a callback function

** that is invoked prior to each [INSERT], [UPDATE], and [DELETE] operation

** ^At most one preupdate hook may be registered at a time on a single

** [database connection]; each call to [sqlite3_preupdate_hook()] overrides

** the previous setting.

** ^The third parameter to [sqlite3_preupdate_hook()] is passed through as

** the first parameter to callbacks.

**

**

** ^The second parameter to the preupdate callback is a pointer to

** the [database connection] that registered the preupdate hook.

** databases.)^

** ^The fifth parameter to the preupdate callback is the name of the

** table that is being modified.

**

** The [sqlite3_preupdate_old()], [sqlite3_preupdate_new()],

** [sqlite3_preupdate_count()], and [sqlite3_preupdate_depth()] interfaces

** attached database. It is not an error if database zDb is not attached

** to the database when the session object is created.

*/

  sqlite3 *db,                    /* Database handle */

  const char *zDb,                /* Name of db (e.g. "main") */

  sqlite3_session **ppSession     /* OUT: New session object */

** are attached is closed. Refer to the documentation for 

** [sqlite3session_create()] for details.

*/

/*

** The return value indicates the final state of the session object: 0 if 

** the session is disabled, or 1 if it is enabled.

*/

/*

** CAPI3REF: Set Or Clear the Indirect Change Flag

** The return value indicates the final state of the indirect flag: 0 if 

** it is clear, or 1 if it is set.

*/

/*

** CAPI3REF: Attach A Table To A Session Object

** SQLITE_OK is returned if the call completes without error. Or, if an error 

** occurs, an SQLite error code (e.g. SQLITE_NOMEM) is returned.

*/

  sqlite3_session *pSession,      /* Session object */

  const char *zTab                /* Table name */

);

** If xFilter returns 0, changes is not tracked. Note that once a table is 

** attached, xFilter will not be called again.

*/

  sqlite3_session *pSession,      /* Session object */

  int(*xFilter)(

    void *pCtx,                   /* Copy of third arg to _filter_table() */

** another field of the same row is updated while the session is enabled, the

** resulting changeset will contain an UPDATE change that updates both fields.

*/

  sqlite3_session *pSession,      /* Session object */

  int *pnChangeset,               /* OUT: Size of buffer at *ppChangeset */

  void **ppChangeset              /* OUT: Buffer containing changeset */

**     the from-table, a DELETE record is added to the session object.

**

**   <li> For each row (primary key) that exists in both tables, but features 

** </ul>

**

** To clarify, if this function is called and then a changeset constructed

** message. It is the responsibility of the caller to free this buffer using

** sqlite3_free().

*/

  sqlite3_session *pSession,

  const char *zFromDb,

  const char *zTbl,

** a single table are grouped together, tables appear in the order in which

** they were attached to the session object).

*/

  sqlite3_session *pSession,      /* Session object */

  int *pnPatchset,                /* OUT: Size of buffer at *ppChangeset */

  void **ppPatchset               /* OUT: Buffer containing changeset */

** guaranteed that a call to sqlite3session_changeset() will return a 

** changeset containing zero changes.

*/

/*

** CAPI3REF: Create An Iterator To Traverse A Changeset 

** the applies to table X, then one for table Y, and then later on visit 

** another change for table X.

*/

  sqlite3_changeset_iter **pp,    /* OUT: New changeset iterator handle */

  int nChangeset,                 /* Size of changeset blob in bytes */

  void *pChangeset                /* Pointer to blob containing changeset */

** codes include SQLITE_CORRUPT (if the changeset buffer is corrupt) or 

** SQLITE_NOMEM.

*/

/*

** CAPI3REF: Obtain The Current Operation From A Changeset Iterator

** SQLite error code is returned. The values of the output variables may not

** be trusted in this case.

*/

  sqlite3_changeset_iter *pIter,  /* Iterator object */

  const char **pzTab,             /* OUT: Pointer to table name */

  int *pnCol,                     /* OUT: Number of columns in table */

** SQLITE_OK is returned and the output variables populated as described

** above.

*/

  sqlite3_changeset_iter *pIter,  /* Iterator object */

  unsigned char **pabPK,          /* OUT: Array of boolean - true for PK cols */

  int *pnCol                      /* OUT: Number of entries in output array */

** If some other error occurs (e.g. an OOM condition), an SQLite error code

** is returned and *ppValue is set to NULL.

*/

  sqlite3_changeset_iter *pIter,  /* Changeset iterator */

  int iVal,                       /* Column number */

  sqlite3_value **ppValue         /* OUT: Old value (or NULL pointer) */

** If some other error occurs (e.g. an OOM condition), an SQLite error code

** is returned and *ppValue is set to NULL.

*/

  sqlite3_changeset_iter *pIter,  /* Changeset iterator */

  int iVal,                       /* Column number */

  sqlite3_value **ppValue         /* OUT: New value (or NULL pointer) */

** If some other error occurs (e.g. an OOM condition), an SQLite error code

** is returned and *ppValue is set to NULL.

*/

  sqlite3_changeset_iter *pIter,  /* Changeset iterator */

  int iVal,                       /* Column number */

  sqlite3_value **ppValue         /* OUT: Value from conflicting row */

**

** In all other cases this function returns SQLITE_MISUSE.

*/

  sqlite3_changeset_iter *pIter,  /* Changeset iterator */

  int *pnOut                      /* OUT: Number of FK violations */

);

**     // An error has occurred 

**   }

*/

/*

** CAPI3REF: Invert A Changeset

** WARNING/TODO: This function currently assumes that the input is a valid

** changeset. If it is not, the results are undefined.

*/

  int nIn, const void *pIn,       /* Input changeset */

  int *pnOut, void **ppOut        /* OUT: Inverse of input */

);

**

** Refer to the sqlite3_changegroup documentation below for details.

*/

  int nA,                         /* Number of bytes in buffer pA */

  void *pA,                       /* Pointer to buffer containing changeset A */

  int nB,                         /* Number of bytes in buffer pB */

** <ul>

**   <li> The table has the same name as the name recorded in the 

**        changeset, and

**        changeset, and

**   <li> The table has primary key columns in the same position as 

**        recorded in the changeset.

**   If a row with matching primary key values is found, but one or more of

**   the non-primary key fields contains a value different from the original

**   row value stored in the changeset, the conflict-handler function is

**

**   If no row with matching primary key values is found in the database,

**   the conflict-handler function is invoked with [SQLITE_CHANGESET_NOTFOUND]

**

** <dt>INSERT Changes<dd>

**   For each INSERT change, an attempt is made to insert the new row into

**

**   If the attempt to insert the row fails because the database already 

**   contains a row with the same primary key values, the conflict handler

**   For each UPDATE change, this function checks if the target database 

**   contains a row with the same primary key value (or values) as the 

**   original row values stored in the changeset. If it does, and the values 

**

**   If a row with matching primary key values is found, but one or more of

**   UPDATE changes only contain values for non-primary key fields that are

**   to be modified, only those fields need to match the original values to

**   avoid the SQLITE_CHANGESET_DATA conflict-handler callback.

** rolled back, restoring the target database to its original state, and an 

** SQLite error code returned.

*/

  sqlite3 *db,                    /* Apply change to "main" db of this handle */

  int nChangeset,                 /* Size of changeset in bytes */

  void *pChangeset,               /* Changeset blob */

** parameter set to a value less than or equal to zero. Other than this,

** no guarantees are made as to the size of the chunks of data returned.

*/

  sqlite3 *db,                    /* Apply change to "main" db of this handle */

  int (*xInput)(void *pIn, void *pData, int *pnData), /* Input function */

  void *pIn,                                          /* First arg for xInput */

  ),

  void *pCtx                      /* First argument passed to xConflict */

);

  int (*xInputA)(void *pIn, void *pData, int *pnData),

  void *pInA,

  int (*xInputB)(void *pIn, void *pData, int *pnData),

  int (*xOutput)(void *pOut, const void *pData, int nData),

  void *pOut

);

  int (*xInput)(void *pIn, void *pData, int *pnData),

  void *pIn,

  int (*xOutput)(void *pOut, const void *pData, int nData),

  void *pOut

);

  sqlite3_changeset_iter **pp,

  int (*xInput)(void *pIn, void *pData, int *pnData),

  void *pIn

);

  sqlite3_session *pSession,

  int (*xOutput)(void *pOut, const void *pData, int nData),

  void *pOut

);

  sqlite3_session *pSession,

  int (*xOutput)(void *pOut, const void *pData, int nData),

  void *pOut

#      include <intrin.h>

#      pragma intrinsic(_byteswap_ushort)

#      pragma intrinsic(_byteswap_ulong)

#      pragma intrinsic(_ReadWriteBarrier)

#    else

#      include <cmnintrin.h>

#include <stddef.h>

/*

** If compiling for a processor that lacks floating point support,

** substitute integer for floating-point

*/

** pagecaches for each database connection.  A positive number is the

** number of pages.  A negative number N translations means that a buffer

** of -1024*N bytes is allocated and used for as many pages as it will hold.

*/

#ifndef SQLITE_DEFAULT_PCACHE_INITSZ

#endif

/*

**

** For best performance, an attempt is made to guess at the byte-order

** using C-preprocessor macros.  If that is unsuccessful, or if

** at run-time.

*/

     defined(__x86_64) || defined(__x86_64__) || defined(_M_X64)  ||    \

     defined(_M_AMD64) || defined(_M_ARM)     || defined(__x86)   ||    \

#endif

# define SQLITE_BIGENDIAN    1

# define SQLITE_LITTLEENDIAN 0

# define SQLITE_UTF16NATIVE  SQLITE_UTF16BE

# ifdef SQLITE_AMALGAMATION

  const int sqlite3one = 1;

# else

  extern const int sqlite3one;

# endif

# define SQLITE_BIGENDIAN    (*(char *)(&sqlite3one)==0)

# define SQLITE_LITTLEENDIAN (*(char *)(&sqlite3one)==1)

# define SQLITE_UTF16NATIVE  (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE)

SQLITE_PRIVATE int sqlite3BtreeCursorRestore(BtCursor*, int*);

SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor*, u8 flags);

#define BTREE_SAVEPOSITION 0x02  /* Leave cursor pointing at NEXT or PREV */

#define BTREE_AUXDELETE    0x04  /* not the primary delete operation */

/* An instance of the BtreePayload object describes the content of a single

** entry in either an index or table btree.

};

SQLITE_PRIVATE int sqlite3BtreeInsert(BtCursor*, const BtreePayload *pPayload,

SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor*, int *pRes);

SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor*, int *pRes);

SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor*, int *pRes);

struct VdbeOp {

  u8 opcode;          /* What operation to perform */

  signed char p4type; /* One of the P4_xxx constants for p4 */

  int p1;             /* First operand */

  int p2;             /* Second parameter (often the jump destination) */

  int p3;             /* The third parameter */

SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe*, u32 addr, int P1);

SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe*, u32 addr, int P2);

SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe*, u32 addr, int P3);

SQLITE_PRIVATE void sqlite3VdbeJumpHere(Vdbe*, int addr);

SQLITE_PRIVATE int sqlite3VdbeChangeToNoop(Vdbe*, int addr);

SQLITE_PRIVATE int sqlite3VdbeDeletePriorOpcode(Vdbe*, u8 op);

SQLITE_PRIVATE   int sqlite3PagerWalCallback(Pager *pPager);

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

SQLITE_PRIVATE   int sqlite3PagerCloseWal(Pager *pPager, sqlite3*);

# ifdef SQLITE_ENABLE_SNAPSHOT

SQLITE_PRIVATE   int sqlite3PagerSnapshotGet(Pager *pPager, sqlite3_snapshot **ppSnapshot);

SQLITE_PRIVATE   int sqlite3PagerSnapshotOpen(Pager *pPager, sqlite3_snapshot *pSnapshot);

SQLITE_PRIVATE   int sqlite3PagerSnapshotRecover(Pager *pPager);

# endif

#else

#endif

#ifdef SQLITE_ENABLE_ZIPVFS

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

  u8 isTransactionSavepoint;    /* True if the outermost savepoint is a TS */

  u8 mTrace;                    /* zero or more SQLITE_TRACE flags */

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

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

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

#define SQLITE_FUNC_MINMAX   0x1000 /* True for min() and max() aggregates */

#define SQLITE_FUNC_SLOCHNG  0x2000 /* "Slow Change". Value constant during a

                                    ** single query - might change over time */

/*

** The following three macros, FUNCTION(), LIKEFUNC() and AGGREGATE() are

#define WHERE_SORTBYGROUP      0x0200 /* Support sqlite3WhereIsSorted() */

#define WHERE_SEEK_TABLE       0x0400 /* Do not defer seeks on main table */

#define WHERE_ORDERBY_LIMIT    0x0800 /* ORDERBY+LIMIT on the inner loop */

                        /*     0x2000    not currently used */

#define WHERE_USE_LIMIT        0x4000 /* Use the LIMIT in cost estimates */

                        /*     0x8000    not currently used */

#define OPFLAG_NCHANGE       0x01    /* OP_Insert: Set to update db->nChange */

                                     /* Also used in P2 (not P5) of OP_Delete */

#define OPFLAG_EPHEM         0x01    /* OP_Column: Ephemeral output is ok */

#define OPFLAG_ISUPDATE      0x04    /* This OP_Insert is an sql UPDATE */

#define OPFLAG_APPEND        0x08    /* This is likely to be an append */

#define OPFLAG_USESEEKRESULT 0x10    /* Try to avoid a seek in BtreeInsert() */

#define OPFLAG_ISNOOP        0x40    /* OP_Delete does pre-update-hook only */

#define OPFLAG_LENGTHARG     0x40    /* OP_Column only used for length() */

#define OPFLAG_TYPEOFARG     0x80    /* OP_Column only used for typeof() */

#define OPFLAG_BULKCSR       0x01    /* OP_Open** used to open bulk cursor */

#define OPFLAG_FORDELETE     0x08    /* OP_Open should use BTREE_FORDELETE */

#define OPFLAG_P2ISREG       0x10    /* P2 to OP_Open** is a register number */

#define OPFLAG_PERMUTE       0x01    /* OP_Compare: use the permutation */

#define OPFLAG_AUXDELETE     0x04    /* OP_Delete: index in a DELETE op */

/*

SQLITE_PRIVATE void sqlite3ExprCode(Parse*, Expr*, int);

SQLITE_PRIVATE void sqlite3ExprCodeCopy(Parse*, Expr*, int);

SQLITE_PRIVATE void sqlite3ExprCodeFactorable(Parse*, Expr*, int);

SQLITE_PRIVATE int sqlite3ExprCodeTemp(Parse*, Expr*, int*);

SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse*, Expr*, int);

SQLITE_PRIVATE void sqlite3ExprCodeAndCache(Parse*, Expr*, int);

SQLITE_PRIVATE void sqlite3ResolvePartIdxLabel(Parse*,int);

SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(Parse*,Table*,int*,int,int,int,int,

                                     u8,u8,int,int*,int*);

SQLITE_PRIVATE void sqlite3CompleteInsertion(Parse*,Table*,int,int,int,int*,int,int,int);

SQLITE_PRIVATE int sqlite3OpenTableAndIndices(Parse*, Table*, int, u8, int, u8*, int*, int*);

SQLITE_PRIVATE void sqlite3BeginWriteOperation(Parse*, int, int);

/*

** The interface to the LEMON-generated parser

*/

SQLITE_PRIVATE void sqlite3Parser(void*, int, Token, Parse*);

#ifdef YYTRACKMAXSTACKDEPTH

SQLITE_PRIVATE   int sqlite3ParserStackPeak(void*);

  #define sqlite3FkDropTable(a,b,c)

  #define sqlite3FkOldmask(a,b)         0

  #define sqlite3FkRequired(a,b,c,d)    0

#endif

#ifndef SQLITE_OMIT_FOREIGN_KEY

SQLITE_PRIVATE   void sqlite3FkDelete(sqlite3 *, Table*);

#endif

/*

** The following singleton contains the global configuration for

** the SQLite library.

*/

   SQLITE_ALLOW_COVERING_INDEX_SCAN,   /* bUseCis */

   0x7ffffffe,                /* mxStrlen */

   0,                         /* neverCorrupt */

   SQLITE_STMTJRNL_SPILL,     /* nStmtSpill */

   {0,0,0,0,0,0,0,0},         /* m */

   {0,0,0,0,0,0,0,0,0},       /* mutex */

  i64 iKey2;                      /* Second key value passed to hook */

  Mem *aNew;                      /* Array of new.* values */

  Table *pTab;                    /* Schema object being upated */          

};

/*

*/

static void *sqlite3MemMalloc(int nByte){

#ifdef SQLITE_MALLOCSIZE

  if( p==0 ){

    testcase( sqlite3GlobalConfig.xLog!=0 );

    sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes of memory", nByte);

#else

  sqlite3_int64 *p;

  assert( nByte>0 );

  p = SQLITE_MALLOC( nByte+8 );

  if( p ){

    p[0] = nByte;

  SQLITE_MEMORY_BARRIER;

#elif defined(__GNUC__)

  __sync_synchronize();

  _ReadWriteBarrier();

#elif defined(MemoryBarrier)

  MemoryBarrier();

** Do a memory allocation with statistics and alarms.  Assume the

** lock is already held.

*/

  void *p;

  assert( sqlite3_mutex_held(mem0.mutex) );

  nFull = sqlite3GlobalConfig.m.xRoundup(n);

  sqlite3StatusHighwater(SQLITE_STATUS_MALLOC_SIZE, n);

  if( mem0.alarmThreshold>0 ){

    sqlite3_int64 nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);

    sqlite3StatusUp(SQLITE_STATUS_MALLOC_COUNT, 1);

  }

  *pp = p;

}

/*

** Allowed values for et_info.flags

*/

#define FLAG_SIGNED  1     /* True if the value to convert is signed */

#define FLAG_STRING  4     /* Allow infinity precision */

  {  '%',  0, 0, etPERCENT,    0,  0 },

  {  'p', 16, 0, etPOINTER,    0,  1 },

};

/*

  etByte done;               /* Loop termination flag */

  etByte xtype = etINVALID;  /* Conversion paradigm */

  u8 bArgList;               /* True for SQLITE_PRINTF_SQLFUNC */

  char prefix;               /* Prefix character.  "+" or "-" or " " or '\0'. */

  sqlite_uint64 longvalue;   /* Value for integer types */

  LONGDOUBLE_TYPE realvalue; /* Value for real types */

  char buf[etBUFSIZE];       /* Conversion buffer */

  bufpt = 0;

  }else{

  }

  for(; (c=(*fmt))!=0; ++fmt){

    if( c!='%' ){

    for(idx=0; idx<ArraySize(fmtinfo); idx++){

      if( c==fmtinfo[idx].fmttype ){

        infop = &fmtinfo[idx];

        break;

      }

    }

        break;

      }

      case etTOKEN: {

        assert( bArgList==0 );

        if( pToken && pToken->n ){

          sqlite3StrAccumAppend(pAccum, (const char*)pToken->z, pToken->n);

        break;

      }

      case etSRCLIST: {

        assert( bArgList==0 );

        assert( k>=0 && k<pSrc->nSrc );

        if( pItem->zDatabase ){

    ** the output.

    */

    width -= length;

    if( zExtra ){

      sqlite3DbFree(pAccum->db, zExtra);

  u32 x;

  memcpy(&x,p,4);

  return x;

  u32 x;

  memcpy(&x,p,4);

  return __builtin_bswap32(x);

  u32 x;

  memcpy(&x,p,4);

  return _byteswap_ulong(x);

SQLITE_PRIVATE void sqlite3Put4byte(unsigned char *p, u32 v){

#if SQLITE_BYTEORDER==4321

  memcpy(p,&v,4);

  u32 x = __builtin_bswap32(v);

  memcpy(p,&x,4);

  u32 x = _byteswap_ulong(v);

  memcpy(p,&x,4);

#else

** overflow, leave *pA unchanged and return 1.

*/

SQLITE_PRIVATE int sqlite3AddInt64(i64 *pA, i64 iB){

  i64 iA = *pA;

  testcase( iA==0 ); testcase( iA==1 );

  testcase( iB==-1 ); testcase( iB==0 );

  }

  *pA += iB;

  return 0; 

}

SQLITE_PRIVATE int sqlite3SubInt64(i64 *pA, i64 iB){

  testcase( iB==SMALLEST_INT64+1 );

  if( iB==SMALLEST_INT64 ){

    testcase( (*pA)==(-1) ); testcase( (*pA)==0 );

  }else{

    return sqlite3AddInt64(pA, -iB);

  }

}

SQLITE_PRIVATE int sqlite3MulInt64(i64 *pA, i64 iB){

  i64 iA = *pA;

  if( iB>0 ){

    if( iA>LARGEST_INT64/iB ) return 1;

  }

  *pA = iA*iB;

  return 0;

}

/*

#define isOpen(pFd) ((pFd)->pMethods!=0)

/*

*/

}

#else

# define pagerUseWal(x) 0

# define pagerRollbackWal(x) 0

*/

#if SQLITE_BYTEORDER==4321

# define get2byteAligned(x)  (*(u16*)(x))

# define get2byteAligned(x)  __builtin_bswap16(*(u16*)(x))

# define get2byteAligned(x)  _byteswap_ushort(*(u16*)(x))

#else

# define get2byteAligned(x)  ((x)[0]<<8 | (x)[1])

** two or more btrees in common both try to lock all their btrees

** at the same instant.

*/

  int i;

  Btree *p;

  assert( sqlite3_mutex_held(db->mutex) );

  for(i=0; i<db->nDb; i++){

    p = db->aDb[i].pBt;

  }

}

  int i;

  Btree *p;

  assert( sqlite3_mutex_held(db->mutex) );

    if( p ) sqlite3BtreeLeave(p);

  }

}

#ifndef NDEBUG

/*

      if( eType==PTRMAP_OVERFLOW1 ){

        CellInfo info;

        pPage->xParseCell(pPage, pCell, &info);

        }

      }else{

        if( get4byte(pCell)==iFrom ){

    assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK );

    assert( iSavepoint>=0 || (iSavepoint==-1 && op==SAVEPOINT_ROLLBACK) );

    sqlite3BtreeEnter(p);

    if( rc==SQLITE_OK ){

      if( iSavepoint<0 && (pBt->btsFlags & BTS_INITIALLY_EMPTY)!=0 ){

        pBt->nPage = 0;

**

**   0: The operation is a read. Populate the overflow cache.

**   1: The operation is a write. Populate the overflow cache.

**

** A total of "amt" bytes are read or written beginning at "offset".

** Data is read to or from the buffer pBuf.

** The content being read or written might appear on the main page

** or be scattered out on multiple overflow pages.

**

** Subsequent calls use this cache to make seeking to the supplied offset 

** more efficient.

**

** invalidated if some other cursor writes to the same table, or if

** the cursor is moved to a different row. Additionally, in auto-vacuum

** mode, the following events may invalidate an overflow page-list cache.

  MemPage *pPage = pCur->apPage[pCur->iPage]; /* Btree page of current entry */

  BtShared *pBt = pCur->pBt;                  /* Btree this cursor belongs to */

#ifdef SQLITE_DIRECT_OVERFLOW_READ

#endif

  assert( pPage );

  assert( pCur->eState==CURSOR_VALID );

  assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );

  assert( cursorHoldsMutex(pCur) );

  getCellInfo(pCur);

  aPayload = pCur->info.pPayload;

  assert( offset+amt <= pCur->info.nPayload );

  assert( aPayload > pPage->aData );

    if( a+offset>pCur->info.nLocal ){

      a = pCur->info.nLocal - offset;

    }

    offset = 0;

    pBuf += a;

    amt -= a;

    nextPage = get4byte(&aPayload[pCur->info.nLocal]);

    /* If the BtCursor.aOverflow[] has not been allocated, allocate it now.

    **

    ** The aOverflow[] array is sized at one entry for each overflow page

    ** in the overflow chain. The page number of the first overflow page is

    ** stored in aOverflow[0], etc. A value of 0 in the aOverflow[] array

    ** means "not yet known" (the cache is lazily populated).

    */

      int nOvfl = (pCur->info.nPayload-pCur->info.nLocal+ovflSize-1)/ovflSize;

      if( nOvfl>pCur->nOvflAlloc ){

        Pgno *aNew = (Pgno*)sqlite3Realloc(

            pCur->aOverflow, nOvfl*2*sizeof(Pgno)

        );

        if( aNew==0 ){

        }else{

          pCur->nOvflAlloc = nOvfl*2;

          pCur->aOverflow = aNew;

        }

      }

      }

    }

      /* If required, populate the overflow page-list cache. */

      if( offset>=ovflSize ){

        /* The only reason to read this page is to obtain the page

        ** data is not required. So first try to lookup the overflow

        ** page-list cache, if any, then fall back to the getOverflowPage()

        ** function.

        */

        assert( pCur->curFlags & BTCF_ValidOvfl );

        assert( pCur->pBtree->db==pBt->db );

        if( pCur->aOverflow[iIdx+1] ){

        ** range of data that is being read (eOp==0) or written (eOp!=0).

        */

#ifdef SQLITE_DIRECT_OVERFLOW_READ

#endif

        int a = amt;

        if( a + offset > ovflSize ){

        **

        **   1) this is a read operation, and 

        **   2) data is required from the start of this overflow page, and

        **

        ** then data can be read directly from the database file into the

        ** output buffer, bypassing the page-cache altogether. This speeds

        ** up loading large records that span many overflow pages.

        */

         && offset==0                                          /* (2) */

        ){

          u8 aSave[4];

          u8 *aWrite = &pBuf[-4];

          memcpy(aSave, aWrite, 4);

          rc = sqlite3OsRead(fd, aWrite, a+4, (i64)pBt->pageSize*(nextPage-1));

          nextPage = get4byte(aWrite);

        {

          DbPage *pDbPage;

          rc = sqlite3PagerGet(pBt->pPager, nextPage, &pDbPage,

          );

          if( rc==SQLITE_OK ){

            aPayload = sqlite3PagerGetData(pDbPage);

            nextPage = get4byte(aPayload);

            sqlite3PagerUnref(pDbPage);

            offset = 0;

          }

        }

        amt -= a;

        pBuf += a;

      }

    }

  }

  if( rc==SQLITE_OK && amt>0 ){

  }

  return rc;

}

  assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );

  return accessPayload(pCur, offset, amt, (unsigned char*)pBuf, 0);

}

#ifndef SQLITE_OMIT_INCRBLOB

  int rc;

  if ( pCur->eState==CURSOR_INVALID ){

    return SQLITE_ABORT;

  }

  assert( cursorOwnsBtShared(pCur) );

  }

}

#endif /* SQLITE_OMIT_INCRBLOB */

      *pRes = 0;

      return SQLITE_OK;

    }

    }

  }

            goto moveto_finish;

          }

          pCur->aiIdx[pCur->iPage] = (u16)idx;

          if( rc ){

            sqlite3_free(pCellKey);

            goto moveto_finish;

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

    MemPage *p = apOld[i];

    szNew[i] = usableSpace - p->nFree;

    for(j=0; j<p->nOverflow; j++){

      szNew[i] += 2 + p->xCellSize(p, p->apOvfl[j]);

    }

SQLITE_PRIVATE int sqlite3BtreeInsert(

  BtCursor *pCur,                /* Insert data into the table of this cursor */

  const BtreePayload *pX,        /* Content of the row to be inserted */

  int seekResult                 /* Result of prior MovetoUnpacked() call */

){

  int rc;

  unsigned char *oldCell;

  unsigned char *newCell = 0;

  if( pCur->eState==CURSOR_FAULT ){

    assert( pCur->skipNext!=SQLITE_OK );

    return pCur->skipNext;

    ** cursors open on the row being replaced */

    invalidateIncrblobCursors(p, pX->nKey, 0);

    /* If the cursor is currently on the last row and we are appending a

    ** new row onto the end, set the "loc" to avoid an unnecessary

    ** btreeMoveto() call */

               && pCur->info.nKey==pX->nKey-1 ){

      loc = -1;

    }else if( loc==0 ){

      if( rc ) return rc;

    }

    if( pX->nMem ){

      UnpackedRecord r;

      r.pKeyInfo = pCur->pKeyInfo;

      r.r1 = 0;

      r.r2 = 0;

      r.eqSeen = 0;

    }else{

    }

    if( rc ) return rc;

  }

    ** from trying to save the current position of the cursor.  */

    pCur->apPage[pCur->iPage]->nOverflow = 0;

    pCur->eState = CURSOR_INVALID;