Lines Matching defs:?8
651 ** Since version 3.6.18, SQLite source code has been stored in the
953 #define SQLITE_TOOBIG 18 /* String or BLOB exceeds size limit */
1006 #define SQLITE_IOERR_SHMOPEN (SQLITE_IOERR | (18<<8))
2449 ** Bob | 28
2463 ** azResult[5] = "28";
2855 #define SQLITE_INSERT 18 /* Table Name NULL */
2865 #define SQLITE_ANALYZE 28 /* Table Name NULL */
6159 #define SQLITE_TESTCTRL_SCRATCHMALLOC 18
7434 #define TK_IF 18
7444 #define TK_ABORT 28
7454 #define TK_COLUMNKW 38
7464 #define TK_INSTEAD 48
7474 #define TK_RESTRICT 58
7484 #define TK_OR 68
7494 #define TK_LE 78
7504 #define TK_STAR 88
7514 #define TK_NULL 98
7709 typedef UINT8_TYPE u8; /* 1-byte unsigned integer */
7710 typedef INT8_TYPE i8; /* 1-byte signed integer */
7914 ** Defer sourcing vdbe.h and btree.h until after the "u8" and
8008 SQLITE_PRIVATE int sqlite3BtreeLockTable(Btree *pBtree, int iTab, u8 isWriteLock);
8208 u8 opcode; /* What operation to perform */
8210 u8 opflags; /* Mask of the OPFLG_* flags in opcodes.h */
8211 u8 p5; /* Fifth parameter is an unsigned character */
8259 u8 opcode; /* What operation to perform */
8284 #define P4_SUBPROGRAM (-18) /* P4 is a pointer to a SubProgram structure */
8353 #define OP_Multiply 88 /* same as TK_STAR */
8357 #define OP_Function 18
8373 #define OP_Le 78 /* same as TK_LE */
8380 #define OP_Or 68 /* same as TK_OR */
8385 #define OP_IfNot 28
8397 #define OP_VerifyCookie 38
8407 #define OP_SeekGe 48
8417 #define OP_InsertInt 58
8435 #define OP_IdxDelete 98
8502 /* 48 */ 0x11, 0x11, 0x08, 0x11, 0x11, 0x11, 0x11, 0x02,\
8507 /* 88 */ 0x4c, 0x4c, 0x4c, 0x4c, 0x01, 0x24, 0x02, 0x01,\
8535 SQLITE_PRIVATE void sqlite3VdbeChangeP5(Vdbe*, u8 P5);
8563 SQLITE_PRIVATE sqlite3_value *sqlite3VdbeGetValue(Vdbe*, int, u8);
8741 SQLITE_PRIVATE u8 sqlite3PagerIsreadonly(Pager*);
9108 ** We cannot use LockFileEx() or UnlockFileEx() on Win95/98/ME because
9126 ** for probabilistic locking in Win95/98/ME. Hence, the locking scheme
9226 ** 2007 August 28
9311 u8 inTrans; /* 0: not writable. 1: Transaction. 2: Checkpoint */
9312 u8 safety_level; /* How aggressive at syncing data to disk */
9341 u8 file_format; /* Schema format version for this file */
9342 u8 enc; /* Text encoding used by this database */
9398 u8 bEnabled; /* False to disable new lookaside allocations */
9399 u8 bMalloced; /* True if pStart obtained from sqlite3_malloc() */
9455 u8 autoCommit; /* The auto-commit flag. */
9456 u8 temp_store; /* 1: file 2: memory 0: default */
9457 u8 mallocFailed; /* True if we have seen a malloc failure */
9458 u8 dfltLockMode; /* Default locking-mode for attached dbs */
9460 u8 suppressErr; /* Do not issue error messages if true */
9461 u8 vtabOnConflict; /* Value to return for s3_vtab_on_conflict() */
9474 u8 busy; /* TRUE if currently initializing */
9475 u8 orphanTrigger; /* Last statement is orphaned TEMP trigger */
9533 u8 isTransactionSavepoint; /* True if the outermost savepoint is a TS */
9627 u8 iPrefEnc; /* Preferred text encoding (SQLITE_UTF8, 16LE, 16BE) */
9628 u8 flags; /* Some combination of SQLITE_FUNC_* */
9750 u8 notNull; /* True if there is a NOT NULL constraint */
9751 u8 isPrimKey; /* True if this column is part of the PRIMARY KEY */
9754 u8 isHidden; /* True if this column is 'hidden' */
9781 u8 enc; /* Text encoding handled by xCmp() */
9782 u8 type; /* One of the SQLITE_COLL_... values below */
9885 u8 bConstraint; /* True if constraints are supported */
9930 u8 tabFlags; /* Mask of TF_* values */
9931 u8 keyConf; /* What to do in case of uniqueness conflict on iPKey */
10002 u8 isDeferred; /* True if constraint checking is deferred till COMMIT */
10003 u8 aAction[2]; /* ON DELETE and ON UPDATE actions, respectively */
10058 u8 enc; /* Text encoding - one of the SQLITE_UTF* values */
10060 u8 *aSortOrder; /* Sort order for each column. May be NULL */
10129 u8 onError; /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */
10130 u8 autoIndex; /* True if is automatically created (ex: by UNIQUE) */
10131 u8 bUnordered; /* Use this index for == or IN queries only */
10135 u8 *aSortOrder; /* Array of size Index.nColumn. True==DESC, False==ASC */
10149 u8 eType; /* SQLITE_NULL, SQLITE_INTEGER ... etc. */
10150 u8 nByte; /* Size in byte of text or blob. */
10180 u8 directMode; /* Direct rendering mode means take data directly
10182 u8 useSortingIdx; /* In direct mode, reference the sorting index rather
10291 u8 op; /* Operation performed by this node */
10324 u8 flags2; /* Second set of flags. EP2_... */
10325 u8 op2; /* If a TK_REGISTER, the original value of Expr.op */
10411 u8 sortOrder; /* 1 for DESC or 0 for ASC */
10412 u8 done; /* A flag to indicate when processing is finished */
10497 u8 jointype; /* Type of join between this able and the previous */
10498 u8 notIndexed; /* True if there is a NOT INDEXED clause */
10499 u8 isCorrelated; /* True if sub-query is correlated */
10501 u8 iSelectId; /* If pSelect!=0, the id of the sub-select in EQP */
10571 u8 iFrom; /* Which entry in the FROM clause */
10572 u8 op, p5; /* Opcode and P5 of the opcode that ends the loop */
10617 u8 okOnePass; /* Ok to use one-pass algorithm for UPDATE or DELETE */
10618 u8 untestedTerms; /* Not all WHERE terms resolved by outer loop */
10619 u8 eDistinct;
10661 u8 allowAgg; /* Aggregate functions allowed here */
10662 u8 hasAgg; /* True if aggregates are seen */
10663 u8 isCheck; /* True if resolving names in a CHECK constraint */
10691 u8 op; /* One of: TK_UNION TK_ALL TK_INTERSECT TK_EXCEPT */
10747 u8 eDest; /* How to dispose of the results */
10748 u8 affinity; /* Affinity used when eDest==SRT_Set */
10833 u8 colNamesSet; /* TRUE after OP_ColumnName has been issued to pVdbe */
10834 u8 nameClash; /* A permanent table name clashes with temp table name */
10835 u8 checkSchema; /* Causes schema cookie check after an error */
10836 u8 nested; /* Number of nested calls to the parser/code generator */
10837 u8 parseError; /* True after a parsing error. Ticket #1794 */
10838 u8 nTempReg; /* Number of temporary registers in aTempReg[] */
10839 u8 nTempInUse; /* Number of aTempReg[] currently checked out */
10850 u8 nColCache; /* Number of entries in the column cache */
10851 u8 iColCache; /* Next entry of the cache to replace */
10855 u8 tempReg; /* iReg is a temp register that needs to be freed */
10862 u8 isMultiWrite; /* True if statement may affect/insert multiple rows */
10863 u8 mayAbort; /* True if statement may throw an ABORT exception */
10880 u8 eTriggerOp; /* TK_UPDATE, TK_INSERT or TK_DELETE */
10881 u8 eOrconf; /* Default ON CONFLICT policy for trigger steps */
10882 u8 disableTriggers; /* True to disable triggers */
10895 u8 explain; /* True if the EXPLAIN flag is found on the query */
10904 u8 declareVtab; /* True if inside sqlite3_declare_vtab() */
10961 u8 op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT */
10962 u8 tr_tm; /* One of TRIGGER_BEFORE, TRIGGER_AFTER */
11021 u8 op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT, TK_SELECT */
11022 u8 orconf; /* OE_Rollback etc. */
11057 u8 mallocFailed; /* Becomes true if any memory allocation fails */
11058 u8 useMalloc; /* 0: none, 1: sqlite3DbMalloc, 2: sqlite3_malloc */
11059 u8 tooBig; /* Becomes true if string size exceeds limits */
11347 SQLITE_PRIVATE int sqlite3RowSetTest(RowSet*, u8 iBatch, i64);
11465 SQLITE_PRIVATE FuncDef *sqlite3FindFunction(sqlite3*,const char*,int,int,u8,int);
11492 ExprList*,Select*,u8);
11493 SQLITE_PRIVATE TriggerStep *sqlite3TriggerUpdateStep(sqlite3*,Token*,ExprList*, Expr*, u8);
11534 SQLITE_PRIVATE int sqlite3AtoF(const char *z, double*, int, u8);
11539 SQLITE_PRIVATE u32 sqlite3Utf8Read(const u8*, const u8**);
11550 SQLITE_PRIVATE u8 sqlite3GetVarint(const unsigned char *, u64 *);
11551 SQLITE_PRIVATE u8 sqlite3GetVarint32(const unsigned char *, u32 *);
11571 #define getVarint32(A,B) (u8)((*(A)<(u8)0x80) ? ((B) = (u32)*(A)),1 : sqlite3GetVarint32((A), (u32 *)&(B)))
11572 #define putVarint32(A,B) (u8)(((u32)(B)<(u32)0x80) ? (*(A) = (unsigned char)(B)),1 : sqlite3PutVarint32((A), (B)))
11582 SQLITE_PRIVATE int sqlite3Atoi64(const char*, i64*, int, u8);
11585 SQLITE_PRIVATE u8 sqlite3HexToInt(int h);
11589 SQLITE_PRIVATE CollSeq *sqlite3FindCollSeq(sqlite3*,u8 enc, const char*,int);
11606 SQLITE_PRIVATE u8 sqlite3GetBoolean(const char *z);
11608 SQLITE_PRIVATE const void *sqlite3ValueText(sqlite3_value*, u8);
11609 SQLITE_PRIVATE int sqlite3ValueBytes(sqlite3_value*, u8);
11610 SQLITE_PRIVATE void sqlite3ValueSetStr(sqlite3_value*, int, const void *,u8,
11614 SQLITE_PRIVATE char *sqlite3Utf16to8(sqlite3 *, const void*, int, u8);
11616 SQLITE_PRIVATE char *sqlite3Utf8to16(sqlite3 *, u8, char *, int, int *);
11618 SQLITE_PRIVATE int sqlite3ValueFromExpr(sqlite3 *, Expr *, u8, u8, sqlite3_value **);
11619 SQLITE_PRIVATE void sqlite3ValueApplyAffinity(sqlite3_value *, u8, u8);
11646 SQLITE_PRIVATE CollSeq *sqlite3GetCollSeq(sqlite3*, u8, CollSeq *, const char*);
11678 SQLITE_PRIVATE void sqlite3BackupUpdate(sqlite3_backup *, Pgno, const u8 *);
11698 SQLITE_PRIVATE void sqlite3TableLock(Parse *, int, int, u8, const char *);
11824 SQLITE_PRIVATE u32 sqlite3Get4byte(const u8*);
11825 SQLITE_PRIVATE void sqlite3Put4byte(u8*, u32);
11884 SQLITE_PRIVATE void sqlite3MemdebugSetType(void*,u8);
11885 SQLITE_PRIVATE int sqlite3MemdebugHasType(void*,u8);
11886 SQLITE_PRIVATE int sqlite3MemdebugNoType(void*,u8);
11927 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
11928 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
11929 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 97, 98, 99,100,101,102,103,
11931 122, 91, 92, 93, 94, 95, 96, 97, 98, 99,100,101,102,103,104,105,106,107,
11944 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, /* 1x */
11945 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, /* 2x */
11946 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, /* 3x */
11947 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, /* 4x */
11948 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, /* 5x */
11949 96, 97, 66, 67, 68, 69, 70, 71, 72, 73,106,107,108,109,110,111, /* 6x */
11950 112, 81, 82, 83, 84, 85, 86, 87, 88, 89,122,123,124,125,126,127, /* 7x */
11995 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, /* 08..0f ........ */
11997 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 18..1f ........ */
11999 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 28..2f ()*+,-./ */
12001 0x0c, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 38..3f 89:;<=>? */
12004 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, /* 48..4f HIJKLMNO */
12006 0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x40, /* 58..5f XYZ[\]^_ */
12008 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, /* 68..6f hijklmno */
12010 0x22, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, /* 78..7f xyz{|}~. */
12013 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* 88..8f ........ */
12015 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* 98..9f ........ */
12017 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* a8..af ........ */
12019 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* b8..bf ........ */
12022 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* c8..cf ........ */
12024 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* d8..df ........ */
12026 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* e8..ef ........ */
12028 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40 /* f8..ff ........ */
12529 ** 2008 June 18
12631 u8 *aRow; /* Data for the current row, if all on one page */
12674 #define VdbeFrameMem(p) ((Mem *)&((u8 *)p)[ROUND8(sizeof(VdbeFrame))])
12699 u8 type; /* One of SQLITE_NULL, SQLITE_TEXT, SQLITE_INTEGER, etc */
12700 u8 enc; /* SQLITE_UTF8, SQLITE_UTF16BE, SQLITE_UTF16LE */
12843 u8 errorAction; /* Recovery action to do in case of an error */
12844 u8 explain; /* True if EXPLAIN present on SQL command */
12845 u8 changeCntOn; /* True to update the change-counter */
12846 u8 expired; /* True if the VM needs to be recompiled */
12847 u8 runOnlyOnce; /* Automatically expire on reset */
12848 u8 minWriteFileFormat; /* Minimum file format for writable database files */
12849 u8 inVtabMethod; /* See comments above */
12850 u8 usesStmtJournal; /* True if uses a statement journal */
12851 u8 readOnly; /* True for read-only statements */
12852 u8 isPrepareV2; /* True if prepared with prepare_v2() */
12911 SQLITE_PRIVATE int sqlite3VdbeMemSetStr(Mem*, const char*, int, u8, void(*)(void*));
12979 SQLITE_PRIVATE int sqlite3VdbeMemTranslate(Mem*, u8);
13479 while( sqlite3Isspace(*zDate) || 'T'==*(u8*)zDate ){ zDate++; }
13753 z[n] = (char)sqlite3UpperToLower[(u8)zMod[n]];
14759 ** 2008 October 28
15029 u8 nTitle; /* Bytes of title; includes '\0' */
15030 u8 eType; /* Allocation type code */
15124 u8 *pU8;
15132 pU8 = (u8*)pAllocation;
15350 SQLITE_PRIVATE void sqlite3MemdebugSetType(void *p, u8 eType){
15368 SQLITE_PRIVATE int sqlite3MemdebugHasType(void *p, u8 eType){
15390 SQLITE_PRIVATE int sqlite3MemdebugNoType(void *p, u8 eType){
16286 u8 *zPool; /* Memory available to be allocated */
16316 u8 *aCtrl;
16393 int i = ((u8 *)p-mem5.zPool)/mem5.szAtom;
16498 iBlock = ((u8 *)pOld-mem5.zPool)/mem5.szAtom;
16502 assert( ((u8 *)pOld-mem5.zPool)%mem5.szAtom==0 );
16646 u8 *zByte; /* Memory usable by this allocator */
16661 zByte = (u8*)sqlite3GlobalConfig.pHeap;
16671 mem5.nBlock = (nByte / (mem5.szAtom+sizeof(u8)));
16673 mem5.aCtrl = (u8 *)&mem5.zPool[mem5.nBlock*mem5.szAtom];
17137 ** 2007 August 28
17413 ** 2007 August 28
17810 ** API as long as we don't call it win running Win95/98/ME. A call to
17811 ** this routine is used to determine if the host is Win95/98/ME or
18921 ** argument. For example, printf("%.78'-") prints 78 minus
18922 ** signs, the same as printf("%.78c",'-').
19374 while( realvalue>=1e8 && exp<=350 ){ realvalue *= 1e-8; exp+=8; }
19376 while( realvalue<1e-8 ){ realvalue *= 1e8; exp-=8; }
19953 static u8 randomByte(void){
19987 wsdPrng.s[i] = (u8)i;
20119 *zOut++ = (u8)(c&0xFF); \
20122 *zOut++ = 0xC0 + (u8)((c>>6)&0x1F); \
20123 *zOut++ = 0x80 + (u8)(c & 0x3F); \
20126 *zOut++ = 0xE0 + (u8)((c>>12)&0x0F); \
20127 *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); \
20128 *zOut++ = 0x80 + (u8)(c & 0x3F); \
20130 *zOut++ = 0xF0 + (u8)((c>>18) & 0x07); \
20131 *zOut++ = 0x80 + (u8)((c>>12) & 0x3F); \
20132 *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); \
20133 *zOut++ = 0x80 + (u8)(c & 0x3F); \
20139 *zOut++ = (u8)(c&0x00FF); \
20140 *zOut++ = (u8)((c>>8)&0x00FF); \
20142 *zOut++ = (u8)(((c>>10)&0x003F) + (((c-0x10000)>>10)&0x00C0)); \
20143 *zOut++ = (u8)(0x00D8 + (((c-0x10000)>>18)&0x03)); \
20144 *zOut++ = (u8)(c&0x00FF); \
20145 *zOut++ = (u8)(0x00DC + ((c>>8)&0x03)); \
20151 *zOut++ = (u8)((c>>8)&0x00FF); \
20152 *zOut++ = (u8)(c&0x00FF); \
20154 *zOut++ = (u8)(0x00D8 + (((c-0x10000)>>18)&0x03)); \
20155 *zOut++ = (u8)(((c>>10)&0x003F) + (((c-0x10000)>>10)&0x00C0)); \
20156 *zOut++ = (u8)(0x00DC + ((c>>8)&0x03)); \
20157 *zOut++ = (u8)(c&0x00FF); \
20257 SQLITE_PRIVATE int sqlite3VdbeMemTranslate(Mem *pMem, u8 desiredEnc){
20284 u8 temp;
20291 zIn = (u8*)pMem->z;
20327 zIn = (u8*)pMem->z;
20339 /* c = sqlite3Utf8Read(zIn, zTerm, (const u8**)&zIn); */
20347 /* c = sqlite3Utf8Read(zIn, zTerm, (const u8**)&zIn); */
20403 u8 bom = 0;
20407 u8 b1 = *(u8 *)pMem->z;
20408 u8 b2 = *(((u8 *)pMem->z) + 1);
20441 const u8 *z = (const u8*)zIn;
20442 const u8 *zTerm;
20446 zTerm = (const u8*)(-1);
20475 c = sqlite3Utf8Read(zIn, (const u8**)&zIn);
20493 SQLITE_PRIVATE char *sqlite3Utf16to8(sqlite3 *db, const void *z, int nByte, u8 enc){
20521 SQLITE_PRIVATE char *sqlite3Utf8to16(sqlite3 *db, u8 enc, char *z, int n, int *pnOut){
20580 c = sqlite3Utf8Read(z, (const u8**)&z);
20877 SQLITE_PRIVATE int sqlite3AtoF(const char *z, double *pResult, int length, u8 enc){
21045 for(i=0; c==0 && i<18; i++){
21049 c = zNum[18*incr] - '8';
21075 SQLITE_PRIVATE int sqlite3Atoi64(const char *zNum, i64 *pNum, int length, u8 enc){
21105 testcase( i==18 );
21200 ** 28 bits - BBBA
21220 u8 buf[10];
21222 p[8] = (u8)v;
21225 p[i] = (u8)((v & 0x7f) | 0x80);
21232 buf[n++] = (u8)((v & 0x7f) | 0x80);
21259 p[0] = (u8)((v>>7) | 0x80);
21260 p[1] = (u8)(v & 0x7f);
21273 ** SLOT_4_2_0 A mask for (0x7f<<28) | SLOT_2_0
21283 SQLITE_PRIVATE u8 sqlite3GetVarint(const unsigned char *p, u64 *v){
21308 assert( SLOT_4_2_0 == ((0xfU<<28) | (0x7f<<14) | (0x7f)) );
21353 /* a: p0<<28 | p2<<14 | p4 (unmasked) */
21357 /* a &= (0x7f<<28)|(0x7f<<14)|(0x7f); */
21361 s = s>>18;
21374 /* b: p1<<28 | p3<<14 | p5 (unmasked) */
21378 /* b &= (0x7f<<28)|(0x7f<<14)|(0x7f); */
21382 s = s>>18;
21390 /* a: p2<<28 | p4<<14 | p6 (unmasked) */
21407 /* b: p3<<28 | p5<<14 | p7 (unmasked) */
21423 /* a: p4<<29 | p6<<15 | p8 (unmasked) */
21453 SQLITE_PRIVATE u8 sqlite3GetVarint32(const unsigned char *p, u32 *v){
21509 u8 n;
21544 /* a: p0<<28 | p2<<14 | p4 (unmasked) */
21561 u8 n;
21589 SQLITE_PRIVATE u32 sqlite3Get4byte(const u8 *p){
21593 p[0] = (u8)(v>>24);
21594 p[1] = (u8)(v>>16);
21595 p[2] = (u8)(v>>8);
21596 p[3] = (u8)v;
21606 SQLITE_PRIVATE u8 sqlite3HexToInt(int h){
21614 return (u8)(h & 0xf);
22100 /* 18 */ "Function",
22110 /* 28 */ "IfNot",
22120 /* 38 */ "VerifyCookie",
22130 /* 48 */ "SeekGe",
22140 /* 58 */ "InsertInt",
22150 /* 68 */ "Or",
22160 /* 78 */ "Le",
22170 /* 88 */ "Multiply",
22180 /* 98 */ "IdxDelete",
23246 u8 id; /* Id of this connection with its os2ShmNode */
23310 OSTRACE(("SHM-LOCK %d %s %s 0x%08lx\n",
24472 ** on 2008-11-28.) These days, all Linux kernels support large files, so
28195 u8 isReadonly; /* True if read-only */
28200 u8 exclMask; /* Mask of exclusive locks held */
28201 u8 sharedMask; /* Mask of shared locks held */
28202 u8 nextShmId; /* Next available unixShm.id value */
28222 u8 hasMutex; /* True if holding the unixShmNode mutex */
28223 u8 id; /* Id of this connection within its unixShmNode */
31330 assert( ArraySize(aSyscall)==18 );
31665 u8 locktype; /* Type of lock currently held on this file */
31667 u8 bPersistWal; /* True to persist WAL files */
31785 ** API as long as we don't call it when running Win95/98/ME. A call to
31786 ** this routine is used to determine if the host is Win95/98/ME or
32731 u8 *aRem = (u8 *)pBuf; /* Data yet to be written */
33085 pFile->locktype = (u8)newLocktype;
33153 pFile->locktype = (u8)locktype;
33319 u8 nextShmId; /* Next available winShm.id value */
33346 u8 hasMutex; /* True if holding the winShmNode mutex */
33350 u8 id; /* Id of this connection with its winShmNode */
33400 OSTRACE(("SHM-LOCK %d %s %s 0x%08lx\n",
34815 #define BITVEC_TELEM u8
35881 u8 *aData; /* Pointer to data block */
35998 ( *(PGroupBlock **)&(((u8*)pPg)[sizeof(PgHdr1) + pCache->szPage]) = pBlock )
36001 ( *(PGroupBlock **)&(((u8*)pPg)[sizeof(PgHdr1) + pCache->szPage]) )
36227 pBlock->aData = (u8 *)&pBlock[1];
36296 int i = ((u8 *)pPg - pBlock->aData) / pList->nByte;
37097 u8 isSorted; /* True if pEntry is sorted */
37098 u8 iBatch; /* Current insert batch */
37387 SQLITE_PRIVATE int sqlite3RowSetTest(RowSet *pRowSet, u8 iBatch, sqlite3_int64 iRowid){
37485 SQLITE_PRIVATE int sqlite3WalClose(Wal *pWal, int sync_flags, int, u8 *);
37501 SQLITE_PRIVATE int sqlite3WalRead(Wal *pWal, Pgno pgno, int *pInWal, int nOut, u8 *pOut);
37532 u8 *zBuf, /* Temporary buffer to use */
38093 ** 28 of the database header by the btree). If the size of the file
38148 u8 exclusiveMode; /* Boolean. True if locking_mode==EXCLUSIVE */
38149 u8 journalMode; /* One of the PAGER_JOURNALMODE_* values */
38150 u8 useJournal; /* Use a rollback journal on this file */
38151 u8 noReadlock; /* Do not bother to obtain readlocks */
38152 u8 noSync; /* Do not sync the journal if true */
38153 u8 fullSync; /* Do extra syncs of the journal for robustness */
38154 u8 ckptSyncFlags; /* SYNC_NORMAL or SYNC_FULL for checkpoint */
38155 u8 syncFlags; /* SYNC_NORMAL or SYNC_FULL otherwise */
38156 u8 tempFile; /* zFilename is a temporary file */
38157 u8 readOnly; /* True for a read-only database */
38158 u8 memDb; /* True to inhibit all file I/O */
38169 u8 eState; /* Pager state (OPEN, READER, WRITER_LOCKED..) */
38170 u8 eLock; /* Current lock held on database file */
38171 u8 changeCountDone; /* Set after incrementing the change-counter */
38172 u8 setMaster; /* True if a m-j name has been written to jrnl */
38173 u8 doNotSpill; /* Do not spill the cache when non-zero */
38174 u8 doNotSyncSpill; /* Do not do a spill that requires jrnl sync */
38175 u8 subjInMemory; /* True to use in-memory sub-journals */
38567 #define put32bits(A,B) sqlite3Put4byte((u8*)A,B)
38599 pPager->eLock = (u8)eLock;
38623 pPager->eLock = (u8)eLock;
38812 ** zero the 28-byte header at the start of the journal file. In either case,
38835 static const char zeroHdr[28] = {0};
38872 ** Followed by (JOURNAL_HDR_SZ - 28) bytes of unused space.
38948 /* In theory, it is only necessary to write the 28 bytes that the
38957 ** (JOURNAL_HDR_SZ - 28) bytes that will not be used. So that is what
39396 ** The first 28 bytes of the journal file are zeroed. This invalidates
39570 static u32 pager_cksum(Pager *pPager, const u8 *aData){
39673 rc = sqlite3OsRead(jfd, (u8*)aData, pPager->pageSize, (*pOffset)+4);
39692 if( !isSavepnt && pager_cksum(pPager, (u8*)aData)!=cksum ){
39706 if( pgno==1 && pPager->nReserve!=((u8*)aData)[20] ){
39707 pPager->nReserve = ((u8*)aData)[20];
39753 PAGERTRACE(("PLAYBACK %d page %d hash(%08x) %s\n",
39754 PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, (u8*)aData),
39769 rc = sqlite3OsWrite(pPager->fd, (u8*)aData, pPager->pageSize, ofst);
39775 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)aData);
39814 memcpy(pData, (u8*)aData, pPager->pageSize);
39844 memcpy(&pPager->dbFileVers, &((u8*)pData)[24],sizeof(pPager->dbFileVers));
39912 pJournal = (sqlite3_file *)(((u8 *)pMaster) + pVfs->szOsFile);
40363 ** of bytes 24..39 of the database. Bytes 28..31 should always be
40375 u8 *dbFileVers = &((u8*)pPg->pData)[24];
40384 PAGERTRACE(("FETCH %d page %d hash(%08x)\n",
40402 change_counter = sqlite3Get4byte((u8*)pPg->pPager->dbFileVers)+1;
40531 sqlite3BackupUpdate(pPager->pBackup, p->pgno, (u8 *)p->pData);
41276 u8 *pTmp = (u8 *)pPager->pTmpSpace;
41420 u8 aMagic[8];
41421 u8 zHeader[sizeof(aJournalMagic)+4];
41429 static const u8 zerobyte = 0;
41584 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)pList->pData);
41586 PAGERTRACE(("STORE %d page %d hash(%08x)\n",
41826 u8 *pPtr;
41913 pPtr = (u8 *)sqlite3MallocZero(
42041 pPager->useJournal = (u8)useJournal;
42055 pPager->tempFile = (u8)tempFile;
42059 pPager->exclusiveMode = (u8)tempFile;
42061 pPager->memDb = (u8)memDb;
42062 pPager->readOnly = (u8)readOnly;
42182 u8 first = 0;
42755 pPager->subjInMemory = (u8)subjInMemory;
42890 cksum = pager_cksum(pPager, (u8*)pData2);
42911 PAGERTRACE(("JOURNAL %d page %d needSync=%d hash(%08x)\n",
43290 ** Ticket [2d1a5c67dfc2363e44f29d9bbd57f] 2011-05-18 */
43570 SQLITE_PRIVATE u8 sqlite3PagerIsreadonly(Pager *pPager){
44013 pPager->exclusiveMode = (u8)eMode;
44039 u8 eOld = pPager->journalMode; /* Prior journalmode */
44076 pPager->journalMode = (u8)eMode;
44187 pPager->ckptSyncFlags, pPager->pageSize, (u8 *)pPager->pTmpSpace,
44343 pPager->pageSize, (u8*)pPager->pTmpSpace);
44414 ** 28: Checksum-2 (second part of checksum for first 24 bytes of header).
44673 u8 isInit; /* 1 when initialized */
44674 u8 bigEndCksum; /* True if checksums in WAL are big-endian */
44789 u8 exclusiveMode; /* Non-zero if connection is in exclusive mode */
44790 u8 writeLock; /* True if in a write transaction */
44791 u8 ckptLock; /* True if holding a checkpoint lock */
44792 u8 readOnly; /* WAL_RDWR, WAL_RDONLY, or WAL_SHM_RDONLY */
44797 u8 lockError; /* True if a locking error has occurred */
44959 u8 *a, /* Content to be checksummed */
45013 walChecksumBytes(1, (u8*)&pWal->hdr, nCksum, 0, pWal->hdr.aCksum);
45036 u8 *aData, /* Pointer to page data */
45037 u8 *aFrame /* OUT: Write encoded frame here */
45063 u8 *aData, /* Pointer to page data (for checksum) */
45064 u8 *aFrame /* Frame data */
45145 VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && rc!=SQLITE_BUSY); )
45161 VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && rc!=SQLITE_BUSY); )
45357 int nByte = (int)((u8 *)&aHash[HASHTABLE_NSLOT] - (u8 *)&aPgno[1]);
45456 u8 aBuf[WAL_HDRSIZE]; /* Buffer to load WAL header into */
45457 u8 *aFrame = 0; /* Malloc'd buffer to load entire frame */
45459 u8 *aData; /* Pointer to data part of aFrame buffer */
45486 pWal->hdr.bigEndCksum = (u8)(magic&0x00000001);
45496 || pWal->hdr.aFrameCksum[1]!=sqlite3Get4byte(&aBuf[28])
45511 aFrame = (u8 *)sqlite3_malloc(szFrame);
46016 u8 *zBuf /* Temporary buffer to use */
46160 u8 *zBuf /* Buffer of at least nBuf bytes */
46247 walChecksumBytes(1, (u8*)&h1, sizeof(h1)-sizeof(h1.aCksum), 0, aCksum);
46621 u8 *pOut /* Buffer to write page data to */
46946 sqlite3Put4byte((u8*)&aSalt[0], 1 + sqlite3Get4byte((u8*)&aSalt[0]));
46986 u8 aFrame[WAL_FRAME_HDRSIZE]; /* Buffer to assemble frame-header in */
47014 u8 aWalHdr[WAL_HDRSIZE]; /* Buffer to assemble wal-header in */
47025 sqlite3Put4byte(&aWalHdr[28], aCksum[1]);
47158 u8 *zBuf, /* Temporary buffer to use */
47403 ** 18 1 File format write version
47410 ** 28 4 Reserved for future use
47417 ** 48 4 Size of page cache
47422 ** 68 4 unused
47615 u8 isInit; /* True if previously initialized. MUST BE FIRST! */
47616 u8 nOverflow; /* Number of overflow cell bodies in aCell[] */
47617 u8 intKey; /* True if intkey flag is set */
47618 u8 leaf; /* True if leaf flag is set */
47619 u8 hasData; /* True if this page stores data */
47620 u8 hdrOffset; /* 100 for page 1. 0 otherwise */
47621 u8 childPtrSize; /* 0 if leaf==1. 4 if leaf==0 */
47629 u8 *pCell; /* Pointers to the body of the overflow cell */
47633 u8 *aData; /* Pointer to disk image of the page data */
47655 u8 eLock; /* READ_LOCK or WRITE_LOCK */
47687 u8 inTrans; /* TRANS_NONE, TRANS_READ or TRANS_WRITE */
47688 u8 sharable; /* True if we can share pBt with another db */
47689 u8 locked; /* True if db currently has pBt locked */
47750 u8 readOnly; /* True if the underlying file is readonly */
47751 u8 pageSizeFixed; /* True if the page size can no longer be changed */
47752 u8 secureDelete; /* True if secure_delete is enabled */
47753 u8 initiallyEmpty; /* Database is empty at start of transaction */
47754 u8 openFlags; /* Flags to sqlite3BtreeOpen() */
47756 u8 autoVacuum; /* True if auto-vacuum is enabled */
47757 u8 incrVacuum; /* True if incr-vacuum is enabled */
47759 u8 inTransaction; /* Transaction state */
47760 u8 doNotUseWAL; /* If true, do not open write-ahead-log file */
47778 u8 isExclusive; /* True if pWriter has an EXCLUSIVE lock on the db */
47779 u8 isPending; /* If waiting for read-locks to clear */
47781 u8 *pTmpSpace; /* BtShared.pageSize bytes of space for tmp use */
47792 u8 *pCell; /* Pointer to the start of cell content */
47837 u8 wrFlag; /* True if writable */
47838 u8 atLast; /* Cursor pointing to the last entry */
47839 u8 validNKey; /* True if info.nKey is valid */
47840 u8 eState; /* One of the CURSOR_XXX constants (see below) */
47843 u8 isIncrblobHandle; /* True if this cursor is an incr. io handle */
47983 #define put2byte(p,v) ((p)[0] = (u8)((v)>>8), (p)[1] = (u8)(v))
48481 static int querySharedCacheTableLock(Btree *p, Pgno iTab, u8 eLock){
48553 static int setSharedCacheTableLock(Btree *p, Pgno iTable, u8 eLock){
49024 static void ptrmapPut(BtShared *pBt, Pgno key, u8 eType, Pgno parent, int *pRC){
49026 u8 *pPtrmap; /* The pointer map data */
49054 pPtrmap = (u8 *)sqlite3PagerGetData(pDbPage);
49076 static int ptrmapGet(BtShared *pBt, Pgno key, u8 *pEType, Pgno *pPgno){
49079 u8 *pPtrmap; /* Pointer map page data */
49090 pPtrmap = (u8 *)sqlite3PagerGetData(pDbPage);
49129 static u8 *findOverflowCell(MemPage *pPage, int iCell){
49158 u8 *pCell, /* Pointer to the cell text. */
49238 static u16 cellSizePtr(MemPage *pPage, u8 *pCell){
49239 u8 *pIter = &pCell[pPage->childPtrSize];
49252 u8 *pEnd;
49305 static void ptrmapPutOvflPtr(MemPage *pPage, u8 *pCell, int *pRC){
49358 u8 *pAddr; /* The i-th cell pointer */
49417 u8 * const data = pPage->aData; /* Local cache of pPage->aData */
49467 data[hdr+7] = (u8)(nFrag + x);
49573 data[hdr+7] -= (u8)frag;
49612 pPage->leaf = (u8)(flagByte>>3); assert( PTF_LEAF == 1<<3 );
49651 u8 hdr; /* Offset to beginning of page header */
49652 u8 *data; /* Equal to pPage->aData */
49754 u8 hdr = pPage->hdrOffset;
49972 u8 nReserve; /* Byte of unused space on each page */
50099 pBt->openFlags = (u8)flags;
50511 u8 av = (u8)autoVacuum;
50572 nPage = nPageHeader = get4byte(28+(u8*)pPage1->aData);
50574 if( nPage==0 || memcmp(24+(u8*)pPage1->aData, 92+(u8*)pPage1->aData,4)!=0 ){
50580 u8 *page1 = pPage1->aData;
50587 if( page1[18]>1 ){
50594 if( page1[18]>2 ){
50738 data[16] = (u8)((pBt->pageSize>>8)&0xff);
50739 data[17] = (u8)((pBt->pageSize>>16)&0xff);
50740 data[18] = 1;
50743 data[20] = (u8)(pBt->pageSize - pBt->usableSize);
50847 pBt->initiallyEmpty = (u8)(pBt->nPage==0);
50896 pBt->isExclusive = (u8)(wrflag>1);
50905 if( pBt->nPage!=get4byte(&pPage1->aData[28]) ){
50908 put4byte(&pPage1->aData[28], pBt->nPage);
50941 u8 isInitOrig = pPage->isInit;
50952 u8 *pCell = findCell(pPage, i);
50986 static int modifyPagePointer(MemPage *pPage, Pgno iFrom, Pgno iTo, u8 eType){
50996 u8 isInitOrig = pPage->isInit;
51004 u8 *pCell = findCell(pPage, i);
51049 u8 eType, /* Pointer map 'type' entry for pDbPage */
51120 static int allocateBtreePage(BtShared *, MemPage **, Pgno *, Pgno, u8);
51148 u8 eType;
51262 put4byte(&pBt->pPage1->aData[28], pBt->nPage);
51322 put4byte(&pBt->pPage1->aData[28], nFin);
51586 int nPage = get4byte(28+(u8*)pPage1->aData);
51662 pBt->nPage = get4byte(28 + pBt->pPage1->aData);
51664 /* The database size was written into the offset 28 of the header
51666 ** 28 is nonzero. */
51745 pCur->wrFlag = (u8)wrFlag;
51999 u8 eType;
52744 u8 *pCell; /* Pointer to current cell in pPage */
52793 u8 * const pCellBody = pCell - pPage->childPtrSize;
53027 u8 exact
53048 u8 searchList = 0; /* If the free-list must be searched for 'nearby' */
53056 u8 eType;
53258 put4byte(28 + (u8*)pBt->pPage1->aData, pBt->nPage);
53515 const u8 *pSrc;
53594 u8 eType = (pgnoPtrmap?PTRMAP_OVERFLOW2:PTRMAP_OVERFLOW1);
53666 u8 *data; /* pPage->aData */
53667 u8 *ptr; /* Used to move bytes around within data[] */
53668 u8 *endPtr; /* End of loop */
53724 u8 *pCell, /* Content of the new cell */
53726 u8 *pTemp, /* Temp storage space for pCell, if needed */
53735 u8 *data; /* The content of the whole page */
53736 u8 *ptr; /* Used for moving information around in data[] */
53737 u8 *endPtr; /* End of the loop */
53815 u8 **apCell, /* Pointers to cell bodies */
53819 u8 *pCellptr; /* Address of next cell pointer */
53821 u8 * const data = pPage->aData; /* Pointer to data for pPage */
53890 static int balance_quick(MemPage *pParent, MemPage *pPage, u8 *pSpace){
53911 u8 *pOut = &pSpace[4];
53912 u8 *pCell = pPage->aOvfl[0].pCell;
53914 u8 *pStop;
53981 u8 e;
53988 u8 *z;
54033 u8 * const aFrom = pFrom->aData;
54034 u8 * const aTo = pTo->aData;
54114 u8 *aOvflSpace, /* page-size bytes of space for parent ovfl */
54136 u8 *pRight; /* Location in parent of right-sibling pointer */
54137 u8 *apDiv[NB-1]; /* Divider cells in pParent */
54140 u8 **apCell = 0; /* All cells begin balanced */
54142 u8 *aSpace1; /* Space for copies of dividers cells */
54252 nMaxCells*sizeof(u8*) /* apCell */
54262 aSpace1 = (u8*)&szCell[nMaxCells];
54304 u8 *aData = pOld->aData;
54316 u8 *pTemp;
54524 u8 *pCell;
54525 u8 *pTemp;
54579 u8 *zChild = &apCopy[nOld-1]->aData[8];
54805 u8 aBalanceQuickSpace[13];
54806 u8 *pFree = 0;
54883 u8 *pSpace = sqlite3PageMalloc(pCur->pBt->pageSize);
55262 u8 eType = 0;
55611 pBt->incrVacuum = (u8)iMeta;
55762 u8 eType, /* Expected pointer map type */
55767 u8 ePtrmapType;
55886 u8 *data;
55923 u8 *pCell;
56330 SQLITE_PRIVATE int sqlite3BtreeLockTable(Btree *p, int iTab, u8 isWriteLock){
56334 u8 lockType = READ_LOCK + isWriteLock;
56412 ** Set both the "read version" (single byte at byte offset 18) and
56425 pBt->doNotUseWAL = (u8)(iVersion==1);
56429 u8 *aData = pBt->pPage1->aData;
56430 if( aData[18]!=(u8)iVersion || aData[19]!=(u8)iVersion ){
56435 aData[18] = (u8)iVersion;
56436 aData[19] = (u8)iVersion;
56449 ** 2009 January 28
56661 static int backupOnePage(sqlite3_backup *p, Pgno iSrcPg, const u8 *zSrcData){
56718 const u8 *zIn = &zSrcData[iOff%nSrcPgsz];
56719 u8 *zDestData = sqlite3PagerGetData(pDestPg);
56720 u8 *zOut = &zDestData[iOff%nDestPgsz];
56730 ((u8 *)sqlite3PagerGetExtra(pDestPg))[0] = 0;
56935 u8 *zData = sqlite3PagerGetData(pSrcPg);
57065 SQLITE_PRIVATE void sqlite3BackupUpdate(sqlite3_backup *pBackup, Pgno iPage, const u8 *aData){
57207 rc = sqlite3VdbeMemTranslate(pMem, (u8)desiredEnc);
57837 u8 enc, /* Encoding of z. 0 for BLOBs */
58102 SQLITE_PRIVATE const void *sqlite3ValueText(sqlite3_value* pVal, u8 enc){
58164 u8 enc, /* Encoding to use */
58165 u8 affinity, /* Affinity to use */
58275 u8 enc, /* Encoding to use */
58294 SQLITE_PRIVATE int sqlite3ValueBytes(sqlite3_value *pVal, u8 enc){
58366 p->isPrepareV2 = (u8)isPrepareV2;
58457 pOp->opcode = (u8)op;
58724 u8 opcode = pOp->opcode;
58870 SQLITE_PRIVATE void sqlite3VdbeChangeP5(Vdbe *p, u8 val){
59052 u8 *aSortOrder;
59374 u8 malloc_failed = db->mallocFailed;
59693 u8 **ppFrom, /* IN/OUT: Allocate from *ppFrom */
59694 u8 *pEnd, /* Pointer to 1 byte past the end of *ppFrom buffer */
59777 u8 *zCsr; /* Memory available for allocation */
59778 u8 *zEnd; /* First byte past allocated memory */
59806 zCsr = (u8*)&p->aOp[p->nOp]; /* Memory avaliable for allocation */
59807 zEnd = (u8*)&p->aOp[p->nOpAlloc]; /* First byte past end of zCsr[] */
59810 p->usesStmtJournal = (u8)(pParse->isMultiWrite && pParse->mayAbort);
59815 zCsr += (zCsr - (u8*)0)&7;
60137 zMaster = sqlite3MPrintf(db, "%s-mj%08X", zMainFile, iRandom&0x7fffffff);
60916 static const u8 aSize[] = { 0, 1, 2, 3, 4, 6, 8, 8, 0, 0, 0, 0 };
60942 ** (2007-08-30) Frank van Vugt has studied this problem closely
60946 ** 48-bits as required by the IEEE standard. (This is the
60992 SQLITE_PRIVATE u32 sqlite3VdbeSerialPut(u8 *buf, int nBuf, Mem *pMem, int file_format){
61010 buf[i] = (u8)(v&0xFF);
61382 (void)getVarint32((u8*)m.z, szHdr);
61391 (void)getVarint32((u8*)&m.z[szHdr-1], typeRowid);
61410 sqlite3VdbeSerialGet((u8*)&m.z[m.n-lenRowid], typeRowid, &v);
61514 SQLITE_PRIVATE sqlite3_value *sqlite3VdbeGetValue(Vdbe *v, int iVar, u8 aff){
61740 u8 enc, /* Encoding of z. 0 for BLOBs */
62582 u8 encoding /* Encoding for the data */
62885 n = sqlite3GetToken((u8*)zSql, &tokenType);
62976 u8 enc = ENC(db);
63267 u8 enc = pRec->enc;
63301 u8 enc /* Use this text encoding */
63343 u8 affinity,
63344 u8 enc
63417 u8 c = pMem->z[j];
63656 u8 resetSchemaOnFault = 0; /* Reset schema after an error if positive */
63657 u8 encoding = ENC(db); /* The database encoding */
63720 u8 op;
63761 u8 *zIdx; /* Index into header */
63762 u8 *zEndHdr; /* Pointer to first byte after the header */
63775 u8 *zNewRecord; /* A buffer to hold the data for the new record */
64375 p->errorAction = (u8)pOp->p2;
65022 u8 op;
65671 u8 *zIdx; /* Index into header */
65672 u8 *zEndHdr; /* Pointer to first byte after the header */
65790 u.am.pC->aRow = (u8*)u.am.zData;
65798 u.am.szHdr = getVarint32((u8*)u.am.zData, u.am.offset);
65845 u.am.zEndHdr = (u8 *)&u.am.zData[u.am.len];
65846 u.am.zIdx = (u8 *)&u.am.zData[u.am.szHdr];
65905 sqlite3VdbeSerialGet((u8 *)&u.am.zRec[u.am.aOffset[u.am.p2]], u.am.aType[u.am.p2], u.am.pDest);
65914 sqlite3VdbeSerialGet((u8*)u.am.zData, u.am.aType[u.am.p2], u.am.pDest);
65993 u8 *zNewRecord; /* A buffer to hold the data for the new record */
66083 u.ao.zNewRecord = (u8 *)pOut->z;
66347 db->autoCommit = (u8)u.ar.desiredAutoCommit;
66350 db->autoCommit = (u8)(1-u.ar.desiredAutoCommit);
66510 u.au.pDb->pSchema->file_format = (u8)pIn3->u.i;
67906 u.bn.pC->nullRow = (u8)u.bn.res;
67972 u.bo.pC->nullRow = (u8)u.bo.res;
68042 u.bp.pC->nullRow = (u8)u.bp.res;
68654 (u8)(u.ca.iSet>=0 ? u.ca.iSet & 0xf : 0xff),
69235 u8 isWriteLock = (u8)pOp->p3;
69590 u8 vtabOnConflict = db->vtabOnConflict;
70396 u8 *aAlloc; /* Allocated space */
70398 u8 *aKey; /* Pointer to current key */
70492 u8 aVarint[9]; /* Buffer large enough for a varint */
70519 u8 aVarint[9]; /* Buffer large enough for a varint */
70551 pIter->aAlloc = (u8 *)sqlite3DbMallocRaw(db, pIter->nAlloc);
71446 u8 zChunk[JOURNAL_CHUNKSIZE]; /* Content of this chunk */
71480 u8 *zOut = zBuf;
71526 u8 *zWrite = (u8 *)zBuf;
71803 ** 2008 August 18
72323 u8 enc = ENC(pParse->db); /* The database encoding */
72472 u8 savedSuppErr; /* Saved value of db->suppressErr */
73217 static u8 binaryCompareP5(Expr *pExpr1, Expr *pExpr2, int jumpIfNull){
73218 u8 aff = (char)sqlite3ExprAffinity(pExpr2);
73219 aff = (u8)sqlite3CompareAffinity(pExpr1, aff) | (u8)jumpIfNull;
73277 sqlite3VdbeChangeP5(pParse->pVdbe, (u8)p5);
73417 pNew->op = (u8)op;
73766 static Expr *exprDup(sqlite3 *db, Expr *p, int flags, u8 **pzBuffer){
73770 u8 *zAlloc;
74269 u8 op;
74313 u8 op;
74671 dest.affinity = (u8)affinity;
75554 u8 enc = ENC(db); /* The text encoding used by this database */
75636 sqlite3VdbeChangeP5(v, (u8)nFarg);
76645 u8 enc = ENC(pParse->db);
76857 zRet = sqlite3MPrintf(db, "%.*s\"%w\"%s", ((u8*)tname.z) - zSql, zSql,
76996 zRet = sqlite3MPrintf(db, "%.*s\"%w\"%s", ((u8*)tname.z) - zSql, zSql,
77308 "'sqlite_autoindex_' || %Q || substr(name,%d+18) "
77656 u8 aCreateTbl[] = {0, 0};
78284 pSample->eType = (u8)eType;
78297 pSample->nByte = (u8)n;
78681 sqlite3VdbeChangeP5(v, (u8)(pFunc->nArg));
79168 pParse->explain = (u8)explainFlag;
79180 u8 isWriteLock; /* True for write lock. False for a read lock */
79198 u8 isWriteLock, /* True for a write lock */
80133 p->aCol[p->nCol-1].notNull = (u8)onError;
80310 pTab->keyConf = (u8)onError;
80408 u8 enc = ENC(db);
80409 u8 initbusy = db->init.busy;
80931 u8 enableLookaside = db->lookaside.bEnabled;
81402 pFKey->aAction[0] = (u8)(flags & 0xff); /* ON DELETE action */
81403 pFKey->aAction[1] = (u8)((flags >> 8 ) & 0xff); /* ON UPDATE action */
81444 pFKey->isDeferred = (u8)isDeferred;
81753 pList->a[0].sortOrder = (u8)sortOrder;
81781 sizeof(u8)*nCol + /* Index.aSortOrder */
81791 pIndex->aSortOrder = (u8 *)(&pIndex->aiRowEst[nCol+1]);
81797 pIndex->onError = (u8)onError;
81798 pIndex->autoIndex = (u8)(pName==0);
81861 pIndex->aSortOrder[i] = (u8)requestedSortOrder;
82921 pKey->aSortOrder = (u8 *)&(pKey->aColl[nCol]);
82922 assert( &pKey->aSortOrder[nCol]==&(((u8 *)pKey)[nBytes]) );
82995 static const u8 aEnc[] = { SQLITE_UTF16BE, SQLITE_UTF16LE, SQLITE_UTF8 };
83023 u8 enc, /* The desired encoding for the collating sequence */
83143 u8 enc,
83180 static int matchQuality(FuncDef *p, int nArg, u8 enc){
83228 u8 c1 = (u8)pDef->zName[0];
83269 u8 enc, /* Preferred text encoding */
83279 h = (sqlite3UpperToLower[(u8)zName[0]] + nName) % ArraySize(db->aFunc.a);
84395 u8 *z1;
84547 u8 matchAll;
84548 u8 matchOne;
84549 u8 matchSet;
84550 u8 noCase;
84603 const u8 *zPattern, /* The glob pattern */
84604 const u8 *zString, /* The string to compare against the glob */
84611 u8 matchOne = pInfo->matchOne;
84612 u8 matchAll = pInfo->matchAll;
84613 u8 matchSet = pInfo->matchSet;
84614 u8 noCase = pInfo->noCase;
85075 u8 *zOld;
85132 static unsigned char * const azOne[] = { (u8*)" " };
85134 aLen = (u8*)lenOne;
85153 aLen[nChar] = (u8)(z - azChar[nChar]);
85207 const u8 *zIn;
85220 zIn = (u8*)sqlite3_value_text(argv[0]);
85221 if( zIn==0 ) zIn = (u8*)"";
85224 u8 prevcode = iCode[zIn[i]&0x7f];
85282 u8 overflow; /* True if integer overflow seen */
85283 u8 approx; /* True if non-integer value was input to the sum */
85493 static void setLikeOptFlag(sqlite3 *db, const char *zName, u8 flagVal){
86644 u8 enableLookaside; /* Copy of db->lookaside.bEnabled */
88318 u8 pik_flags;
89985 static u8 getSafetyLevel(const char *z){
89988 static const u8 iOffset[] = {0, 1, 2, 4, 9, 12, 16};
89989 static const u8 iLength[] = {2, 2, 3, 5, 3, 4, 4};
89990 static const u8 iValue[] = {1, 0, 0, 0, 1, 1, 2};
89993 return (u8)sqlite3Atoi(z);
90007 SQLITE_PRIVATE u8 sqlite3GetBoolean(const char *z){
90041 return (u8)((i>=0&&i<=2)?i:0);
90098 db->temp_store = (u8)ts;
90208 static const char *actionName(u8 action){
90470 db->dfltLockMode = (u8)eMode;
90578 db->nextAutovac = (u8)eAuto;
91096 sqlite3VdbeChangeP5(v, (u8)i);
91209 u8 enc;
91747 u8 encoding;
91749 encoding = (u8)meta[BTREE_TEXT_ENCODING-1] & 3;
91780 pDb->pSchema->file_format = (u8)meta[BTREE_FILE_FORMAT-1];
92304 *pzTail = (u8 *)zSql + sqlite3Utf16ByteLen(zSql, chars_parsed);
92385 pDest->eDest = (u8)eDest;
92479 u8 i; /* Beginning of keyword text in zKeyText[] */
92480 u8 nChar; /* Length of the keyword in characters */
92481 u8 code; /* Join type mask */
92489 /* cross */ { 28, 5, JT_INNER|JT_CROSS },
93112 pInfo->aSortOrder = (u8*)&pInfo->aColl[nExpr];
94011 u8 op = 0; /* One of the SRT_ operations to apply to self */
94595 pKeyMerge->aSortOrder = (u8*)&pKeyMerge->aColl[nOrderBy];
94635 pKeyDup->aSortOrder = (u8*)&pKeyDup->aColl[nExpr];
95016 ** (18) If the sub-query is a compound select, then all terms of the
95163 /* Restriction 18. */
95180 ** 17 and 18 above) it must be a UNION ALL and the parent query must
95287 u8 jointype = 0;
95425 static u8 minMaxQuery(Select *p){
95968 sqlite3VdbeChangeP5(v, (u8)nArg);
96198 explainSetInteger(pItem->iSelectId, (u8)pParse->iNextSelectId);
96760 u8 flag = minMaxQuery(p);
97382 pTrigger->op = (u8)op;
97505 u8 op, /* Trigger opcode */
97534 u8 orconf /* The conflict algorithm (OE_Abort, OE_Replace, etc.) */
97566 u8 orconf /* The conflict algorithm. (OE_Abort, OE_Ignore, etc) */
97864 pParse->eOrconf = (orconf==OE_Default)?pStep->orconf:(u8)orconf;
98122 sqlite3VdbeChangeP5(v, (u8)bRecursive);
98324 u8 enc = ENC(sqlite3VdbeDb(v));
100328 p->pVTable->bConstraint = (u8)va_arg(ap, int);
100449 u8 wtFlags; /* TERM_xxx bit flags. See below */
100450 u8 nChild; /* Number of children that must disable us */
100480 u8 op; /* Split operator. TK_AND or TK_OR */
100680 static int whereClauseInsert(WhereClause *pWC, Expr *p, u8 wtFlags){
100727 pWC->op = (u8)op;
101048 if( cnt!=0 && 255!=(u8)z[cnt-1] ){
101557 static const u8 ops[] = {TK_GE, TK_LE};
101612 u8 c, *pC; /* Last character before the first wildcard */
101613 pC = (u8*)&pStr2->u.zToken[sqlite3Strlen30(pStr2->u.zToken)-1];
102403 pIdx->aSortOrder = (u8*)&pIdx->aiColumn[nColumn];
102551 pIdxCons[j].op = (u8)pTerm->eOperator;
102830 const u8 *z;
102837 z = (const u8 *)sqlite3_value_blob(pVal);
102847 z = (const u8 *)sqlite3ValueText(pVal, pColl->enc);
102908 u8 aff,
102984 u8 aff = p->pTable->aCol[p->aiColumn[0]].affinity;
103068 u8 aff; /* Column affinity */
103125 u8 aff; /* Column affinity */
103132 u8 aSpan[SQLITE_INDEX_SAMPLES+1]; /* Histogram regions that are spanned */
103133 u8 aSingle[SQLITE_INDEX_SAMPLES+1]; /* Histogram regions hit once */
104262 const u8 aMoveOp[] = {
104348 static const u8 aStartOp[] = {
104358 static const u8 aEndOp[] = {
104703 static const u8 aStep[] = { OP_Next, OP_Prev };
104704 static const u8 aStart[] = { OP_Rewind, OP_Last };
104958 pWInfo->pWC = pWC = (WhereClause *)&((u8 *)pWInfo)[nByteWInfo];
105227 pLevel->iFrom = (u8)bestJ;
105653 pA->op = (u8)op;
105733 u8 yy210;
105824 /* 10 */ 55, 55, 48, 53, 53, 53, 53, 52, 52, 51,
105833 /* 100 */ 379, 378, 7, 491, 590, 584, 200, 199, 198, 58,
105855 /* 320 */ 237, 239, 414, 341, 237, 602, 590, 584, 18, 603,
105856 /* 330 */ 166, 601, 87, 382, 379, 378, 67, 623, 622, 38,
105892 /* 690 */ 334, 414, 353, 601, 68, 168, 590, 584, 132, 365,
105901 /* 780 */ 503, 601, 105, 601, 108, 601, 109, 204, 28, 56,
105916 /* 930 */ 98, 225, 601, 138, 601, 137, 232, 56, 45, 47,
105931 /* 1080 */ 601, 89, 601, 101, 621, 601, 88, 47, 582, 581,
105963 /* 1400 */ 466, 463, 601, 78, 154, 414, 462, 152, 601, 77,
105981 /* 0 */ 19, 142, 143, 144, 145, 24, 1, 26, 77, 78,
105982 /* 10 */ 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
105983 /* 20 */ 89, 90, 91, 92, 15, 98, 26, 27, 7, 8,
105984 /* 30 */ 49, 50, 77, 78, 79, 80, 109, 82, 83, 84,
105985 /* 40 */ 85, 86, 87, 88, 89, 90, 91, 92, 22, 68,
105986 /* 50 */ 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
105987 /* 60 */ 79, 80, 23, 82, 83, 84, 85, 86, 87, 88,
105989 /* 80 */ 25, 82, 83, 84, 85, 86, 87, 88, 89, 90,
105993 /* 120 */ 16, 174, 175, 68, 69, 70, 71, 72, 73, 74,
105994 /* 130 */ 75, 76, 77, 78, 79, 80, 118, 82, 83, 84,
105995 /* 140 */ 85, 86, 87, 88, 89, 90, 91, 92, 19, 23,
105996 /* 150 */ 92, 97, 98, 24, 96, 97, 98, 99, 100, 101,
105998 /* 170 */ 97, 98, 99, 100, 101, 102, 86, 87, 49, 50,
105999 /* 180 */ 118, 116, 109, 25, 94, 95, 32, 97, 88, 89,
106000 /* 190 */ 90, 91, 92, 128, 104, 41, 106, 68, 69, 70,
106001 /* 200 */ 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
106002 /* 210 */ 11, 82, 83, 84, 85, 86, 87, 88, 89, 90,
106003 /* 220 */ 91, 92, 19, 19, 86, 87, 88, 89, 90, 91,
106007 /* 260 */ 171, 118, 94, 170, 171, 23, 98, 25, 185, 186,
106008 /* 270 */ 243, 68, 69, 70, 71, 72, 73, 74, 75, 76,
106009 /* 280 */ 77, 78, 79, 80, 126, 82, 83, 84, 85, 86,
106010 /* 290 */ 87, 88, 89, 90, 91, 92, 19, 129, 130, 131,
106011 /* 300 */ 88, 23, 172, 173, 105, 106, 107, 150, 22, 26,
106015 /* 340 */ 26, 27, 118, 16, 110, 68, 69, 70, 71, 72,
106016 /* 350 */ 73, 74, 75, 76, 77, 78, 79, 80, 118, 82,
106017 /* 360 */ 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
106020 /* 390 */ 112, 26, 114, 115, 128, 23, 36, 174, 175, 88,
106022 /* 410 */ 120, 51, 25, 136, 169, 170, 171, 194, 58, 68,
106023 /* 420 */ 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
106024 /* 430 */ 79, 80, 23, 82, 83, 84, 85, 86, 87, 88,
106027 /* 460 */ 165, 116, 28, 28, 112, 174, 114, 115, 108, 174,
106030 /* 490 */ 23, 57, 25, 68, 69, 70, 71, 72, 73, 74,
106031 /* 500 */ 75, 76, 77, 78, 79, 80, 119, 82, 83, 84,
106032 /* 510 */ 85, 86, 87, 88, 89, 90, 91, 92, 19, 194,
106037 /* 560 */ 174, 175, 22, 23, 239, 25, 25, 68, 69, 70,
106038 /* 570 */ 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
106039 /* 580 */ 205, 82, 83, 84, 85, 86, 87, 88, 89, 90,
106045 /* 640 */ 248, 68, 69, 70, 71, 72, 73, 74, 75, 76,
106046 /* 650 */ 77, 78, 79, 80, 193, 82, 83, 84, 85, 86,
106047 /* 660 */ 87, 88, 89, 90, 91, 92, 19, 194, 194, 150,
106050 /* 690 */ 2, 165, 218, 174, 175, 50, 49, 50, 22, 48,
106052 /* 710 */ 167, 168, 120, 239, 23, 68, 69, 70, 71, 72,
106053 /* 720 */ 73, 74, 75, 76, 77, 78, 79, 80, 150, 82,
106054 /* 730 */ 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
106059 /* 780 */ 29, 174, 175, 174, 175, 174, 175, 160, 22, 68,
106060 /* 790 */ 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
106061 /* 800 */ 79, 80, 150, 82, 83, 84, 85, 86, 87, 88,
106067 /* 860 */ 175, 190, 191, 68, 69, 70, 71, 72, 73, 74,
106068 /* 870 */ 75, 76, 77, 78, 79, 80, 150, 82, 83, 84,
106069 /* 880 */ 85, 86, 87, 88, 89, 90, 91, 92, 19, 150,
106074 /* 930 */ 175, 187, 174, 175, 174, 175, 205, 68, 69, 70,
106075 /* 940 */ 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
106076 /* 950 */ 150, 82, 83, 84, 85, 86, 87, 88, 89, 90,
106083 /* 1020 */ 77, 78, 79, 80, 150, 82, 83, 84, 85, 86,
106084 /* 1030 */ 87, 88, 89, 90, 91, 92, 19, 98, 150, 165,
106090 /* 1090 */ 73, 74, 75, 76, 77, 78, 79, 80, 166, 82,
106091 /* 1100 */ 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
106098 /* 1170 */ 56, 165, 150, 65, 174, 175, 15, 86, 87, 88,
106099 /* 1180 */ 66, 165, 140, 150, 93, 94, 95, 165, 194, 98,
106102 /* 1210 */ 216, 180, 98, 251, 165, 221, 150, 149, 6, 165,
106112 /* 1310 */ 165, 98, 194, 165, 125, 22, 165, 150, 150, 26,
106114 /* 1330 */ 94, 95, 165, 165, 98, 150, 218, 150, 193, 157,
106120 /* 1390 */ 150, 98, 165, 165, 211, 174, 175, 150, 55, 165,
106127 /* 1460 */ 184, 176, 179, 156, 176, 176, 18, 157, 156, 237,
106128 /* 1470 */ 45, 157, 156, 135, 157, 157, 238, 156, 68, 157,
106129 /* 1480 */ 189, 189, 139, 219, 22, 157, 18, 192, 192, 192,
106131 /* 1500 */ 153, 157, 38, 245, 196, 166, 232, 198, 177, 177,
106153 /* 100 */ -69, -45, -45, -45, -45, -45, -1, 58, 138, 100,
106184 /* 410 */ 240, 224, 143, 62, 18, 71, 39, 9, 5,
106535 /* 18 */ "cmd ::= END trans_opt",
106545 /* 28 */ "ifnotexists ::=",
106555 /* 38 */ "id ::= ID",
106565 /* 48 */ "typetoken ::= typename LP signed COMMA signed RP",
106575 /* 58 */ "ccons ::= DEFAULT LP expr RP",
106585 /* 68 */ "ccons ::= defer_subclause",
106595 /* 78 */ "refact ::= SET NULL",
106605 /* 88 */ "conslist_opt ::=",
106615 /* 98 */ "defer_subclause_opt ::=",
107642 case 18: /* cmd ::= END trans_opt */ yytestcase(yyruleno==18);
107674 case 28: /* ifnotexists ::= */
107680 case 98: /* defer_subclause_opt ::= */ yytestcase(yyruleno==98);
107721 case 38: /* id ::= ID */
107754 case 48: /* typetoken ::= typename LP signed COMMA signed RP */
107767 case 58: /* ccons ::= DEFAULT LP expr RP */
107801 case 68: /* ccons ::= defer_subclause */
107823 case 78: /* refact ::= SET NULL */
107844 case 88: /* conslist_opt ::= */
107872 {yygotominor.yy210 = (u8)yymsp[0].minor.yy4;}
107908 yymsp[0].minor.yy387->op = (u8)yymsp[-1].minor.yy4;
107971 if( ALWAYS(yygotominor.yy259 && yygotominor.yy259->nSrc>0) ) yygotominor.yy259->a[yygotominor.yy259->nSrc-1].jointype = (u8)yymsp[0].minor.yy4;
108053 if( yygotominor.yy322 ) yygotominor.yy322->a[yygotominor.yy322->nExpr-1].sortOrder = (u8)yymsp[0].minor.yy4;
108059 if( yygotominor.yy322 && ALWAYS(yygotominor.yy322->a) ) yygotominor.yy322->a[0].sortOrder = (u8)yymsp[0].minor.yy4;
108453 if( yygotominor.yy322 ) yygotominor.yy322->a[yygotominor.yy322->nExpr-1].sortOrder = (u8)yymsp[0].minor.yy4;
108466 if( yygotominor.yy322 ) yygotominor.yy322->a[yygotominor.yy322->nExpr-1].sortOrder = (u8)yymsp[0].minor.yy4;
109012 0, 97, 98, 99,100,101,102,103,104,105, 0, 0, 0, 0, 0, 0, /* 8x */
109016 0, 97, 98, 99,100,101,102,103,104,105, 0, 0, 0, 0, 0, 0, /* Cx */
109095 72, 101, 114, 70, 0, 45, 0, 0, 78, 0, 73, 0, 0,
109098 0, 65, 6, 0, 48, 86, 98, 0, 115, 97, 0, 0, 44,
109100 92, 0, 0, 121, 102, 56, 120, 53, 28, 51, 0, 87, 0,
109101 96, 26, 0, 95, 0, 0, 0, 91, 88, 93, 84, 105, 14,
109102 39, 104, 0, 77, 0, 18, 85, 107, 32, 0, 117, 76, 109,
109103 58, 46, 80, 0, 0, 90, 40, 0, 112, 0, 36, 0, 0,
109111 0, 0, 0, 0, 30, 0, 54, 0, 38, 0, 0, 0, 1,
109114 0, 0, 0, 0, 11, 68, 75, 0, 8, 0, 100, 94, 0,
109132 36, 41, 46, 48, 53, 54, 59, 62, 65, 67, 69, 78, 81,
109194 testcase( i==18 ); /* SELECT */
109204 testcase( i==28 ); /* ON */
109214 testcase( i==38 ); /* CONSTRAINT */
109224 testcase( i==48 ); /* ATTACH */
109234 testcase( i==58 ); /* NO */
109244 testcase( i==68 ); /* DETACH */
109254 testcase( i==78 ); /* VIRTUAL */
109264 testcase( i==88 ); /* TO */
109274 testcase( i==98 ); /* DEFERRED */
109332 /* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */
109636 u8 enableLookaside; /* Saved value of db->lookaside.bEnabled */
109876 u8 state = 0; /* Current state, using numbers defined in header comment */
109877 u8 token; /* Value of the next token */
109883 static const u8 trans[8][8] = {
109899 static const u8 trans[3][3] = {
109965 if( IdChar((u8)*zSql) ){
110648 p = (LookasideSlot*)&((u8*)p)[sz];
111049 static const u8 delays[] =
111051 static const u8 totals[] =
111052 { 0, 1, 3, 8, 18, 33, 53, 78, 103, 128, 178, 228 };
111230 p = sqlite3FindFunction(db, zFunctionName, nName, nArg, (u8)enc, 0);
111242 p = sqlite3FindFunction(db, zFunctionName, nName, nArg, (u8)enc, 1);
111774 u8 enc,
111775 u8 collType,
111804 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 0);
111834 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 1);
111839 pColl->enc = (u8)(enc2 | (enc & SQLITE_UTF16_ALIGNED));
112509 rc = createCollation(db, zName, (u8)enc, SQLITE_COLL_USER, pCtx, xCompare, 0);
112529 rc = createCollation(db, zName, (u8)enc, SQLITE_COLL_USER, pCtx, xCompare, xDel);
112552 rc = createCollation(db, zName8, (u8)enc, SQLITE_COLL_USER, pCtx, xCompare, 0);
113030 rc = (sqlite3KeywordCode((u8*)zWord, n)!=TK_ID) ? SQLITE_N_KEYWORD : 0;
114128 typedef unsigned char u8; /* 1-byte (or larger) unsigned integer */
114195 u8 bHasStat; /* True if %_stat table exists */
114196 u8 bHasDocsize; /* True if %_docsize table exists */
114197 u8 bDescIdx; /* True if doclists are in reverse order */
114244 u8 isEof; /* True if at End Of Results */
114245 u8 isRequireSeek; /* True if must seek pStmt to %_content row */
114254 u8 bDesc; /* True to sort in descending order */
114363 u8 bEof; /* True this expression is at EOF already */
114364 u8 bStart; /* True if iDocid is valid */
114365 u8 bDeferred; /* True if this expression is entirely deferred */
114466 SQLITE_PRIVATE void sqlite3Fts3DoclistPrev(int,char*,int,char**,sqlite3_int64*,int*,u8*);
117810 u8 *pbEof /* OUT: End-of-file flag */
117868 u8 *pbEof /* OUT: Set to 1 if EOF */
118796 u8 c = 0;
118844 u8 bEof;
119421 memset(&pCsr->csr, 0, ((u8*)&pCsr[1]) - (u8*)&pCsr->csr);
119541 ** 2008 Nov 28
121230 char zReverse[28];
121452 /* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */
122481 #define SQL_CONTENT_INSERT 18
122536 /* 18 */ "INSERT INTO %Q.'%q_content' VALUES(%s)",
123451 u8 bEof = 0;
123494 u8 bEof = 0;
127141 typedef unsigned char u8;
127229 ** supported cell size is 48 bytes (8 byte rowid + ten 4 byte coordinates).
127291 u8 *zData;
127349 static int readInt16(u8 *p){
127352 static void readCoord(u8 *p, RtreeCoord *pCoord){
127361 static i64 readInt64(u8 *p){
127364 (((i64)p[1]) << 48) +
127379 static int writeInt16(u8 *p, int i){
127384 static int writeCoord(u8 *p, RtreeCoord *pCoord){
127395 static int writeInt64(u8 *p, i64 i){
127397 p[1] = (i>>48)&0xFF;
127430 (iNode>>56) ^ (iNode>>48) ^ (iNode>>40) ^ (iNode>>32) ^
127480 pNode->zData = (u8 *)&pNode[1];
127520 const u8 *zBlob = sqlite3_column_blob(pRtree->pReadNode, 0);
127527 pNode->zData = (u8 *)&pNode[1];
127588 u8 *p = &pNode->zData[4 + pRtree->nBytesPerCell*iCell];
127600 u8 *pDst = &pNode->zData[4 + pRtree->nBytesPerCell*iCell];
127601 u8 *pSrc = &pDst[pRtree->nBytesPerCell];
128417 u8 op;
130169 node.zData = (u8 *)sqlite3_value_blob(apArg[1]);
130204 u8 *zBlob = (u8 *)sqlite3_value_blob(apArg[0]);