Lines Matching refs:p
959 int (*xUnfetch)(sqlite3_file*, sqlite3_int64 iOfst, void *p);
5865 const sqlite3_module *p, /* Methods for the module */
5871 const sqlite3_module *p, /* Methods for the module */
7337 SQLITE_API int SQLITE_STDCALL sqlite3_backup_step(sqlite3_backup *p, int nPage);
7338 SQLITE_API int SQLITE_STDCALL sqlite3_backup_finish(sqlite3_backup *p);
7339 SQLITE_API int SQLITE_STDCALL sqlite3_backup_remaining(sqlite3_backup *p);
7340 SQLITE_API int SQLITE_STDCALL sqlite3_backup_pagecount(sqlite3_backup *p);
9413 SQLITE_PRIVATE int sqlite3BtreeSetPageSize(Btree *p, int nPagesize, int nReserve, int eFix);
9419 SQLITE_PRIVATE int sqlite3BtreeGetReserveNoMutex(Btree *p);
9464 SQLITE_PRIVATE int sqlite3BtreeNewDb(Btree *p);
9672 void *p; /* Generic pointer */ member
11782 void *p; /* Pointer to sampled record */ member
13332 # define sqlite3ParseToplevel(p) ((p)->pToplevel ? (p)->pToplevel : (p)) argument
13341 # define sqlite3ParseToplevel(p) p argument
13572 SQLITE_PRIVATE void sqlite3VtabDisconnect(sqlite3 *db, Table *p);
13686 SQLITE_PRIVATE int sqlite3JournalExists(sqlite3_file *p);
13689 #define sqlite3JournalExists(p) 1 argument
13696 SQLITE_PRIVATE void sqlite3ExprSetHeightAndFlags(Parse *pParse, Expr *p);
14653 #define VdbeFrameMem(p) ((Mem *)&((u8 *)p)[ROUND8(sizeof(VdbeFrame))]) argument
14734 #define MemSetTypeFlag(p, f) \ argument
14735 ((p)->flags = ((p)->flags&~(MEM_TypeMask|MEM_Zero))|f)
14941 SQLITE_PRIVATE void sqlite3VdbeMemRelease(Mem *p);
14951 SQLITE_PRIVATE int sqlite3VdbeTransferError(Vdbe *p);
14978 # define sqlite3VdbeCheckFk(p,i) 0 argument
15229 HashElem *p; in sqlite3_db_status() local
15242 for(p=sqliteHashFirst(&pSchema->trigHash); p; p=sqliteHashNext(p)){ in sqlite3_db_status()
15243 sqlite3DeleteTrigger(db, (Trigger*)sqliteHashData(p)); in sqlite3_db_status()
15245 for(p=sqliteHashFirst(&pSchema->tblHash); p; p=sqliteHashNext(p)){ in sqlite3_db_status()
15246 sqlite3DeleteTable(db, (Table *)sqliteHashData(p)); in sqlite3_db_status()
15460 static int parseTimezone(const char *zDate, DateTime *p){ in parseTimezone() argument
15465 p->tz = 0; in parseTimezone()
15482 p->tz = sgn*(nMn + nHr*60); in parseTimezone()
15495 static int parseHhMmSs(const char *zDate, DateTime *p){ in parseHhMmSs() argument
15521 p->validJD = 0; in parseHhMmSs()
15522 p->validHMS = 1; in parseHhMmSs()
15523 p->h = h; in parseHhMmSs()
15524 p->m = m; in parseHhMmSs()
15525 p->s = s + ms; in parseHhMmSs()
15526 if( parseTimezone(zDate, p) ) return 1; in parseHhMmSs()
15527 p->validTZ = (p->tz!=0)?1:0; in parseHhMmSs()
15537 static void computeJD(DateTime *p){ in computeJD() argument
15540 if( p->validJD ) return; in computeJD()
15541 if( p->validYMD ){ in computeJD()
15542 Y = p->Y; in computeJD()
15543 M = p->M; in computeJD()
15544 D = p->D; in computeJD()
15558 p->iJD = (sqlite3_int64)((X1 + X2 + D + B - 1524.5 ) * 86400000); in computeJD()
15559 p->validJD = 1; in computeJD()
15560 if( p->validHMS ){ in computeJD()
15561 p->iJD += p->h*3600000 + p->m*60000 + (sqlite3_int64)(p->s*1000); in computeJD()
15562 if( p->validTZ ){ in computeJD()
15563 p->iJD -= p->tz*60000; in computeJD()
15564 p->validYMD = 0; in computeJD()
15565 p->validHMS = 0; in computeJD()
15566 p->validTZ = 0; in computeJD()
15583 static int parseYyyyMmDd(const char *zDate, DateTime *p){ in parseYyyyMmDd() argument
15597 if( parseHhMmSs(zDate, p)==0 ){ in parseYyyyMmDd()
15600 p->validHMS = 0; in parseYyyyMmDd()
15604 p->validJD = 0; in parseYyyyMmDd()
15605 p->validYMD = 1; in parseYyyyMmDd()
15606 p->Y = neg ? -Y : Y; in parseYyyyMmDd()
15607 p->M = M; in parseYyyyMmDd()
15608 p->D = D; in parseYyyyMmDd()
15609 if( p->validTZ ){ in parseYyyyMmDd()
15610 computeJD(p); in parseYyyyMmDd()
15620 static int setDateTimeToCurrent(sqlite3_context *context, DateTime *p){ in setDateTimeToCurrent() argument
15621 p->iJD = sqlite3StmtCurrentTime(context); in setDateTimeToCurrent()
15622 if( p->iJD>0 ){ in setDateTimeToCurrent()
15623 p->validJD = 1; in setDateTimeToCurrent()
15649 DateTime *p in parseDateOrTime() argument
15652 if( parseYyyyMmDd(zDate,p)==0 ){ in parseDateOrTime()
15654 }else if( parseHhMmSs(zDate, p)==0 ){ in parseDateOrTime()
15657 return setDateTimeToCurrent(context, p); in parseDateOrTime()
15659 p->iJD = (sqlite3_int64)(r*86400000.0 + 0.5); in parseDateOrTime()
15660 p->validJD = 1; in parseDateOrTime()
15669 static void computeYMD(DateTime *p){ in computeYMD() argument
15671 if( p->validYMD ) return; in computeYMD()
15672 if( !p->validJD ){ in computeYMD()
15673 p->Y = 2000; in computeYMD()
15674 p->M = 1; in computeYMD()
15675 p->D = 1; in computeYMD()
15677 Z = (int)((p->iJD + 43200000)/86400000); in computeYMD()
15685 p->D = B - D - X1; in computeYMD()
15686 p->M = E<14 ? E-1 : E-13; in computeYMD()
15687 p->Y = p->M>2 ? C - 4716 : C - 4715; in computeYMD()
15689 p->validYMD = 1; in computeYMD()
15695 static void computeHMS(DateTime *p){ in computeHMS() argument
15697 if( p->validHMS ) return; in computeHMS()
15698 computeJD(p); in computeHMS()
15699 s = (int)((p->iJD + 43200000) % 86400000); in computeHMS()
15700 p->s = s/1000.0; in computeHMS()
15701 s = (int)p->s; in computeHMS()
15702 p->s -= s; in computeHMS()
15703 p->h = s/3600; in computeHMS()
15704 s -= p->h*3600; in computeHMS()
15705 p->m = s/60; in computeHMS()
15706 p->s += s - p->m*60; in computeHMS()
15707 p->validHMS = 1; in computeHMS()
15713 static void computeYMD_HMS(DateTime *p){ in computeYMD_HMS() argument
15714 computeYMD(p); in computeYMD_HMS()
15715 computeHMS(p); in computeYMD_HMS()
15721 static void clearYMD_HMS_TZ(DateTime *p){ in clearYMD_HMS_TZ() argument
15722 p->validYMD = 0; in clearYMD_HMS_TZ()
15723 p->validHMS = 0; in clearYMD_HMS_TZ()
15724 p->validTZ = 0; in clearYMD_HMS_TZ()
15799 DateTime *p, /* Date at which to calculate offset */ in localtimeOffset() argument
15810 x = *p; in localtimeOffset()
15877 static int parseModifier(sqlite3_context *pCtx, const char *zMod, DateTime *p){ in parseModifier() argument
15896 computeJD(p); in parseModifier()
15897 p->iJD += localtimeOffset(p, pCtx, &rc); in parseModifier()
15898 clearYMD_HMS_TZ(p); in parseModifier()
15910 if( strcmp(z, "unixepoch")==0 && p->validJD ){ in parseModifier()
15911 p->iJD = (p->iJD + 43200)/86400 + 21086676*(i64)10000000; in parseModifier()
15912 clearYMD_HMS_TZ(p); in parseModifier()
15918 computeJD(p); in parseModifier()
15919 c1 = localtimeOffset(p, pCtx, &rc); in parseModifier()
15921 p->iJD -= c1; in parseModifier()
15922 clearYMD_HMS_TZ(p); in parseModifier()
15923 p->iJD += c1 - localtimeOffset(p, pCtx, &rc); in parseModifier()
15941 computeYMD_HMS(p); in parseModifier()
15942 p->validTZ = 0; in parseModifier()
15943 p->validJD = 0; in parseModifier()
15944 computeJD(p); in parseModifier()
15945 Z = ((p->iJD + 129600000)/86400000) % 7; in parseModifier()
15947 p->iJD += (n - Z)*86400000; in parseModifier()
15948 clearYMD_HMS_TZ(p); in parseModifier()
15962 computeYMD(p); in parseModifier()
15963 p->validHMS = 1; in parseModifier()
15964 p->h = p->m = 0; in parseModifier()
15965 p->s = 0.0; in parseModifier()
15966 p->validTZ = 0; in parseModifier()
15967 p->validJD = 0; in parseModifier()
15969 p->D = 1; in parseModifier()
15972 computeYMD(p); in parseModifier()
15973 p->M = 1; in parseModifier()
15974 p->D = 1; in parseModifier()
16016 computeJD(p); in parseModifier()
16017 clearYMD_HMS_TZ(p); in parseModifier()
16018 p->iJD += tx.iJD; in parseModifier()
16027 computeJD(p); in parseModifier()
16031 p->iJD += (sqlite3_int64)(r*86400000.0 + rRounder); in parseModifier()
16033 p->iJD += (sqlite3_int64)(r*(86400000.0/24.0) + rRounder); in parseModifier()
16035 p->iJD += (sqlite3_int64)(r*(86400000.0/(24.0*60.0)) + rRounder); in parseModifier()
16037 p->iJD += (sqlite3_int64)(r*(86400000.0/(24.0*60.0*60.0)) + rRounder); in parseModifier()
16040 computeYMD_HMS(p); in parseModifier()
16041 p->M += (int)r; in parseModifier()
16042 x = p->M>0 ? (p->M-1)/12 : (p->M-12)/12; in parseModifier()
16043 p->Y += x; in parseModifier()
16044 p->M -= x*12; in parseModifier()
16045 p->validJD = 0; in parseModifier()
16046 computeJD(p); in parseModifier()
16049 p->iJD += (sqlite3_int64)((r - y)*30.0*86400000.0 + rRounder); in parseModifier()
16053 computeYMD_HMS(p); in parseModifier()
16054 p->Y += y; in parseModifier()
16055 p->validJD = 0; in parseModifier()
16056 computeJD(p); in parseModifier()
16058 p->iJD += (sqlite3_int64)((r - y)*365.0*86400000.0 + rRounder); in parseModifier()
16063 clearYMD_HMS_TZ(p); in parseModifier()
16086 DateTime *p in isDate() argument
16091 memset(p, 0, sizeof(*p)); in isDate()
16093 return setDateTimeToCurrent(context, p); in isDate()
16097 p->iJD = (sqlite3_int64)(sqlite3_value_double(argv[0])*86400000.0 + 0.5); in isDate()
16098 p->validJD = 1; in isDate()
16101 if( !z || parseDateOrTime(context, (char*)z, p) ){ in isDate()
16107 if( z==0 || parseModifier(context, (char*)z, p) ) return 1; in isDate()
16629 SQLITE_PRIVATE int sqlite3OsUnfetch(sqlite3_file *id, i64 iOff, void *p){ in sqlite3OsUnfetch() argument
16630 return id->pMethods->xUnfetch(id, iOff, p); in sqlite3OsUnfetch()
16638 SQLITE_PRIVATE int sqlite3OsUnfetch(sqlite3_file *id, i64 iOff, void *p){ in sqlite3OsUnfetch() argument
16761 void *p = sqlite3_malloc(10); in sqlite3OsInit() local
16762 if( p==0 ) return SQLITE_NOMEM; in sqlite3OsInit()
16763 sqlite3_free(p); in sqlite3OsInit()
16808 sqlite3_vfs *p = vfsList; in vfsUnlink() local
16809 while( p->pNext && p->pNext!=pVfs ){ in vfsUnlink()
16810 p = p->pNext; in vfsUnlink()
16812 if( p->pNext==pVfs ){ in vfsUnlink()
16813 p->pNext = pVfs->pNext; in vfsUnlink()
17139 void *p = SQLITE_MALLOC( nByte ); in sqlite3MemMalloc() local
17140 if( p==0 ){ in sqlite3MemMalloc()
17144 return p; in sqlite3MemMalloc()
17146 sqlite3_int64 *p; in sqlite3MemMalloc()
17149 p = SQLITE_MALLOC( nByte+8 ); in sqlite3MemMalloc()
17150 if( p ){ in sqlite3MemMalloc()
17151 p[0] = nByte; in sqlite3MemMalloc()
17152 p++; in sqlite3MemMalloc()
17157 return (void *)p; in sqlite3MemMalloc()
17173 sqlite3_int64 *p = (sqlite3_int64*)pPrior; in sqlite3MemFree()
17175 p--; in sqlite3MemFree()
17176 SQLITE_FREE(p); in sqlite3MemFree()
17188 sqlite3_int64 *p; in sqlite3MemSize()
17190 p = (sqlite3_int64*)pPrior; in sqlite3MemSize()
17191 p--; in sqlite3MemSize()
17192 return (int)p[0]; in sqlite3MemSize()
17208 void *p = SQLITE_REALLOC(pPrior, nByte); in sqlite3MemRealloc() local
17209 if( p==0 ){ in sqlite3MemRealloc()
17215 return p; in sqlite3MemRealloc()
17217 sqlite3_int64 *p = (sqlite3_int64*)pPrior; in sqlite3MemRealloc()
17220 p--; in sqlite3MemRealloc()
17221 p = SQLITE_REALLOC(p, nByte+8 ); in sqlite3MemRealloc()
17222 if( p ){ in sqlite3MemRealloc()
17223 p[0] = nByte; in sqlite3MemRealloc()
17224 p++; in sqlite3MemRealloc()
17231 return (void*)p; in sqlite3MemRealloc()
17461 struct MemBlockHdr *p; in sqlite3MemsysGetHeader() local
17466 p = (struct MemBlockHdr*)pAllocation; in sqlite3MemsysGetHeader()
17467 p--; in sqlite3MemsysGetHeader()
17468 assert( p->iForeGuard==(int)FOREGUARD ); in sqlite3MemsysGetHeader()
17469 nReserve = ROUND8(p->iSize); in sqlite3MemsysGetHeader()
17477 while( nReserve-- > p->iSize ) assert( pU8[nReserve]==0x65 ); in sqlite3MemsysGetHeader()
17478 return p; in sqlite3MemsysGetHeader()
17484 static int sqlite3MemSize(void *p){ in sqlite3MemSize() argument
17486 if( !p ){ in sqlite3MemSize()
17489 pHdr = sqlite3MemsysGetHeader(p); in sqlite3MemSize()
17555 void *p = 0; in sqlite3MemMalloc() local
17563 p = malloc(totalSize); in sqlite3MemMalloc()
17564 if( p ){ in sqlite3MemMalloc()
17565 z = p; in sqlite3MemMalloc()
17600 p = (void*)pInt; in sqlite3MemMalloc()
17603 return p; in sqlite3MemMalloc()
17689 SQLITE_PRIVATE void sqlite3MemdebugSetType(void *p, u8 eType){ in sqlite3MemdebugSetType() argument
17690 if( p && sqlite3GlobalConfig.m.xMalloc==sqlite3MemMalloc ){ in sqlite3MemdebugSetType()
17692 pHdr = sqlite3MemsysGetHeader(p); in sqlite3MemdebugSetType()
17707 SQLITE_PRIVATE int sqlite3MemdebugHasType(void *p, u8 eType){ in sqlite3MemdebugHasType() argument
17709 if( p && sqlite3GlobalConfig.m.xMalloc==sqlite3MemMalloc ){ in sqlite3MemdebugHasType()
17711 pHdr = sqlite3MemsysGetHeader(p); in sqlite3MemdebugHasType()
17729 SQLITE_PRIVATE int sqlite3MemdebugNoType(void *p, u8 eType){ in sqlite3MemdebugNoType() argument
17731 if( p && sqlite3GlobalConfig.m.xMalloc==sqlite3MemMalloc ){ in sqlite3MemdebugNoType()
17733 pHdr = sqlite3MemsysGetHeader(p); in sqlite3MemdebugNoType()
18113 void *p = memsys3Checkout(mem3.iMaster, mem3.szMaster); in memsys3FromMaster() local
18117 return p; in memsys3FromMaster()
18275 Mem3Block *p = (Mem3Block*)pOld; in memsys3FreeUnsafe() local
18279 assert( p>mem3.aPool && p<&mem3.aPool[mem3.nPool] ); in memsys3FreeUnsafe()
18280 i = p - mem3.aPool; in memsys3FreeUnsafe()
18315 static int memsys3Size(void *p){ in memsys3Size() argument
18317 if( p==0 ) return 0; in memsys3Size()
18318 pBlock = (Mem3Block*)p; in memsys3Size()
18338 sqlite3_int64 *p; in memsys3Malloc() local
18341 p = memsys3MallocUnsafe(nBytes); in memsys3Malloc()
18343 return (void*)p; in memsys3Malloc()
18361 void *p; in memsys3Realloc() local
18374 p = memsys3MallocUnsafe(nBytes); in memsys3Realloc()
18375 if( p ){ in memsys3Realloc()
18377 memcpy(p, pPrior, nOld); in memsys3Realloc()
18379 memcpy(p, pPrior, nBytes); in memsys3Realloc()
18384 return p; in memsys3Realloc()
18729 static int memsys5Size(void *p){ in memsys5Size() argument
18731 if( p ){ in memsys5Size()
18732 int i = (int)(((u8 *)p-mem5.zPool)/mem5.szAtom); in memsys5Size()
18882 sqlite3_int64 *p = 0; in memsys5Malloc() local
18885 p = memsys5MallocUnsafe(nBytes); in memsys5Malloc()
18888 return (void*)p; in memsys5Malloc()
18918 void *p; in memsys5Realloc() local
18930 p = memsys5MallocUnsafe(nBytes); in memsys5Realloc()
18931 if( p ){ in memsys5Realloc()
18932 memcpy(p, pPrior, nOld); in memsys5Realloc()
18936 return p; in memsys5Realloc()
19206 SQLITE_API void SQLITE_STDCALL sqlite3_mutex_free(sqlite3_mutex *p){ in sqlite3_mutex_free() argument
19207 if( p ){ in sqlite3_mutex_free()
19208 sqlite3GlobalConfig.mutex.xMutexFree(p); in sqlite3_mutex_free()
19216 SQLITE_API void SQLITE_STDCALL sqlite3_mutex_enter(sqlite3_mutex *p){ in sqlite3_mutex_enter() argument
19217 if( p ){ in sqlite3_mutex_enter()
19218 sqlite3GlobalConfig.mutex.xMutexEnter(p); in sqlite3_mutex_enter()
19226 SQLITE_API int SQLITE_STDCALL sqlite3_mutex_try(sqlite3_mutex *p){ in sqlite3_mutex_try() argument
19228 if( p ){ in sqlite3_mutex_try()
19229 return sqlite3GlobalConfig.mutex.xMutexTry(p); in sqlite3_mutex_try()
19240 SQLITE_API void SQLITE_STDCALL sqlite3_mutex_leave(sqlite3_mutex *p){ in sqlite3_mutex_leave() argument
19241 if( p ){ in sqlite3_mutex_leave()
19242 sqlite3GlobalConfig.mutex.xMutexLeave(p); in sqlite3_mutex_leave()
19251 SQLITE_API int SQLITE_STDCALL sqlite3_mutex_held(sqlite3_mutex *p){ in sqlite3_mutex_held() argument
19252 return p==0 || sqlite3GlobalConfig.mutex.xMutexHeld(p); in sqlite3_mutex_held()
19254 SQLITE_API int SQLITE_STDCALL sqlite3_mutex_notheld(sqlite3_mutex *p){ in sqlite3_mutex_notheld() argument
19255 return p==0 || sqlite3GlobalConfig.mutex.xMutexNotheld(p); in sqlite3_mutex_notheld()
19305 static void noopMutexFree(sqlite3_mutex *p){ UNUSED_PARAMETER(p); return; } in noopMutexFree() argument
19306 static void noopMutexEnter(sqlite3_mutex *p){ UNUSED_PARAMETER(p); return; } in noopMutexEnter() argument
19307 static int noopMutexTry(sqlite3_mutex *p){ in noopMutexTry() argument
19308 UNUSED_PARAMETER(p); in noopMutexTry()
19311 static void noopMutexLeave(sqlite3_mutex *p){ UNUSED_PARAMETER(p); return; } in noopMutexLeave() argument
19351 sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX; in debugMutexHeld() local
19352 return p==0 || p->cnt>0; in debugMutexHeld()
19355 sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX; in debugMutexNotheld() local
19356 return p==0 || p->cnt==0; in debugMutexNotheld()
19402 sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX; in debugMutexFree() local
19403 assert( p->cnt==0 ); in debugMutexFree()
19404 if( p->id==SQLITE_MUTEX_RECURSIVE || p->id==SQLITE_MUTEX_FAST ){ in debugMutexFree()
19405 sqlite3_free(p); in debugMutexFree()
19425 sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX; in debugMutexEnter() local
19426 assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) ); in debugMutexEnter()
19427 p->cnt++; in debugMutexEnter()
19430 sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX; in debugMutexTry() local
19431 assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) ); in debugMutexTry()
19432 p->cnt++; in debugMutexTry()
19443 sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX; in debugMutexLeave() local
19445 p->cnt--; in debugMutexLeave()
19446 assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) ); in debugMutexLeave()
19553 static int pthreadMutexHeld(sqlite3_mutex *p){ in pthreadMutexHeld() argument
19554 return (p->nRef!=0 && pthread_equal(p->owner, pthread_self())); in pthreadMutexHeld()
19556 static int pthreadMutexNotheld(sqlite3_mutex *p){ in pthreadMutexNotheld() argument
19557 return p->nRef==0 || pthread_equal(p->owner, pthread_self())==0; in pthreadMutexNotheld()
19624 sqlite3_mutex *p; in pthreadMutexAlloc() local
19627 p = sqlite3MallocZero( sizeof(*p) ); in pthreadMutexAlloc()
19628 if( p ){ in pthreadMutexAlloc()
19632 pthread_mutex_init(&p->mutex, 0); in pthreadMutexAlloc()
19638 pthread_mutex_init(&p->mutex, &recursiveAttr); in pthreadMutexAlloc()
19645 p = sqlite3MallocZero( sizeof(*p) ); in pthreadMutexAlloc()
19646 if( p ){ in pthreadMutexAlloc()
19647 pthread_mutex_init(&p->mutex, 0); in pthreadMutexAlloc()
19658 p = &staticMutexes[iType-2]; in pthreadMutexAlloc()
19663 if( p ) p->id = iType; in pthreadMutexAlloc()
19665 return p; in pthreadMutexAlloc()
19674 static void pthreadMutexFree(sqlite3_mutex *p){ in pthreadMutexFree() argument
19675 assert( p->nRef==0 ); in pthreadMutexFree()
19677 if( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE ) in pthreadMutexFree()
19680 pthread_mutex_destroy(&p->mutex); in pthreadMutexFree()
19681 sqlite3_free(p); in pthreadMutexFree()
19701 static void pthreadMutexEnter(sqlite3_mutex *p){ in pthreadMutexEnter() argument
19702 assert( p->id==SQLITE_MUTEX_RECURSIVE || pthreadMutexNotheld(p) ); in pthreadMutexEnter()
19717 if( p->nRef>0 && pthread_equal(p->owner, self) ){ in pthreadMutexEnter()
19718 p->nRef++; in pthreadMutexEnter()
19720 pthread_mutex_lock(&p->mutex); in pthreadMutexEnter()
19721 assert( p->nRef==0 ); in pthreadMutexEnter()
19722 p->owner = self; in pthreadMutexEnter()
19723 p->nRef = 1; in pthreadMutexEnter()
19729 pthread_mutex_lock(&p->mutex); in pthreadMutexEnter()
19731 assert( p->nRef>0 || p->owner==0 ); in pthreadMutexEnter()
19732 p->owner = pthread_self(); in pthreadMutexEnter()
19733 p->nRef++; in pthreadMutexEnter()
19738 if( p->trace ){ in pthreadMutexEnter()
19739 printf("enter mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef); in pthreadMutexEnter()
19743 static int pthreadMutexTry(sqlite3_mutex *p){ in pthreadMutexTry() argument
19745 assert( p->id==SQLITE_MUTEX_RECURSIVE || pthreadMutexNotheld(p) ); in pthreadMutexTry()
19760 if( p->nRef>0 && pthread_equal(p->owner, self) ){ in pthreadMutexTry()
19761 p->nRef++; in pthreadMutexTry()
19763 }else if( pthread_mutex_trylock(&p->mutex)==0 ){ in pthreadMutexTry()
19764 assert( p->nRef==0 ); in pthreadMutexTry()
19765 p->owner = self; in pthreadMutexTry()
19766 p->nRef = 1; in pthreadMutexTry()
19775 if( pthread_mutex_trylock(&p->mutex)==0 ){ in pthreadMutexTry()
19777 p->owner = pthread_self(); in pthreadMutexTry()
19778 p->nRef++; in pthreadMutexTry()
19787 if( rc==SQLITE_OK && p->trace ){ in pthreadMutexTry()
19788 printf("enter mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef); in pthreadMutexTry()
19800 static void pthreadMutexLeave(sqlite3_mutex *p){ in pthreadMutexLeave() argument
19801 assert( pthreadMutexHeld(p) ); in pthreadMutexLeave()
19803 p->nRef--; in pthreadMutexLeave()
19804 if( p->nRef==0 ) p->owner = 0; in pthreadMutexLeave()
19806 assert( p->nRef==0 || p->id==SQLITE_MUTEX_RECURSIVE ); in pthreadMutexLeave()
19809 if( p->nRef==0 ){ in pthreadMutexLeave()
19810 pthread_mutex_unlock(&p->mutex); in pthreadMutexLeave()
19813 pthread_mutex_unlock(&p->mutex); in pthreadMutexLeave()
19817 if( p->trace ){ in pthreadMutexLeave()
19818 printf("leave mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef); in pthreadMutexLeave()
20202 static int winMutexHeld(sqlite3_mutex *p){
20203 return p->nRef!=0 && p->owner==GetCurrentThreadId();
20206 static int winMutexNotheld2(sqlite3_mutex *p, DWORD tid){
20207 return p->nRef==0 || p->owner!=tid;
20210 static int winMutexNotheld(sqlite3_mutex *p){
20212 return winMutexNotheld2(p, tid);
20326 sqlite3_mutex *p;
20331 p = sqlite3MallocZero( sizeof(*p) );
20332 if( p ){
20333 p->id = iType;
20336 p->trace = 1;
20340 InitializeCriticalSectionEx(&p->mutex, 0, 0);
20342 InitializeCriticalSection(&p->mutex);
20354 p = &winMutex_staticMutexes[iType-2];
20355 p->id = iType;
20358 p->trace = 1;
20364 return p;
20373 static void winMutexFree(sqlite3_mutex *p){
20374 assert( p );
20375 assert( p->nRef==0 && p->owner==0 );
20376 if( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE ){
20377 DeleteCriticalSection(&p->mutex);
20378 sqlite3_free(p);
20397 static void winMutexEnter(sqlite3_mutex *p){
20402 assert( p );
20403 assert( p->id==SQLITE_MUTEX_RECURSIVE || winMutexNotheld2(p, tid) );
20405 assert( p );
20408 EnterCriticalSection(&p->mutex);
20410 assert( p->nRef>0 || p->owner==0 );
20411 p->owner = tid;
20412 p->nRef++;
20413 if( p->trace ){
20415 tid, p, p->trace, p->nRef));
20420 static int winMutexTry(sqlite3_mutex *p){
20425 assert( p );
20426 assert( p->id==SQLITE_MUTEX_RECURSIVE || winMutexNotheld2(p, tid) );
20445 if( winMutex_isNt && TryEnterCriticalSection(&p->mutex) ){
20447 p->owner = tid;
20448 p->nRef++;
20453 UNUSED_PARAMETER(p);
20456 if( p->trace ){
20458 tid, p, p->trace, p->owner, p->nRef, sqlite3ErrName(rc)));
20470 static void winMutexLeave(sqlite3_mutex *p){
20474 assert( p );
20476 assert( p->nRef>0 );
20477 assert( p->owner==tid );
20478 p->nRef--;
20479 if( p->nRef==0 ) p->owner = 0;
20480 assert( p->nRef==0 || p->id==SQLITE_MUTEX_RECURSIVE );
20483 LeaveCriticalSection(&p->mutex);
20485 if( p->trace ){
20487 tid, p, p->trace, p->nRef));
20788 void *p;
20801 p = sqlite3GlobalConfig.m.xMalloc(nFull);
20803 if( p==0 && mem0.alarmCallback ){
20805 p = sqlite3GlobalConfig.m.xMalloc(nFull);
20808 if( p ){
20809 nFull = sqlite3MallocSize(p);
20813 *pp = p;
20822 void *p;
20829 p = 0;
20832 mallocWithAlarm((int)n, &p);
20835 p = sqlite3GlobalConfig.m.xMalloc((int)n);
20837 assert( EIGHT_BYTE_ALIGNMENT(p) ); /* IMP: R-11148-40995 */
20838 return p;
20879 void *p;
20885 p = mem0.pScratchFree;
20892 p = sqlite3Malloc(n);
20893 if( sqlite3GlobalConfig.bMemstat && p ){
20895 sqlite3StatusUp(SQLITE_STATUS_SCRATCH_OVERFLOW, sqlite3MallocSize(p));
20898 sqlite3MemdebugSetType(p, MEMTYPE_SCRATCH);
20910 if( p ) scratchAllocOut++;
20913 return p;
20915 SQLITE_PRIVATE void sqlite3ScratchFree(void *p){
20916 if( p ){
20927 if( p>=sqlite3GlobalConfig.pScratch && p<mem0.pScratchEnd ){
20930 pSlot = (ScratchFreeslot*)p;
20940 assert( sqlite3MemdebugHasType(p, MEMTYPE_SCRATCH) );
20941 assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_SCRATCH) );
20942 sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
20944 int iSize = sqlite3MallocSize(p);
20949 sqlite3GlobalConfig.m.xFree(p);
20952 sqlite3GlobalConfig.m.xFree(p);
20962 static int isLookaside(sqlite3 *db, void *p){
20963 return p>=db->lookaside.pStart && p<db->lookaside.pEnd;
20973 SQLITE_PRIVATE int sqlite3MallocSize(void *p){
20974 assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
20975 return sqlite3GlobalConfig.m.xSize(p);
20977 SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3 *db, void *p){
20979 assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );
20980 assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
20981 return sqlite3MallocSize(p);
20984 if( isLookaside(db, p) ){
20987 assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
20988 assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
20989 return sqlite3GlobalConfig.m.xSize(p);
20993 SQLITE_API sqlite3_uint64 SQLITE_STDCALL sqlite3_msize(void *p){
20994 assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );
20995 assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
20996 return (sqlite3_uint64)sqlite3GlobalConfig.m.xSize(p);
21002 SQLITE_API void SQLITE_STDCALL sqlite3_free(void *p){
21003 if( p==0 ) return; /* IMP: R-49053-54554 */
21004 assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
21005 assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );
21008 sqlite3StatusDown(SQLITE_STATUS_MEMORY_USED, sqlite3MallocSize(p));
21010 sqlite3GlobalConfig.m.xFree(p);
21013 sqlite3GlobalConfig.m.xFree(p);
21021 static SQLITE_NOINLINE void measureAllocationSize(sqlite3 *db, void *p){
21022 *db->pnBytesFreed += sqlite3DbMallocSize(db,p);
21029 SQLITE_PRIVATE void sqlite3DbFree(sqlite3 *db, void *p){
21031 if( p==0 ) return;
21034 measureAllocationSize(db, p);
21037 if( isLookaside(db, p) ){
21038 LookasideSlot *pBuf = (LookasideSlot*)p;
21041 memset(p, 0xaa, db->lookaside.sz);
21049 assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
21050 assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
21051 assert( db!=0 || sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) );
21052 sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
21053 sqlite3_free(p);
21130 void *p = sqlite3Malloc(n);
21131 if( p ){
21132 memset(p, 0, (size_t)n);
21134 return p;
21142 void *p = sqlite3DbMallocRaw(db, n);
21143 if( p ){
21144 memset(p, 0, (size_t)n);
21146 return p;
21168 void *p;
21198 p = sqlite3Malloc(n);
21199 if( !p && db ){
21202 sqlite3MemdebugSetType(p,
21204 return p;
21211 SQLITE_PRIVATE void *sqlite3DbRealloc(sqlite3 *db, void *p, u64 n){
21216 if( p==0 ){
21219 if( isLookaside(db, p) ){
21221 return p;
21225 memcpy(pNew, p, db->lookaside.sz);
21226 sqlite3DbFree(db, p);
21229 assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
21230 assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
21231 sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
21232 pNew = sqlite3_realloc64(p, n);
21247 SQLITE_PRIVATE void *sqlite3DbReallocOrFree(sqlite3 *db, void *p, u64 n){
21249 pNew = sqlite3DbRealloc(db, p, n);
21251 sqlite3DbFree(db, p);
21482 static void setStrAccumError(StrAccum *p, u8 eError){
21484 p->accError = eError;
21485 p->nAlloc = 0;
21491 static sqlite3_int64 getIntArg(PrintfArguments *p){
21492 if( p->nArg<=p->nUsed ) return 0;
21493 return sqlite3_value_int64(p->apArg[p->nUsed++]);
21495 static double getDoubleArg(PrintfArguments *p){
21496 if( p->nArg<=p->nUsed ) return 0.0;
21497 return sqlite3_value_double(p->apArg[p->nUsed++]);
21499 static char *getTextArg(PrintfArguments *p){
21500 if( p->nArg<=p->nUsed ) return 0;
21501 return (char*)sqlite3_value_text(p->apArg[p->nUsed++]);
22091 static int sqlite3StrAccumEnlarge(StrAccum *p, int N){
22093 assert( p->nChar+(i64)N >= p->nAlloc ); /* Only called if really needed */
22094 if( p->accError ){
22095 testcase(p->accError==STRACCUM_TOOBIG);
22096 testcase(p->accError==STRACCUM_NOMEM);
22099 if( p->mxAlloc==0 ){
22100 N = p->nAlloc - p->nChar - 1;
22101 setStrAccumError(p, STRACCUM_TOOBIG);
22104 char *zOld = (p->zText==p->zBase ? 0 : p->zText);
22105 i64 szNew = p->nChar;
22107 if( szNew+p->nChar<=p->mxAlloc ){
22110 szNew += p->nChar;
22112 if( szNew > p->mxAlloc ){
22113 sqlite3StrAccumReset(p);
22114 setStrAccumError(p, STRACCUM_TOOBIG);
22117 p->nAlloc = (int)szNew;
22119 if( p->db ){
22120 zNew = sqlite3DbRealloc(p->db, zOld, p->nAlloc);
22122 zNew = sqlite3_realloc64(zOld, p->nAlloc);
22125 assert( p->zText!=0 || p->nChar==0 );
22126 if( zOld==0 && p->nChar>0 ) memcpy(zNew, p->zText, p->nChar);
22127 p->zText = zNew;
22128 p->nAlloc = sqlite3DbMallocSize(p->db, zNew);
22130 sqlite3StrAccumReset(p);
22131 setStrAccumError(p, STRACCUM_NOMEM);
22141 SQLITE_PRIVATE void sqlite3AppendChar(StrAccum *p, int N, char c){
22142 testcase( p->nChar + (i64)N > 0x7fffffff );
22143 if( p->nChar+(i64)N >= p->nAlloc && (N = sqlite3StrAccumEnlarge(p, N))<=0 ){
22146 while( (N--)>0 ) p->zText[p->nChar++] = c;
22157 static void SQLITE_NOINLINE enlargeAndAppend(StrAccum *p, const char *z, int N){
22158 N = sqlite3StrAccumEnlarge(p, N);
22160 memcpy(&p->zText[p->nChar], z, N);
22161 p->nChar += N;
22169 SQLITE_PRIVATE void sqlite3StrAccumAppend(StrAccum *p, const char *z, int N){
22171 assert( p->zText!=0 || p->nChar==0 || p->accError );
22173 assert( p->accError==0 || p->nAlloc==0 );
22174 if( p->nChar+N >= p->nAlloc ){
22175 enlargeAndAppend(p,z,N);
22177 assert( p->zText );
22178 p->nChar += N;
22179 memcpy(&p->zText[p->nChar-N], z, N);
22186 SQLITE_PRIVATE void sqlite3StrAccumAppendAll(StrAccum *p, const char *z){
22187 sqlite3StrAccumAppend(p, z, sqlite3Strlen30(z));
22196 SQLITE_PRIVATE char *sqlite3StrAccumFinish(StrAccum *p){
22197 if( p->zText ){
22198 p->zText[p->nChar] = 0;
22199 if( p->mxAlloc>0 && p->zText==p->zBase ){
22200 p->zText = sqlite3DbMallocRaw(p->db, p->nChar+1 );
22201 if( p->zText ){
22202 memcpy(p->zText, p->zBase, p->nChar+1);
22204 setStrAccumError(p, STRACCUM_NOMEM);
22208 return p->zText;
22214 SQLITE_PRIVATE void sqlite3StrAccumReset(StrAccum *p){
22215 if( p->zText!=p->zBase ){
22216 sqlite3DbFree(p->db, p->zText);
22218 p->zText = 0;
22235 SQLITE_PRIVATE void sqlite3StrAccumInit(StrAccum *p, sqlite3 *db, char *zBase, int n, int mx){
22236 p->zText = p->zBase = zBase;
22237 p->db = db;
22238 p->nChar = 0;
22239 p->nAlloc = n;
22240 p->mxAlloc = mx;
22241 p->accError = 0;
22436 SQLITE_PRIVATE TreeView *sqlite3TreeViewPush(TreeView *p, u8 moreToFollow){
22437 if( p==0 ){
22438 p = sqlite3_malloc64( sizeof(*p) );
22439 if( p==0 ) return 0;
22440 memset(p, 0, sizeof(*p));
22442 p->iLevel++;
22445 if( p->iLevel<sizeof(p->bLine) ) p->bLine[p->iLevel] = moreToFollow;
22446 return p;
22449 SQLITE_PRIVATE void sqlite3TreeViewPop(TreeView *p){
22450 if( p==0 ) return;
22451 p->iLevel--;
22452 if( p->iLevel<0 ) sqlite3_free(p);
22456 SQLITE_PRIVATE void sqlite3TreeViewLine(TreeView *p, const char *zFormat, ...){
22462 if( p ){
22463 for(i=0; i<p->iLevel && i<sizeof(p->bLine)-1; i++){
22464 sqlite3StrAccumAppend(&acc, p->bLine[i] ? "| " : " ", 4);
22466 sqlite3StrAccumAppend(&acc, p->bLine[i] ? "|-- " : "'-- ", 4);
22477 SQLITE_PRIVATE void sqlite3TreeViewItem(TreeView *p, const char *zLabel, u8 moreToFollow){
22478 p = sqlite3TreeViewPush(p, moreToFollow);
22479 sqlite3TreeViewLine(p, "%s", zLabel);
22486 SQLITE_PRIVATE void sqlite3XPrintf(StrAccum *p, u32 bFlags, const char *zFormat, ...){
22489 sqlite3VXPrintf(p, bFlags, zFormat, ap);
22537 struct sqlite3PrngType *p = &GLOBAL(struct sqlite3PrngType, sqlite3Prng);
22538 # define wsdPrng p[0]
22684 SQLiteThread *p;
22693 p = sqlite3Malloc(sizeof(*p));
22694 if( p==0 ) return SQLITE_NOMEM;
22695 memset(p, 0, sizeof(*p));
22696 p->xTask = xTask;
22697 p->pIn = pIn;
22701 rc = pthread_create(&p->tid, 0, xTask, pIn);
22704 p->done = 1;
22705 p->pOut = xTask(pIn);
22707 *ppThread = p;
22712 SQLITE_PRIVATE int sqlite3ThreadJoin(SQLiteThread *p, void **ppOut){
22716 if( NEVER(p==0) ) return SQLITE_NOMEM;
22717 if( p->done ){
22718 *ppOut = p->pOut;
22721 rc = pthread_join(p->tid, ppOut) ? SQLITE_ERROR : SQLITE_OK;
22723 sqlite3_free(p);
22750 SQLiteThread *p = (SQLiteThread *)pArg;
22752 assert( p!=0 );
22760 assert( p->id==GetCurrentThreadId() );
22762 assert( p->xTask!=0 );
22763 p->pResult = p->xTask(p->pIn);
22775 SQLiteThread *p;
22780 p = sqlite3Malloc(sizeof(*p));
22781 if( p==0 ) return SQLITE_NOMEM;
22783 memset(p, 0, sizeof(*p));
22785 p->xTask = xTask;
22786 p->pIn = pIn;
22787 p->tid = (void*)_beginthreadex(0, 0, sqlite3ThreadProc, p, 0, &p->id);
22788 if( p->tid==0 ){
22789 memset(p, 0, sizeof(*p));
22792 if( p->xTask==0 ){
22793 p->id = GetCurrentThreadId();
22794 p->pResult = xTask(pIn);
22796 *ppThread = p;
22803 SQLITE_PRIVATE int sqlite3ThreadJoin(SQLiteThread *p, void **ppOut){
22808 if( NEVER(p==0) ) return SQLITE_NOMEM;
22809 if( p->xTask==0 ){
22810 assert( p->id==GetCurrentThreadId() );
22812 assert( p->tid==0 );
22814 assert( p->id!=0 && p->id!=GetCurrentThreadId() );
22815 rc = sqlite3Win32Wait((HANDLE)p->tid);
22817 bRc = CloseHandle((HANDLE)p->tid);
22820 if( rc==WAIT_OBJECT_0 ) *ppOut = p->pResult;
22821 sqlite3_free(p);
22850 SQLiteThread *p;
22855 p = sqlite3Malloc(sizeof(*p));
22856 if( p==0 ) return SQLITE_NOMEM;
22857 if( (SQLITE_PTR_TO_INT(p)/17)&1 ){
22858 p->xTask = xTask;
22859 p->pIn = pIn;
22861 p->xTask = 0;
22862 p->pResult = xTask(pIn);
22864 *ppThread = p;
22869 SQLITE_PRIVATE int sqlite3ThreadJoin(SQLiteThread *p, void **ppOut){
22872 if( NEVER(p==0) ) return SQLITE_NOMEM;
22873 if( p->xTask ){
22874 *ppOut = p->xTask(p->pIn);
22876 *ppOut = p->pResult;
22878 sqlite3_free(p);
24148 static int SQLITE_NOINLINE putVarint64(unsigned char *p, u64 v){
24152 p[8] = (u8)v;
24155 p[i] = (u8)((v & 0x7f) | 0x80);
24168 p[i] = buf[j];
24172 SQLITE_PRIVATE int sqlite3PutVarint(unsigned char *p, u64 v){
24174 p[0] = v&0x7f;
24178 p[0] = ((v>>7)&0x7f)|0x80;
24179 p[1] = v&0x7f;
24182 return putVarint64(p,v);
24202 SQLITE_PRIVATE u8 sqlite3GetVarint(const unsigned char *p, u64 *v){
24205 a = *p;
24213 p++;
24214 b = *p;
24229 p++;
24231 a |= *p;
24245 p++;
24247 b |= *p;
24269 p++;
24271 a |= *p;
24290 p++;
24292 b |= *p;
24306 p++;
24308 a |= *p;
24323 p++;
24325 b |= *p;
24339 p++;
24341 a |= *p;
24351 b = p[-4];
24372 SQLITE_PRIVATE u8 sqlite3GetVarint32(const unsigned char *p, u32 *v){
24377 a = *p;
24389 p++;
24390 b = *p;
24402 p++;
24404 a |= *p;
24430 p -= 2;
24431 n = sqlite3GetVarint(p, &v64);
24446 p++;
24448 b |= *p;
24460 p++;
24462 a |= *p;
24482 p -= 4;
24483 n = sqlite3GetVarint(p, &v64);
24508 SQLITE_PRIVATE u32 sqlite3Get4byte(const u8 *p){
24509 testcase( p[0]&0x80 );
24510 return ((unsigned)p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3];
24512 SQLITE_PRIVATE void sqlite3Put4byte(unsigned char *p, u32 v){
24513 p[0] = (u8)(v>>24);
24514 p[1] = (u8)(v>>16);
24515 p[2] = (u8)(v>>8);
24516 p[3] = (u8)v;
25983 static const char *unixNextSystemCall(sqlite3_vfs *p, const char *zName){
25986 UNUSED_PARAMETER(p);
26115 static int lockTrace(int fd, int op, struct flock *p){
26124 s = osFcntl(fd, op, p);
26128 if( p->l_type==F_RDLCK ){
26130 }else if( p->l_type==F_WRLCK ){
26132 }else if( p->l_type==F_UNLCK ){
26137 assert( p->l_whence==SEEK_SET );
26138 s = osFcntl(fd, op, p);
26141 threadid, fd, zOpName, zType, (int)p->l_start, (int)p->l_len,
26142 (int)p->l_pid, s);
26143 if( s==(-1) && op==F_SETLK && (p->l_type==F_RDLCK || p->l_type==F_WRLCK) ){
26145 l2 = *p;
26643 UnixUnusedFd *p;
26645 for(p=pInode->pUnused; p; p=pNext){
26646 pNext = p->pNext;
26647 robust_close(pFile, p->fd, __LINE__);
26648 sqlite3_free(p);
27173 UnixUnusedFd *p = pFile->pUnused;
27174 p->pNext = pInode->pUnused;
27175 pInode->pUnused = p;
29437 unixFile *p = (unixFile*)id;
29440 if( p->sectorSize==0 ) unixSectorSize(id);
29441 rc = p->deviceCharacteristics;
29443 if( p->ctrlFlags & UNIXFILE_PSOW ){
29649 unixShmNode *p = pFd->pInode->pShmNode;
29651 if( p && p->nRef==0 ){
29654 assert( p->pInode==pFd->pInode );
29655 sqlite3_mutex_free(p->mutex);
29656 for(i=0; i<p->nRegion; i+=nShmPerMap){
29657 if( p->h>=0 ){
29658 osMunmap(p->apRegion[i], p->szRegion);
29660 sqlite3_free(p->apRegion[i]);
29663 sqlite3_free(p->apRegion);
29664 if( p->h>=0 ){
29665 robust_close(pFd, p->h, __LINE__);
29666 p->h = -1;
29668 p->pInode->pShmNode = 0;
29669 sqlite3_free(p);
29709 struct unixShm *p = 0; /* The connection to be opened */
29717 p = sqlite3_malloc64( sizeof(*p) );
29718 if( p==0 ) return SQLITE_NOMEM;
29719 memset(p, 0, sizeof(*p));
29807 p->pShmNode = pShmNode;
29809 p->id = pShmNode->nextShmId++;
29812 pDbFd->pShm = p;
29823 p->pNext = pShmNode->pFirst;
29824 pShmNode->pFirst = p;
29831 sqlite3_free(p);
29863 unixShm *p;
29875 p = pDbFd->pShm;
29876 pShmNode = p->pShmNode;
29999 unixShm *p = pDbFd->pShm; /* The shared memory being locked */
30001 unixShmNode *pShmNode = p->pShmNode; /* The underlying file iNode */
30025 if( pX==p ) continue;
30026 assert( (pX->exclMask & (p->exclMask|p->sharedMask))==0 );
30039 p->exclMask &= ~mask;
30040 p->sharedMask &= ~mask;
30068 p->sharedMask |= mask;
30087 assert( (p->sharedMask & mask)==0 );
30088 p->exclMask |= mask;
30094 p->id, osGetpid(0), p->sharedMask, p->exclMask));
30123 unixShm *p; /* The connection to be closed */
30129 p = pDbFd->pShm;
30130 if( p==0 ) return SQLITE_OK;
30131 pShmNode = p->pShmNode;
30139 for(pp=&pShmNode->pFirst; (*pp)!=p; pp = &(*pp)->pNext){}
30140 *pp = p->pNext;
30143 sqlite3_free(p);
30364 static int unixUnfetch(sqlite3_file *fd, i64 iOff, void *p){
30372 assert( (p==0)==(pFd->nFetchOut==0) );
30375 assert( p==0 || p==&((u8 *)pFd->pMapRegion)[iOff] );
30377 if( p ){
30386 UNUSED_PARAMETER(p);
30454 static const sqlite3_io_methods *FINDER##Impl(const char *z, unixFile *p){ \
30455 UNUSED_PARAMETER(z); UNUSED_PARAMETER(p); \
30458 static const sqlite3_io_methods *(*const FINDER)(const char*,unixFile *p) \
31122 unixFile *p = (unixFile *)pFile;
31194 memset(p, 0, sizeof(unixFile));
31207 p->pUnused = pUnused;
31244 assert( !p->pUnused );
31277 if( p->pUnused ){
31278 p->pUnused->fd = fd;
31279 p->pUnused->flags = flags;
31288 robust_close(p, fd, __LINE__);
31297 p->openFlags = openFlags;
31306 storeLastErrno(p, errno);
31307 robust_close(p, fd, __LINE__);
31362 sqlite3_free(p->pUnused);
31527 static void (*unixDlSym(sqlite3_vfs *NotUsed, void *p, const char*zSym))(void){
31548 return (*x)(p, zSym);
33608 static int winMemSize(void *p);
34375 static const char *winNextSystemCall(sqlite3_vfs *p, const char *zName){
34378 UNUSED_PARAMETER(p);
34613 void *p;
34623 p = osHeapAlloc(hHeap, SQLITE_WIN32_HEAP_FLAGS, (SIZE_T)nBytes);
34624 if( !p ){
34628 return p;
34656 void *p;
34667 p = osHeapAlloc(hHeap, SQLITE_WIN32_HEAP_FLAGS, (SIZE_T)nBytes);
34669 p = osHeapReAlloc(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior, (SIZE_T)nBytes);
34671 if( !p ){
34676 return p;
34682 static int winMemSize(void *p){
34691 assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, p) );
34693 if( !p ) return 0;
34694 n = osHeapSize(hHeap, SQLITE_WIN32_HEAP_FLAGS, p);
34697 p, osGetLastError(), (void*)hHeap);
36566 winFile *p = (winFile*)id;
36568 ((p->ctrlFlags & WINFILE_PSOW)?SQLITE_IOCAP_POWERSAFE_OVERWRITE:0);
36743 winShmNode *p;
36748 while( (p = *pp)!=0 ){
36749 if( p->nRef==0 ){
36751 if( p->mutex ){ sqlite3_mutex_free(p->mutex); }
36752 for(i=0; i<p->nRegion; i++){
36753 BOOL bRc = osUnmapViewOfFile(p->aRegion[i].pMap);
36757 bRc = osCloseHandle(p->aRegion[i].hMap);
36762 if( p->hFile.h!=NULL && p->hFile.h!=INVALID_HANDLE_VALUE ){
36764 winClose((sqlite3_file *)&p->hFile);
36770 winDelete(pVfs, p->zFilename, 0);
36774 *pp = p->pNext;
36775 sqlite3_free(p->aRegion);
36776 sqlite3_free(p);
36778 pp = &p->pNext;
36791 struct winShm *p; /* The connection to be opened */
36802 p = sqlite3MallocZero( sizeof(*p) );
36803 if( p==0 ) return SQLITE_IOERR_NOMEM;
36807 sqlite3_free(p);
36866 p->pShmNode = pShmNode;
36868 p->id = pShmNode->nextShmId++;
36871 pDbFd->pShm = p;
36882 p->pNext = pShmNode->pFirst;
36883 pShmNode->pFirst = p;
36891 sqlite3_free(p);
36906 winShm *p; /* The connection to be closed */
36911 p = pDbFd->pShm;
36912 if( p==0 ) return SQLITE_OK;
36913 pShmNode = p->pShmNode;
36918 for(pp=&pShmNode->pFirst; (*pp)!=p; pp = &(*pp)->pNext){}
36919 *pp = p->pNext;
36922 sqlite3_free(p);
36949 winShm *p = pDbFd->pShm; /* The shared memory being locked */
36951 winShmNode *pShmNode = p->pShmNode;
36971 if( pX==p ) continue;
36972 assert( (pX->exclMask & (p->exclMask|p->sharedMask))==0 );
36985 p->exclMask &= ~mask;
36986 p->sharedMask &= ~mask;
37014 p->sharedMask |= mask;
37033 assert( (p->sharedMask & mask)==0 );
37034 p->exclMask |= mask;
37040 osGetCurrentProcessId(), p->id, p->sharedMask, p->exclMask,
37199 char *p = (char *)pShmNode->aRegion[iRegion].pMap;
37200 *pp = (void *)&p[iOffsetShift];
37407 static int winUnfetch(sqlite3_file *fd, i64 iOff, void *p){
37414 assert( (p==0)==(pFd->nFetchOut==0) );
37417 assert( p==0 || p==&((u8 *)pFd->pMapRegion)[iOff] );
37420 osGetCurrentProcessId(), pFd, iOff, p));
37422 if( p ){
38959 Bitvec *p;
38960 assert( sizeof(*p)==BITVEC_SZ );
38961 p = sqlite3MallocZero( sizeof(*p) );
38962 if( p ){
38963 p->iSize = iSize;
38965 return p;
38973 SQLITE_PRIVATE int sqlite3BitvecTest(Bitvec *p, u32 i){
38974 if( p==0 ) return 0;
38975 if( i>p->iSize || i==0 ) return 0;
38977 while( p->iDivisor ){
38978 u32 bin = i/p->iDivisor;
38979 i = i%p->iDivisor;
38980 p = p->u.apSub[bin];
38981 if (!p) {
38985 if( p->iSize<=BITVEC_NBIT ){
38986 return (p->u.aBitmap[i/BITVEC_SZELEM] & (1<<(i&(BITVEC_SZELEM-1))))!=0;
38989 while( p->u.aHash[h] ){
38990 if( p->u.aHash[h]==i ) return 1;
39009 SQLITE_PRIVATE int sqlite3BitvecSet(Bitvec *p, u32 i){
39011 if( p==0 ) return SQLITE_OK;
39013 assert( i<=p->iSize );
39015 while((p->iSize > BITVEC_NBIT) && p->iDivisor) {
39016 u32 bin = i/p->iDivisor;
39017 i = i%p->iDivisor;
39018 if( p->u.apSub[bin]==0 ){
39019 p->u.apSub[bin] = sqlite3BitvecCreate( p->iDivisor );
39020 if( p->u.apSub[bin]==0 ) return SQLITE_NOMEM;
39022 p = p->u.apSub[bin];
39024 if( p->iSize<=BITVEC_NBIT ){
39025 p->u.aBitmap[i/BITVEC_SZELEM] |= 1 << (i&(BITVEC_SZELEM-1));
39032 if( !p->u.aHash[h] ){
39033 if (p->nSet<(BITVEC_NINT-1)) {
39042 if( p->u.aHash[h]==i ) return SQLITE_OK;
39045 } while( p->u.aHash[h] );
39050 if( p->nSet>=BITVEC_MXHASH ){
39053 u32 *aiValues = sqlite3StackAllocRaw(0, sizeof(p->u.aHash));
39057 memcpy(aiValues, p->u.aHash, sizeof(p->u.aHash));
39058 memset(p->u.apSub, 0, sizeof(p->u.apSub));
39059 p->iDivisor = (p->iSize + BITVEC_NPTR - 1)/BITVEC_NPTR;
39060 rc = sqlite3BitvecSet(p, i);
39062 if( aiValues[j] ) rc |= sqlite3BitvecSet(p, aiValues[j]);
39069 p->nSet++;
39070 p->u.aHash[h] = i;
39080 SQLITE_PRIVATE void sqlite3BitvecClear(Bitvec *p, u32 i, void *pBuf){
39081 if( p==0 ) return;
39084 while( p->iDivisor ){
39085 u32 bin = i/p->iDivisor;
39086 i = i%p->iDivisor;
39087 p = p->u.apSub[bin];
39088 if (!p) {
39092 if( p->iSize<=BITVEC_NBIT ){
39093 p->u.aBitmap[i/BITVEC_SZELEM] &= ~(1 << (i&(BITVEC_SZELEM-1)));
39097 memcpy(aiValues, p->u.aHash, sizeof(p->u.aHash));
39098 memset(p->u.aHash, 0, sizeof(p->u.aHash));
39099 p->nSet = 0;
39103 p->nSet++;
39104 while( p->u.aHash[h] ){
39108 p->u.aHash[h] = aiValues[j];
39117 SQLITE_PRIVATE void sqlite3BitvecDestroy(Bitvec *p){
39118 if( p==0 ) return;
39119 if( p->iDivisor ){
39122 sqlite3BitvecDestroy(p->u.apSub[i]);
39125 sqlite3_free(p);
39132 SQLITE_PRIVATE u32 sqlite3BitvecSize(Bitvec *p){
39133 return p->iSize;
39301 PCache *p = pPage->pCache;
39304 assert( pPage->pDirtyNext || pPage==p->pDirtyTail );
39305 assert( pPage->pDirtyPrev || pPage==p->pDirty );
39308 if( p->pSynced==pPage ){
39313 p->pSynced = pSynced;
39319 assert( pPage==p->pDirtyTail );
39320 p->pDirtyTail = pPage->pDirtyPrev;
39325 assert( pPage==p->pDirty );
39326 p->pDirty = pPage->pDirtyNext;
39327 if( p->pDirty==0 && p->bPurgeable ){
39328 assert( p->eCreate==1 );
39329 p->eCreate = 2;
39336 assert( pPage->pDirtyNext==0 && pPage->pDirtyPrev==0 && p->pDirty!=pPage );
39338 pPage->pDirtyNext = p->pDirty;
39343 p->pDirtyTail = pPage;
39344 if( p->bPurgeable ){
39345 assert( p->eCreate==2 );
39346 p->eCreate = 1;
39349 p->pDirty = pPage;
39350 if( !p->pSynced && 0==(pPage->flags&PGHDR_NEED_SYNC) ){
39351 p->pSynced = pPage;
39360 static void pcacheUnpin(PgHdr *p){
39361 if( p->pCache->bPurgeable ){
39362 if( p->pgno==1 ){
39363 p->pCache->pPage1 = 0;
39365 sqlite3GlobalConfig.pcache2.xUnpin(p->pCache->pCache, p->pPage, 0);
39375 static int numberOfCachePages(PCache *p){
39376 if( p->szCache>=0 ){
39379 return p->szCache;
39384 return (int)((-1024*(i64)p->szCache)/(p->szPage+p->szExtra));
39426 PCache *p /* Preallocated space for the PCache */
39428 memset(p, 0, sizeof(PCache));
39429 p->szPage = 1;
39430 p->szExtra = szExtra;
39431 p->bPurgeable = bPurgeable;
39432 p->eCreate = 2;
39433 p->xStress = xStress;
39434 p->pStress = pStress;
39435 p->szCache = 100;
39436 return sqlite3PcacheSetPageSize(p, szPage);
39625 SQLITE_PRIVATE void SQLITE_NOINLINE sqlite3PcacheRelease(PgHdr *p){
39626 assert( p->nRef>0 );
39627 p->nRef--;
39628 if( p->nRef==0 ){
39629 p->pCache->nRef--;
39630 if( (p->flags&PGHDR_DIRTY)==0 ){
39631 pcacheUnpin(p);
39632 }else if( p->pDirtyPrev!=0 ){
39634 pcacheManageDirtyList(p, PCACHE_DIRTYLIST_FRONT);
39642 SQLITE_PRIVATE void sqlite3PcacheRef(PgHdr *p){
39643 assert(p->nRef>0);
39644 p->nRef++;
39652 SQLITE_PRIVATE void sqlite3PcacheDrop(PgHdr *p){
39653 assert( p->nRef==1 );
39654 if( p->flags&PGHDR_DIRTY ){
39655 pcacheManageDirtyList(p, PCACHE_DIRTYLIST_REMOVE);
39657 p->pCache->nRef--;
39658 if( p->pgno==1 ){
39659 p->pCache->pPage1 = 0;
39661 sqlite3GlobalConfig.pcache2.xUnpin(p->pCache->pCache, p->pPage, 1);
39668 SQLITE_PRIVATE void sqlite3PcacheMakeDirty(PgHdr *p){
39669 p->flags &= ~PGHDR_DONT_WRITE;
39670 assert( p->nRef>0 );
39671 if( 0==(p->flags & PGHDR_DIRTY) ){
39672 p->flags |= PGHDR_DIRTY;
39673 pcacheManageDirtyList(p, PCACHE_DIRTYLIST_ADD);
39681 SQLITE_PRIVATE void sqlite3PcacheMakeClean(PgHdr *p){
39682 if( (p->flags & PGHDR_DIRTY) ){
39683 pcacheManageDirtyList(p, PCACHE_DIRTYLIST_REMOVE);
39684 p->flags &= ~(PGHDR_DIRTY|PGHDR_NEED_SYNC);
39685 if( p->nRef==0 ){
39686 pcacheUnpin(p);
39695 PgHdr *p;
39696 while( (p = pCache->pDirty)!=0 ){
39697 sqlite3PcacheMakeClean(p);
39705 PgHdr *p;
39706 for(p=pCache->pDirty; p; p=p->pDirtyNext){
39707 p->flags &= ~PGHDR_NEED_SYNC;
39715 SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr *p, Pgno newPgno){
39716 PCache *pCache = p->pCache;
39717 assert( p->nRef>0 );
39719 sqlite3GlobalConfig.pcache2.xRekey(pCache->pCache, p->pPage, p->pgno,newPgno);
39720 p->pgno = newPgno;
39721 if( (p->flags&PGHDR_DIRTY) && (p->flags&PGHDR_NEED_SYNC) ){
39722 pcacheManageDirtyList(p, PCACHE_DIRTYLIST_FRONT);
39737 PgHdr *p;
39739 for(p=pCache->pDirty; p; p=pNext){
39740 pNext = p->pDirtyNext;
39745 assert( p->pgno>0 );
39746 if( ALWAYS(p->pgno>pgno) ){
39747 assert( p->flags&PGHDR_DIRTY );
39748 sqlite3PcacheMakeClean(p);
39814 PgHdr *a[N_SORT_BUCKET], *p;
39818 p = pIn;
39819 pIn = p->pDirty;
39820 p->pDirty = 0;
39823 a[i] = p;
39826 p = pcacheMergeDirtyList(a[i], p);
39834 a[i] = pcacheMergeDirtyList(a[i], p);
39837 p = a[0];
39839 p = pcacheMergeDirtyList(p, a[i]);
39841 return p;
39848 PgHdr *p;
39849 for(p=pCache->pDirty; p; p=p->pDirtyNext){
39850 p->pDirty = p->pDirtyNext;
39865 SQLITE_PRIVATE int sqlite3PcachePageRefcount(PgHdr *p){
39866 return p->nRef;
40093 PgFreeslot *p;
40102 p = (PgFreeslot*)pBuf;
40103 p->pNext = pcache1.pFree;
40104 pcache1.pFree = p;
40121 void *p = 0;
40125 p = (PgHdr1 *)pcache1.pFree;
40126 if( p ){
40136 if( p==0 ){
40140 p = sqlite3Malloc(nByte);
40142 if( p ){
40143 int sz = sqlite3MallocSize(p);
40150 sqlite3MemdebugSetType(p, MEMTYPE_PCACHE);
40152 return p;
40158 static int pcache1Free(void *p){
40160 if( p==0 ) return 0;
40161 if( p>=pcache1.pStart && p<pcache1.pEnd ){
40165 pSlot = (PgFreeslot*)p;
40173 assert( sqlite3MemdebugHasType(p, MEMTYPE_PCACHE) );
40174 sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
40175 nFreed = sqlite3MallocSize(p);
40181 sqlite3_free(p);
40190 static int pcache1MemSize(void *p){
40191 if( p>=pcache1.pStart && p<pcache1.pEnd ){
40195 assert( sqlite3MemdebugHasType(p, MEMTYPE_PCACHE) );
40196 sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
40197 iSize = sqlite3MallocSize(p);
40198 sqlite3MemdebugSetType(p, MEMTYPE_PCACHE);
40208 PgHdr1 *p = 0;
40218 p = sqlite3Malloc(sizeof(PgHdr1) + pCache->szExtra);
40219 if( !pPg || !p ){
40221 sqlite3_free(p);
40226 p = (PgHdr1 *)&((u8 *)pPg)[pCache->szPage];
40231 p->page.pBuf = pPg;
40232 p->page.pExtra = &p[1];
40236 return p;
40248 static void pcache1FreePage(PgHdr1 *p){
40249 if( ALWAYS(p) ){
40250 PCache1 *pCache = p->pCache;
40251 assert( sqlite3_mutex_held(p->pCache->pGroup->mutex) );
40252 pcache1Free(p->page.pBuf);
40254 sqlite3_free(p);
40274 SQLITE_PRIVATE void sqlite3PageFree(void *p){
40275 pcache1Free(p);
40312 static void pcache1ResizeHash(PCache1 *p){
40317 assert( sqlite3_mutex_held(p->pGroup->mutex) );
40319 nNew = p->nHash*2;
40324 pcache1LeaveMutex(p->pGroup);
40325 if( p->nHash ){ sqlite3BeginBenignMalloc(); }
40327 if( p->nHash ){ sqlite3EndBenignMalloc(); }
40328 pcache1EnterMutex(p->pGroup);
40330 for(i=0; i<p->nHash; i++){
40332 PgHdr1 *pNext = p->apHash[i];
40340 sqlite3_free(p->apHash);
40341 p->apHash = apNew;
40342 p->nHash = nNew;
40407 PgHdr1 *p = pGroup->pLruTail;
40408 assert( p->pCache->pGroup==pGroup );
40409 assert( p->isPinned==0 );
40410 pcache1PinPage(p);
40411 pcache1RemoveFromHash(p);
40412 pcache1FreePage(p);
40479 static void pcache1Destroy(sqlite3_pcache *p);
40546 static void pcache1Cachesize(sqlite3_pcache *p, int nMax){
40547 PCache1 *pCache = (PCache1 *)p;
40565 static void pcache1Shrink(sqlite3_pcache *p){
40566 PCache1 *pCache = (PCache1*)p;
40582 static int pcache1Pagecount(sqlite3_pcache *p){
40584 PCache1 *pCache = (PCache1*)p;
40735 sqlite3_pcache *p,
40739 PCache1 *pCache = (PCache1 *)p;
40773 sqlite3_pcache *p,
40777 PCache1 *pCache = (PCache1 *)p;
40815 sqlite3_pcache *p,
40820 PCache1 *pCache = (PCache1 *)p;
40854 static void pcache1Truncate(sqlite3_pcache *p, unsigned int iLimit){
40855 PCache1 *pCache = (PCache1 *)p;
40869 static void pcache1Destroy(sqlite3_pcache *p){
40870 PCache1 *pCache = (PCache1 *)p;
40938 PgHdr1 *p;
40940 while( (nReq<0 || nFree<nReq) && ((p=pcache1.grp.pLruTail)!=0) ){
40941 nFree += pcache1MemSize(p->page.pBuf);
40943 nFree += sqlite3MemSize(p);
40945 assert( p->isPinned==0 );
40946 pcache1PinPage(p);
40947 pcache1RemoveFromHash(p);
40948 pcache1FreePage(p);
40967 PgHdr1 *p;
40969 for(p=pcache1.grp.pLruHead; p; p=p->pLruNext){
40970 assert( p->isPinned==0 );
41118 RowSet *p;
41119 assert( N >= ROUND8(sizeof(*p)) );
41120 p = pSpace;
41121 p->pChunk = 0;
41122 p->db = db;
41123 p->pEntry = 0;
41124 p->pLast = 0;
41125 p->pForest = 0;
41126 p->pFresh = (struct RowSetEntry*)(ROUND8(sizeof(*p)) + (char*)p);
41127 p->nFresh = (u16)((N - ROUND8(sizeof(*p)))/sizeof(struct RowSetEntry));
41128 p->rsFlags = ROWSET_SORTED;
41129 p->iBatch = 0;
41130 return p;
41138 SQLITE_PRIVATE void sqlite3RowSetClear(RowSet *p){
41140 for(pChunk=p->pChunk; pChunk; pChunk = pNextChunk){
41142 sqlite3DbFree(p->db, pChunk);
41144 p->pChunk = 0;
41145 p->nFresh = 0;
41146 p->pEntry = 0;
41147 p->pLast = 0;
41148 p->pForest = 0;
41149 p->rsFlags = ROWSET_SORTED;
41160 static struct RowSetEntry *rowSetEntryAlloc(RowSet *p){
41161 assert( p!=0 );
41162 if( p->nFresh==0 ){
41164 pNew = sqlite3DbMallocRaw(p->db, sizeof(*pNew));
41168 pNew->pNextChunk = p->pChunk;
41169 p->pChunk = pNew;
41170 p->pFresh = pNew->aEntry;
41171 p->nFresh = ROWSET_ENTRY_PER_CHUNK;
41173 p->nFresh--;
41174 return p->pFresh++;
41183 SQLITE_PRIVATE void sqlite3RowSetInsert(RowSet *p, i64 rowid){
41188 assert( p!=0 && (p->rsFlags & ROWSET_NEXT)==0 );
41190 pEntry = rowSetEntryAlloc(p);
41194 pLast = p->pLast;
41196 if( (p->rsFlags & ROWSET_SORTED)!=0 && rowid<=pLast->v ){
41197 p->rsFlags &= ~ROWSET_SORTED;
41201 p->pEntry = pEntry;
41203 p->pLast = pEntry;
41284 struct RowSetEntry *p;
41285 rowSetTreeToList(pIn->pLeft, ppFirst, &p);
41286 p->pRight = pIn;
41316 struct RowSetEntry *p; /* Root of the new tree */
41322 p = *ppList;
41323 *ppList = p->pRight;
41324 p->pLeft = p->pRight = 0;
41325 return p;
41328 p = *ppList;
41329 if( p==0 ){
41332 p->pLeft = pLeft;
41333 *ppList = p->pRight;
41334 p->pRight = rowSetNDeepTree(ppList, iDepth-1);
41335 return p;
41344 struct RowSetEntry *p; /* Current tree root */
41348 p = pList;
41349 pList = p->pRight;
41350 p->pLeft = p->pRight = 0;
41352 pLeft = p;
41353 p = pList;
41354 pList = p->pRight;
41355 p->pLeft = pLeft;
41356 p->pRight = rowSetNDeepTree(&pList, iDepth);
41358 return p;
41367 static void rowSetToList(RowSet *p){
41370 assert( p!=0 && (p->rsFlags & ROWSET_NEXT)==0 );
41372 if( (p->rsFlags & ROWSET_SORTED)==0 ){
41373 p->pEntry = rowSetEntrySort(p->pEntry);
41380 assert( p->pForest==0 );
41382 while( p->pForest ){
41383 struct RowSetEntry *pTree = p->pForest->pLeft;
41387 p->pEntry = rowSetEntryMerge(p->pEntry, pHead);
41389 p->pForest = p->pForest->pRight;
41392 p->rsFlags |= ROWSET_NEXT; /* Verify this routine is never called again */
41403 SQLITE_PRIVATE int sqlite3RowSetNext(RowSet *p, i64 *pRowid){
41404 assert( p!=0 );
41407 if( (p->rsFlags & ROWSET_NEXT)==0 ) rowSetToList(p);
41410 if( p->pEntry ){
41411 *pRowid = p->pEntry->v;
41412 p->pEntry = p->pEntry->pRight;
41413 if( p->pEntry==0 ){
41414 sqlite3RowSetClear(p);
41431 struct RowSetEntry *p, *pTree;
41439 p = pRowSet->pEntry;
41440 if( p ){
41443 p = rowSetEntrySort(p);
41448 pTree->pLeft = rowSetListToTree(p);
41454 p = rowSetEntryMerge(pAux, p);
41462 pTree->pLeft = rowSetListToTree(p);
41476 p = pTree->pLeft;
41477 while( p ){
41478 if( p->v<iRowid ){
41479 p = p->pRight;
41480 }else if( p->v>iRowid ){
41481 p = p->pLeft;
41761 #define PAGERID(p) ((int)(p->fd))
42468 static int assert_pager_state(Pager *p){
42469 Pager *pPager = p;
42472 assert( p->eState==PAGER_OPEN
42473 || p->eState==PAGER_READER
42474 || p->eState==PAGER_WRITER_LOCKED
42475 || p->eState==PAGER_WRITER_CACHEMOD
42476 || p->eState==PAGER_WRITER_DBMOD
42477 || p->eState==PAGER_WRITER_FINISHED
42478 || p->eState==PAGER_ERROR
42485 assert( p->tempFile==0 || p->eLock==EXCLUSIVE_LOCK );
42486 assert( p->tempFile==0 || pPager->changeCountDone );
42491 assert( p->journalMode==PAGER_JOURNALMODE_OFF || p->useJournal );
42492 assert( p->journalMode!=PAGER_JOURNALMODE_OFF || !isOpen(p->jfd) );
42503 assert( p->noSync );
42504 assert( p->journalMode==PAGER_JOURNALMODE_OFF
42505 || p->journalMode==PAGER_JOURNALMODE_MEMORY
42507 assert( p->eState!=PAGER_ERROR && p->eState!=PAGER_OPEN );
42508 assert( pagerUseWal(p)==0 );
42515 assert( p->eLock!=PENDING_LOCK );
42517 switch( p->eState ){
42526 assert( p->eLock!=UNKNOWN_LOCK );
42527 assert( p->eLock>=SHARED_LOCK );
42531 assert( p->eLock!=UNKNOWN_LOCK );
42534 assert( p->eLock>=RESERVED_LOCK );
42543 assert( p->eLock!=UNKNOWN_LOCK );
42551 assert( p->eLock>=RESERVED_LOCK );
42552 assert( isOpen(p->jfd)
42553 || p->journalMode==PAGER_JOURNALMODE_OFF
42554 || p->journalMode==PAGER_JOURNALMODE_WAL
42562 assert( p->eLock==EXCLUSIVE_LOCK );
42565 assert( p->eLock>=EXCLUSIVE_LOCK );
42566 assert( isOpen(p->jfd)
42567 || p->journalMode==PAGER_JOURNALMODE_OFF
42568 || p->journalMode==PAGER_JOURNALMODE_WAL
42574 assert( p->eLock==EXCLUSIVE_LOCK );
42577 assert( isOpen(p->jfd)
42578 || p->journalMode==PAGER_JOURNALMODE_OFF
42579 || p->journalMode==PAGER_JOURNALMODE_WAL
42606 static char *print_pager_state(Pager *p){
42618 , p->zFilename
42619 , p->eState==PAGER_OPEN ? "OPEN" :
42620 p->eState==PAGER_READER ? "READER" :
42621 p->eState==PAGER_WRITER_LOCKED ? "WRITER_LOCKED" :
42622 p->eState==PAGER_WRITER_CACHEMOD ? "WRITER_CACHEMOD" :
42623 p->eState==PAGER_WRITER_DBMOD ? "WRITER_DBMOD" :
42624 p->eState==PAGER_WRITER_FINISHED ? "WRITER_FINISHED" :
42625 p->eState==PAGER_ERROR ? "ERROR" : "?error?"
42626 , (int)p->errCode
42627 , p->eLock==NO_LOCK ? "NO_LOCK" :
42628 p->eLock==RESERVED_LOCK ? "RESERVED" :
42629 p->eLock==EXCLUSIVE_LOCK ? "EXCLUSIVE" :
42630 p->eLock==SHARED_LOCK ? "SHARED" :
42631 p->eLock==UNKNOWN_LOCK ? "UNKNOWN" : "?error?"
42632 , p->exclusiveMode ? "exclusive" : "normal"
42633 , p->journalMode==PAGER_JOURNALMODE_MEMORY ? "memory" :
42634 p->journalMode==PAGER_JOURNALMODE_OFF ? "off" :
42635 p->journalMode==PAGER_JOURNALMODE_DELETE ? "delete" :
42636 p->journalMode==PAGER_JOURNALMODE_PERSIST ? "persist" :
42637 p->journalMode==PAGER_JOURNALMODE_TRUNCATE ? "truncate" :
42638 p->journalMode==PAGER_JOURNALMODE_WAL ? "wal" : "?error?"
42639 , (int)p->tempFile, (int)p->memDb, (int)p->useJournal
42640 , p->journalOff, p->journalHdr
42641 , (int)p->dbSize, (int)p->dbOrigSize, (int)p->dbFileSize
42659 PagerSavepoint *p;
42663 p = &pPager->aSavepoint[i];
42664 if( p->nOrig>=pgno && 0==sqlite3BitvecTest(p->pInSavepoint, pgno) ){
43358 PagerSavepoint *p = &pPager->aSavepoint[ii];
43359 if( pgno<=p->nOrig ){
43360 rc |= sqlite3BitvecSet(p->pInSavepoint, pgno);
43621 PgHdr *p = sqlite3PagerLookup(pPager, 1);
43622 if( p ){
43623 p->pageHash = 0;
43624 sqlite3PagerUnrefNotNull(p);
44677 PgHdr *p; /* For looping over pages */
44683 for(p=pList; p && p->pDirty; p=p->pDirty){
44684 assert( p->pgno < p->pDirty->pgno );
44696 for(p=pList; (*ppNext = p)!=0; p=p->pDirty){
44697 if( p->pgno<=nTruncate ){
44698 ppNext = &p->pDirty;
44713 for(p=pList; p; p=p->pDirty){
44714 sqlite3BackupUpdate(pPager->pBackup, p->pgno, (u8 *)p->pData);
44720 for(p=pList; p; p=p->pDirty){
44721 pager_set_pagehash(p);
45526 PgHdr *p; /* Memory mapped page to return */
45529 *ppPage = p = pPager->pMmapFreelist;
45530 pPager->pMmapFreelist = p->pDirty;
45531 p->pDirty = 0;
45532 memset(p->pExtra, 0, pPager->nExtra);
45534 *ppPage = p = (PgHdr *)sqlite3MallocZero(sizeof(PgHdr) + pPager->nExtra);
45535 if( p==0 ){
45539 p->pExtra = (void *)&p[1];
45540 p->flags = PGHDR_MMAP;
45541 p->nRef = 1;
45542 p->pPager = pPager;
45545 assert( p->pExtra==(void *)&p[1] );
45546 assert( p->pPage==0 );
45547 assert( p->flags==PGHDR_MMAP );
45548 assert( p->pPager==pPager );
45549 assert( p->nRef==1 );
45551 p->pgno = pgno;
45552 p->pData = pData;
45576 PgHdr *p;
45578 for(p=pPager->pMmapFreelist; p; p=pNext){
45579 pNext = p->pDirty;
45580 sqlite3_free(p);
46019 static int pagerStress(void *p, PgHdr *pPg){
46020 Pager *pPager = (Pager *)p;
50241 WalIterator *p, /* Iterator */
50249 iMin = p->iPrior;
50251 for(i=p->nSegment-1; i>=0; i--){
50252 struct WalSegment *pSegment = &p->aSegment[i];
50266 *piPage = p->iPrior = iRet;
50376 struct Sublist *p = &aSub[iSub];
50377 assert( p->aList && p->nList<=(1<<iSub) );
50378 assert( p->aList==&aList[iList&~((2<<iSub)-1)] );
50379 walMerge(aContent, p->aList, p->nList, &aMerge, &nMerge, aBuffer);
50387 struct Sublist *p = &aSub[iSub];
50388 assert( p->nList<=(1<<iSub) );
50389 assert( p->aList==&aList[nList&~((2<<iSub)-1)] );
50390 walMerge(aContent, p->aList, p->nList, &aMerge, &nMerge, aBuffer);
50409 static void walIteratorFree(WalIterator *p){
50410 sqlite3_free(p);
50426 WalIterator *p; /* Return value */
50445 p = (WalIterator *)sqlite3_malloc64(nByte);
50446 if( !p ){
50449 memset(p, 0, nByte);
50450 p->nSegment = nSegment;
50479 aIndex = &((ht_slot *)&p->aSegment[p->nSegment])[iZero];
50486 p->aSegment[i].iZero = iZero;
50487 p->aSegment[i].nEntry = nEntry;
50488 p->aSegment[i].aIndex = aIndex;
50489 p->aSegment[i].aPgno = (u32 *)aPgno;
50495 walIteratorFree(p);
50497 *pp = p;
51618 WalWriter *p, /* WAL to write to */
51624 if( iOffset<p->iSyncPoint && iOffset+iAmt>=p->iSyncPoint ){
51625 int iFirstAmt = (int)(p->iSyncPoint - iOffset);
51626 rc = sqlite3OsWrite(p->pFd, pContent, iFirstAmt, iOffset);
51631 assert( p->syncFlags & (SQLITE_SYNC_NORMAL|SQLITE_SYNC_FULL) );
51632 rc = sqlite3OsSync(p->pFd, p->syncFlags & SQLITE_SYNC_MASK);
51635 rc = sqlite3OsWrite(p->pFd, pContent, iAmt, iOffset);
51643 WalWriter *p, /* Where to write the frame */
51656 walEncodeFrame(p->pWal, pPage->pgno, nTruncate, pData, aFrame);
51657 rc = walWriteToLog(p, aFrame, sizeof(aFrame), iOffset);
51660 rc = walWriteToLog(p, pData, p->szPage, iOffset+sizeof(aFrame));
51678 PgHdr *p; /* Iterator to run through pList with. */
51693 { int cnt; for(cnt=0, p=pList; p; p=p->pDirty, cnt++){}
51761 for(p=pList; p; p=p->pDirty){
51765 nDbSize = (isCommit && p->pDirty==0) ? nTruncate : 0;
51766 rc = walWriteOneFrame(&w, p, nDbSize, iOffset);
51768 pLast = p;
51820 for(p=pList; p && rc==SQLITE_OK; p=p->pDirty){
51822 rc = walIndexAppend(pWal, iFrame, p->pgno);
52714 #define btreeIntegrity(p) \
52715 assert( p->pBt->inTransaction!=TRANS_NONE || p->pBt->nTransaction==0 ); \
52716 assert( p->pBt->inTransaction>=p->inTrans );
52761 #define put2byte(p,v) ((p)[0] = (u8)((v)>>8), (p)[1] = (u8)(v))
52775 static void lockBtreeMutex(Btree *p){
52776 assert( p->locked==0 );
52777 assert( sqlite3_mutex_notheld(p->pBt->mutex) );
52778 assert( sqlite3_mutex_held(p->db->mutex) );
52780 sqlite3_mutex_enter(p->pBt->mutex);
52781 p->pBt->db = p->db;
52782 p->locked = 1;
52789 static void SQLITE_NOINLINE unlockBtreeMutex(Btree *p){
52790 BtShared *pBt = p->pBt;
52791 assert( p->locked==1 );
52793 assert( sqlite3_mutex_held(p->db->mutex) );
52794 assert( p->db==pBt->db );
52797 p->locked = 0;
52801 static void SQLITE_NOINLINE btreeLockCarefully(Btree *p);
52819 SQLITE_PRIVATE void sqlite3BtreeEnter(Btree *p){
52824 assert( p->pNext==0 || p->pNext->pBt>p->pBt );
52825 assert( p->pPrev==0 || p->pPrev->pBt<p->pBt );
52826 assert( p->pNext==0 || p->pNext->db==p->db );
52827 assert( p->pPrev==0 || p->pPrev->db==p->db );
52828 assert( p->sharable || (p->pNext==0 && p->pPrev==0) );
52831 assert( !p->locked || p->wantToLock>0 );
52832 assert( p->sharable || p->wantToLock==0 );
52835 assert( sqlite3_mutex_held(p->db->mutex) );
52839 assert( (p->locked==0 && p->sharable) || p->pBt->db==p->db );
52841 if( !p->sharable ) return;
52842 p->wantToLock++;
52843 if( p->locked ) return;
52844 btreeLockCarefully(p);
52853 static void SQLITE_NOINLINE btreeLockCarefully(Btree *p){
52860 if( sqlite3_mutex_try(p->pBt->mutex)==SQLITE_OK ){
52861 p->pBt->db = p->db;
52862 p->locked = 1;
52871 for(pLater=p->pNext; pLater; pLater=pLater->pNext){
52879 lockBtreeMutex(p);
52880 for(pLater=p->pNext; pLater; pLater=pLater->pNext){
52891 SQLITE_PRIVATE void sqlite3BtreeLeave(Btree *p){
52892 assert( sqlite3_mutex_held(p->db->mutex) );
52893 if( p->sharable ){
52894 assert( p->wantToLock>0 );
52895 p->wantToLock--;
52896 if( p->wantToLock==0 ){
52897 unlockBtreeMutex(p);
52909 SQLITE_PRIVATE int sqlite3BtreeHoldsMutex(Btree *p){
52910 assert( p->sharable==0 || p->locked==0 || p->wantToLock>0 );
52911 assert( p->sharable==0 || p->locked==0 || p->db==p->pBt->db );
52912 assert( p->sharable==0 || p->locked==0 || sqlite3_mutex_held(p->pBt->mutex) );
52913 assert( p->sharable==0 || p->locked==0 || sqlite3_mutex_held(p->db->mutex) );
52915 return (p->sharable==0 || p->locked);
52951 Btree *p;
52954 p = db->aDb[i].pBt;
52955 if( p ) sqlite3BtreeEnter(p);
52960 Btree *p;
52963 p = db->aDb[i].pBt;
52964 if( p ) sqlite3BtreeLeave(p);
52972 SQLITE_PRIVATE int sqlite3BtreeSharable(Btree *p){
52973 return p->sharable;
52989 Btree *p;
52990 p = db->aDb[i].pBt;
52991 if( p && p->sharable &&
52992 (p->wantToLock==0 || !sqlite3_mutex_held(p->pBt->mutex)) ){
53013 Btree *p;
53019 p = db->aDb[iDb].pBt;
53020 assert( p!=0 );
53021 return p->sharable==0 || p->locked==1;
53036 SQLITE_PRIVATE void sqlite3BtreeEnter(Btree *p){
53037 p->pBt->db = p->db;
53042 Btree *p = db->aDb[i].pBt;
53043 if( p ){
53044 p->pBt->db = p->db;
53225 HashElem *p;
53226 for(p=sqliteHashFirst(&pSchema->idxHash); p; p=sqliteHashNext(p)){
53227 Index *pIdx = (Index *)sqliteHashData(p);
53279 BtCursor *p;
53280 for(p=pBtree->pBt->pCursor; p; p=p->pNext){
53281 if( p->pgnoRoot==iRoot
53282 && p->pBtree!=pBtree
53283 && 0==(p->pBtree->db->flags & SQLITE_ReadUncommitted)
53298 static int querySharedCacheTableLock(Btree *p, Pgno iTab, u8 eLock){
53299 BtShared *pBt = p->pBt;
53302 assert( sqlite3BtreeHoldsMutex(p) );
53304 assert( p->db!=0 );
53305 assert( !(p->db->flags&SQLITE_ReadUncommitted)||eLock==WRITE_LOCK||iTab==1 );
53311 assert( eLock==READ_LOCK || (p==pBt->pWriter && p->inTrans==TRANS_WRITE) );
53315 if( !p->sharable ){
53322 if( pBt->pWriter!=p && (pBt->btsFlags & BTS_EXCLUSIVE)!=0 ){
53323 sqlite3ConnectionBlocked(p->db, pBt->pWriter->db);
53338 assert( eLock==READ_LOCK || pIter->pBtree==p || pIter->eLock==READ_LOCK);
53339 if( pIter->pBtree!=p && pIter->iTable==iTab && pIter->eLock!=eLock ){
53340 sqlite3ConnectionBlocked(p->db, pIter->pBtree->db);
53342 assert( p==pBt->pWriter );
53370 static int setSharedCacheTableLock(Btree *p, Pgno iTable, u8 eLock){
53371 BtShared *pBt = p->pBt;
53375 assert( sqlite3BtreeHoldsMutex(p) );
53377 assert( p->db!=0 );
53383 assert( 0==(p->db->flags&SQLITE_ReadUncommitted) || eLock==WRITE_LOCK );
53387 assert( p->sharable );
53388 assert( SQLITE_OK==querySharedCacheTableLock(p, iTable, eLock) );
53392 if( pIter->iTable==iTable && pIter->pBtree==p ){
53407 pLock->pBtree = p;
53434 static void clearAllSharedCacheTableLocks(Btree *p){
53435 BtShared *pBt = p->pBt;
53438 assert( sqlite3BtreeHoldsMutex(p) );
53439 assert( p->sharable || 0==*ppIter );
53440 assert( p->inTrans>0 );
53446 if( pLock->pBtree==p ){
53448 assert( pLock->iTable!=1 || pLock==&p->lock );
53458 if( pBt->pWriter==p ){
53478 static void downgradeAllSharedCacheTableLocks(Btree *p){
53479 BtShared *pBt = p->pBt;
53480 if( pBt->pWriter==p ){
53485 assert( pLock->eLock==READ_LOCK || pLock->pBtree==p );
53501 static int cursorHoldsMutex(BtCursor *p){
53502 return sqlite3_mutex_held(p->pBt->mutex);
53517 BtCursor *p;
53519 for(p=pBt->pCursor; p; p=p->pNext){
53520 invalidateOverflowCache(p);
53543 BtCursor *p;
53546 for(p=pBt->pCursor; p; p=p->pNext){
53547 if( (p->curFlags & BTCF_Incrblob)!=0
53548 && (isClearTable || p->info.nKey==iRow)
53550 p->eState = CURSOR_INVALID;
53618 Bitvec *p = pBt->pHasContent;
53619 return (p && (pgno>sqlite3BitvecSize(p) || sqlite3BitvecTest(p, pgno)));
53712 BtCursor *p;
53715 for(p=pBt->pCursor; p; p=p->pNext){
53716 if( p!=pExcept && (0==iRoot || p->pgnoRoot==iRoot) ) break;
53718 return p ? saveCursorsOnList(p, iRoot, pExcept) : SQLITE_OK;
53727 BtCursor *p, /* The first cursor that needs saving */
53732 if( p!=pExcept && (0==iRoot || p->pgnoRoot==iRoot) ){
53733 if( p->eState==CURSOR_VALID || p->eState==CURSOR_SKIPNEXT ){
53734 int rc = saveCursorPosition(p);
53739 testcase( p->iPage>0 );
53740 btreeReleaseAllCursorPages(p);
53743 p = p->pNext;
53744 }while( p );
53825 #define restoreCursorPosition(p) \
53826 (p->eState>=CURSOR_REQUIRESEEK ? \
53827 btreeRestoreCursorPosition(p) : \
54834 SQLITE_PRIVATE u32 sqlite3BtreeLastPage(Btree *p){
54835 assert( sqlite3BtreeHoldsMutex(p) );
54836 assert( ((p->pBt->nPage)&0x8000000)==0 );
54837 return btreePagecount(p->pBt);
54958 Btree *p; /* Handle to return */
54995 p = sqlite3MallocZero(sizeof(Btree));
54996 if( !p ){
54999 p->inTrans = TRANS_NONE;
55000 p->db = db;
55002 p->lock.pBtree = p;
55003 p->lock.iTable = 1;
55018 p->sharable = 1;
55020 sqlite3_free(p);
55030 sqlite3_free(p);
55051 sqlite3_free(p);
55055 p->pBt = pBt;
55070 p->sharable = 1;
55104 p->pBt = pBt;
55151 if( p->sharable ){
55176 if( p->sharable ){
55182 if( p->pBt<pSib->pBt ){
55183 p->pNext = pSib;
55184 p->pPrev = 0;
55185 pSib->pPrev = p;
55187 while( pSib->pNext && pSib->pNext->pBt<p->pBt ){
55190 p->pNext = pSib->pNext;
55191 p->pPrev = pSib;
55192 if( p->pNext ){
55193 p->pNext->pPrev = p;
55195 pSib->pNext = p;
55202 *ppBtree = p;
55210 sqlite3_free(p);
55217 if( sqlite3BtreeSchema(p, 0, 0)==0 ){
55218 sqlite3PagerSetCachesize(p->pBt->pPager, SQLITE_DEFAULT_CACHE_SIZE);
55313 SQLITE_PRIVATE int sqlite3BtreeClose(Btree *p){
55314 BtShared *pBt = p->pBt;
55318 assert( sqlite3_mutex_held(p->db->mutex) );
55319 sqlite3BtreeEnter(p);
55324 if( pTmp->pBtree==p ){
55333 sqlite3BtreeRollback(p, SQLITE_OK, 0);
55334 sqlite3BtreeLeave(p);
55340 assert( p->wantToLock==0 && p->locked==0 );
55341 if( !p->sharable || removeFromSharingList(pBt) ){
55358 assert( p->wantToLock==0 );
55359 assert( p->locked==0 );
55360 if( p->pPrev ) p->pPrev->pNext = p->pNext;
55361 if( p->pNext ) p->pNext->pPrev = p->pPrev;
55364 sqlite3_free(p);
55383 SQLITE_PRIVATE int sqlite3BtreeSetCacheSize(Btree *p, int mxPage){
55384 BtShared *pBt = p->pBt;
55385 assert( sqlite3_mutex_held(p->db->mutex) );
55386 sqlite3BtreeEnter(p);
55388 sqlite3BtreeLeave(p);
55397 SQLITE_PRIVATE int sqlite3BtreeSetMmapLimit(Btree *p, sqlite3_int64 szMmap){
55398 BtShared *pBt = p->pBt;
55399 assert( sqlite3_mutex_held(p->db->mutex) );
55400 sqlite3BtreeEnter(p);
55402 sqlite3BtreeLeave(p);
55417 Btree *p, /* The btree to set the safety level on */
55420 BtShared *pBt = p->pBt;
55421 assert( sqlite3_mutex_held(p->db->mutex) );
55422 sqlite3BtreeEnter(p);
55424 sqlite3BtreeLeave(p);
55433 SQLITE_PRIVATE int sqlite3BtreeSyncDisabled(Btree *p){
55434 BtShared *pBt = p->pBt;
55436 assert( sqlite3_mutex_held(p->db->mutex) );
55437 sqlite3BtreeEnter(p);
55440 sqlite3BtreeLeave(p);
55464 SQLITE_PRIVATE int sqlite3BtreeSetPageSize(Btree *p, int pageSize, int nReserve, int iFix){
55466 BtShared *pBt = p->pBt;
55468 sqlite3BtreeEnter(p);
55473 sqlite3BtreeLeave(p);
55490 sqlite3BtreeLeave(p);
55497 SQLITE_PRIVATE int sqlite3BtreeGetPageSize(Btree *p){
55498 return p->pBt->pageSize;
55512 SQLITE_PRIVATE int sqlite3BtreeGetReserveNoMutex(Btree *p){
55514 assert( sqlite3_mutex_held(p->pBt->mutex) );
55515 n = p->pBt->pageSize - p->pBt->usableSize;
55528 SQLITE_PRIVATE int sqlite3BtreeGetOptimalReserve(Btree *p){
55530 sqlite3BtreeEnter(p);
55531 n = sqlite3BtreeGetReserveNoMutex(p);
55533 if( n<p->pBt->optimalReserve ) n = p->pBt->optimalReserve;
55535 sqlite3BtreeLeave(p);
55545 SQLITE_PRIVATE int sqlite3BtreeMaxPageCount(Btree *p, int mxPage){
55547 sqlite3BtreeEnter(p);
55548 n = sqlite3PagerMaxPageCount(p->pBt->pPager, mxPage);
55549 sqlite3BtreeLeave(p);
55558 SQLITE_PRIVATE int sqlite3BtreeSecureDelete(Btree *p, int newFlag){
55560 if( p==0 ) return 0;
55561 sqlite3BtreeEnter(p);
55563 p->pBt->btsFlags &= ~BTS_SECURE_DELETE;
55564 if( newFlag ) p->pBt->btsFlags |= BTS_SECURE_DELETE;
55566 b = (p->pBt->btsFlags & BTS_SECURE_DELETE)!=0;
55567 sqlite3BtreeLeave(p);
55577 SQLITE_PRIVATE int sqlite3BtreeSetAutoVacuum(Btree *p, int autoVacuum){
55581 BtShared *pBt = p->pBt;
55585 sqlite3BtreeEnter(p);
55592 sqlite3BtreeLeave(p);
55601 SQLITE_PRIVATE int sqlite3BtreeGetAutoVacuum(Btree *p){
55606 sqlite3BtreeEnter(p);
55608 (!p->pBt->autoVacuum)?BTREE_AUTOVACUUM_NONE:
55609 (!p->pBt->incrVacuum)?BTREE_AUTOVACUUM_FULL:
55612 sqlite3BtreeLeave(p);
55886 SQLITE_PRIVATE int sqlite3BtreeNewDb(Btree *p){
55888 sqlite3BtreeEnter(p);
55889 p->pBt->nPage = 0;
55890 rc = newDatabase(p->pBt);
55891 sqlite3BtreeLeave(p);
55930 SQLITE_PRIVATE int sqlite3BtreeBeginTrans(Btree *p, int wrflag){
55932 BtShared *pBt = p->pBt;
55935 sqlite3BtreeEnter(p);
55936 btreeIntegrity(p);
55942 if( p->inTrans==TRANS_WRITE || (p->inTrans==TRANS_READ && !wrflag) ){
55965 if( pIter->pBtree!=p ){
55972 sqlite3ConnectionBlocked(p->db, pBlock);
55981 rc = querySharedCacheTableLock(p, MASTER_ROOT, READ_LOCK);
56000 rc = sqlite3PagerBegin(pBt->pPager,wrflag>1,sqlite3TempInMemory(p->db));
56014 if( p->inTrans==TRANS_NONE ){
56017 if( p->sharable ){
56018 assert( p->lock.pBtree==p && p->lock.iTable==1 );
56019 p->lock.eLock = READ_LOCK;
56020 p->lock.pNext = pBt->pLock;
56021 pBt->pLock = &p->lock;
56025 p->inTrans = (wrflag?TRANS_WRITE:TRANS_READ);
56026 if( p->inTrans>pBt->inTransaction ){
56027 pBt->inTransaction = p->inTrans;
56033 pBt->pWriter = p;
56060 rc = sqlite3PagerOpenSavepoint(pBt->pPager, p->db->nSavepoint);
56063 btreeIntegrity(p);
56064 sqlite3BtreeLeave(p);
56400 SQLITE_PRIVATE int sqlite3BtreeIncrVacuum(Btree *p){
56402 BtShared *pBt = p->pBt;
56404 sqlite3BtreeEnter(p);
56405 assert( pBt->inTransaction==TRANS_WRITE && p->inTrans==TRANS_WRITE );
56429 sqlite3BtreeLeave(p);
56521 SQLITE_PRIVATE int sqlite3BtreeCommitPhaseOne(Btree *p, const char *zMaster){
56523 if( p->inTrans==TRANS_WRITE ){
56524 BtShared *pBt = p->pBt;
56525 sqlite3BtreeEnter(p);
56530 sqlite3BtreeLeave(p);
56539 sqlite3BtreeLeave(p);
56548 static void btreeEndTransaction(Btree *p){
56549 BtShared *pBt = p->pBt;
56550 sqlite3 *db = p->db;
56551 assert( sqlite3BtreeHoldsMutex(p) );
56556 if( p->inTrans>TRANS_NONE && db->nVdbeRead>1 ){
56560 downgradeAllSharedCacheTableLocks(p);
56561 p->inTrans = TRANS_READ;
56567 if( p->inTrans!=TRANS_NONE ){
56568 clearAllSharedCacheTableLocks(p);
56577 p->inTrans = TRANS_NONE;
56581 btreeIntegrity(p);
56610 SQLITE_PRIVATE int sqlite3BtreeCommitPhaseTwo(Btree *p, int bCleanup){
56612 if( p->inTrans==TRANS_NONE ) return SQLITE_OK;
56613 sqlite3BtreeEnter(p);
56614 btreeIntegrity(p);
56619 if( p->inTrans==TRANS_WRITE ){
56621 BtShared *pBt = p->pBt;
56626 sqlite3BtreeLeave(p);
56629 p->iDataVersion--; /* Compensate for pPager->iDataVersion++; */
56634 btreeEndTransaction(p);
56635 sqlite3BtreeLeave(p);
56642 SQLITE_PRIVATE int sqlite3BtreeCommit(Btree *p){
56644 sqlite3BtreeEnter(p);
56645 rc = sqlite3BtreeCommitPhaseOne(p, 0);
56647 rc = sqlite3BtreeCommitPhaseTwo(p, 0);
56649 sqlite3BtreeLeave(p);
56680 BtCursor *p;
56686 for(p=pBtree->pBt->pCursor; p; p=p->pNext){
56688 if( writeOnly && (p->curFlags & BTCF_WriteFlag)==0 ){
56689 if( p->eState==CURSOR_VALID || p->eState==CURSOR_SKIPNEXT ){
56690 rc = saveCursorPosition(p);
56697 sqlite3BtreeClearCursor(p);
56698 p->eState = CURSOR_FAULT;
56699 p->skipNext = errCode;
56701 for(i=0; i<=p->iPage; i++){
56702 releasePage(p->apPage[i]);
56703 p->apPage[i] = 0;
56722 SQLITE_PRIVATE int sqlite3BtreeRollback(Btree *p, int tripCode, int writeOnly){
56724 BtShared *pBt = p->pBt;
56729 sqlite3BtreeEnter(p);
56737 int rc2 = sqlite3BtreeTripAllCursors(p, tripCode, writeOnly);
56741 btreeIntegrity(p);
56743 if( p->inTrans==TRANS_WRITE ){
56768 btreeEndTransaction(p);
56769 sqlite3BtreeLeave(p);
56791 SQLITE_PRIVATE int sqlite3BtreeBeginStmt(Btree *p, int iStatement){
56793 BtShared *pBt = p->pBt;
56794 sqlite3BtreeEnter(p);
56795 assert( p->inTrans==TRANS_WRITE );
56798 assert( iStatement>p->db->nSavepoint );
56806 sqlite3BtreeLeave(p);
56822 SQLITE_PRIVATE int sqlite3BtreeSavepoint(Btree *p, int op, int iSavepoint){
56824 if( p && p->inTrans==TRANS_WRITE ){
56825 BtShared *pBt = p->pBt;
56828 sqlite3BtreeEnter(p);
56842 sqlite3BtreeLeave(p);
56880 Btree *p, /* The btree */
56886 BtShared *pBt = p->pBt; /* Shared b-tree handle */
56888 assert( sqlite3BtreeHoldsMutex(p) );
56895 assert( hasSharedCacheTableLock(p, iTable, pKeyInfo!=0, wrFlag+1) );
56896 assert( wrFlag==0 || !hasReadConflicts(p, iTable) );
56899 assert( p->inTrans>TRANS_NONE );
56900 assert( wrFlag==0 || p->inTrans==TRANS_WRITE );
56920 pCur->pBtree = p;
56933 Btree *p, /* The btree */
56940 sqlite3BtreeEnter(p);
56941 rc = btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur);
56942 sqlite3BtreeLeave(p);
56966 SQLITE_PRIVATE void sqlite3BtreeCursorZero(BtCursor *p){
56967 memset(p, 0, offsetof(BtCursor, iPage));
60612 Btree *p = pCur->pBtree;
60613 BtShared *pBt = p->pBt;
60626 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
60652 invalidateIncrblobCursors(p, nKey, 0);
60750 Btree *p = pCur->pBtree;
60751 BtShared *pBt = p->pBt;
60763 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
60764 assert( !hasReadConflicts(p, pCur->pgnoRoot) );
60801 invalidateIncrblobCursors(p, pCur->info.nKey, 0);
60872 static int btreeCreateTable(Btree *p, int *piTable, int createTabFlags){
60873 BtShared *pBt = p->pBt;
60879 assert( sqlite3BtreeHoldsMutex(p) );
60904 sqlite3BtreeGetMeta(p, BTREE_LARGEST_ROOT_PAGE, &pgnoRoot);
60991 rc = sqlite3BtreeUpdateMeta(p, 4, pgnoRoot);
61014 SQLITE_PRIVATE int sqlite3BtreeCreateTable(Btree *p, int *piTable, int flags){
61016 sqlite3BtreeEnter(p);
61017 rc = btreeCreateTable(p, piTable, flags);
61018 sqlite3BtreeLeave(p);
61092 SQLITE_PRIVATE int sqlite3BtreeClearTable(Btree *p, int iTable, int *pnChange){
61094 BtShared *pBt = p->pBt;
61095 sqlite3BtreeEnter(p);
61096 assert( p->inTrans==TRANS_WRITE );
61104 invalidateIncrblobCursors(p, 0, 1);
61107 sqlite3BtreeLeave(p);
61140 static int btreeDropTable(Btree *p, Pgno iTable, int *piMoved){
61143 BtShared *pBt = p->pBt;
61145 assert( sqlite3BtreeHoldsMutex(p) );
61146 assert( p->inTrans==TRANS_WRITE );
61157 sqlite3ConnectionBlocked(p->db, pBt->pCursor->pBtree->db);
61163 rc = sqlite3BtreeClearTable(p, iTable, 0);
61178 sqlite3BtreeGetMeta(p, BTREE_LARGEST_ROOT_PAGE, &maxRootPgno);
61227 rc = sqlite3BtreeUpdateMeta(p, 4, maxRootPgno);
61243 SQLITE_PRIVATE int sqlite3BtreeDropTable(Btree *p, int iTable, int *piMoved){
61245 sqlite3BtreeEnter(p);
61246 rc = btreeDropTable(p, iTable, piMoved);
61247 sqlite3BtreeLeave(p);
61272 SQLITE_PRIVATE void sqlite3BtreeGetMeta(Btree *p, int idx, u32 *pMeta){
61273 BtShared *pBt = p->pBt;
61275 sqlite3BtreeEnter(p);
61276 assert( p->inTrans>TRANS_NONE );
61277 assert( SQLITE_OK==querySharedCacheTableLock(p, MASTER_ROOT, READ_LOCK) );
61282 *pMeta = sqlite3PagerDataVersion(pBt->pPager) + p->iDataVersion;
61295 sqlite3BtreeLeave(p);
61302 SQLITE_PRIVATE int sqlite3BtreeUpdateMeta(Btree *p, int idx, u32 iMeta){
61303 BtShared *pBt = p->pBt;
61307 sqlite3BtreeEnter(p);
61308 assert( p->inTrans==TRANS_WRITE );
61322 sqlite3BtreeLeave(p);
61405 SQLITE_PRIVATE Pager *sqlite3BtreePager(Btree *p){
61406 return p->pBt->pPager;
61915 Btree *p, /* The btree to be checked */
61924 BtShared *pBt = p->pBt;
61927 sqlite3BtreeEnter(p);
61928 assert( p->inTrans>TRANS_NONE && pBt->inTransaction>TRANS_NONE );
61941 sqlite3BtreeLeave(p);
61948 sqlite3BtreeLeave(p);
62011 sqlite3BtreeLeave(p);
62031 SQLITE_PRIVATE const char *sqlite3BtreeGetFilename(Btree *p){
62032 assert( p->pBt->pPager!=0 );
62033 return sqlite3PagerFilename(p->pBt->pPager, 1);
62044 SQLITE_PRIVATE const char *sqlite3BtreeGetJournalname(Btree *p){
62045 assert( p->pBt->pPager!=0 );
62046 return sqlite3PagerJournalname(p->pBt->pPager);
62052 SQLITE_PRIVATE int sqlite3BtreeIsInTrans(Btree *p){
62053 assert( p==0 || sqlite3_mutex_held(p->db->mutex) );
62054 return (p && (p->inTrans==TRANS_WRITE));
62066 SQLITE_PRIVATE int sqlite3BtreeCheckpoint(Btree *p, int eMode, int *pnLog, int *pnCkpt){
62068 if( p ){
62069 BtShared *pBt = p->pBt;
62070 sqlite3BtreeEnter(p);
62076 sqlite3BtreeLeave(p);
62085 SQLITE_PRIVATE int sqlite3BtreeIsInReadTrans(Btree *p){
62086 assert( p );
62087 assert( sqlite3_mutex_held(p->db->mutex) );
62088 return p->inTrans!=TRANS_NONE;
62091 SQLITE_PRIVATE int sqlite3BtreeIsInBackup(Btree *p){
62092 assert( p );
62093 assert( sqlite3_mutex_held(p->db->mutex) );
62094 return p->nBackup!=0;
62117 SQLITE_PRIVATE void *sqlite3BtreeSchema(Btree *p, int nBytes, void(*xFree)(void *)){
62118 BtShared *pBt = p->pBt;
62119 sqlite3BtreeEnter(p);
62124 sqlite3BtreeLeave(p);
62133 SQLITE_PRIVATE int sqlite3BtreeSchemaLocked(Btree *p){
62135 assert( sqlite3_mutex_held(p->db->mutex) );
62136 sqlite3BtreeEnter(p);
62137 rc = querySharedCacheTableLock(p, MASTER_ROOT, READ_LOCK);
62139 sqlite3BtreeLeave(p);
62150 SQLITE_PRIVATE int sqlite3BtreeLockTable(Btree *p, int iTab, u8 isWriteLock){
62152 assert( p->inTrans!=TRANS_NONE );
62153 if( p->sharable ){
62158 sqlite3BtreeEnter(p);
62159 rc = querySharedCacheTableLock(p, iTab, lockType);
62161 rc = setSharedCacheTableLock(p, iTab, lockType);
62163 sqlite3BtreeLeave(p);
62290 SQLITE_PRIVATE int sqlite3BtreeIsReadonly(Btree *p){
62291 return (p->pBt->btsFlags & BTS_READ_ONLY)!=0;
62417 static int setDestPgsz(sqlite3_backup *p){
62419 rc = sqlite3BtreeSetPageSize(p->pDest,sqlite3BtreeGetPageSize(p->pSrc),-1,0);
62429 static int checkReadTransaction(sqlite3 *db, Btree *p){
62430 if( sqlite3BtreeIsInReadTrans(p) ){
62451 sqlite3_backup *p; /* Value to return */
62475 p = 0;
62481 p = (sqlite3_backup *)sqlite3MallocZero(sizeof(sqlite3_backup));
62482 if( !p ){
62488 if( p ){
62489 p->pSrc = findBtree(pDestDb, pSrcDb, zSrcDb);
62490 p->pDest = findBtree(pDestDb, pDestDb, zDestDb);
62491 p->pDestDb = pDestDb;
62492 p->pSrcDb = pSrcDb;
62493 p->iNext = 1;
62494 p->isAttached = 0;
62496 if( 0==p->pSrc || 0==p->pDest
62497 || setDestPgsz(p)==SQLITE_NOMEM
62498 || checkReadTransaction(pDestDb, p->pDest)!=SQLITE_OK
62505 sqlite3_free(p);
62506 p = 0;
62509 if( p ){
62510 p->pSrc->nBackup++;
62515 return p;
62533 sqlite3_backup *p, /* Backup handle */
62538 Pager * const pDestPager = sqlite3BtreePager(p->pDest);
62539 const int nSrcPgsz = sqlite3BtreeGetPageSize(p->pSrc);
62540 int nDestPgsz = sqlite3BtreeGetPageSize(p->pDest);
62547 int nSrcReserve = sqlite3BtreeGetReserveNoMutex(p->pSrc);
62548 int nDestReserve = sqlite3BtreeGetOptimalReserve(p->pDest);
62553 assert( sqlite3BtreeGetReserveNoMutex(p->pSrc)>=0 );
62554 assert( p->bDestLocked );
62555 assert( !isFatalError(p->rc) );
62556 assert( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) );
62593 if( iDest==PENDING_BYTE_PAGE(p->pDest->pBt) ) continue;
62611 sqlite3Put4byte(&zOut[28], sqlite3BtreeLastPage(p->pSrc));
62641 static void attachBackupObject(sqlite3_backup *p){
62643 assert( sqlite3BtreeHoldsMutex(p->pSrc) );
62644 pp = sqlite3PagerBackupPtr(sqlite3BtreePager(p->pSrc));
62645 p->pNext = *pp;
62646 *pp = p;
62647 p->isAttached = 1;
62653 SQLITE_API int SQLITE_STDCALL sqlite3_backup_step(sqlite3_backup *p, int nPage){
62660 if( p==0 ) return SQLITE_MISUSE_BKPT;
62662 sqlite3_mutex_enter(p->pSrcDb->mutex);
62663 sqlite3BtreeEnter(p->pSrc);
62664 if( p->pDestDb ){
62665 sqlite3_mutex_enter(p->pDestDb->mutex);
62668 rc = p->rc;
62670 Pager * const pSrcPager = sqlite3BtreePager(p->pSrc); /* Source pager */
62671 Pager * const pDestPager = sqlite3BtreePager(p->pDest); /* Dest pager */
62679 if( p->pDestDb && p->pSrc->pBt->inTransaction==TRANS_WRITE ){
62686 if( SQLITE_OK==rc && p->bDestLocked==0
62687 && SQLITE_OK==(rc = sqlite3BtreeBeginTrans(p->pDest, 2))
62689 p->bDestLocked = 1;
62690 sqlite3BtreeGetMeta(p->pDest, BTREE_SCHEMA_VERSION, &p->iDestSchema);
62697 if( rc==SQLITE_OK && 0==sqlite3BtreeIsInReadTrans(p->pSrc) ){
62698 rc = sqlite3BtreeBeginTrans(p->pSrc, 0);
62704 pgszSrc = sqlite3BtreeGetPageSize(p->pSrc);
62705 pgszDest = sqlite3BtreeGetPageSize(p->pDest);
62706 destMode = sqlite3PagerGetJournalMode(sqlite3BtreePager(p->pDest));
62714 nSrcPage = (int)sqlite3BtreeLastPage(p->pSrc);
62716 for(ii=0; (nPage<0 || ii<nPage) && p->iNext<=(Pgno)nSrcPage && !rc; ii++){
62717 const Pgno iSrcPg = p->iNext; /* Source page number */
62718 if( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) ){
62723 rc = backupOnePage(p, iSrcPg, sqlite3PagerGetData(pSrcPg), 0);
62727 p->iNext++;
62730 p->nPagecount = nSrcPage;
62731 p->nRemaining = nSrcPage+1-p->iNext;
62732 if( p->iNext>(Pgno)nSrcPage ){
62734 }else if( !p->isAttached ){
62735 attachBackupObject(p);
62746 rc = sqlite3BtreeNewDb(p->pDest);
62750 rc = sqlite3BtreeUpdateMeta(p->pDest,1,p->iDestSchema+1);
62753 if( p->pDestDb ){
62754 sqlite3ResetAllSchemasOfConnection(p->pDestDb);
62757 rc = sqlite3BtreeSetVersion(p->pDest, 2);
62774 assert( pgszSrc==sqlite3BtreeGetPageSize(p->pSrc) );
62775 assert( pgszDest==sqlite3BtreeGetPageSize(p->pDest) );
62779 if( nDestTruncate==(int)PENDING_BYTE_PAGE(p->pDest->pBt) ){
62807 nDestTruncate==(int)(PENDING_BYTE_PAGE(p->pDest->pBt)-1)
62819 if( iPg!=PENDING_BYTE_PAGE(p->pDest->pBt) ){
62863 && SQLITE_OK==(rc = sqlite3BtreeCommitPhaseTwo(p->pDest, 0))
62877 TESTONLY( rc2 = ) sqlite3BtreeCommitPhaseOne(p->pSrc, 0);
62878 TESTONLY( rc2 |= ) sqlite3BtreeCommitPhaseTwo(p->pSrc, 0);
62885 p->rc = rc;
62887 if( p->pDestDb ){
62888 sqlite3_mutex_leave(p->pDestDb->mutex);
62890 sqlite3BtreeLeave(p->pSrc);
62891 sqlite3_mutex_leave(p->pSrcDb->mutex);
62898 SQLITE_API int SQLITE_STDCALL sqlite3_backup_finish(sqlite3_backup *p){
62904 if( p==0 ) return SQLITE_OK;
62905 pSrcDb = p->pSrcDb;
62907 sqlite3BtreeEnter(p->pSrc);
62908 if( p->pDestDb ){
62909 sqlite3_mutex_enter(p->pDestDb->mutex);
62913 if( p->pDestDb ){
62914 p->pSrc->nBackup--;
62916 if( p->isAttached ){
62917 pp = sqlite3PagerBackupPtr(sqlite3BtreePager(p->pSrc));
62918 while( *pp!=p ){
62921 *pp = p->pNext;
62925 sqlite3BtreeRollback(p->pDest, SQLITE_OK, 0);
62928 rc = (p->rc==SQLITE_DONE) ? SQLITE_OK : p->rc;
62929 if( p->pDestDb ){
62930 sqlite3Error(p->pDestDb, rc);
62933 sqlite3LeaveMutexAndCloseZombie(p->pDestDb);
62935 sqlite3BtreeLeave(p->pSrc);
62936 if( p->pDestDb ){
62940 sqlite3_free(p);
62950 SQLITE_API int SQLITE_STDCALL sqlite3_backup_remaining(sqlite3_backup *p){
62952 if( p==0 ){
62957 return p->nRemaining;
62964 SQLITE_API int SQLITE_STDCALL sqlite3_backup_pagecount(sqlite3_backup *p){
62966 if( p==0 ){
62971 return p->nPagecount;
62987 sqlite3_backup *p; /* Iterator variable */
62988 for(p=pBackup; p; p=p->pNext){
62989 assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) );
62990 if( !isFatalError(p->rc) && iPage<p->iNext ){
62996 assert( p->pDestDb );
62997 sqlite3_mutex_enter(p->pDestDb->mutex);
62998 rc = backupOnePage(p, iPage, aData, 1);
62999 sqlite3_mutex_leave(p->pDestDb->mutex);
63002 p->rc = rc;
63020 sqlite3_backup *p; /* Iterator variable */
63021 for(p=pBackup; p; p=p->pNext){
63022 assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) );
63023 p->iNext = 1;
63114 SQLITE_PRIVATE int sqlite3VdbeCheckMemInvariants(Mem *p){
63118 assert( (p->flags & MEM_Dyn)==0 || p->xDel!=0 );
63124 assert( (p->flags & MEM_Dyn)==0 || p->szMalloc==0 );
63127 assert( (p->flags & (MEM_Int|MEM_Real))!=(MEM_Int|MEM_Real) );
63130 assert( p->szMalloc==0
63131 || p->szMalloc==sqlite3DbMallocSize(p->db,p->zMalloc) );
63141 if( (p->flags & (MEM_Str|MEM_Blob)) && p->n>0 ){
63143 ((p->szMalloc>0 && p->z==p->zMalloc)? 1 : 0) +
63144 ((p->flags&MEM_Dyn)!=0 ? 1 : 0) +
63145 ((p->flags&MEM_Ephem)!=0 ? 1 : 0) +
63146 ((p->flags&MEM_Static)!=0 ? 1 : 0) == 1
63445 static SQLITE_NOINLINE void vdbeMemClearExternAndSetNull(Mem *p){
63446 assert( p->db==0 || sqlite3_mutex_held(p->db->mutex) );
63447 assert( VdbeMemDynamic(p) );
63448 if( p->flags&MEM_Agg ){
63449 sqlite3VdbeMemFinalize(p, p->u.pDef);
63450 assert( (p->flags & MEM_Agg)==0 );
63451 testcase( p->flags & MEM_Dyn );
63453 if( p->flags&MEM_Dyn ){
63454 assert( (p->flags&MEM_RowSet)==0 );
63455 assert( p->xDel!=SQLITE_DYNAMIC && p->xDel!=0 );
63456 p->xDel((void *)p->z);
63457 }else if( p->flags&MEM_RowSet ){
63458 sqlite3RowSetClear(p->u.pRowSet);
63459 }else if( p->flags&MEM_Frame ){
63460 VdbeFrame *pFrame = p->u.pFrame;
63464 p->flags = MEM_Null;
63475 static SQLITE_NOINLINE void vdbeMemClear(Mem *p){
63476 if( VdbeMemDynamic(p) ){
63477 vdbeMemClearExternAndSetNull(p);
63479 if( p->szMalloc ){
63480 sqlite3DbFree(p->db, p->zMalloc);
63481 p->szMalloc = 0;
63483 p->z = 0;
63496 SQLITE_PRIVATE void sqlite3VdbeMemRelease(Mem *p){
63497 assert( sqlite3VdbeCheckMemInvariants(p) );
63498 if( VdbeMemDynamic(p) || p->szMalloc ){
63499 vdbeMemClear(p);
63743 SQLITE_PRIVATE void sqlite3ValueSetNull(sqlite3_value *p){
63744 sqlite3VdbeMemSetNull((Mem*)p);
63825 SQLITE_PRIVATE int sqlite3VdbeMemTooBig(Mem *p){
63826 assert( p->db!=0 );
63827 if( p->flags & (MEM_Str|MEM_Blob) ){
63828 int n = p->n;
63829 if( p->flags & MEM_Zero ){
63830 n += p->u.nZero;
63832 return n>p->db->aLimit[SQLITE_LIMIT_LENGTH];
64153 Mem *p = sqlite3DbMallocZero(db, sizeof(*p));
64154 if( p ){
64155 p->flags = MEM_Null;
64156 p->db = db;
64158 return p;
64183 static sqlite3_value *valueNew(sqlite3 *db, struct ValueNewStat4Ctx *p){
64185 if( p ){
64186 UnpackedRecord *pRec = p->ppRec[0];
64189 Index *pIdx = p->pIdx; /* Index being probed */
64197 pRec->pKeyInfo = sqlite3KeyInfoOfIndex(p->pParse, pIdx);
64212 p->ppRec[0] = pRec;
64215 pRec->nField = p->iVal+1;
64216 return &pRec->aMem[p->iVal];
64219 UNUSED_PARAMETER(p);
64247 Expr *p, /* The expression to evaluate */
64264 assert( (p->flags & EP_TokenOnly)==0 );
64265 pList = p->x.pList;
64267 nName = sqlite3Strlen30(p->u.zToken);
64268 pFunc = sqlite3FindFunction(db, p->u.zToken, nName, nVal, enc, 0);
64772 Mem *p = (Mem*)pVal;
64773 if( (p->flags & MEM_Blob)!=0 || sqlite3ValueText(pVal, enc) ){
64774 if( p->flags & MEM_Zero ){
64775 return p->n + p->u.nZero;
64777 return p->n;
64805 Vdbe *p;
64806 p = sqlite3DbMallocZero(db, sizeof(Vdbe) );
64807 if( p==0 ) return 0;
64808 p->db = db;
64810 db->pVdbe->pPrev = p;
64812 p->pNext = db->pVdbe;
64813 p->pPrev = 0;
64814 db->pVdbe = p;
64815 p->magic = VDBE_MAGIC_INIT;
64816 p->pParse = pParse;
64820 return p;
64826 SQLITE_PRIVATE void sqlite3VdbeSetSql(Vdbe *p, const char *z, int n, int isPrepareV2){
64828 if( p==0 ) return;
64832 assert( p->zSql==0 );
64833 p->zSql = sqlite3DbStrNDup(p->db, z, n);
64834 p->isPrepareV2 = (u8)isPrepareV2;
64841 Vdbe *p = (Vdbe *)pStmt;
64842 return (p && p->isPrepareV2) ? p->zSql : 0;
64878 Parse *p = v->pParse;
64888 int nNew = (p->nOpAlloc>=512 ? p->nOpAlloc*2 : p->nOpAlloc+nOp);
64890 int nNew = (p->nOpAlloc ? p->nOpAlloc*2 : (int)(1024/sizeof(Op)));
64895 assert( nNew>=(p->nOpAlloc+nOp) );
64896 pNew = sqlite3DbRealloc(p->db, v->aOp, nNew*sizeof(Op));
64898 p->nOpAlloc = sqlite3DbMallocSize(p->db, pNew)/sizeof(Op);
64931 SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe *p, int op, int p1, int p2, int p3){
64935 i = p->nOp;
64936 assert( p->magic==VDBE_MAGIC_INIT );
64938 if( p->pParse->nOpAlloc<=i ){
64939 if( growOpArray(p, 1) ){
64943 p->nOp++;
64944 pOp = &p->aOp[i];
64950 pOp->p4.p = 0;
64956 if( p->db->flags & SQLITE_VdbeAddopTrace ){
64958 Parse *pParse = p->pParse;
64966 sqlite3VdbePrintOp(0, i, &p->aOp[i]);
64979 SQLITE_PRIVATE int sqlite3VdbeAddOp0(Vdbe *p, int op){
64980 return sqlite3VdbeAddOp3(p, op, 0, 0, 0);
64982 SQLITE_PRIVATE int sqlite3VdbeAddOp1(Vdbe *p, int op, int p1){
64983 return sqlite3VdbeAddOp3(p, op, p1, 0, 0);
64985 SQLITE_PRIVATE int sqlite3VdbeAddOp2(Vdbe *p, int op, int p1, int p2){
64986 return sqlite3VdbeAddOp3(p, op, p1, p2, 0);
64994 Vdbe *p, /* Add the opcode to this VM */
65002 int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3);
65003 sqlite3VdbeChangeP4(p, addr, zP4, p4type);
65015 SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe *p, int iDb, char *zWhere){
65017 int addr = sqlite3VdbeAddOp3(p, OP_ParseSchema, iDb, 0, 0);
65018 sqlite3VdbeChangeP4(p, addr, zWhere, P4_DYNAMIC);
65019 for(j=0; j<p->db->nDb; j++) sqlite3VdbeUsesBtree(p, j);
65026 Vdbe *p, /* Add the opcode to this VM */
65033 int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3);
65034 sqlite3VdbeChangeP4(p, addr, SQLITE_INT_TO_PTR(p4), P4_INT32);
65053 Parse *p = v->pParse;
65054 int i = p->nLabel++;
65057 p->aLabel = sqlite3DbReallocOrFree(p->db, p->aLabel,
65058 (i*2+1)*sizeof(p->aLabel[0]));
65060 if( p->aLabel ){
65061 p->aLabel[i] = -1;
65072 Parse *p = v->pParse;
65075 assert( j<p->nLabel );
65076 if( ALWAYS(j>=0) && p->aLabel ){
65077 p->aLabel[j] = v->nOp;
65079 p->iFixedOp = v->nOp - 1;
65085 SQLITE_PRIVATE void sqlite3VdbeRunOnlyOnce(Vdbe *p){
65086 p->runOnlyOnce = 1;
65115 static Op *opIterNext(VdbeOpIter *p){
65116 Vdbe *v = p->v;
65121 if( p->iSub<=p->nSub ){
65123 if( p->iSub==0 ){
65127 aOp = p->apSub[p->iSub-1]->aOp;
65128 nOp = p->apSub[p->iSub-1]->nOp;
65130 assert( p->iAddr<nOp );
65132 pRet = &aOp[p->iAddr];
65133 p->iAddr++;
65134 if( p->iAddr==nOp ){
65135 p->iSub++;
65136 p->iAddr = 0;
65140 int nByte = (p->nSub+1)*sizeof(SubProgram*);
65142 for(j=0; j<p->nSub; j++){
65143 if( p->apSub[j]==pRet->p4.pProgram ) break;
65145 if( j==p->nSub ){
65146 p->apSub = sqlite3DbReallocOrFree(v->db, p->apSub, nByte);
65147 if( !p->apSub ){
65150 p->apSub[p->nSub++] = pRet->p4.pProgram;
65226 static void resolveP2Values(Vdbe *p, int *pMaxFuncArgs){
65230 Parse *pParse = p->pParse;
65232 p->readOnly = 1;
65233 p->bIsReader = 0;
65234 for(pOp=p->aOp, i=p->nOp-1; i>=0; i--, pOp++){
65246 if( pOp->p2!=0 ) p->readOnly = 0;
65251 p->bIsReader = 1;
65259 p->readOnly = 0;
65260 p->bIsReader = 1;
65270 assert( p->nOp - i >= 3 );
65298 sqlite3DbFree(p->db, pParse->aLabel);
65302 assert( p->bIsReader!=0 || DbMaskAllZero(p->btreeMask) );
65308 SQLITE_PRIVATE int sqlite3VdbeCurrentAddr(Vdbe *p){
65309 assert( p->magic==VDBE_MAGIC_INIT );
65310 return p->nOp;
65324 SQLITE_PRIVATE VdbeOp *sqlite3VdbeTakeOpArray(Vdbe *p, int *pnOp, int *pnMaxArg){
65325 VdbeOp *aOp = p->aOp;
65326 assert( aOp && !p->db->mallocFailed );
65329 assert( DbMaskAllZero(p->btreeMask) );
65331 resolveP2Values(p, pnMaxArg);
65332 *pnOp = p->nOp;
65333 p->aOp = 0;
65341 SQLITE_PRIVATE int sqlite3VdbeAddOpList(Vdbe *p, int nOp, VdbeOpList const *aOp, int iLineno){
65343 assert( p->magic==VDBE_MAGIC_INIT );
65344 if( p->nOp + nOp > p->pParse->nOpAlloc && growOpArray(p, nOp) ){
65347 addr = p->nOp;
65353 VdbeOp *pOut = &p->aOp[i+addr];
65364 pOut->p4.p = 0;
65375 if( p->db->flags & SQLITE_VdbeAddopTrace ){
65376 sqlite3VdbePrintOp(0, i+addr, &p->aOp[i+addr]);
65380 p->nOp += nOp;
65390 Vdbe *p, /* VM to add scanstatus() to */
65397 int nByte = (p->nScan+1) * sizeof(ScanStatus);
65399 aNew = (ScanStatus*)sqlite3DbRealloc(p->db, p->aScan, nByte);
65401 ScanStatus *pNew = &aNew[p->nScan++];
65406 pNew->zName = sqlite3DbStrDup(p->db, zName);
65407 p->aScan = aNew;
65419 SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe *p, u32 addr, int val){
65420 assert( p!=0 );
65421 if( ((u32)p->nOp)>addr ){
65422 p->aOp[addr].p1 = val;
65430 SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe *p, u32 addr, int val){
65431 assert( p!=0 );
65432 if( ((u32)p->nOp)>addr ){
65433 p->aOp[addr].p2 = val;
65440 SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe *p, u32 addr, int val){
65441 assert( p!=0 );
65442 if( ((u32)p->nOp)>addr ){
65443 p->aOp[addr].p3 = val;
65451 SQLITE_PRIVATE void sqlite3VdbeChangeP5(Vdbe *p, u8 val){
65452 assert( p!=0 );
65453 if( p->aOp ){
65454 assert( p->nOp>0 );
65455 p->aOp[p->nOp-1].p5 = val;
65463 SQLITE_PRIVATE void sqlite3VdbeJumpHere(Vdbe *p, int addr){
65464 sqlite3VdbeChangeP2(p, addr, p->nOp);
65465 p->pParse->iFixedOp = p->nOp - 1;
65511 Mem *p = (Mem*)p4;
65512 if( p->szMalloc ) sqlite3DbFree(db, p->zMalloc);
65513 sqlite3DbFree(db, p);
65534 freeP4(db, pOp->p4type, pOp->p4.p);
65548 SQLITE_PRIVATE void sqlite3VdbeLinkSubProgram(Vdbe *pVdbe, SubProgram *p){
65549 p->pNext = pVdbe->pProgram;
65550 pVdbe->pProgram = p;
65556 SQLITE_PRIVATE void sqlite3VdbeChangeToNoop(Vdbe *p, int addr){
65557 if( addr<p->nOp ){
65558 VdbeOp *pOp = &p->aOp[addr];
65559 sqlite3 *db = p->db;
65560 freeP4(db, pOp->p4type, pOp->p4.p);
65563 if( addr==p->nOp-1 ) p->nOp--;
65571 SQLITE_PRIVATE int sqlite3VdbeDeletePriorOpcode(Vdbe *p, u8 op){
65572 if( (p->nOp-1)>(p->pParse->iFixedOp) && p->aOp[p->nOp-1].opcode==op ){
65573 sqlite3VdbeChangeToNoop(p, p->nOp-1);
65597 SQLITE_PRIVATE void sqlite3VdbeChangeP4(Vdbe *p, int addr, const char *zP4, int n){
65600 assert( p!=0 );
65601 db = p->db;
65602 assert( p->magic==VDBE_MAGIC_INIT );
65603 if( p->aOp==0 || db->mallocFailed ){
65609 assert( p->nOp>0 );
65610 assert( addr<p->nOp );
65612 addr = p->nOp - 1;
65614 pOp = &p->aOp[addr];
65618 freeP4(db, pOp->p4type, pOp->p4.p);
65619 pOp->p4.p = 0;
65626 pOp->p4.p = 0;
65629 pOp->p4.p = (void*)zP4;
65632 pOp->p4.p = (void*)zP4;
65635 assert( ((VTable *)zP4)->db==p->db );
65637 pOp->p4.p = (void*)zP4;
65641 pOp->p4.z = sqlite3DbStrNDup(p->db, zP4, n);
65665 static void vdbeVComment(Vdbe *p, const char *zFormat, va_list ap){
65666 assert( p->nOp>0 || p->aOp==0 );
65667 assert( p->aOp==0 || p->aOp[p->nOp-1].zComment==0 || p->db->mallocFailed );
65668 if( p->nOp ){
65669 assert( p->aOp );
65670 sqlite3DbFree(p->db, p->aOp[p->nOp-1].zComment);
65671 p->aOp[p->nOp-1].zComment = sqlite3VMPrintf(p->db, zFormat, ap);
65674 SQLITE_PRIVATE void sqlite3VdbeComment(Vdbe *p, const char *zFormat, ...){
65676 if( p ){
65678 vdbeVComment(p, zFormat, ap);
65682 SQLITE_PRIVATE void sqlite3VdbeNoopComment(Vdbe *p, const char *zFormat, ...){
65684 if( p ){
65685 sqlite3VdbeAddOp0(p, OP_Noop);
65687 vdbeVComment(p, zFormat, ap);
65715 SQLITE_PRIVATE VdbeOp *sqlite3VdbeGetOp(Vdbe *p, int addr){
65719 assert( p->magic==VDBE_MAGIC_INIT );
65721 addr = p->nOp - 1;
65723 assert( (addr>=0 && addr<p->nOp) || p->db->mallocFailed );
65724 if( p->db->mallocFailed ){
65727 return &p->aOp[addr];
65940 SQLITE_PRIVATE void sqlite3VdbeUsesBtree(Vdbe *p, int i){
65941 assert( i>=0 && i<p->db->nDb && i<(int)sizeof(yDbMask)*8 );
65942 assert( i<(int)sizeof(p->btreeMask)*8 );
65943 DbMaskSet(p->btreeMask, i);
65944 if( i!=1 && sqlite3BtreeSharable(p->db->aDb[i].pBt) ){
65945 DbMaskSet(p->lockMask, i);
65971 SQLITE_PRIVATE void sqlite3VdbeEnter(Vdbe *p){
65976 if( DbMaskAllZero(p->lockMask) ) return; /* The common case */
65977 db = p->db;
65981 if( i!=1 && DbMaskTest(p->lockMask,i) && ALWAYS(aDb[i].pBt!=0) ){
65992 SQLITE_PRIVATE void sqlite3VdbeLeave(Vdbe *p){
65997 if( DbMaskAllZero(p->lockMask) ) return; /* The common case */
65998 db = p->db;
66002 if( i!=1 && DbMaskTest(p->lockMask,i) && ALWAYS(aDb[i].pBt!=0) ){
66039 static void releaseMemArray(Mem *p, int N){
66040 if( p && N ){
66041 Mem *pEnd = &p[N];
66042 sqlite3 *db = p->db;
66046 if( p->szMalloc ) sqlite3DbFree(db, p->zMalloc);
66047 }while( (++p)<pEnd );
66051 assert( (&p[1])==pEnd || p[0].db==p[1].db );
66052 assert( sqlite3VdbeCheckMemInvariants(p) );
66066 testcase( p->flags & MEM_Agg );
66067 testcase( p->flags & MEM_Dyn );
66068 testcase( p->flags & MEM_Frame );
66069 testcase( p->flags & MEM_RowSet );
66070 if( p->flags&(MEM_Agg|MEM_Dyn|MEM_Frame|MEM_RowSet) ){
66071 sqlite3VdbeMemRelease(p);
66072 }else if( p->szMalloc ){
66073 sqlite3DbFree(db, p->zMalloc);
66074 p->szMalloc = 0;
66077 p->flags = MEM_Undefined;
66078 }while( (++p)<pEnd );
66087 SQLITE_PRIVATE void sqlite3VdbeFrameDelete(VdbeFrame *p){
66089 Mem *aMem = VdbeFrameMem(p);
66090 VdbeCursor **apCsr = (VdbeCursor **)&aMem[p->nChildMem];
66091 for(i=0; i<p->nChildCsr; i++){
66092 sqlite3VdbeFreeCursor(p->v, apCsr[i]);
66094 releaseMemArray(aMem, p->nChildMem);
66095 sqlite3DbFree(p->v->db, p);
66115 Vdbe *p /* The VDBE */
66121 sqlite3 *db = p->db; /* The database connection */
66124 Mem *pMem = &p->aMem[1]; /* First Mem of result set */
66126 assert( p->explain );
66127 assert( p->magic==VDBE_MAGIC_RUN );
66128 assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY || p->rc==SQLITE_NOMEM );
66135 p->pResultSet = 0;
66137 if( p->rc==SQLITE_NOMEM ){
66151 nRow = p->nOp;
66152 if( p->explain==1 ){
66157 assert( p->nMem>9 );
66158 pSub = &p->aMem[9];
66171 i = p->pc++;
66172 }while( i<nRow && p->explain==2 && p->aOp[i].opcode!=OP_Explain );
66174 p->rc = SQLITE_OK;
66177 p->rc = SQLITE_INTERRUPT;
66179 sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3ErrStr(p->rc));
66183 if( i<p->nOp ){
66186 pOp = &p->aOp[i];
66191 i -= p->nOp;
66197 if( p->explain==1 ){
66242 assert( p->db->mallocFailed );
66256 if( p->explain==1 ){
66258 assert( p->db->mallocFailed );
66269 assert( p->db->mallocFailed );
66280 p->nResColumn = 8 - 4*(p->explain-1);
66281 p->pResultSet = &p->aMem[1];
66282 p->rc = SQLITE_OK;
66293 SQLITE_PRIVATE void sqlite3VdbePrintSql(Vdbe *p){
66295 if( p->zSql ){
66296 z = p->zSql;
66297 }else if( p->nOp>=1 ){
66298 const VdbeOp *pOp = &p->aOp[0];
66312 SQLITE_PRIVATE void sqlite3VdbeIOTraceSql(Vdbe *p){
66313 int nOp = p->nOp;
66317 pOp = &p->aOp[0];
66382 SQLITE_PRIVATE void sqlite3VdbeRewind(Vdbe *p){
66386 assert( p!=0 );
66387 assert( p->magic==VDBE_MAGIC_INIT );
66391 assert( p->nOp>0 );
66394 p->magic = VDBE_MAGIC_RUN;
66397 for(i=1; i<p->nMem; i++){
66398 assert( p->aMem[i].db==p->db );
66401 p->pc = -1;
66402 p->rc = SQLITE_OK;
66403 p->errorAction = OE_Abort;
66404 p->magic = VDBE_MAGIC_RUN;
66405 p->nChange = 0;
66406 p->cacheCtr = 1;
66407 p->minWriteFileFormat = 255;
66408 p->iStatement = 0;
66409 p->nFkConstraint = 0;
66411 for(i=0; i<p->nOp; i++){
66412 p->aOp[i].cnt = 0;
66413 p->aOp[i].cycles = 0;
66437 Vdbe *p, /* The VDBE */
66451 assert( p!=0 );
66452 assert( p->nOp>0 );
66454 assert( p->magic==VDBE_MAGIC_INIT );
66455 assert( pParse==p->pParse );
66456 db = p->db;
66479 zCsr = (u8*)&p->aOp[p->nOp]; /* Memory avaliable for allocation */
66480 zEnd = (u8*)&p->aOp[pParse->nOpAlloc]; /* First byte past end of zCsr[] */
66482 resolveP2Values(p, &nArg);
66483 p->usesStmtJournal = (u8)(pParse->isMultiWrite && pParse->mayAbort);
66490 p->expired = 0;
66504 p->aMem = allocSpace(p->aMem, nMem*sizeof(Mem), &zCsr, zEnd, &nByte);
66505 p->aVar = allocSpace(p->aVar, nVar*sizeof(Mem), &zCsr, zEnd, &nByte);
66506 p->apArg = allocSpace(p->apArg, nArg*sizeof(Mem*), &zCsr, zEnd, &nByte);
66507 p->azVar = allocSpace(p->azVar, nVar*sizeof(char*), &zCsr, zEnd, &nByte);
66508 p->apCsr = allocSpace(p->apCsr, nCursor*sizeof(VdbeCursor*),
66510 p->aOnceFlag = allocSpace(p->aOnceFlag, nOnce, &zCsr, zEnd, &nByte);
66512 p->anExec = allocSpace(p->anExec, p->nOp*sizeof(i64), &zCsr, zEnd, &nByte);
66515 p->pFree = sqlite3DbMallocZero(db, nByte);
66517 zCsr = p->pFree;
66521 p->nCursor = nCursor;
66522 p->nOnceFlag = nOnce;
66523 if( p->aVar ){
66524 p->nVar = (ynVar)nVar;
66526 p->aVar[n].flags = MEM_Null;
66527 p->aVar[n].db = db;
66530 if( p->azVar && pParse->nzVar>0 ){
66531 p->nzVar = pParse->nzVar;
66532 memcpy(p->azVar, pParse->azVar, p->nzVar*sizeof(p->azVar[0]));
66535 if( p->aMem ){
66536 p->aMem--; /* aMem[] goes from 1..nMem */
66537 p->nMem = nMem; /* not from 0..nMem-1 */
66539 p->aMem[n].flags = MEM_Undefined;
66540 p->aMem[n].db = db;
66543 p->explain = pParse->explain;
66544 sqlite3VdbeRewind(p);
66551 SQLITE_PRIVATE void sqlite3VdbeFreeCursor(Vdbe *p, VdbeCursor *pCx){
66555 sqlite3VdbeSorterClose(p->db, pCx);
66577 static void closeCursorsInFrame(Vdbe *p){
66578 if( p->apCsr ){
66580 for(i=0; i<p->nCursor; i++){
66581 VdbeCursor *pC = p->apCsr[i];
66583 sqlite3VdbeFreeCursor(p, pC);
66584 p->apCsr[i] = 0;
66623 static void closeAllCursors(Vdbe *p){
66624 if( p->pFrame ){
66626 for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent);
66628 p->pFrame = 0;
66629 p->nFrame = 0;
66631 assert( p->nFrame==0 );
66632 closeCursorsInFrame(p);
66633 if( p->aMem ){
66634 releaseMemArray(&p->aMem[1], p->nMem);
66636 while( p->pDelFrame ){
66637 VdbeFrame *pDel = p->pDelFrame;
66638 p->pDelFrame = pDel->pParent;
66643 if( p->pAuxData ) sqlite3VdbeDeleteAuxData(p, -1, 0);
66644 assert( p->pAuxData==0 );
66650 static void Cleanup(Vdbe *p){
66651 sqlite3 *db = p->db;
66657 if( p->apCsr ) for(i=0; i<p->nCursor; i++) assert( p->apCsr[i]==0 );
66658 if( p->aMem ){
66659 for(i=1; i<=p->nMem; i++) assert( p->aMem[i].flags==MEM_Undefined );
66663 sqlite3DbFree(db, p->zErrMsg);
66664 p->zErrMsg = 0;
66665 p->pResultSet = 0;
66674 SQLITE_PRIVATE void sqlite3VdbeSetNumCols(Vdbe *p, int nResColumn){
66677 sqlite3 *db = p->db;
66679 releaseMemArray(p->aColName, p->nResColumn*COLNAME_N);
66680 sqlite3DbFree(db, p->aColName);
66682 p->nResColumn = (u16)nResColumn;
66683 p->aColName = pColName = (Mem*)sqlite3DbMallocZero(db, sizeof(Mem)*n );
66684 if( p->aColName==0 ) return;
66687 pColName->db = p->db;
66703 Vdbe *p, /* Vdbe being configured */
66711 assert( idx<p->nResColumn );
66713 if( p->db->mallocFailed ){
66717 assert( p->aColName!=0 );
66718 pColName = &(p->aColName[idx+var*p->nResColumn]);
66730 static int vdbeCommit(sqlite3 *db, Vdbe *p){
66740 UNUSED_PARAMETER(p);
66749 rc = sqlite3VtabSync(db, p);
66978 Vdbe *p;
66982 p = db->pVdbe;
66983 while( p ){
66984 if( sqlite3_stmt_busy((sqlite3_stmt*)p) ){
66986 if( p->readOnly==0 ) nWrite++;
66987 if( p->bIsReader ) nRead++;
66989 p = p->pNext;
67009 SQLITE_PRIVATE int sqlite3VdbeCloseStatement(Vdbe *p, int eOp){
67010 sqlite3 *const db = p->db;
67018 if( db->nStatement && p->iStatement ){
67020 const int iSavepoint = p->iStatement-1;
67024 assert( p->iStatement==(db->nStatement+db->nSavepoint) );
67042 p->iStatement = 0;
67057 db->nDeferredCons = p->nStmtDefCons;
67058 db->nDeferredImmCons = p->nStmtDefImmCons;
67075 SQLITE_PRIVATE int sqlite3VdbeCheckFk(Vdbe *p, int deferred){
67076 sqlite3 *db = p->db;
67078 || (!deferred && p->nFkConstraint>0)
67080 p->rc = SQLITE_CONSTRAINT_FOREIGNKEY;
67081 p->errorAction = OE_Abort;
67082 sqlite3SetString(&p->zErrMsg, db, "FOREIGN KEY constraint failed");
67102 SQLITE_PRIVATE int sqlite3VdbeHalt(Vdbe *p){
67104 sqlite3 *db = p->db;
67122 if( p->db->mallocFailed ){
67123 p->rc = SQLITE_NOMEM;
67125 if( p->aOnceFlag ) memset(p->aOnceFlag, 0, p->nOnceFlag);
67126 closeAllCursors(p);
67127 if( p->magic!=VDBE_MAGIC_RUN ){
67134 if( p->pc>=0 && p->bIsReader ){
67140 sqlite3VdbeEnter(p);
67143 mrc = p->rc & 0xff;
67159 if( !p->readOnly || mrc!=SQLITE_INTERRUPT ){
67160 if( (mrc==SQLITE_NOMEM || mrc==SQLITE_FULL) && p->usesStmtJournal ){
67169 p->nChange = 0;
67175 if( p->rc==SQLITE_OK ){
67176 sqlite3VdbeCheckFk(p, 0);
67187 && db->nVdbeWrite==(p->readOnly==0)
67189 if( p->rc==SQLITE_OK || (p->errorAction==OE_Fail && !isSpecialError) ){
67190 rc = sqlite3VdbeCheckFk(p, 1);
67192 if( NEVER(p->readOnly) ){
67193 sqlite3VdbeLeave(p);
67202 rc = vdbeCommit(db, p);
67204 if( rc==SQLITE_BUSY && p->readOnly ){
67205 sqlite3VdbeLeave(p);
67208 p->rc = rc;
67210 p->nChange = 0;
67219 p->nChange = 0;
67223 if( p->rc==SQLITE_OK || p->errorAction==OE_Fail ){
67225 }else if( p->errorAction==OE_Abort ){
67231 p->nChange = 0;
67242 rc = sqlite3VdbeCloseStatement(p, eStatementOp);
67244 if( p->rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT ){
67245 p->rc = rc;
67246 sqlite3DbFree(db, p->zErrMsg);
67247 p->zErrMsg = 0;
67252 p->nChange = 0;
67259 if( p->changeCntOn ){
67261 sqlite3VdbeSetChanges(db, p->nChange);
67265 p->nChange = 0;
67269 sqlite3VdbeLeave(p);
67273 if( p->pc>=0 ){
67275 if( !p->readOnly ) db->nVdbeWrite--;
67276 if( p->bIsReader ) db->nVdbeRead--;
67281 p->magic = VDBE_MAGIC_HALT;
67283 if( p->db->mallocFailed ){
67284 p->rc = SQLITE_NOMEM;
67296 return (p->rc==SQLITE_BUSY ? SQLITE_BUSY : SQLITE_OK);
67304 SQLITE_PRIVATE void sqlite3VdbeResetStepResult(Vdbe *p){
67305 p->rc = SQLITE_OK;
67316 SQLITE_PRIVATE int sqlite3VdbeTransferError(Vdbe *p){
67317 sqlite3 *db = p->db;
67318 int rc = p->rc;
67319 if( p->zErrMsg ){
67323 sqlite3ValueSetStr(db->pErr, -1, p->zErrMsg, SQLITE_UTF8, SQLITE_TRANSIENT);
67365 SQLITE_PRIVATE int sqlite3VdbeReset(Vdbe *p){
67367 db = p->db;
67373 sqlite3VdbeHalt(p);
67380 if( p->pc>=0 ){
67381 vdbeInvokeSqllog(p);
67382 sqlite3VdbeTransferError(p);
67383 sqlite3DbFree(db, p->zErrMsg);
67384 p->zErrMsg = 0;
67385 if( p->runOnlyOnce ) p->expired = 1;
67386 }else if( p->rc && p->expired ){
67391 sqlite3ErrorWithMsg(db, p->rc, p->zErrMsg ? "%s" : 0, p->zErrMsg);
67392 sqlite3DbFree(db, p->zErrMsg);
67393 p->zErrMsg = 0;
67398 Cleanup(p);
67408 for(i=0; i<p->nOp; i++){
67409 fprintf(out, "%02x", p->aOp[i].opcode);
67412 if( p->zSql ){
67415 for(i=0; (c = p->zSql[i])!=0; i++){
67422 for(i=0; i<p->nOp; i++){
67425 p->aOp[i].cnt,
67426 p->aOp[i].cycles,
67427 p->aOp[i].cnt>0 ? p->aOp[i].cycles/p->aOp[i].cnt : 0
67430 sqlite3VdbePrintOp(out, i, &p->aOp[i]);
67436 p->iCurrentTime = 0;
67437 p->magic = VDBE_MAGIC_INIT;
67438 return p->rc & db->errMask;
67445 SQLITE_PRIVATE int sqlite3VdbeFinalize(Vdbe *p){
67447 if( p->magic==VDBE_MAGIC_RUN || p->magic==VDBE_MAGIC_HALT ){
67448 rc = sqlite3VdbeReset(p);
67449 assert( (rc & p->db->errMask)==rc );
67451 sqlite3VdbeDelete(p);
67498 SQLITE_PRIVATE void sqlite3VdbeClearObject(sqlite3 *db, Vdbe *p){
67501 assert( p->db==0 || p->db==db );
67502 releaseMemArray(p->aVar, p->nVar);
67503 releaseMemArray(p->aColName, p->nResColumn*COLNAME_N);
67504 for(pSub=p->pProgram; pSub; pSub=pNext){
67509 for(i=p->nzVar-1; i>=0; i--) sqlite3DbFree(db, p->azVar[i]);
67510 vdbeFreeOpArray(db, p->aOp, p->nOp);
67511 sqlite3DbFree(db, p->aColName);
67512 sqlite3DbFree(db, p->zSql);
67513 sqlite3DbFree(db, p->pFree);
67515 for(i=0; i<p->nScan; i++){
67516 sqlite3DbFree(db, p->aScan[i].zName);
67518 sqlite3DbFree(db, p->aScan);
67525 SQLITE_PRIVATE void sqlite3VdbeDelete(Vdbe *p){
67528 if( NEVER(p==0) ) return;
67529 db = p->db;
67531 sqlite3VdbeClearObject(db, p);
67532 if( p->pPrev ){
67533 p->pPrev->pNext = p->pNext;
67535 assert( db->pVdbe==p );
67536 db->pVdbe = p->pNext;
67538 if( p->pNext ){
67539 p->pNext->pPrev = p->pPrev;
67541 p->magic = VDBE_MAGIC_DEAD;
67542 p->db = 0;
67543 sqlite3DbFree(db, p);
67551 static int SQLITE_NOINLINE handleDeferredMoveto(VdbeCursor *p){
67556 assert( p->deferredMoveto );
67557 assert( p->isTable );
67558 rc = sqlite3BtreeMovetoUnpacked(p->pCursor, 0, p->movetoTarget, 0, &res);
67564 p->deferredMoveto = 0;
67565 p->cacheStatus = CACHE_STALE;
67576 static int SQLITE_NOINLINE handleMovedCursor(VdbeCursor *p){
67578 assert( p->pCursor!=0 );
67579 assert( sqlite3BtreeCursorHasMoved(p->pCursor) );
67580 rc = sqlite3BtreeCursorRestore(p->pCursor, &isDifferentRow);
67581 p->cacheStatus = CACHE_STALE;
67582 if( isDifferentRow ) p->nullRow = 1;
67590 SQLITE_PRIVATE int sqlite3VdbeCursorRestore(VdbeCursor *p){
67591 if( sqlite3BtreeCursorHasMoved(p->pCursor) ){
67592 return handleMovedCursor(p);
67610 SQLITE_PRIVATE int sqlite3VdbeCursorMoveto(VdbeCursor *p){
67611 if( p->deferredMoveto ){
67612 return handleDeferredMoveto(p);
67614 if( p->pCursor && sqlite3BtreeCursorHasMoved(p->pCursor) ){
67615 return handleMovedCursor(p);
67972 UnpackedRecord *p; /* Unpacked record to return */
67983 p = (UnpackedRecord *)sqlite3DbMallocRaw(pKeyInfo->db, nByte);
67984 *ppFree = (char *)p;
67985 if( !p ) return 0;
67987 p = (UnpackedRecord*)&pSpace[nOff];
67991 p->aMem = (Mem*)&((char*)p)[ROUND8(sizeof(UnpackedRecord))];
67993 p->pKeyInfo = pKeyInfo;
67994 p->nField = pKeyInfo->nField + 1;
67995 return p;
68007 UnpackedRecord *p /* Populate this structure before returning. */
68014 Mem *pMem = p->aMem;
68016 p->default_rc = 0;
68031 if( (++u)>=p->nField ) break;
68034 p->nField = u;
68727 SQLITE_PRIVATE RecordCompare sqlite3VdbeFindCompare(UnpackedRecord *p){
68741 if( (p->pKeyInfo->nField + p->pKeyInfo->nXField)<=13 ){
68742 int flags = p->aMem[0].flags;
68743 if( p->pKeyInfo->aSortOrder[0] ){
68744 p->r1 = 1;
68745 p->r2 = -1;
68747 p->r1 = -1;
68748 p->r2 = 1;
68756 if( (flags & (MEM_Real|MEM_Null|MEM_Blob))==0 && p->pKeyInfo->aColl[0]==0 ){
68910 Vdbe *p;
68911 for(p = db->pVdbe; p; p=p->pNext){
68912 p->expired = 1;
68967 SQLITE_PRIVATE void sqlite3VtabImportErrmsg(Vdbe *p, sqlite3_vtab *pVtab){
68968 sqlite3 *db = p->db;
68969 sqlite3DbFree(db, p->zErrMsg);
68970 p->zErrMsg = sqlite3DbStrDup(db, pVtab->zErrMsg);
69004 Vdbe *p = (Vdbe*)pStmt;
69005 return p==0 || p->expired;
69014 static int vdbeSafety(Vdbe *p){
69015 if( p->db==0 ){
69022 static int vdbeSafetyNotNull(Vdbe *p){
69023 if( p==0 ){
69027 return vdbeSafety(p);
69088 Vdbe *p = (Vdbe*)pStmt;
69093 for(i=0; i<p->nVar; i++){
69094 sqlite3VdbeMemRelease(&p->aVar[i]);
69095 p->aVar[i].flags = MEM_Null;
69097 if( p->isPrepareV2 && p->expmask ){
69098 p->expired = 1;
69110 Mem *p = (Mem*)pVal;
69111 if( p->flags & (MEM_Blob|MEM_Str) ){
69112 sqlite3VdbeMemExpandBlob(p);
69113 p->flags |= MEM_Blob;
69114 return p->n ? p->z : 0;
69213 const void *p, /* Value to destroy */
69223 xDel((void*)p);
69407 static int sqlite3Step(Vdbe *p){
69411 assert(p);
69412 if( p->magic!=VDBE_MAGIC_RUN ){
69430 if( (rc = p->rc&0xff)==SQLITE_BUSY || rc==SQLITE_LOCKED ){
69431 sqlite3_reset((sqlite3_stmt*)p);
69436 sqlite3_reset((sqlite3_stmt*)p);
69441 db = p->db;
69443 p->rc = SQLITE_NOMEM;
69447 if( p->pc<=0 && p->expired ){
69448 p->rc = SQLITE_SCHEMA;
69452 if( p->pc<0 ){
69467 sqlite3OsCurrentTimeInt64(db->pVfs, &p->startTime);
69472 if( p->readOnly==0 ) db->nVdbeWrite++;
69473 if( p->bIsReader ) db->nVdbeRead++;
69474 p->pc = 0;
69477 p->rcApp = SQLITE_OK;
69480 if( p->explain ){
69481 rc = sqlite3VdbeList(p);
69486 rc = sqlite3VdbeExec(p);
69493 if( rc!=SQLITE_ROW && db->xProfile && !db->init.busy && p->zSql ){
69496 db->xProfile(db->pProfileArg, p->zSql, (iNow - p->startTime)*1000000);
69501 assert( p->rc==SQLITE_OK );
69502 p->rc = doWalCallbacks(db);
69503 if( p->rc!=SQLITE_OK ){
69509 if( SQLITE_NOMEM==sqlite3ApiExit(p->db, p->rc) ){
69510 p->rc = SQLITE_NOMEM;
69523 assert( (p->rc!=SQLITE_ROW && p->rc!=SQLITE_DONE) || p->rc==p->rcApp );
69524 if( p->isPrepareV2 && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){
69529 rc = sqlite3VdbeTransferError(p);
69590 SQLITE_API void *SQLITE_STDCALL sqlite3_user_data(sqlite3_context *p){
69591 assert( p && p->pFunc );
69592 return p->pFunc->pUserData;
69605 SQLITE_API sqlite3 *SQLITE_STDCALL sqlite3_context_db_handle(sqlite3_context *p){
69606 assert( p && p->pFunc );
69607 return p->pOut->db;
69617 SQLITE_PRIVATE sqlite3_int64 sqlite3StmtCurrentTime(sqlite3_context *p){
69620 sqlite3_int64 *piTime = &p->pVdbe->iCurrentTime;
69621 assert( p->pVdbe!=0 );
69624 sqlite3_int64 *piTime = p->pVdbe!=0 ? &p->pVdbe->iCurrentTime : &iTime;
69627 rc = sqlite3OsCurrentTimeInt64(p->pOut->db->pVfs, piTime);
69659 static SQLITE_NOINLINE void *createAggContext(sqlite3_context *p, int nByte){
69660 Mem *pMem = p->pMem;
69668 pMem->u.pDef = p->pFunc;
69681 SQLITE_API void *SQLITE_STDCALL sqlite3_aggregate_context(sqlite3_context *p, int nByte){
69682 assert( p && p->pFunc && p->pFunc->xStep );
69683 assert( sqlite3_mutex_held(p->pOut->db->mutex) );
69685 if( (p->pMem->flags & MEM_Agg)==0 ){
69686 return createAggContext(p, nByte);
69688 return (void*)p->pMem->z;
69772 SQLITE_API int SQLITE_STDCALL sqlite3_aggregate_count(sqlite3_context *p){
69773 assert( p && p->pMem && p->pFunc && p->pFunc->xStep );
69774 return p->pMem->n;
69881 Vdbe *p = (Vdbe *)pStmt;
69882 if( p ){
69883 p->rc = sqlite3ApiExit(p->db, p->rc);
69884 sqlite3_mutex_leave(p->db->mutex);
69977 Vdbe *p;
69987 p = (Vdbe *)pStmt;
69988 db = p->db;
69995 ret = xFunc(&p->aColName[N]);
70115 static int vdbeUnbind(Vdbe *p, int i){
70117 if( vdbeSafetyNotNull(p) ){
70120 sqlite3_mutex_enter(p->db->mutex);
70121 if( p->magic!=VDBE_MAGIC_RUN || p->pc>=0 ){
70122 sqlite3Error(p->db, SQLITE_MISUSE);
70123 sqlite3_mutex_leave(p->db->mutex);
70125 "bind on a busy prepared statement: [%s]", p->zSql);
70128 if( i<1 || i>p->nVar ){
70129 sqlite3Error(p->db, SQLITE_RANGE);
70130 sqlite3_mutex_leave(p->db->mutex);
70134 pVar = &p->aVar[i];
70137 sqlite3Error(p->db, SQLITE_OK);
70148 if( p->isPrepareV2 &&
70149 ((i<32 && p->expmask & ((u32)1 << i)) || p->expmask==0xffffffff)
70151 p->expired = 1;
70167 Vdbe *p = (Vdbe *)pStmt;
70171 rc = vdbeUnbind(p, i);
70174 pVar = &p->aVar[i-1];
70177 rc = sqlite3VdbeChangeEncoding(pVar, ENC(p->db));
70179 sqlite3Error(p->db, rc);
70180 rc = sqlite3ApiExit(p->db, rc);
70182 sqlite3_mutex_leave(p->db->mutex);
70218 Vdbe *p = (Vdbe *)pStmt;
70219 rc = vdbeUnbind(p, i);
70221 sqlite3VdbeMemSetDouble(&p->aVar[i-1], rValue);
70222 sqlite3_mutex_leave(p->db->mutex);
70226 SQLITE_API int SQLITE_STDCALL sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue){
70227 return sqlite3_bind_int64(p, i, (i64)iValue);
70231 Vdbe *p = (Vdbe *)pStmt;
70232 rc = vdbeUnbind(p, i);
70234 sqlite3VdbeMemSetInt64(&p->aVar[i-1], iValue);
70235 sqlite3_mutex_leave(p->db->mutex);
70241 Vdbe *p = (Vdbe*)pStmt;
70242 rc = vdbeUnbind(p, i);
70244 sqlite3_mutex_leave(p->db->mutex);
70317 Vdbe *p = (Vdbe *)pStmt;
70318 rc = vdbeUnbind(p, i);
70320 sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n);
70321 sqlite3_mutex_leave(p->db->mutex);
70331 Vdbe *p = (Vdbe*)pStmt;
70332 return p ? p->nVar : 0;
70342 Vdbe *p = (Vdbe*)pStmt;
70343 if( p==0 || i<1 || i>p->nzVar ){
70346 return p->azVar[i-1];
70354 SQLITE_PRIVATE int sqlite3VdbeParameterIndex(Vdbe *p, const char *zName, int nName){
70356 if( p==0 ){
70360 for(i=0; i<p->nzVar; i++){
70361 const char *z = p->azVar[i];
70496 Vdbe *p = (Vdbe*)pStmt;
70498 if( idx<0 || idx>=p->nScan ) return 1;
70499 pScan = &p->aScan[idx];
70502 *(sqlite3_int64*)pOut = p->anExec[pScan->addrLoop];
70506 *(sqlite3_int64*)pOut = p->anExec[pScan->addrVisit];
70525 *(const char**)pOut = p->aOp[ pScan->addrExplain ].p4.z;
70533 *(int*)pOut = p->aOp[ pScan->addrExplain ].p1;
70550 Vdbe *p = (Vdbe*)pStmt;
70551 memset(p->anExec, 0, p->nOp * sizeof(i64));
70627 Vdbe *p, /* The prepared statement being evaluated */
70640 db = p->db;
70651 }else if( p->nVar==0 ){
70675 idx = sqlite3VdbeParameterIndex(p, zRawSql, nToken);
70680 assert( idx>0 && idx<=p->nVar );
70681 pVar = &p->aVar[idx-1];
70825 static void updateMaxBlobsize(Mem *p){
70826 if( (p->flags & (MEM_Str|MEM_Blob))!=0 && p->n>sqlite3_max_blobsize ){
70827 sqlite3_max_blobsize = p->n;
70918 Vdbe *p, /* The virtual machine */
70942 Mem *pMem = &p->aMem[p->nMem-iCur];
70950 assert( iCur<p->nCursor );
70951 if( p->apCsr[iCur] ){
70952 sqlite3VdbeFreeCursor(p, p->apCsr[iCur]);
70953 p->apCsr[iCur] = 0;
70956 p->apCsr[iCur] = pCx = (VdbeCursor*)pMem->z;
71196 static void memTracePrint(Mem *p){
71197 if( p->flags & MEM_Undefined ){
71199 }else if( p->flags & MEM_Null ){
71201 }else if( (p->flags & (MEM_Int|MEM_Str))==(MEM_Int|MEM_Str) ){
71202 printf(" si:%lld", p->u.i);
71203 }else if( p->flags & MEM_Int ){
71204 printf(" i:%lld", p->u.i);
71206 }else if( p->flags & MEM_Real ){
71207 printf(" r:%g", p->u.r);
71209 }else if( p->flags & MEM_RowSet ){
71213 sqlite3VdbeMemPrettyPrint(p, zBuf);
71217 static void registerTrace(int iReg, Mem *p){
71219 memTracePrint(p);
71343 Savepoint *p;
71344 for(p=db->pSavepoint; p; p=p->pNext) n++;
71354 static Mem *out2Prerelease(Vdbe *p, VdbeOp *pOp){
71357 assert( pOp->p2<=(p->nMem-p->nCursor) );
71358 pOut = &p->aMem[pOp->p2];
71359 memAboutToChange(p, pOut);
71371 Vdbe *p /* The VDBE */
71373 Op *aOp = p->aOp; /* Copy of p->aOp */
71379 sqlite3 *db = p->db; /* The database */
71387 Mem *aMem = p->aMem; /* Copy of p->aMem */
71399 assert( p->magic==VDBE_MAGIC_RUN ); /* sqlite3_step() verifies this */
71400 sqlite3VdbeEnter(p);
71401 if( p->rc==SQLITE_NOMEM ){
71406 assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY );
71407 assert( p->bIsReader || p->readOnly!=0 );
71408 p->rc = SQLITE_OK;
71409 p->iCurrentTime = 0;
71410 assert( p->explain==0 );
71411 p->pResultSet = 0;
71414 sqlite3VdbeIOTraceSql(p);
71418 nProgressLimit = (unsigned)p->aCounter[SQLITE_STMTSTATUS_VM_STEP];
71428 if( p->pc==0
71429 && (p->db->flags & (SQLITE_VdbeListing|SQLITE_VdbeEQP|SQLITE_VdbeTrace))!=0
71433 sqlite3VdbePrintSql(p);
71434 if( p->db->flags & SQLITE_VdbeListing ){
71436 for(i=0; i<p->nOp; i++){
71440 if( p->db->flags & SQLITE_VdbeEQP ){
71441 for(i=0; i<p->nOp; i++){
71449 if( p->db->flags & SQLITE_VdbeTrace ) printf("VDBE Trace:\n");
71453 for(pOp=&aOp[p->pc]; rc==SQLITE_OK; pOp++){
71454 assert( pOp>=aOp && pOp<&aOp[p->nOp]);
71461 if( p->anExec ) p->anExec[(int)(pOp-aOp)]++;
71490 assert( pOp->p1<=(p->nMem-p->nCursor) );
71497 assert( pOp->p2<=(p->nMem-p->nCursor) );
71504 assert( pOp->p3<=(p->nMem-p->nCursor) );
71511 assert( pOp->p2<=(p->nMem-p->nCursor) );
71512 memAboutToChange(p, &aMem[pOp->p2]);
71516 assert( pOp->p3<=(p->nMem-p->nCursor) );
71517 memAboutToChange(p, &aMem[pOp->p3]);
71615 assert( pOp->p1>0 && pOp->p1<=(p->nMem-p->nCursor) );
71618 memAboutToChange(p, pIn1);
71655 assert( pOp->p1>0 && pOp->p1<=(p->nMem-p->nCursor) );
71656 assert( pOp->p2>=0 && pOp->p2<p->nOp );
71657 assert( pOp->p3>=0 && pOp->p3<p->nOp );
71678 assert( pIn1->u.i>=0 && pIn1->u.i<p->nOp );
71681 assert( pCaller->p2>=0 && pCaller->p2<p->nOp );
71763 if( pOp->p1==SQLITE_OK && p->pFrame ){
71765 pFrame = p->pFrame;
71766 p->pFrame = pFrame->pParent;
71767 p->nFrame--;
71768 sqlite3VdbeSetChanges(db, p->nChange);
71777 pcx = p->aOp[pcx].p2-1;
71779 aOp = p->aOp;
71780 aMem = p->aMem;
71784 p->rc = pOp->p1;
71785 p->errorAction = (u8)pOp->p2;
71786 p->pc = pcx;
71787 if( p->rc ){
71803 sqlite3SetString(&p->zErrMsg, db, "%s constraint failed: %s",
71806 sqlite3SetString(&p->zErrMsg, db, "%s", pOp->p4.z);
71808 sqlite3SetString(&p->zErrMsg, db, "%s constraint failed", zType);
71810 sqlite3_log(pOp->p1, zLogFmt, pcx, p->zSql, p->zErrMsg);
71812 rc = sqlite3VdbeHalt(p);
71815 p->rc = rc = SQLITE_BUSY;
71817 assert( rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT );
71819 rc = p->rc ? SQLITE_ERROR : SQLITE_DONE;
71830 pOut = out2Prerelease(p, pOp);
71842 pOut = out2Prerelease(p, pOp);
71856 pOut = out2Prerelease(p, pOp);
71874 pOut = out2Prerelease(p, pOp);
71913 pOut = out2Prerelease(p, pOp);
71921 assert( pOp->p3<=(p->nMem-p->nCursor) );
71944 pOut = out2Prerelease(p, pOp);
71946 assert( pOp->p3<=(p->nMem-p->nCursor) );
71950 memAboutToChange(p, pOut);
71967 assert( pOp->p1>0 && pOp->p1<=(p->nMem-p->nCursor) );
71981 pOut = out2Prerelease(p, pOp);
71999 assert( pOp->p1>0 && pOp->p1<=p->nVar );
72000 assert( pOp->p4.z==0 || pOp->p4.z==p->azVar[pOp->p1-1] );
72001 pVar = &p->aVar[pOp->p1 - 1];
72005 pOut = out2Prerelease(p, pOp);
72034 assert( pOut<=&aMem[(p->nMem-p->nCursor)] );
72035 assert( pIn1<=&aMem[(p->nMem-p->nCursor)] );
72037 memAboutToChange(p, pOut);
72117 assert( p->nResColumn==pOp->p2 );
72119 assert( pOp->p1+pOp->p2<=(p->nMem-p->nCursor)+1 );
72136 if( SQLITE_OK!=(rc = sqlite3VdbeCheckFk(p, 0)) ){
72138 assert( p->usesStmtJournal );
72157 assert( p->iStatement==0 || db->flags&SQLITE_CountRows );
72158 rc = sqlite3VdbeCloseStatement(p, SAVEPOINT_RELEASE);
72164 p->cacheCtr = (p->cacheCtr + 2)|1;
72170 pMem = p->pResultSet = &aMem[pOp->p1];
72183 p->pc = (int)(pOp - aOp) + 1;
72411 apVal = p->apArg;
72413 assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) );
72415 memAboutToChange(p, ctx.pOut);
72417 assert( n==0 || (pOp->p2>0 && pOp->p2+n<=(p->nMem-p->nCursor)+1) );
72430 ctx.pVdbe = p;
72440 sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3_value_text(ctx.pOut));
72443 sqlite3VdbeDeleteAuxData(p, (int)(pOp - aOp), pOp->p1);
72549 memAboutToChange(p, pIn1);
72623 memAboutToChange(p, pIn1);
72818 memAboutToChange(p, pOut);
72888 assert( p1>0 && p1+mx<=(p->nMem-p->nCursor)+1 );
72889 assert( p2>0 && p2+mx<=(p->nMem-p->nCursor)+1 );
72891 assert( p1>0 && p1+n<=(p->nMem-p->nCursor)+1 );
72892 assert( p2>0 && p2+n<=(p->nMem-p->nCursor)+1 );
73033 assert( pOp->p1<p->nOnceFlag );
73034 VdbeBranchTaken(p->aOnceFlag[pOp->p1]!=0, 2);
73035 if( p->aOnceFlag[pOp->p1] ){
73038 p->aOnceFlag[pOp->p1] = 1;
73150 assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) );
73152 memAboutToChange(p, pDest);
73153 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
73154 pC = p->apCsr[pOp->p1];
73168 if( pC->cacheStatus!=p->cacheCtr ){
73209 pC->cacheStatus = p->cacheCtr;
73407 assert( pIn1 <= &p->aMem[(p->nMem-p->nCursor)] );
73469 assert( nField>0 && pOp->p2>0 && pOp->p2+nField<=(p->nMem-p->nCursor)+1 );
73473 file_format = p->minWriteFileFormat;
73478 memAboutToChange(p, pOut);
73560 assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) );
73584 pCrsr = p->apCsr[pOp->p1]->pCursor;
73588 pOut = out2Prerelease(p, pOp);
73620 assert( p->bIsReader );
73627 sqlite3SetString(&p->zErrMsg, db, "cannot open savepoint - "
73679 sqlite3SetString(&p->zErrMsg, db, "no such savepoint: %s", zName);
73685 sqlite3SetString(&p->zErrMsg, db,
73697 if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){
73701 if( sqlite3VdbeHalt(p)==SQLITE_BUSY ){
73702 p->pc = (int)(pOp - aOp);
73704 p->rc = rc = SQLITE_BUSY;
73708 rc = p->rc;
73791 assert( p->bIsReader );
73799 sqlite3SetString(&p->zErrMsg, db, "cannot rollback transaction - "
73808 sqlite3SetString(&p->zErrMsg, db, "cannot commit transaction - "
73816 }else if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){
73820 if( sqlite3VdbeHalt(p)==SQLITE_BUSY ){
73821 p->pc = (int)(pOp - aOp);
73823 p->rc = rc = SQLITE_BUSY;
73829 if( p->rc==SQLITE_OK ){
73836 sqlite3SetString(&p->zErrMsg, db,
73885 assert( p->bIsReader );
73886 assert( p->readOnly==0 || pOp->p2==0 );
73888 assert( DbMaskTest(p->btreeMask, pOp->p1) );
73898 p->pc = (int)(pOp - aOp);
73899 p->rc = rc = SQLITE_BUSY;
73906 if( pOp->p2 && p->usesStmtJournal
73910 if( p->iStatement==0 ){
73913 p->iStatement = db->nSavepoint + db->nStatement;
73916 rc = sqlite3VtabSavepoint(db, SAVEPOINT_BEGIN, p->iStatement-1);
73918 rc = sqlite3BtreeBeginStmt(pBt, p->iStatement);
73924 p->nStmtDefCons = db->nDeferredCons;
73925 p->nStmtDefImmCons = db->nDeferredImmCons;
73941 sqlite3DbFree(db, p->zErrMsg);
73942 p->zErrMsg = sqlite3DbStrDup(db, "database schema has changed");
73959 p->expired = 1;
73982 assert( p->bIsReader );
73988 assert( DbMaskTest(p->btreeMask, iDb) );
73991 pOut = out2Prerelease(p, pOp);
74010 assert( DbMaskTest(p->btreeMask, pOp->p1) );
74011 assert( p->readOnly==0 );
74031 p->expired = 0;
74113 pCur = p->apCsr[pOp->p1];
74125 assert( p->bIsReader );
74127 || p->readOnly==0 );
74129 if( p->expired ){
74139 assert( DbMaskTest(p->btreeMask, iDb) );
74146 if( pDb->pSchema->file_format < p->minWriteFileFormat ){
74147 p->minWriteFileFormat = pDb->pSchema->file_format;
74154 assert( p2<=(p->nMem-p->nCursor) );
74180 pCur = allocateCursor(p, pOp->p1, nField, iDb, 1);
74240 pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, 1);
74291 pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, 1);
74309 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
74310 pC = p->apCsr[pOp->p1];
74339 pCx = allocateCursor(p, pOp->p1, pOp->p3, -1, 0);
74354 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
74355 sqlite3VdbeFreeCursor(p, p->apCsr[pOp->p1]);
74356 p->apCsr[pOp->p1] = 0;
74443 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
74445 pC = p->apCsr[pOp->p1];
74599 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
74600 pC = p->apCsr[pOp->p1];
74688 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
74690 pC = p->apCsr[pOp->p1];
74779 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
74780 pC = p->apCsr[pOp->p1];
74811 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
74812 assert( p->apCsr[pOp->p1]!=0 );
74813 pOut = out2Prerelease(p, pOp);
74814 pOut->u.i = p->apCsr[pOp->p1]->seqCount++;
74844 pOut = out2Prerelease(p, pOp);
74845 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
74846 pC = p->apCsr[pOp->p1];
74899 if( p->pFrame ){
74900 for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent);
74906 assert( pOp->p3<=(p->nMem-p->nCursor) );
74908 memAboutToChange(p, pMem);
75012 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
75014 pC = p->apCsr[pOp->p1];
75032 if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++;
75088 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
75089 pC = p->apCsr[pOp->p1];
75114 if( pOp->p2 & OPFLAG_NCHANGE ) p->nChange++;
75125 sqlite3VdbeSetChanges(db, p->nChange);
75126 p->nChange = 0;
75150 pC = p->apCsr[pOp->p1];
75178 pC = p->apCsr[pOp->p1];
75182 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
75183 p->apCsr[pOp->p3]->cacheStatus = CACHE_STALE;
75217 memAboutToChange(p, pOut);
75220 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
75221 pC = p->apCsr[pOp->p1];
75293 pOut = out2Prerelease(p, pOp);
75294 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
75295 pC = p->apCsr[pOp->p1];
75309 sqlite3VtabImportErrmsg(p, pVtab);
75335 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
75336 pC = p->apCsr[pOp->p1];
75363 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
75364 pC = p->apCsr[pOp->p1];
75403 p->aCounter[SQLITE_STMTSTATUS_SORT]++;
75423 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
75424 pC = p->apCsr[pOp->p1];
75441 assert( pOp->p2>0 && pOp->p2<p->nOp );
75514 pC = p->apCsr[pOp->p1];
75521 if( p->apCsr[pOp->p1]==0 ) break;
75525 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
75526 assert( pOp->p5<ArraySize(p->aCounter) );
75527 pC = p->apCsr[pOp->p1];
75554 p->aCounter[pOp->p5]++;
75593 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
75594 pC = p->apCsr[pOp->p1];
75600 if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++;
75634 assert( pOp->p2>0 && pOp->p2+pOp->p3<=(p->nMem-p->nCursor)+1 );
75635 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
75636 pC = p->apCsr[pOp->p1];
75671 pOut = out2Prerelease(p, pOp);
75672 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
75673 pC = p->apCsr[pOp->p1];
75752 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
75753 pC = p->apCsr[pOp->p1];
75812 assert( p->readOnly==0 );
75813 pOut = out2Prerelease(p, pOp);
75817 p->errorAction = OE_Abort;
75820 assert( DbMaskTest(p->btreeMask, iDb) );
75859 assert( p->readOnly==0 );
75860 assert( DbMaskTest(p->btreeMask, pOp->p2) );
75865 p->nChange += nChange;
75868 memAboutToChange(p, &aMem[pOp->p3]);
75886 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
75887 pC = p->apCsr[pOp->p1];
75928 pOut = out2Prerelease(p, pOp);
75931 assert( DbMaskTest(p->btreeMask, pOp->p1) );
75932 assert( p->readOnly==0 );
75977 initData.pzErrMsg = &p->zErrMsg;
76084 assert( p->bIsReader );
76089 assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) );
76099 assert( DbMaskTest(p->btreeMask, pOp->p5) );
76263 for(pFrame=p->pFrame; pFrame && pFrame->token!=t; pFrame=pFrame->pParent);
76267 if( p->nFrame>=db->aLimit[SQLITE_LIMIT_TRIGGER_DEPTH] ){
76269 sqlite3SetString(&p->zErrMsg, db, "too many levels of trigger recursion");
76296 pFrame->v = p;
76300 pFrame->aMem = p->aMem;
76301 pFrame->nMem = p->nMem;
76302 pFrame->apCsr = p->apCsr;
76303 pFrame->nCursor = p->nCursor;
76304 pFrame->aOp = p->aOp;
76305 pFrame->nOp = p->nOp;
76307 pFrame->aOnceFlag = p->aOnceFlag;
76308 pFrame->nOnceFlag = p->nOnceFlag;
76310 pFrame->anExec = p->anExec;
76325 p->nFrame++;
76326 pFrame->pParent = p->pFrame;
76328 pFrame->nChange = p->nChange;
76329 pFrame->nDbChange = p->db->nChange;
76330 p->nChange = 0;
76331 p->pFrame = pFrame;
76332 p->aMem = aMem = &VdbeFrameMem(pFrame)[-1];
76333 p->nMem = pFrame->nChildMem;
76334 p->nCursor = (u16)pFrame->nChildCsr;
76335 p->apCsr = (VdbeCursor **)&aMem[p->nMem+1];
76336 p->aOp = aOp = pProgram->aOp;
76337 p->nOp = pProgram->nOp;
76338 p->aOnceFlag = (u8 *)&p->apCsr[p->nCursor];
76339 p->nOnceFlag = pProgram->nOnce;
76341 p->anExec = 0;
76344 memset(p->aOnceFlag, 0, p->nOnceFlag);
76364 pOut = out2Prerelease(p, pOp);
76365 pFrame = p->pFrame;
76388 p->nFkConstraint += pOp->p2;
76410 VdbeBranchTaken(p->nFkConstraint==0 && db->nDeferredImmCons==0, 2);
76411 if( p->nFkConstraint==0 && db->nDeferredImmCons==0 ) goto jump_to_p2;
76431 if( p->pFrame ){
76432 for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent);
76553 apVal = p->apArg;
76558 memAboutToChange(p, pRec);
76561 assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) );
76567 ctx.pVdbe = p;
76572 sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3_value_text(&t));
76599 assert( pOp->p1>0 && pOp->p1<=(p->nMem-p->nCursor) );
76604 sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3_value_text(pMem));
76631 assert( p->readOnly==0 );
76672 pOut = out2Prerelease(p, pOp);
76683 assert( p->readOnly==0 );
76709 sqlite3SetString(&p->zErrMsg, db,
76765 assert( p->readOnly==0 );
76766 rc = sqlite3RunVacuum(&p->zErrMsg, db);
76782 assert( DbMaskTest(p->btreeMask, pOp->p1) );
76783 assert( p->readOnly==0 );
76809 p->expired = 1;
76835 assert( DbMaskTest(p->btreeMask, p1) );
76840 sqlite3SetString(&p->zErrMsg, db, "database table is locked: %s", z);
76861 if( pVTab ) sqlite3VtabImportErrmsg(p, pVTab->pVtab);
76887 rc = sqlite3VtabCallCreate(db, pOp->p1, zTab, &p->zErrMsg);
76921 assert( p->bIsReader );
76931 sqlite3VtabImportErrmsg(p, pVtab);
76937 pCur = allocateCursor(p, pOp->p1, 0, -1, 0);
76986 pCur = p->apCsr[pOp->p1];
77001 apArg = p->apArg;
77006 sqlite3VtabImportErrmsg(p, pVtab);
77031 VdbeCursor *pCur = p->apCsr[pOp->p1];
77033 assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) );
77035 memAboutToChange(p, pDest);
77047 sqlite3VtabImportErrmsg(p, pVtab);
77076 pCur = p->apCsr[pOp->p1];
77092 sqlite3VtabImportErrmsg(p, pVtab);
77120 assert( p->readOnly==0 );
77129 sqlite3VtabImportErrmsg(p, pVtab);
77130 p->expired = 0;
77176 assert( p->readOnly==0 );
77187 apArg = p->apArg;
77191 memAboutToChange(p, pX);
77198 sqlite3VtabImportErrmsg(p, pVtab);
77207 p->errorAction = ((pOp->p5==OE_Replace) ? OE_Abort : pOp->p5);
77210 p->nChange++;
77223 pOut = out2Prerelease(p, pOp);
77243 pOut = out2Prerelease(p, pOp);
77274 && !p->doingRerun
77275 && (zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0
77277 z = sqlite3VdbeExpandSql(p, zTrace);
77282 zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql);
77286 if( DbMaskTest(p->btreeMask, i)==0 ) continue;
77293 && (zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0
77342 assert( pOp>=&aOp[-1] && pOp<&aOp[p->nOp-1] );
77363 p->rc = rc;
77366 (int)(pOp - aOp), p->zSql, p->zErrMsg);
77367 sqlite3VdbeHalt(p);
77380 p->aCounter[SQLITE_STMTSTATUS_VM_STEP] += (int)nVmStep;
77381 sqlite3VdbeLeave(p);
77388 sqlite3SetString(&p->zErrMsg, db, "string or blob too big");
77396 sqlite3SetString(&p->zErrMsg, db, "out of memory");
77404 assert( p->zErrMsg==0 );
77407 sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3ErrStr(rc));
77417 p->rc = rc;
77418 sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3ErrStr(rc));
77475 static int blobSeekToRow(Incrblob *p, sqlite3_int64 iRow, char **pzErr){
77478 Vdbe *v = (Vdbe *)p->pStmt;
77487 rc = sqlite3_step(p->pStmt);
77490 u32 type = pC->aType[p->iCol];
77492 zErr = sqlite3MPrintf(p->db, "cannot open value of type %s",
77496 sqlite3_finalize(p->pStmt);
77497 p->pStmt = 0;
77499 p->iOffset = pC->aType[p->iCol + pC->nField];
77500 p->nByte = sqlite3VdbeSerialTypeLen(type);
77501 p->pCsr = pC->pCursor;
77502 sqlite3BtreeIncrblobCursor(p->pCsr);
77508 }else if( p->pStmt ){
77509 rc = sqlite3_finalize(p->pStmt);
77510 p->pStmt = 0;
77512 zErr = sqlite3MPrintf(p->db, "no such rowid: %lld", iRow);
77515 zErr = sqlite3MPrintf(p->db, "%s", sqlite3_errmsg(p->db));
77767 Incrblob *p = (Incrblob *)pBlob;
77771 if( p ){
77772 db = p->db;
77774 rc = sqlite3_finalize(p->pStmt);
77775 sqlite3DbFree(db, p);
77794 Incrblob *p = (Incrblob *)pBlob;
77798 if( p==0 ) return SQLITE_MISUSE_BKPT;
77799 db = p->db;
77801 v = (Vdbe*)p->pStmt;
77803 if( n<0 || iOffset<0 || ((sqlite3_int64)iOffset+n)>p->nByte ){
77816 sqlite3BtreeEnterCursor(p->pCsr);
77817 rc = xCall(p->pCsr, iOffset+p->iOffset, n, z);
77818 sqlite3BtreeLeaveCursor(p->pCsr);
77821 p->pStmt = 0;
77853 Incrblob *p = (Incrblob *)pBlob;
77854 return (p && p->pStmt) ? p->nByte : 0;
77869 Incrblob *p = (Incrblob *)pBlob;
77872 if( p==0 ) return SQLITE_MISUSE_BKPT;
77873 db = p->db;
77876 if( p->pStmt==0 ){
77883 rc = blobSeekToRow(p, iRow, &zErr);
77892 assert( rc==SQLITE_OK || p->pStmt==0 );
78354 #define SRVAL(p) ((void*)((SorterRecord*)(p) + 1))
78385 PmaReader *p, /* PmaReader from which to take the blob */
78392 if( p->aMap ){
78393 *ppOut = &p->aMap[p->iReadOff];
78394 p->iReadOff += nByte;
78398 assert( p->aBuffer );
78403 iBuf = p->iReadOff % p->nBuffer;
78409 if( (p->iEof - p->iReadOff) > (i64)p->nBuffer ){
78410 nRead = p->nBuffer;
78412 nRead = (int)(p->iEof - p->iReadOff);
78417 rc = sqlite3OsRead(p->pFd, p->aBuffer, nRead, p->iReadOff);
78421 nAvail = p->nBuffer - iBuf;
78427 *ppOut = &p->aBuffer[iBuf];
78428 p->iReadOff += nByte;
78436 if( p->nAlloc<nByte ){
78438 int nNew = MAX(128, p->nAlloc*2);
78440 aNew = sqlite3Realloc(p->aAlloc, nNew);
78442 p->nAlloc = nNew;
78443 p->aAlloc = aNew;
78448 memcpy(p->aAlloc, &p->aBuffer[iBuf], nAvail);
78449 p->iReadOff += nAvail;
78460 if( nRem>p->nBuffer ) nCopy = p->nBuffer;
78461 rc = vdbePmaReadBlob(p, nCopy, &aNext);
78463 assert( aNext!=p->aAlloc );
78464 memcpy(&p->aAlloc[nByte - nRem], aNext, nCopy);
78468 *ppOut = p->aAlloc;
78478 static int vdbePmaReadVarint(PmaReader *p, u64 *pnOut){
78481 if( p->aMap ){
78482 p->iReadOff += sqlite3GetVarint(&p->aMap[p->iReadOff], pnOut);
78484 iBuf = p->iReadOff % p->nBuffer;
78485 if( iBuf && (p->nBuffer-iBuf)>=9 ){
78486 p->iReadOff += sqlite3GetVarint(&p->aBuffer[iBuf], pnOut);
78491 rc = vdbePmaReadBlob(p, 1, &a);
78921 SorterRecord *p;
78923 for(p=pRecord; p; p=pNext){
78924 pNext = p->u.pNext;
78925 sqlite3DbFree(db, p);
79171 void *p = 0;
79175 sqlite3OsFetch(pFd, 0, (int)nByte, &p);
79176 sqlite3OsUnfetch(pFd, 0, p);
79269 static SorterCompare vdbeSorterGetCompare(VdbeSorter *p){
79270 if( p->typeMask==SORTER_TYPE_INTEGER ){
79272 }else if( p->typeMask==SORTER_TYPE_TEXT ){
79286 SorterRecord *p;
79292 p = pList->pList;
79300 while( p ){
79303 if( (u8*)p==pList->aMemory ){
79306 assert( p->u.iNext<sqlite3MallocSize(pList->aMemory) );
79307 pNext = (SorterRecord*)&pList->aMemory[p->u.iNext];
79310 pNext = p->u.pNext;
79313 p->u.pNext = 0;
79315 vdbeSorterMerge(pTask, p, aSlot[i], &p);
79318 aSlot[i] = p;
79319 p = pNext;
79322 p = 0;
79324 vdbeSorterMerge(pTask, p, aSlot[i], &p);
79326 pList->pList = p;
79340 PmaWriter *p, /* Object to populate */
79344 memset(p, 0, sizeof(PmaWriter));
79345 p->aBuffer = (u8*)sqlite3Malloc(nBuf);
79346 if( !p->aBuffer ){
79347 p->eFWErr = SQLITE_NOMEM;
79349 p->iBufEnd = p->iBufStart = (iStart % nBuf);
79350 p->iWriteOff = iStart - p->iBufStart;
79351 p->nBuffer = nBuf;
79352 p->pFd = pFd;
79360 static void vdbePmaWriteBlob(PmaWriter *p, u8 *pData, int nData){
79362 while( nRem>0 && p->eFWErr==0 ){
79364 if( nCopy>(p->nBuffer - p->iBufEnd) ){
79365 nCopy = p->nBuffer - p->iBufEnd;
79368 memcpy(&p->aBuffer[p->iBufEnd], &pData[nData-nRem], nCopy);
79369 p->iBufEnd += nCopy;
79370 if( p->iBufEnd==p->nBuffer ){
79371 p->eFWErr = sqlite3OsWrite(p->pFd,
79372 &p->aBuffer[p->iBufStart], p->iBufEnd - p->iBufStart,
79373 p->iWriteOff + p->iBufStart
79375 p->iBufStart = p->iBufEnd = 0;
79376 p->iWriteOff += p->nBuffer;
79378 assert( p->iBufEnd<p->nBuffer );
79393 static int vdbePmaWriterFinish(PmaWriter *p, i64 *piEof){
79395 if( p->eFWErr==0 && ALWAYS(p->aBuffer) && p->iBufEnd>p->iBufStart ){
79396 p->eFWErr = sqlite3OsWrite(p->pFd,
79397 &p->aBuffer[p->iBufStart], p->iBufEnd - p->iBufStart,
79398 p->iWriteOff + p->iBufStart
79401 *piEof = (p->iWriteOff + p->iBufEnd);
79402 sqlite3_free(p->aBuffer);
79403 rc = p->eFWErr;
79404 memset(p, 0, sizeof(PmaWriter));
79412 static void vdbePmaWriteVarint(PmaWriter *p, u64 iVal){
79416 vdbePmaWriteBlob(p, aByte, nByte);
79467 SorterRecord *p;
79474 for(p=pList->pList; p; p=pNext){
79475 pNext = p->u.pNext;
79476 vdbePmaWriteVarint(&writer, p->nVal);
79477 vdbePmaWriteBlob(&writer, SRVAL(p), p->nVal);
79478 if( pList->aMemory==0 ) sqlite3_free(p);
79480 pList->pList = p;
79808 void *p = (void*)pIncr;
79810 return vdbeSorterCreateThread(pIncr->pTask, vdbeIncrPopulateThread, p);
80245 MergeEngine *p = pRoot;
80256 PmaReader *pReadr = &p->aReadr[iIter];
80267 p = pReadr->pIncr->pMerger;
80273 p->aReadr[iSeq % SORTER_MAX_MERGE_COUNT].pIncr = pIncr;
80418 PmaReader *p = &pMain->aReadr[iTask];
80419 assert( p->pIncr==0 || (
80420 (p->pIncr->pTask==&pSorter->aTask[iTask]) /* a */
80421 && (iTask!=pSorter->nTask-1 || p->pIncr->bUseThread==0) /* b */
80423 rc = vdbePmaReaderIncrInit(p, INCRINIT_TASK);
80604 char *p;
80605 r2 = pSorter->pUnpacked = sqlite3VdbeAllocUnpackedRecord(pKeyInfo,0,0,&p);
80606 assert( pSorter->pUnpacked==(UnpackedRecord*)p );
80676 static int createFile(JournalFile *p){
80678 if( !p->pReal ){
80679 sqlite3_file *pReal = (sqlite3_file *)&p[1];
80680 rc = sqlite3OsOpen(p->pVfs, p->zJournal, pReal, p->flags, 0);
80682 p->pReal = pReal;
80683 if( p->iSize>0 ){
80684 assert(p->iSize<=p->nBuf);
80685 rc = sqlite3OsWrite(p->pReal, p->zBuf, p->iSize, 0);
80693 p->pReal = 0;
80704 JournalFile *p = (JournalFile *)pJfd;
80705 if( p->pReal ){
80706 sqlite3OsClose(p->pReal);
80708 sqlite3_free(p->zBuf);
80722 JournalFile *p = (JournalFile *)pJfd;
80723 if( p->pReal ){
80724 rc = sqlite3OsRead(p->pReal, zBuf, iAmt, iOfst);
80725 }else if( (iAmt+iOfst)>p->iSize ){
80728 memcpy(zBuf, &p->zBuf[iOfst], iAmt);
80743 JournalFile *p = (JournalFile *)pJfd;
80744 if( !p->pReal && (iOfst+iAmt)>p->nBuf ){
80745 rc = createFile(p);
80748 if( p->pReal ){
80749 rc = sqlite3OsWrite(p->pReal, zBuf, iAmt, iOfst);
80751 memcpy(&p->zBuf[iOfst], zBuf, iAmt);
80752 if( p->iSize<(iOfst+iAmt) ){
80753 p->iSize = (iOfst+iAmt);
80765 JournalFile *p = (JournalFile *)pJfd;
80766 if( p->pReal ){
80767 rc = sqlite3OsTruncate(p->pReal, size);
80768 }else if( size<p->iSize ){
80769 p->iSize = size;
80779 JournalFile *p = (JournalFile *)pJfd;
80780 if( p->pReal ){
80781 rc = sqlite3OsSync(p->pReal, flags);
80793 JournalFile *p = (JournalFile *)pJfd;
80794 if( p->pReal ){
80795 rc = sqlite3OsFileSize(p->pReal, pSize);
80797 *pSize = (sqlite_int64) p->iSize;
80835 JournalFile *p = (JournalFile *)pJfd;
80836 memset(p, 0, sqlite3JournalSize(pVfs));
80838 p->zBuf = sqlite3MallocZero(nBuf);
80839 if( !p->zBuf ){
80845 p->pMethod = &JournalFileMethods;
80846 p->nBuf = nBuf;
80847 p->flags = flags;
80848 p->zJournal = zName;
80849 p->pVfs = pVfs;
80857 SQLITE_PRIVATE int sqlite3JournalCreate(sqlite3_file *p){
80858 if( p->pMethods!=&JournalFileMethods ){
80861 return createFile((JournalFile *)p);
80870 SQLITE_PRIVATE int sqlite3JournalExists(sqlite3_file *p){
80871 return (p->pMethods!=&JournalFileMethods || ((JournalFile *)p)->pReal!=0);
80955 MemJournal *p = (MemJournal *)pJfd;
80962 assert( iOfst+iAmt<=p->endpoint.iOffset );
80964 if( p->readpoint.iOffset!=iOfst || iOfst==0 ){
80966 for(pChunk=p->pFirst;
80973 pChunk = p->readpoint.pChunk;
80985 p->readpoint.iOffset = iOfst+iAmt;
80986 p->readpoint.pChunk = pChunk;
81000 MemJournal *p = (MemJournal *)pJfd;
81007 assert( iOfst==p->endpoint.iOffset );
81011 FileChunk *pChunk = p->endpoint.pChunk;
81012 int iChunkOffset = (int)(p->endpoint.iOffset%JOURNAL_CHUNKSIZE);
81023 assert( p->pFirst );
81026 assert( !p->pFirst );
81027 p->pFirst = pNew;
81029 p->endpoint.pChunk = pNew;
81032 memcpy(&p->endpoint.pChunk->zChunk[iChunkOffset], zWrite, iSpace);
81035 p->endpoint.iOffset += iSpace;
81045 MemJournal *p = (MemJournal *)pJfd;
81049 pChunk = p->pFirst;
81085 MemJournal *p = (MemJournal *)pJfd;
81086 *pSize = (sqlite_int64) p->endpoint.iOffset;
81119 MemJournal *p = (MemJournal *)pJfd;
81120 assert( EIGHT_BYTE_ALIGNMENT(p) );
81121 memset(p, 0, sqlite3MemJournalSize());
81122 p->pMethod = (sqlite3_io_methods*)&MemJournalMethods;
81202 SQLITE_PRIVATE int sqlite3WalkExprList(Walker *pWalker, ExprList *p){
81205 if( p ){
81206 for(i=p->nExpr, pItem=p->a; i>0; i--, pItem++){
81219 SQLITE_PRIVATE int sqlite3WalkSelectExpr(Walker *pWalker, Select *p){
81220 if( sqlite3WalkExprList(pWalker, p->pEList) ) return WRC_Abort;
81221 if( sqlite3WalkExpr(pWalker, p->pWhere) ) return WRC_Abort;
81222 if( sqlite3WalkExprList(pWalker, p->pGroupBy) ) return WRC_Abort;
81223 if( sqlite3WalkExpr(pWalker, p->pHaving) ) return WRC_Abort;
81224 if( sqlite3WalkExprList(pWalker, p->pOrderBy) ) return WRC_Abort;
81225 if( sqlite3WalkExpr(pWalker, p->pLimit) ) return WRC_Abort;
81226 if( sqlite3WalkExpr(pWalker, p->pOffset) ) return WRC_Abort;
81237 SQLITE_PRIVATE int sqlite3WalkSelectFrom(Walker *pWalker, Select *p){
81242 pSrc = p->pSrc;
81269 SQLITE_PRIVATE int sqlite3WalkSelect(Walker *pWalker, Select *p){
81271 if( p==0 || (pWalker->xSelectCallback==0 && pWalker->xSelectCallback2==0) ){
81276 while( p ){
81278 rc = pWalker->xSelectCallback(pWalker, p);
81281 if( sqlite3WalkSelectExpr(pWalker, p)
81282 || sqlite3WalkSelectFrom(pWalker, p)
81288 pWalker->xSelectCallback2(pWalker, p);
81290 p = p->pPrior;
81827 Expr *p = sqlite3ExprAlloc(db, TK_COLUMN, 0, 0);
81828 if( p ){
81830 p->pTab = pItem->pTab;
81831 p->iTable = pItem->iCursor;
81832 if( p->pTab->iPKey==iCol ){
81833 p->iColumn = -1;
81835 p->iColumn = (ynVar)iCol;
81840 ExprSetProperty(p, EP_Resolved);
81842 return p;
81882 static int exprProbability(Expr *p){
81884 if( p->op!=TK_FLOAT ) return -1;
81885 sqlite3AtoF(p->u.zToken, &r, sqlite3Strlen30(p->u.zToken), SQLITE_UTF8);
82435 static int resolveSelectStep(Walker *pWalker, Select *p){
82448 assert( p!=0 );
82449 if( p->selFlags & SF_Resolved ){
82464 if( (p->selFlags & SF_Expanded)==0 ){
82465 sqlite3SelectPrep(pParse, p, pOuterNC);
82469 isCompound = p->pPrior!=0;
82471 pLeftmost = p;
82472 while( p ){
82473 assert( (p->selFlags & SF_Expanded)!=0 );
82474 assert( (p->selFlags & SF_Resolved)==0 );
82475 p->selFlags |= SF_Resolved;
82482 if( sqlite3ResolveExprNames(&sNC, p->pLimit) ||
82483 sqlite3ResolveExprNames(&sNC, p->pOffset) ){
82493 if( p->selFlags & SF_Converted ){
82494 Select *pSub = p->pSrc->a[0].pSelect;
82495 assert( p->pSrc->nSrc==1 && p->pOrderBy );
82497 pSub->pOrderBy = p->pOrderBy;
82498 p->pOrderBy = 0;
82503 for(i=0; i<p->pSrc->nSrc; i++){
82504 struct SrcList_item *pItem = &p->pSrc->a[i];
82532 sNC.pSrcList = p->pSrc;
82536 pEList = p->pEList;
82548 assert( (p->selFlags & SF_Aggregate)==0 );
82549 pGroupBy = p->pGroupBy;
82552 p->selFlags |= SF_Aggregate | (sNC.ncFlags&NC_MinMaxAgg);
82559 if( p->pHaving && !pGroupBy ){
82572 sNC.pEList = p->pEList;
82573 if( sqlite3ResolveExprNames(&sNC, p->pHaving) ) return WRC_Abort;
82574 if( sqlite3ResolveExprNames(&sNC, p->pWhere) ) return WRC_Abort;
82587 if( p->selFlags & SF_Converted ){
82588 Select *pSub = p->pSrc->a[0].pSelect;
82589 p->pOrderBy = pSub->pOrderBy;
82604 && resolveOrderGroupBy(&sNC, p, p->pOrderBy, "ORDER")
82618 if( resolveOrderGroupBy(&sNC, p, pGroupBy, "GROUP") || db->mallocFailed ){
82632 p = p->pPrior;
82747 Select *p, /* The SELECT statement being coded. */
82752 assert( p!=0 );
82758 sqlite3WalkSelect(&w, p);
82927 Expr *p = pExpr;
82928 while( p ){
82929 int op = p->op;
82930 if( p->flags & EP_Generic ) break;
82932 p = p->pLeft;
82935 if( op==TK_COLLATE || (op==TK_REGISTER && p->op2==TK_COLLATE) ){
82936 pColl = sqlite3GetCollSeq(pParse, ENC(db), 0, p->u.zToken);
82941 && p->pTab!=0
82945 int j = p->iColumn;
82947 const char *zColl = p->pTab->aCol[j].zColl;
82952 if( p->flags & EP_Collate ){
82953 if( p->pLeft && (p->pLeft->flags & EP_Collate)!=0 ){
82954 p = p->pLeft;
82956 Expr *pNext = p->pRight;
82958 assert( p->x.pList==0 || p->pRight==0 );
82962 if( p->x.pList!=0 && ALWAYS(!ExprHasProperty(p, EP_xIsSelect)) ){
82964 for(i=0; ALWAYS(i<p->x.pList->nExpr); i++){
82965 if( ExprHasProperty(p->x.pList->a[i].pExpr, EP_Collate) ){
82966 pNext = p->x.pList->a[i].pExpr;
82971 p = pNext;
83143 static void heightOfExpr(Expr *p, int *pnHeight){
83144 if( p ){
83145 if( p->nHeight>*pnHeight ){
83146 *pnHeight = p->nHeight;
83150 static void heightOfExprList(ExprList *p, int *pnHeight){
83151 if( p ){
83153 for(i=0; i<p->nExpr; i++){
83154 heightOfExpr(p->a[i].pExpr, pnHeight);
83158 static void heightOfSelect(Select *p, int *pnHeight){
83159 if( p ){
83160 heightOfExpr(p->pWhere, pnHeight);
83161 heightOfExpr(p->pHaving, pnHeight);
83162 heightOfExpr(p->pLimit, pnHeight);
83163 heightOfExpr(p->pOffset, pnHeight);
83164 heightOfExprList(p->pEList, pnHeight);
83165 heightOfExprList(p->pGroupBy, pnHeight);
83166 heightOfExprList(p->pOrderBy, pnHeight);
83167 heightOfSelect(p->pPrior, pnHeight);
83181 static void exprSetHeight(Expr *p){
83183 heightOfExpr(p->pLeft, &nHeight);
83184 heightOfExpr(p->pRight, &nHeight);
83185 if( ExprHasProperty(p, EP_xIsSelect) ){
83186 heightOfSelect(p->x.pSelect, &nHeight);
83187 }else if( p->x.pList ){
83188 heightOfExprList(p->x.pList, &nHeight);
83189 p->flags |= EP_Propagate & sqlite3ExprListFlags(p->x.pList);
83191 p->nHeight = nHeight + 1;
83202 SQLITE_PRIVATE void sqlite3ExprSetHeightAndFlags(Parse *pParse, Expr *p){
83204 exprSetHeight(p);
83205 sqlite3ExprCheckHeight(pParse, p->nHeight);
83212 SQLITE_PRIVATE int sqlite3SelectExprHeight(Select *p){
83214 heightOfSelect(p, &nHeight);
83222 SQLITE_PRIVATE void sqlite3ExprSetHeightAndFlags(Parse *pParse, Expr *p){
83223 if( p && p->x.pList && !ExprHasProperty(p, EP_xIsSelect) ){
83224 p->flags |= EP_Propagate & sqlite3ExprListFlags(p->x.pList);
83353 Expr *p;
83356 p = sqlite3ExprAnd(pParse->db, pLeft, pRight);
83358 p = sqlite3ExprAlloc(pParse->db, op, pToken, 1);
83359 sqlite3ExprAttachSubtrees(pParse->db, p, pLeft, pRight);
83361 if( p ) {
83362 sqlite3ExprCheckHeight(pParse, p->nHeight);
83364 return p;
83381 static int exprAlwaysTrue(Expr *p){
83383 if( ExprHasProperty(p, EP_FromJoin) ) return 0;
83384 if( !sqlite3ExprIsInteger(p, &v) ) return 0;
83387 static int exprAlwaysFalse(Expr *p){
83389 if( ExprHasProperty(p, EP_FromJoin) ) return 0;
83390 if( !sqlite3ExprIsInteger(p, &v) ) return 0;
83524 SQLITE_PRIVATE void sqlite3ExprDelete(sqlite3 *db, Expr *p){
83525 if( p==0 ) return;
83527 assert( !ExprHasProperty(p, EP_IntValue) || p->u.iValue>=0 );
83528 if( !ExprHasProperty(p, EP_TokenOnly) ){
83530 assert( p->x.pList==0 || p->pRight==0 );
83531 sqlite3ExprDelete(db, p->pLeft);
83532 sqlite3ExprDelete(db, p->pRight);
83533 if( ExprHasProperty(p, EP_MemToken) ) sqlite3DbFree(db, p->u.zToken);
83534 if( ExprHasProperty(p, EP_xIsSelect) ){
83535 sqlite3SelectDelete(db, p->x.pSelect);
83537 sqlite3ExprListDelete(db, p->x.pList);
83540 if( !ExprHasProperty(p, EP_Static) ){
83541 sqlite3DbFree(db, p);
83550 static int exprStructSize(Expr *p){
83551 if( ExprHasProperty(p, EP_TokenOnly) ) return EXPR_TOKENONLYSIZE;
83552 if( ExprHasProperty(p, EP_Reduced) ) return EXPR_REDUCEDSIZE;
83590 static int dupedExprStructSize(Expr *p, int flags){
83598 assert( !ExprHasProperty(p, EP_TokenOnly|EP_Reduced) );
83599 assert( !ExprHasProperty(p, EP_FromJoin) );
83600 assert( !ExprHasProperty(p, EP_MemToken) );
83601 assert( !ExprHasProperty(p, EP_NoReduce) );
83602 if( p->pLeft || p->x.pList ){
83605 assert( p->pRight==0 );
83617 static int dupedExprNodeSize(Expr *p, int flags){
83618 int nByte = dupedExprStructSize(p, flags) & 0xfff;
83619 if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){
83620 nByte += sqlite3Strlen30(p->u.zToken)+1;
83638 static int dupedExprSize(Expr *p, int flags){
83640 if( p ){
83641 nByte = dupedExprNodeSize(p, flags);
83643 nByte += dupedExprSize(p->pLeft, flags) + dupedExprSize(p->pRight, flags);
83657 static Expr *exprDup(sqlite3 *db, Expr *p, int flags, u8 **pzBuffer){
83659 if( p ){
83671 zAlloc = sqlite3DbMallocRaw(db, dupedExprSize(p, flags));
83681 const unsigned nStructSize = dupedExprStructSize(p, flags);
83684 if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){
83685 nToken = sqlite3Strlen30(p->u.zToken) + 1;
83690 assert( ExprHasProperty(p, EP_Reduced)==0 );
83691 memcpy(zAlloc, p, nNewSize);
83693 int nSize = exprStructSize(p);
83694 memcpy(zAlloc, p, nSize);
83706 memcpy(zToken, p->u.zToken, nToken);
83709 if( 0==((p->flags|pNew->flags) & EP_TokenOnly) ){
83711 if( ExprHasProperty(p, EP_xIsSelect) ){
83712 pNew->x.pSelect = sqlite3SelectDup(db, p->x.pSelect, isReduced);
83714 pNew->x.pList = sqlite3ExprListDup(db, p->x.pList, isReduced);
83720 zAlloc += dupedExprNodeSize(p, flags);
83722 pNew->pLeft = exprDup(db, p->pLeft, EXPRDUP_REDUCE, &zAlloc);
83723 pNew->pRight = exprDup(db, p->pRight, EXPRDUP_REDUCE, &zAlloc);
83729 if( !ExprHasProperty(p, EP_TokenOnly) ){
83730 pNew->pLeft = sqlite3ExprDup(db, p->pLeft, 0);
83731 pNew->pRight = sqlite3ExprDup(db, p->pRight, 0);
83746 static With *withDup(sqlite3 *db, With *p){
83748 if( p ){
83749 int nByte = sizeof(*p) + sizeof(p->a[0]) * (p->nCte-1);
83753 pRet->nCte = p->nCte;
83754 for(i=0; i<p->nCte; i++){
83755 pRet->a[i].pSelect = sqlite3SelectDup(db, p->a[i].pSelect, 0);
83756 pRet->a[i].pCols = sqlite3ExprListDup(db, p->a[i].pCols, 0);
83757 pRet->a[i].zName = sqlite3DbStrDup(db, p->a[i].zName);
83784 SQLITE_PRIVATE Expr *sqlite3ExprDup(sqlite3 *db, Expr *p, int flags){
83785 return exprDup(db, p, flags, 0);
83787 SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3 *db, ExprList *p, int flags){
83791 if( p==0 ) return 0;
83794 pNew->nExpr = i = p->nExpr;
83795 if( (flags & EXPRDUP_REDUCE)==0 ) for(i=1; i<p->nExpr; i+=i){}
83796 pNew->a = pItem = sqlite3DbMallocRaw(db, i*sizeof(p->a[0]) );
83801 pOldItem = p->a;
83802 for(i=0; i<p->nExpr; i++, pItem++, pOldItem++){
83823 SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3 *db, SrcList *p, int flags){
83827 if( p==0 ) return 0;
83828 nByte = sizeof(*p) + (p->nSrc>0 ? sizeof(p->a[0]) * (p->nSrc-1) : 0);
83831 pNew->nSrc = pNew->nAlloc = p->nSrc;
83832 for(i=0; i<p->nSrc; i++){
83834 struct SrcList_item *pOldItem = &p->a[i];
83861 SQLITE_PRIVATE IdList *sqlite3IdListDup(sqlite3 *db, IdList *p){
83864 if( p==0 ) return 0;
83867 pNew->nId = p->nId;
83868 pNew->a = sqlite3DbMallocRaw(db, p->nId*sizeof(p->a[0]) );
83876 for(i=0; i<p->nId; i++){
83878 struct IdList_item *pOldItem = &p->a[i];
83884 SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, Select *p, int flags){
83886 if( p==0 ) return 0;
83887 pNew = sqlite3DbMallocRaw(db, sizeof(*p) );
83889 pNew->pEList = sqlite3ExprListDup(db, p->pEList, flags);
83890 pNew->pSrc = sqlite3SrcListDup(db, p->pSrc, flags);
83891 pNew->pWhere = sqlite3ExprDup(db, p->pWhere, flags);
83892 pNew->pGroupBy = sqlite3ExprListDup(db, p->pGroupBy, flags);
83893 pNew->pHaving = sqlite3ExprDup(db, p->pHaving, flags);
83894 pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy, flags);
83895 pNew->op = p->op;
83896 pNew->pPrior = pPrior = sqlite3SelectDup(db, p->pPrior, flags);
83899 pNew->pLimit = sqlite3ExprDup(db, p->pLimit, flags);
83900 pNew->pOffset = sqlite3ExprDup(db, p->pOffset, flags);
83903 pNew->selFlags = p->selFlags & ~SF_UsesEphemeral;
83906 pNew->nSelectRow = p->nSelectRow;
83907 pNew->pWith = withDup(db, p->pWith);
83908 sqlite3SelectSetName(pNew, p->zSelName);
83912 SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, Select *p, int flags){
83913 assert( p==0 );
84148 static int exprIsConst(Expr *p, int initFlag, int iCur){
84155 sqlite3WalkExpr(&w, p);
84167 SQLITE_PRIVATE int sqlite3ExprIsConstant(Expr *p){
84168 return exprIsConst(p, 1, 0);
84177 SQLITE_PRIVATE int sqlite3ExprIsConstantNotJoin(Expr *p){
84178 return exprIsConst(p, 2, 0);
84187 SQLITE_PRIVATE int sqlite3ExprIsTableConstant(Expr *p, int iCur){
84188 return exprIsConst(p, 3, iCur);
84200 SQLITE_PRIVATE int sqlite3ExprIsConstantOrFunction(Expr *p, u8 isInit){
84202 return exprIsConst(p, 4+isInit, 0);
84211 SQLITE_PRIVATE int sqlite3ExprIsInteger(Expr *p, int *pValue){
84216 assert( p->op!=TK_INTEGER || (p->flags & EP_IntValue)!=0
84217 || sqlite3GetInt32(p->u.zToken, &rc)==0 );
84219 if( p->flags & EP_IntValue ){
84220 *pValue = p->u.iValue;
84223 switch( p->op ){
84225 rc = sqlite3ExprIsInteger(p->pLeft, pValue);
84230 if( sqlite3ExprIsInteger(p->pLeft, &v) ){
84256 SQLITE_PRIVATE int sqlite3ExprCanBeNull(const Expr *p){
84258 while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ p = p->pLeft; }
84259 op = p->op;
84260 if( op==TK_REGISTER ) op = p->op2;
84268 assert( p->pTab!=0 );
84269 return ExprHasProperty(p, EP_CanBeNull) ||
84270 (p->iColumn>=0 && p->pTab->aCol[p->iColumn].notNull==0);
84286 SQLITE_PRIVATE int sqlite3ExprNeedsNoAffinityChange(const Expr *p, char aff){
84289 while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ p = p->pLeft; }
84290 op = p->op;
84291 if( op==TK_REGISTER ) op = p->op2;
84306 assert( p->iTable>=0 ); /* p cannot be part of a CHECK constraint */
84307 return p->iColumn<0
84339 static int isCandidateForInOpt(Select *p){
84343 if( p==0 ) return 0; /* right-hand side of IN is SELECT */
84344 if( p->pPrior ) return 0; /* Not a compound SELECT */
84345 if( p->selFlags & (SF_Distinct|SF_Aggregate) ){
84346 testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct );
84347 testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate );
84350 assert( p->pGroupBy==0 ); /* Has no GROUP BY clause */
84351 if( p->pLimit ) return 0; /* Has no LIMIT clause */
84352 assert( p->pOffset==0 ); /* No LIMIT means no OFFSET */
84353 if( p->pWhere ) return 0; /* Has no WHERE clause */
84354 pSrc = p->pSrc;
84362 pEList = p->pEList;
84484 Select *p; /* SELECT to the right of IN operator */
84497 p = (ExprHasProperty(pX, EP_xIsSelect) ? pX->x.pSelect : 0);
84498 if( pParse->nErr==0 && isCandidateForInOpt(p) ){
84505 assert( p ); /* Because of isCandidateForInOpt(p) */
84506 assert( p->pEList!=0 ); /* Because of isCandidateForInOpt(p) */
84507 assert( p->pEList->a[0].pExpr!=0 ); /* Because of isCandidateForInOpt(p) */
84508 assert( p->pSrc!=0 ); /* Because of isCandidateForInOpt(p) */
84509 pTab = p->pSrc->a[0].pTab;
84510 pExpr = p->pEList->a[0].pExpr;
85092 static void cacheEntryClear(Parse *pParse, struct yColCache *p){
85093 if( p->tempReg ){
85095 pParse->aTempReg[pParse->nTempReg++] = p->iReg;
85097 p->tempReg = 0;
85110 struct yColCache *p;
85128 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
85129 assert( p->iReg==0 || p->iTable!=iTab || p->iColumn!=iCol );
85134 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
85135 if( p->iReg==0 ){
85136 p->iLevel = pParse->iCacheLevel;
85137 p->iTable = iTab;
85138 p->iColumn = iCol;
85139 p->iReg = iReg;
85140 p->tempReg = 0;
85141 p->lru = pParse->iCacheCnt++;
85149 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
85150 if( p->lru<minLru ){
85152 minLru = p->lru;
85156 p = &pParse->aColCache[idxLru];
85157 p->iLevel = pParse->iCacheLevel;
85158 p->iTable = iTab;
85159 p->iColumn = iCol;
85160 p->iReg = iReg;
85161 p->tempReg = 0;
85162 p->lru = pParse->iCacheCnt++;
85174 struct yColCache *p;
85175 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
85176 int r = p->iReg;
85178 cacheEntryClear(pParse, p);
85179 p->iReg = 0;
85205 struct yColCache *p;
85213 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
85214 if( p->iReg && p->iLevel>pParse->iCacheLevel ){
85215 cacheEntryClear(pParse, p);
85216 p->iReg = 0;
85229 struct yColCache *p;
85230 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
85231 if( p->iReg==iReg ){
85232 p->tempReg = 0;
85281 struct yColCache *p;
85283 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
85284 if( p->iReg>0 && p->iTable==iTable && p->iColumn==iColumn ){
85285 p->lru = pParse->iCacheCnt++;
85286 sqlite3ExprCachePinRegister(pParse, p->iReg);
85287 return p->iReg;
85305 struct yColCache *p;
85312 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
85313 if( p->iReg ){
85314 cacheEntryClear(pParse, p);
85315 p->iReg = 0;
85348 struct yColCache *p;
85349 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
85350 int r = p->iReg;
85360 static void exprToRegister(Expr *p, int iReg){
85361 p->op2 = p->op;
85362 p->op = TK_REGISTER;
85363 p->iTable = iReg;
85364 ExprClearProperty(p, EP_Skip);
86000 ExprList *p;
86002 p = pParse->pConstExpr;
86004 p = sqlite3ExprListAppend(pParse, p, pExpr);
86005 if( p ){
86006 struct ExprList_item *pItem = &p->a[p->nExpr-1];
86010 pParse->pConstExpr = p;
86033 ExprList *p = pParse->pConstExpr;
86036 if( p ){
86038 for(pItem=p->a, i=p->nExpr; i>0; pItem++, i--){
86924 struct SrcCount *p = pWalker->u.pSrcCount;
86925 SrcList *pSrc = p->pSrc;
86931 p->nThis++;
86933 p->nOther++;
87183 struct yColCache *p;
87184 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
87185 if( p->iReg==iReg ){
87186 p->tempReg = 1;
87512 FKey *p;
87514 for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
87515 zWhere = whereOrName(pParse->db, zWhere, p->pFrom->zName);
87799 FKey *p;
87800 for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
87801 Table *pFrom = p->pFrom;
87803 reloadTableSchema(pParse, p->pFrom, pFrom->zName);
88362 static void sampleClear(sqlite3 *db, Stat4Sample *p){
88364 if( p->nRowid ){
88365 sqlite3DbFree(db, p->u.aRowid);
88366 p->nRowid = 0;
88374 static void sampleSetRowid(sqlite3 *db, Stat4Sample *p, int n, const u8 *pData){
88376 if( p->nRowid ) sqlite3DbFree(db, p->u.aRowid);
88377 p->u.aRowid = sqlite3DbMallocRaw(db, n);
88378 if( p->u.aRowid ){
88379 p->nRowid = n;
88380 memcpy(p->u.aRowid, pData, n);
88382 p->nRowid = 0;
88390 static void sampleSetRowidInt64(sqlite3 *db, Stat4Sample *p, i64 iRowid){
88392 if( p->nRowid ) sqlite3DbFree(db, p->u.aRowid);
88393 p->nRowid = 0;
88394 p->u.iRowid = iRowid;
88403 static void sampleCopy(Stat4Accum *p, Stat4Sample *pTo, Stat4Sample *pFrom){
88407 memcpy(pTo->anEq, pFrom->anEq, sizeof(tRowcnt)*p->nCol);
88408 memcpy(pTo->anLt, pFrom->anLt, sizeof(tRowcnt)*p->nCol);
88409 memcpy(pTo->anDLt, pFrom->anDLt, sizeof(tRowcnt)*p->nCol);
88411 sampleSetRowid(p->db, pTo, pFrom->nRowid, pFrom->u.aRowid);
88413 sampleSetRowidInt64(p->db, pTo, pFrom->u.iRowid);
88422 Stat4Accum *p = (Stat4Accum*)pOld;
88425 for(i=0; i<p->nCol; i++) sampleClear(p->db, p->aBest+i);
88426 for(i=0; i<p->mxSample; i++) sampleClear(p->db, p->a+i);
88427 sampleClear(p->db, &p->current);
88429 sqlite3DbFree(p->db, p);
88460 Stat4Accum *p;
88480 n = sizeof(*p)
88490 p = sqlite3DbMallocZero(db, n);
88491 if( p==0 ){
88496 p->db = db;
88497 p->nRow = 0;
88498 p->nCol = nCol;
88499 p->nKeyCol = nKeyCol;
88500 p->current.anDLt = (tRowcnt*)&p[1];
88501 p->current.anEq = &p->current.anDLt[nColUp];
88508 p->iGet = -1;
88509 p->mxSample = mxSample;
88510 p->nPSample = (tRowcnt)(sqlite3_value_int64(argv[2])/(mxSample/3+1) + 1);
88511 p->current.anLt = &p->current.anEq[nColUp];
88512 p->iPrn = 0x689e962d*(u32)nCol ^ 0xd0944565*(u32)sqlite3_value_int(argv[2]);
88515 p->a = (struct Stat4Sample*)&p->current.anLt[nColUp];
88516 p->aBest = &p->a[mxSample];
88517 pSpace = (u8*)(&p->a[mxSample+nCol]);
88519 p->a[i].anEq = (tRowcnt *)pSpace; pSpace += (sizeof(tRowcnt) * nColUp);
88520 p->a[i].anLt = (tRowcnt *)pSpace; pSpace += (sizeof(tRowcnt) * nColUp);
88521 p->a[i].anDLt = (tRowcnt *)pSpace; pSpace += (sizeof(tRowcnt) * nColUp);
88523 assert( (pSpace - (u8*)p)==n );
88526 p->aBest[i].iCol = i;
88535 sqlite3_result_blob(context, p, sizeof(*p), stat4Destructor);
88613 static void sampleInsert(Stat4Accum *p, Stat4Sample *pNew, int nEqZero){
88629 for(i=p->nSample-1; i>=0; i--){
88630 Stat4Sample *pOld = &p->a[i];
88634 assert( sampleIsBetter(p, pNew, pOld) );
88635 if( pUpgrade==0 || sampleIsBetter(p, pOld, pUpgrade) ){
88649 if( p->nSample>=p->mxSample ){
88650 Stat4Sample *pMin = &p->a[p->iMin];
88654 sampleClear(p->db, pMin);
88655 memmove(pMin, &pMin[1], sizeof(p->a[0])*(p->nSample-p->iMin-1));
88656 pSample = &p->a[p->nSample-1];
88661 p->nSample = p->mxSample-1;
88668 assert( p->nSample==0
88669 || pNew->anLt[p->nCol-1] > p->a[p->nSample-1].anLt[p->nCol-1] );
88673 pSample = &p->a[p->nSample];
88674 sampleCopy(p, pSample, pNew);
88675 p->nSample++;
88683 if( p->nSample>=p->mxSample ){
88685 for(i=0; i<p->mxSample; i++){
88686 if( p->a[i].isPSample ) continue;
88687 if( iMin<0 || sampleIsBetter(p, &p->a[iMin], &p->a[i]) ){
88692 p->iMin = iMin;
88703 static void samplePushPrevious(Stat4Accum *p, int iChng){
88709 for(i=(p->nCol-2); i>=iChng; i--){
88710 Stat4Sample *pBest = &p->aBest[i];
88711 pBest->anEq[i] = p->current.anEq[i];
88712 if( p->nSample<p->mxSample || sampleIsBetter(p, pBest, &p->a[p->iMin]) ){
88713 sampleInsert(p, pBest, i);
88718 for(i=p->nSample-1; i>=0; i--){
88720 for(j=iChng; j<p->nCol; j++){
88721 if( p->a[i].anEq[j]==0 ) p->a[i].anEq[j] = p->current.anEq[j];
88728 tRowcnt nLt = p->current.anLt[0];
88729 tRowcnt nEq = p->current.anEq[0];
88732 if( (nLt/p->nPSample)!=(nLt+nEq)/p->nPSample ){
88733 p->current.isPSample = 1;
88734 sampleInsert(p, &p->current, 0);
88735 p->current.isPSample = 0;
88739 if( p->nSample<p->mxSample
88740 || sampleIsBetter(p, &p->current, &p->a[p->iMin])
88742 sampleInsert(p, &p->current, 0);
88748 UNUSED_PARAMETER( p );
88777 Stat4Accum *p = (Stat4Accum*)sqlite3_value_blob(argv[0]);
88782 assert( p->nCol>0 );
88783 assert( iChng<p->nCol );
88785 if( p->nRow==0 ){
88787 for(i=0; i<p->nCol; i++) p->current.anEq[i] = 1;
88790 samplePushPrevious(p, iChng);
88795 p->current.anEq[i]++;
88797 for(i=iChng; i<p->nCol; i++){
88798 p->current.anDLt[i]++;
88800 p->current.anLt[i] += p->current.anEq[i];
88802 p->current.anEq[i] = 1;
88805 p->nRow++;
88808 sampleSetRowidInt64(p->db, &p->current, sqlite3_value_int64(argv[2]));
88810 sampleSetRowid(p->db, &p->current, sqlite3_value_bytes(argv[2]),
88813 p->current.iHash = p->iPrn = p->iPrn*1103515245 + 12345;
88818 tRowcnt nLt = p->current.anLt[p->nCol-1];
88821 if( (nLt/p->nPSample)!=(nLt+1)/p->nPSample ){
88822 p->current.isPSample = 1;
88823 p->current.iCol = 0;
88824 sampleInsert(p, &p->current, p->nCol-1);
88825 p->current.isPSample = 0;
88829 for(i=0; i<(p->nCol-1); i++){
88830 p->current.iCol = i;
88831 if( i>=iChng || sampleIsBetterPost(p, &p->current, &p->aBest[i]) ){
88832 sampleCopy(p, &p->aBest[i], &p->current);
88875 Stat4Accum *p = (Stat4Accum*)sqlite3_value_blob(argv[0]);
88913 char *zRet = sqlite3MallocZero( (p->nKeyCol+1)*25 );
88919 sqlite3_snprintf(24, zRet, "%llu", (u64)p->nRow);
88921 for(i=0; i<p->nKeyCol; i++){
88922 u64 nDistinct = p->current.anDLt[i] + 1;
88923 u64 iVal = (p->nRow + nDistinct - 1) / nDistinct;
88926 assert( p->current.anEq[i] );
88934 if( p->iGet<0 ){
88935 samplePushPrevious(p, 0);
88936 p->iGet = 0;
88938 if( p->iGet<p->nSample ){
88939 Stat4Sample *pS = p->a + p->iGet;
88950 assert( p->iGet<p->nSample );
88952 case STAT_GET_NEQ: aCnt = p->a[p->iGet].anEq; break;
88953 case STAT_GET_NLT: aCnt = p->a[p->iGet].anLt; break;
88955 aCnt = p->a[p->iGet].anDLt;
88956 p->iGet++;
88964 char *zRet = sqlite3MallocZero(p->nCol * 25);
88970 for(i=0; i<p->nCol; i++){
89620 IndexSample *p = &pIdx->aSample[j];
89621 sqlite3DbFree(db, p->p);
89832 pSample->p = sqlite3DbMallocZero(db, pSample->n + 2);
89833 if( pSample->p==0 ){
89837 memcpy(pSample->p, sqlite3_column_blob(pStmt, 4), pSample->n);
90361 SQLITE_PRIVATE void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *pKey){
90374 codeAttach(pParse, SQLITE_ATTACH, &attach_func, p, p, pDbname, pKey);
90871 TableLock *p;
90875 p = &pToplevel->aTableLock[i];
90876 if( p->iDb==iDb && p->iTab==iTab ){
90877 p->isWriteLock = (p->isWriteLock || isWriteLock);
90886 p = &pToplevel->aTableLock[pToplevel->nTableLock++];
90887 p->iDb = iDb;
90888 p->iTab = iTab;
90889 p->isWriteLock = isWriteLock;
90890 p->zName = zName;
90909 TableLock *p = &pParse->aTableLock[i];
90910 int p1 = p->iDb;
90911 sqlite3VdbeAddOp4(pVdbe, OP_TableLock, p1, p->iTab, p->isWriteLock,
90912 p->zName, P4_STATIC);
91113 Table *p = 0;
91129 p = sqlite3HashFind(&db->aDb[j].pSchema->tblHash, zName);
91130 if( p ) break;
91132 return p;
91151 Table *p;
91159 p = sqlite3FindTable(pParse->db, zName, zDbase);
91160 if( p==0 ){
91172 p = 0;
91175 return p;
91190 struct SrcList_item *p
91193 assert( p->pSchema==0 || p->zDatabase==0 );
91194 if( p->pSchema ){
91195 int iDb = sqlite3SchemaToIndex(pParse->db, p->pSchema);
91198 zDb = p->zDatabase;
91200 return sqlite3LocateTable(pParse, isView, p->zName, zDb);
91216 Index *p = 0;
91226 p = sqlite3HashFind(&pSchema->idxHash, zName);
91227 if( p ) break;
91229 return p;
91235 static void freeIndex(sqlite3 *db, Index *p){
91237 sqlite3DeleteIndexSamples(db, p);
91239 sqlite3ExprDelete(db, p->pPartIdxWhere);
91240 sqlite3DbFree(db, p->zColAff);
91241 if( p->isResized ) sqlite3DbFree(db, p->azColl);
91243 sqlite3_free(p->aiRowEst);
91245 sqlite3DbFree(db, p);
91265 Index *p;
91268 p = pIndex->pTable->pIndex;
91269 while( ALWAYS(p) && p->pNext!=pIndex ){ p = p->pNext; }
91270 if( ALWAYS(p && p->pNext==pIndex) ){
91271 p->pNext = pIndex->pNext;
91454 Table *p;
91463 p = sqlite3HashInsert(&pDb->pSchema->tblHash, zTabName, 0);
91464 sqlite3DeleteTable(db, p);
91496 SQLITE_PRIVATE void sqlite3OpenMasterTable(Parse *p, int iDb){
91497 Vdbe *v = sqlite3GetVdbe(p);
91498 sqlite3TableLock(p, iDb, MASTER_ROOT, 1, SCHEMA_TABLE(iDb));
91500 if( p->nTab==0 ){
91501 p->nTab = 1;
91606 Index *p;
91607 for(p=pTab->pIndex; p && !IsPrimaryKeyIndex(p); p=p->pNext){}
91608 return p;
91863 Table *p;
91868 if( (p = pParse->pNewTable)==0 ) return;
91870 if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
91871 sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName);
91877 for(i=0; i<p->nCol; i++){
91878 if( STRICMP(z, p->aCol[i].zName) ){
91884 if( (p->nCol & 0x7)==0 ){
91886 aNew = sqlite3DbRealloc(db,p->aCol,(p->nCol+8)*sizeof(p->aCol[0]));
91891 p->aCol = aNew;
91893 pCol = &p->aCol[p->nCol];
91894 memset(pCol, 0, sizeof(p->aCol[0]));
91903 p->nCol++;
91913 Table *p;
91914 p = pParse->pNewTable;
91915 if( p==0 || NEVER(p->nCol<1) ) return;
91916 p->aCol[p->nCol-1].notNull = (u8)onError;
92016 Table *p;
92019 p = pParse->pNewTable;
92020 if( p==0 || NEVER(p->nCol<1) ) return;
92021 pCol = &p->aCol[p->nCol-1];
92039 Table *p;
92042 p = pParse->pNewTable;
92043 if( p!=0 ){
92044 pCol = &(p->aCol[p->nCol-1]);
92132 Index *p;
92134 p = sqlite3CreateIndex(pParse, 0, 0, 0, pList, onError, 0,
92136 if( p ){
92137 p->idxType = SQLITE_IDXTYPE_PRIMARYKEY;
92177 Table *p;
92182 if( (p = pParse->pNewTable)==0 ) return;
92183 i = p->nCol-1;
92190 sqlite3DbFree(db, p->aCol[i].zColl);
92191 p->aCol[i].zColl = zColl;
92197 for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
92200 pIdx->azColl[0] = p->aCol[i].zColl;
92326 static char *createTableStmt(sqlite3 *db, Table *p){
92332 for(pCol = p->aCol, i=0; i<p->nCol; i++, pCol++){
92335 n += identLength(p->zName);
92345 n += 35 + 6*p->nCol;
92353 identPut(zStmt, &k, p->zName);
92355 for(pCol=p->aCol, i=0; i<p->nCol; i++, pCol++){
92618 Table *p; /* The new table */
92626 p = pParse->pNewTable;
92627 if( p==0 ) return;
92638 p->tnum = db->init.newTnum;
92643 if( (p->tabFlags & TF_Autoincrement) ){
92648 if( (p->tabFlags & TF_HasPrimaryKey)==0 ){
92649 sqlite3ErrorMsg(pParse, "PRIMARY KEY missing on table %s", p->zName);
92651 p->tabFlags |= TF_WithoutRowid;
92652 convertToWithoutRowidTable(pParse, p);
92656 iDb = sqlite3SchemaToIndex(db, p->pSchema);
92661 if( p->pCheck ){
92662 sqlite3ResolveSelfReference(pParse, p, NC_IsCheck, 0, p->pCheck);
92667 estimateTableWidth(p);
92668 for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
92693 if( p->pSelect==0 ){
92732 assert( p->aCol==0 );
92733 p->nCol = pSelTab->nCol;
92734 p->aCol = pSelTab->aCol;
92743 zStmt = createTableStmt(db, p);
92763 p->zName,
92764 p->zName,
92776 if( p->tabFlags & TF_Autoincrement ){
92790 sqlite3MPrintf(db, "tbl_name='%q' AND type!='trigger'", p->zName));
92798 Schema *pSchema = p->pSchema;
92800 pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName, p);
92802 assert( p==pOld ); /* Malloc must have failed inside HashInsert() */
92810 if( !p->pSelect ){
92818 p->addColOffset = 13 + sqlite3Utf8CharLen(zName, nName);
92837 Table *p;
92852 p = pParse->pNewTable;
92853 if( p==0 || pParse->nErr ){
92858 iDb = sqlite3SchemaToIndex(db, p->pSchema);
92870 p->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
92876 sqlite3ViewGetColumnNames(pParse, p);
93372 Table *p = pParse->pNewTable;
93379 if( p==0 || IN_DECLARE_VTAB ) goto fk_end;
93381 int iCol = p->nCol-1;
93386 p->aCol[iCol].zName, pTo);
93408 pFKey->pFrom = p;
93409 pFKey->pNextFrom = p->pFKey;
93418 pFKey->aCol[0].iFrom = p->nCol-1;
93422 for(j=0; j<p->nCol; j++){
93423 if( sqlite3StrICmp(p->aCol[j].zName, pFromCol->a[i].zName)==0 ){
93428 if( j>=p->nCol ){
93449 assert( sqlite3SchemaMutexHeld(db, 0, p->pSchema) );
93450 pNextTo = (FKey *)sqlite3HashInsert(&p->pSchema->fkeyHash,
93465 p->pFKey = pFKey;
93596 Index *p; /* Allocated index object */
93604 p = sqlite3DbMallocZero(db, nByte + nExtra);
93605 if( p ){
93606 char *pExtra = ((char*)p)+ROUND8(sizeof(Index));
93607 p->azColl = (char**)pExtra; pExtra += ROUND8(sizeof(char*)*nCol);
93608 p->aiRowLogEst = (LogEst*)pExtra; pExtra += sizeof(LogEst)*(nCol+1);
93609 p->aiColumn = (i16*)pExtra; pExtra += sizeof(i16)*nCol;
93610 p->aSortOrder = (u8*)pExtra;
93611 p->nColumn = nCol;
93612 p->nKeyCol = nCol - 1;
93613 *ppExtra = ((char*)p) + nByte;
93615 return p;
94001 Index *p;
94003 p = sqlite3HashInsert(&pIndex->pSchema->idxHash,
94005 if( p ){
94006 assert( p==pIndex ); /* Malloc must have failed */
94509 SrcList *p, /* The left part of the FROM clause already seen */
94519 if( !p && (pOn || pUsing) ){
94525 p = sqlite3SrcListAppend(db, p, pTable, pDatabase);
94526 if( p==0 || NEVER(p->nSrc==0) ){
94529 pItem = &p->a[p->nSrc-1];
94537 return p;
94540 assert( p==0 );
94551 SQLITE_PRIVATE void sqlite3SrcListIndexedBy(Parse *pParse, SrcList *p, Token *pIndexedBy){
94553 if( p && ALWAYS(p->nSrc>0) ){
94554 struct SrcList_item *pItem = &p->a[p->nSrc-1];
94581 SQLITE_PRIVATE void sqlite3SrcListShiftJoinType(SrcList *p){
94582 if( p ){
94584 for(i=p->nSrc-1; i>0; i--){
94585 p->a[i].jointype = p->a[i-1].jointype;
94587 p->a[0].jointype = 0;
95193 CollSeq *p;
95196 p = pColl;
95197 if( !p ){
95198 p = sqlite3FindCollSeq(db, enc, zName, 0);
95200 if( !p || !p->xCmp ){
95205 p = sqlite3FindCollSeq(db, enc, zName, 0);
95207 if( p && !p->xCmp && synthCollSeq(db, p) ){
95208 p = 0;
95210 assert( !p || p->xCmp );
95211 if( p==0 ){
95214 return p;
95232 CollSeq *p = sqlite3GetCollSeq(pParse, ENC(db), pColl, zName);
95233 if( !p ){
95236 assert( p==pColl );
95357 FuncDef *p, /* The function we are evaluating for match quality */
95364 if( nArg==(-2) ) return (p->xFunc==0 && p->xStep==0) ? 0 : FUNC_PERFECT_MATCH;
95367 if( p->nArg!=nArg && p->nArg>=0 ) return 0;
95371 if( p->nArg==nArg ){
95378 if( enc==(p->funcFlags & SQLITE_FUNC_ENCMASK) ){
95380 }else if( (enc & p->funcFlags & 2)!=0 ){
95397 FuncDef *p;
95398 for(p=pHash->a[h]; p; p=p->pHash){
95399 if( sqlite3StrNICmp(p->zName, zFunc, nFunc)==0 && p->zName[nFunc]==0 ){
95400 return p;
95458 FuncDef *p; /* Iterator variable */
95469 p = functionSearch(&db->aFunc, h, zName, nName);
95470 while( p ){
95471 int score = matchQuality(p, nArg, enc);
95473 pBest = p;
95476 p = p->pNext;
95494 p = functionSearch(pHash, h, zName, nName);
95495 while( p ){
95496 int score = matchQuality(p, nArg, enc);
95498 pBest = p;
95501 p = p->pNext;
95533 SQLITE_PRIVATE void sqlite3SchemaClear(void *p){
95537 Schema *pSchema = (Schema *)p;
95566 Schema * p;
95568 p = (Schema *)sqlite3BtreeSchema(pBt, sizeof(Schema), sqlite3SchemaClear);
95570 p = (Schema *)sqlite3DbMallocZero(0, sizeof(Schema));
95572 if( !p ){
95574 }else if ( 0==p->file_format ){
95575 sqlite3HashInit(&p->tblHash);
95576 sqlite3HashInit(&p->idxHash);
95577 sqlite3HashInit(&p->trigHash);
95578 sqlite3HashInit(&p->fkeyHash);
95579 p->enc = SQLITE_UTF8;
95581 return p;
96926 unsigned char *p;
96933 p = contextMalloc(context, n);
96934 if( p ){
96935 sqlite3_randomness(n, p);
96936 sqlite3_result_blob(context, (char*)p, n, sqlite3_free);
97843 SumCtx *p;
97847 p = sqlite3_aggregate_context(context, sizeof(*p));
97849 if( p && type!=SQLITE_NULL ){
97850 p->cnt++;
97853 p->rSum += v;
97854 if( (p->approx|p->overflow)==0 && sqlite3AddInt64(&p->iSum, v) ){
97855 p->overflow = 1;
97858 p->rSum += sqlite3_value_double(argv[0]);
97859 p->approx = 1;
97864 SumCtx *p;
97865 p = sqlite3_aggregate_context(context, 0);
97866 if( p && p->cnt>0 ){
97867 if( p->overflow ){
97869 }else if( p->approx ){
97870 sqlite3_result_double(context, p->rSum);
97872 sqlite3_result_int64(context, p->iSum);
97877 SumCtx *p;
97878 p = sqlite3_aggregate_context(context, 0);
97879 if( p && p->cnt>0 ){
97880 sqlite3_result_double(context, p->rSum/(double)p->cnt);
97884 SumCtx *p;
97885 p = sqlite3_aggregate_context(context, 0);
97887 sqlite3_result_double(context, p ? p->rSum : (double)0);
97903 CountCtx *p;
97904 p = sqlite3_aggregate_context(context, sizeof(*p));
97905 if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && p ){
97906 p->n++;
97914 assert( argc==1 || p==0 || p->n>0x7fffffff
97915 || p->n==sqlite3_aggregate_count(context) );
97919 CountCtx *p;
97920 p = sqlite3_aggregate_context(context, 0);
97921 sqlite3_result_int64(context, p ? p->n : 0);
98900 static void fkTriggerDelete(sqlite3 *dbMem, Trigger *p){
98901 if( p ){
98902 TriggerStep *pStep = p->step_list;
98906 sqlite3ExprDelete(dbMem, p->pWhen);
98907 sqlite3DbFree(dbMem, p);
98941 FKey *p;
98942 for(p=pTab->pFKey; p; p=p->pNextFrom){
98943 if( p->isDeferred || (db->flags & SQLITE_DeferFKs) ) break;
98945 if( !p ) return;
98991 FKey *p, /* Foreign key for which pTab is the child */
98996 for(i=0; i<p->nCol; i++){
98997 int iChildKey = p->aCol[i].iFrom;
99018 FKey *p,
99023 for(i=0; i<p->nCol; i++){
99024 char *zKey = p->aCol[i].zCol;
99048 Trigger *p = pTop->pTriggerPrg->pTrigger;
99049 if( (p==pFKey->apTrigger[0] && pFKey->aAction[0]==OE_SetNull)
99050 || (p==pFKey->apTrigger[1] && pFKey->aAction[1]==OE_SetNull)
99283 FKey *p;
99285 for(p=pTab->pFKey; p; p=p->pNextFrom){
99286 for(i=0; i<p->nCol; i++) mask |= COLUMN_MASK(p->aCol[i].iFrom);
99288 for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
99290 sqlite3FkLocateIndex(pParse, pTab, p, &pIdx, 0);
99329 FKey *p;
99332 for(p=pTab->pFKey; p; p=p->pNextFrom){
99333 if( fkChildIsModified(pTab, p, aChange, chngRowid) ) return 1;
99337 for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
99338 if( fkParentIsModified(pTab, p, aChange, chngRowid) ) return 1;
99604 void *p = (void *)pFKey->pNextTo;
99605 const char *z = (p ? pFKey->pNextTo->zTo : pFKey->zTo);
99606 sqlite3HashInsert(&pTab->pSchema->fkeyHash, z, p);
99785 static int readsTable(Parse *p, int iDb, Table *pTab){
99786 Vdbe *v = sqlite3GetVdbe(p);
99790 VTable *pVTab = IsVirtual(pTab) ? sqlite3GetVTable(p->db, pTab) : 0;
99873 AutoincInfo *p; /* Information about an AUTOINCREMENT */
99886 for(p = pParse->pAinc; p; p = p->pNext){
99887 pDb = &db->aDb[p->iDb];
99888 memId = p->regCtr;
99890 sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenRead);
99893 sqlite3VdbeAddOp4(v, OP_String8, 0, memId-1, 0, p->pTab->zName, 0);
99929 AutoincInfo *p;
99934 for(p = pParse->pAinc; p; p = p->pNext){
99935 Db *pDb = &db->aDb[p->iDb];
99938 int memId = p->regCtr;
99942 sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenWrite);
104773 HashElem *p;
104778 for(p=sqliteHashFirst(&db->aCollSeq); p; p=sqliteHashNext(p)){
104779 CollSeq *pColl = (CollSeq *)sqliteHashData(p);
106315 SQLITE_PRIVATE int sqlite3Reprepare(Vdbe *p){
106321 assert( sqlite3_mutex_held(sqlite3VdbeDb(p)->mutex) );
106322 zSql = sqlite3_sql((sqlite3_stmt *)p);
106324 db = sqlite3VdbeDb(p);
106326 rc = sqlite3LockAndPrepare(db, zSql, -1, 0, p, &pNew, 0);
106336 sqlite3VdbeSwap((Vdbe*)pNew, p);
106337 sqlite3TransferBindings(pNew, (sqlite3_stmt*)p);
106531 static void clearSelect(sqlite3 *db, Select *p, int bFree){
106532 while( p ){
106533 Select *pPrior = p->pPrior;
106534 sqlite3ExprListDelete(db, p->pEList);
106535 sqlite3SrcListDelete(db, p->pSrc);
106536 sqlite3ExprDelete(db, p->pWhere);
106537 sqlite3ExprListDelete(db, p->pGroupBy);
106538 sqlite3ExprDelete(db, p->pHaving);
106539 sqlite3ExprListDelete(db, p->pOrderBy);
106540 sqlite3ExprDelete(db, p->pLimit);
106541 sqlite3ExprDelete(db, p->pOffset);
106542 sqlite3WithDelete(db, p->pWith);
106543 if( bFree ) sqlite3DbFree(db, p);
106544 p = pPrior;
106617 SQLITE_PRIVATE void sqlite3SelectSetName(Select *p, const char *zName){
106618 if( p && zName ){
106619 sqlite3_snprintf(sizeof(p->zSelName), p->zSelName, "%s", zName);
106628 SQLITE_PRIVATE void sqlite3SelectDelete(sqlite3 *db, Select *p){
106629 clearSelect(db, p, 1);
106635 static Select *findRightmost(Select *p){
106636 while( p->pNext ) p = p->pNext;
106637 return p;
106660 Token *p;
106681 p = apAll[i];
106683 if( p->n==aKeyword[j].nChar
106684 && sqlite3StrNICmp((char*)p->z, &zKeyText[aKeyword[j].i], p->n)==0 ){
106829 static void setJoinExpr(Expr *p, int iTable){
106830 while( p ){
106831 ExprSetProperty(p, EP_FromJoin);
106832 assert( !ExprHasProperty(p, EP_TokenOnly|EP_Reduced) );
106833 ExprSetVVAProperty(p, EP_NoReduce);
106834 p->iRightJoinTable = (i16)iTable;
106835 setJoinExpr(p->pLeft, iTable);
106836 p = p->pRight;
106854 static int sqliteProcessJoin(Parse *pParse, Select *p){
106860 pSrc = p->pSrc;
106888 isOuter, &p->pWhere);
106906 p->pWhere = sqlite3ExprAnd(pParse->db, p->pWhere, pRight->pOn);
106935 isOuter, &p->pWhere);
107125 Select *p, /* The complete select statement being coded */
107149 codeOffset(v, p->iOffset, iContinue);
107244 codeOffset(v, p->iOffset, iContinue);
107296 pushOntoSorter(pParse, pSort, p, r1+nPrefixReg, 1, nPrefixReg);
107322 pushOntoSorter(pParse, pSort, p, regResult, 1, nPrefixReg);
107348 pushOntoSorter(pParse, pSort, p, regResult, 1, nPrefixReg);
107362 pushOntoSorter(pParse, pSort, p, regResult, nResultCol, nPrefixReg);
107438 if( pSort==0 && p->iLimit ){
107439 sqlite3VdbeAddOp2(v, OP_DecrJumpZero, p->iLimit, iBreak); VdbeCoverage(v);
107448 KeyInfo *p = sqlite3DbMallocZero(0,
107450 if( p ){
107451 p->aSortOrder = (u8*)&p->aColl[N+X];
107452 p->nField = (u16)N;
107453 p->nXField = (u16)X;
107454 p->enc = ENC(db);
107455 p->db = db;
107456 p->nRef = 1;
107460 return p;
107466 SQLITE_PRIVATE void sqlite3KeyInfoUnref(KeyInfo *p){
107467 if( p ){
107468 assert( p->nRef>0 );
107469 p->nRef--;
107470 if( p->nRef==0 ) sqlite3DbFree(0, p);
107477 SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoRef(KeyInfo *p){
107478 if( p ){
107479 assert( p->nRef>0 );
107480 p->nRef++;
107482 return p;
107492 SQLITE_PRIVATE int sqlite3KeyInfoIsWriteable(KeyInfo *p){ return p->nRef==1; }
107631 Select *p, /* The SELECT statement */
107653 struct ExprList_item *aOutEx = p->pEList->a;
107682 codeOffset(v, p->iOffset, addrContinue);
107687 codeOffset(v, p->iOffset, addrContinue);
107856 Expr *p = pS->pEList->a[iCol].pExpr;
107860 zType = columnType(&sNC, p,&zOrigDb,&zOrigTab,&zOrigCol, &estWidth);
107900 Expr *p = pS->pEList->a[0].pExpr;
107905 zType = columnType(&sNC, p, &zOrigDb, &zOrigTab, &zOrigCol, &estWidth);
107939 Expr *p = pEList->a[i].pExpr;
107945 zType = columnType(&sNC, p, &zOrigDb, &zOrigTab, &zOrigCol, 0);
107955 zType = columnType(&sNC, p, 0, 0, 0, 0);
107990 Expr *p;
107991 p = pEList->a[i].pExpr;
107992 if( NEVER(p==0) ) continue;
107996 }else if( (p->op==TK_COLUMN || p->op==TK_AGG_COLUMN) && pTabList ){
107999 int iCol = p->iColumn;
108001 if( pTabList->a[j].iCursor==p->iTable ) break;
108055 Expr *p; /* Expression for a single result column */
108073 p = sqlite3ExprSkipCollate(pEList->a[i].pExpr);
108078 Expr *pColExpr = p; /* The expression that is the result column name */
108157 Expr *p;
108169 p = a[i].pExpr;
108171 pCol->zType = sqlite3DbStrDup(db, columnType(&sNC, p,0,0,0, &pCol->szEst));
108174 pCol->affinity = sqlite3ExprAffinity(p);
108176 pColl = sqlite3ExprCollSeq(pParse, p);
108263 static void computeLimitRegisters(Parse *pParse, Select *p, int iBreak){
108268 if( p->iLimit ) return;
108277 assert( p->pOffset==0 || p->pLimit!=0 );
108278 if( p->pLimit ){
108279 p->iLimit = iLimit = ++pParse->nMem;
108282 if( sqlite3ExprIsInteger(p->pLimit, &n) ){
108287 }else if( n>=0 && p->nSelectRow>(u64)n ){
108288 p->nSelectRow = n;
108291 sqlite3ExprCode(pParse, p->pLimit, iLimit);
108296 if( p->pOffset ){
108297 p->iOffset = iOffset = ++pParse->nMem;
108299 sqlite3ExprCode(pParse, p->pOffset, iOffset);
108323 static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){
108325 if( p->pPrior ){
108326 pRet = multiSelectCollSeq(pParse, p->pPrior, iCol);
108331 if( pRet==0 && iCol<p->pEList->nExpr ){
108332 pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
108346 static KeyInfo *multiSelectOrderByKeyInfo(Parse *pParse, Select *p, int nExtra){
108347 ExprList *pOrderBy = p->pOrderBy;
108348 int nOrderBy = p->pOrderBy->nExpr;
108361 pColl = multiSelectCollSeq(pParse, p, pItem->u.x.iOrderByCol-1);
108414 Select *p, /* The recursive SELECT to be coded */
108417 SrcList *pSrc = p->pSrc; /* The FROM clause of the recursive query */
108418 int nCol = p->pEList->nExpr; /* Number of columns in the recursive table */
108420 Select *pSetup = p->pPrior; /* The setup query */
108440 computeLimitRegisters(pParse, p, addrBreak);
108441 pLimit = p->pLimit;
108442 pOffset = p->pOffset;
108443 regLimit = p->iLimit;
108444 regOffset = p->iOffset;
108445 p->pLimit = p->pOffset = 0;
108446 p->iLimit = p->iOffset = 0;
108447 pOrderBy = p->pOrderBy;
108461 if( p->op==TK_UNION ){
108473 KeyInfo *pKeyInfo = multiSelectOrderByKeyInfo(pParse, p, 1);
108482 p->addrOpenEphm[0] = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iDistinct, 0);
108483 p->selFlags |= SF_UsesEphemeral;
108487 p->pOrderBy = 0;
108492 pSetup->pNext = p;
108510 selectInnerLoop(pParse, p, p->pEList, iCurrent,
108521 p->pPrior = 0;
108522 sqlite3Select(pParse, p, &destQueue);
108523 assert( p->pPrior==0 );
108524 p->pPrior = pSetup;
108531 sqlite3ExprListDelete(pParse->db, p->pOrderBy);
108532 p->pOrderBy = pOrderBy;
108533 p->pLimit = pLimit;
108534 p->pOffset = pOffset;
108542 Select *p, /* The right-most of SELECTs to be coded */
108550 static void selectWrongNumTermsError(Parse *pParse, Select *p){
108551 if( p->selFlags & SF_Values ){
108555 " do not have the same number of result columns", selectOpName(p->op));
108572 Select *p, /* The right-most of SELECTs to be coded */
108576 int nExpr = p->pEList->nExpr;
108579 assert( p->selFlags & SF_MultiValue );
108581 assert( p->selFlags & SF_Values );
108582 assert( p->op==TK_ALL || (p->op==TK_SELECT && p->pPrior==0) );
108583 assert( p->pLimit==0 );
108584 assert( p->pOffset==0 );
108585 if( p->pEList->nExpr!=nExpr ){
108586 selectWrongNumTermsError(pParse, p);
108589 if( p->pPrior==0 ) break;
108590 assert( p->pPrior->pNext==p );
108591 p = p->pPrior;
108594 while( p ){
108595 pPrior = p->pPrior;
108596 p->pPrior = 0;
108597 rc = sqlite3Select(pParse, p, pDest);
108598 p->pPrior = pPrior;
108600 p->nSelectRow = nRow;
108601 p = p->pNext;
108639 Select *p, /* The right-most of SELECTs to be coded */
108656 assert( p && p->pPrior ); /* Calling function guarantees this much */
108657 assert( (p->selFlags & SF_Recursive)==0 || p->op==TK_ALL || p->op==TK_UNION );
108659 pPrior = p->pPrior;
108663 selectOpName(p->op));
108669 selectOpName(p->op));
108680 assert( p->pEList );
108681 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, dest.iSDParm, p->pEList->nExpr);
108688 if( p->selFlags & SF_MultiValue ){
108689 rc = multiSelectValues(pParse, p, &dest);
108696 assert( p->pEList && pPrior->pEList );
108697 if( p->pEList->nExpr!=pPrior->pEList->nExpr ){
108698 selectWrongNumTermsError(pParse, p);
108704 if( p->selFlags & SF_Recursive ){
108705 generateWithRecursiveQuery(pParse, p, &dest);
108711 if( p->pOrderBy ){
108712 return multiSelectOrderBy(pParse, p, pDest);
108717 switch( p->op ){
108722 pPrior->iLimit = p->iLimit;
108723 pPrior->iOffset = p->iOffset;
108724 pPrior->pLimit = p->pLimit;
108725 pPrior->pOffset = p->pOffset;
108728 p->pLimit = 0;
108729 p->pOffset = 0;
108733 p->pPrior = 0;
108734 p->iLimit = pPrior->iLimit;
108735 p->iOffset = pPrior->iOffset;
108736 if( p->iLimit ){
108737 addr = sqlite3VdbeAddOp1(v, OP_IfNot, p->iLimit); VdbeCoverage(v);
108741 rc = sqlite3Select(pParse, p, &dest);
108743 pDelete = p->pPrior;
108744 p->pPrior = pPrior;
108745 p->nSelectRow += pPrior->nSelectRow;
108748 && nLimit>0 && p->nSelectRow > (u64)nLimit
108750 p->nSelectRow = nLimit;
108766 testcase( p->op==TK_EXCEPT );
108767 testcase( p->op==TK_UNION );
108773 assert( p->pLimit==0 ); /* Not allowed on leftward elements */
108774 assert( p->pOffset==0 ); /* Not allowed on leftward elements */
108781 assert( p->pOrderBy==0 );
108783 assert( p->addrOpenEphm[0] == -1 );
108784 p->addrOpenEphm[0] = addr;
108785 findRightmost(p)->selFlags |= SF_UsesEphemeral;
108786 assert( p->pEList );
108801 if( p->op==TK_EXCEPT ){
108804 assert( p->op==TK_UNION );
108807 p->pPrior = 0;
108808 pLimit = p->pLimit;
108809 p->pLimit = 0;
108810 pOffset = p->pOffset;
108811 p->pOffset = 0;
108814 rc = sqlite3Select(pParse, p, &uniondest);
108818 sqlite3ExprListDelete(db, p->pOrderBy);
108819 pDelete = p->pPrior;
108820 p->pPrior = pPrior;
108821 p->pOrderBy = 0;
108822 if( p->op==TK_UNION ) p->nSelectRow += pPrior->nSelectRow;
108823 sqlite3ExprDelete(db, p->pLimit);
108824 p->pLimit = pLimit;
108825 p->pOffset = pOffset;
108826 p->iLimit = 0;
108827 p->iOffset = 0;
108835 assert( p->pEList );
108837 Select *pFirst = p;
108843 computeLimitRegisters(pParse, p, iBreak);
108846 selectInnerLoop(pParse, p, p->pEList, unionTab,
108855 default: assert( p->op==TK_INTERSECT ); {
108869 assert( p->pOrderBy==0 );
108872 assert( p->addrOpenEphm[0] == -1 );
108873 p->addrOpenEphm[0] = addr;
108874 findRightmost(p)->selFlags |= SF_UsesEphemeral;
108875 assert( p->pEList );
108889 assert( p->addrOpenEphm[1] == -1 );
108890 p->addrOpenEphm[1] = addr;
108891 p->pPrior = 0;
108892 pLimit = p->pLimit;
108893 p->pLimit = 0;
108894 pOffset = p->pOffset;
108895 p->pOffset = 0;
108898 rc = sqlite3Select(pParse, p, &intersectdest);
108900 pDelete = p->pPrior;
108901 p->pPrior = pPrior;
108902 if( p->nSelectRow>pPrior->nSelectRow ) p->nSelectRow = pPrior->nSelectRow;
108903 sqlite3ExprDelete(db, p->pLimit);
108904 p->pLimit = pLimit;
108905 p->pOffset = pOffset;
108910 assert( p->pEList );
108912 Select *pFirst = p;
108918 computeLimitRegisters(pParse, p, iBreak);
108924 selectInnerLoop(pParse, p, p->pEList, tab1,
108935 explainComposite(pParse, p->op, iSub1, iSub2, p->op!=TK_ALL);
108946 if( p->selFlags & SF_UsesEphemeral ){
108953 assert( p->pNext==0 );
108954 nCol = p->pEList->nExpr;
108961 *apColl = multiSelectCollSeq(pParse, p, i);
108967 for(pLoop=p; pLoop; pLoop=pLoop->pPrior){
109015 Select *p, /* The SELECT statement */
109046 codeOffset(v, p->iOffset, iContinue);
109075 sqlite3CompareAffinity(p->pEList->a[0].pExpr, pDest->affSdst);
109137 if( p->iLimit ){
109138 sqlite3VdbeAddOp2(v, OP_DecrJumpZero, p->iLimit, iBreak); VdbeCoverage(v);
109237 Select *p, /* The right-most of SELECTs to be coded */
109279 assert( p->pOrderBy!=0 );
109290 op = p->op;
109291 pPrior = p->pPrior;
109293 pOrderBy = p->pOrderBy;
109302 for(i=1; db->mallocFailed==0 && i<=p->pEList->nExpr; i++){
109333 testcase( pItem->u.x.iOrderByCol > p->pEList->nExpr );
109336 pKeyMerge = multiSelectOrderByKeyInfo(pParse, p, 1);
109343 p->pOrderBy = pOrderBy;
109353 int nExpr = p->pEList->nExpr;
109362 pKeyDup->aColl[i] = multiSelectCollSeq(pParse, p, i);
109370 p->pPrior = 0;
109372 sqlite3ResolveOrderGroupBy(pParse, p, p->pOrderBy, "ORDER");
109378 computeLimitRegisters(pParse, p, labelEnd);
109379 if( p->iLimit && op==TK_ALL ){
109382 sqlite3VdbeAddOp2(v, OP_Copy, p->iOffset ? p->iOffset+1 : p->iLimit,
109388 sqlite3ExprDelete(db, p->pLimit);
109389 p->pLimit = 0;
109390 sqlite3ExprDelete(db, p->pOffset);
109391 p->pOffset = 0;
109418 savedLimit = p->iLimit;
109419 savedOffset = p->iOffset;
109420 p->iLimit = regLimitB;
109421 p->iOffset = 0;
109423 sqlite3Select(pParse, p, &destB);
109424 p->iLimit = savedLimit;
109425 p->iOffset = savedOffset;
109433 p, &destA, pDest, regOutA,
109442 p, &destB, pDest, regOutB,
109458 p->nSelectRow += pPrior->nSelectRow;
109466 if( p->nSelectRow > pPrior->nSelectRow ) p->nSelectRow = pPrior->nSelectRow;
109534 if( p->pPrior ){
109535 sqlite3SelectDelete(db, p->pPrior);
109537 p->pPrior = pPrior;
109538 pPrior->pNext = p;
109542 explainComposite(pParse, p->op, iSub1, iSub2, 0);
109608 Select *p, /* SELECT statement in which to make substitutions */
109615 if( !p ) return;
109616 substExprList(db, p->pEList, iTable, pEList);
109617 substExprList(db, p->pGroupBy, iTable, pEList);
109618 substExprList(db, p->pOrderBy, iTable, pEList);
109619 p->pHaving = substExpr(db, p->pHaving, iTable, pEList);
109620 p->pWhere = substExpr(db, p->pWhere, iTable, pEList);
109621 substSelect(db, p->pPrior, iTable, pEList);
109622 pSrc = p->pSrc;
109774 Select *p, /* The parent or outer SELECT statement */
109794 assert( p!=0 );
109795 assert( p->pPrior==0 ); /* Unable to flatten compound queries */
109797 pSrc = p->pSrc;
109806 if( (p->pWhere && ExprHasProperty(p->pWhere,EP_Subquery))
109807 || (sqlite3ExprListFlags(p->pEList) & EP_Subquery)!=0
109808 || (sqlite3ExprListFlags(p->pOrderBy) & EP_Subquery)!=0
109821 if( pSub->pLimit && p->pLimit ) return 0; /* Restriction (13) */
109823 if( (p->selFlags & SF_Compound)!=0 && pSub->pLimit ){
109831 if( (p->selFlags & SF_Distinct)!=0 && subqueryIsAgg ){
109834 if( p->pOrderBy && pSub->pOrderBy ){
109838 if( pSub->pLimit && p->pWhere ) return 0; /* Restriction (19) */
109839 if( pSub->pLimit && (p->selFlags & SF_Distinct)!=0 ){
109847 if( (p->selFlags & SF_Recursive) && pSub->pPrior ){
109896 if( isAgg || (p->selFlags & SF_Distinct)!=0 || pSrc->nSrc!=1 ){
109914 if( p->pOrderBy ){
109916 for(ii=0; ii<p->pOrderBy->nExpr; ii++){
109917 if( p->pOrderBy->a[ii].u.x.iOrderByCol==0 ) return 0;
109923 SELECTTRACE(1,pParse,p,("flatten %s.%p from term %d\n",
109967 ExprList *pOrderBy = p->pOrderBy;
109968 Expr *pLimit = p->pLimit;
109969 Expr *pOffset = p->pOffset;
109970 Select *pPrior = p->pPrior;
109971 p->pOrderBy = 0;
109972 p->pSrc = 0;
109973 p->pPrior = 0;
109974 p->pLimit = 0;
109975 p->pOffset = 0;
109976 pNew = sqlite3SelectDup(db, p, 0);
109978 p->pOffset = pOffset;
109979 p->pLimit = pLimit;
109980 p->pOrderBy = pOrderBy;
109981 p->pSrc = pSrc;
109982 p->op = TK_ALL;
109984 p->pPrior = pPrior;
109988 pNew->pNext = p;
109989 p->pPrior = pNew;
109990 SELECTTRACE(2,pParse,p,
110045 for(pParent=p; pParent; pParent=pParent->pPrior, pSub=pSub->pPrior){
110053 assert( pParent==p ); /* First time through the loop */
110056 assert( pParent!=p ); /* 2nd and subsequent times through the loop */
110187 sqlite3TreeViewSelect(0, p, 0);
110246 static Table *isSimpleCount(Select *p, AggInfo *pAggInfo){
110250 assert( !p->pGroupBy );
110252 if( p->pWhere || p->pEList->nExpr!=1
110253 || p->pSrc->nSrc!=1 || p->pSrc->a[0].pSelect
110257 pTab = p->pSrc->a[0].pTab;
110258 pExpr = p->pEList->a[0].pExpr;
110316 static int convertCompoundSelectToSubquery(Walker *pWalker, Select *p){
110326 if( p->pPrior==0 ) return WRC_Continue;
110327 if( p->pOrderBy==0 ) return WRC_Continue;
110328 for(pX=p; pX && (pX->op==TK_ALL || pX->op==TK_SELECT); pX=pX->pPrior){}
110330 a = p->pOrderBy->a;
110331 for(i=p->pOrderBy->nExpr-1; i>=0; i--){
110345 *pNew = *p;
110346 p->pSrc = pNewSrc;
110347 p->pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ALL, 0));
110348 p->op = TK_SELECT;
110349 p->pWhere = 0;
110353 p->pPrior = 0;
110354 p->pNext = 0;
110355 p->pWith = 0;
110356 p->selFlags &= ~SF_Compound;
110357 assert( (p->selFlags & SF_Converted)==0 );
110358 p->selFlags |= SF_Converted;
110384 With *p;
110385 for(p=pWith; p; p=p->pOuter){
110387 for(i=0; i<p->nCte; i++){
110388 if( sqlite3StrICmp(zName, p->a[i].zName)==0 ){
110389 *ppContext = p;
110390 return &p->a[i];
110546 static void selectPopWith(Walker *pWalker, Select *p){
110548 With *pWith = findRightmost(p)->pWith;
110582 static int selectExpander(Walker *pWalker, Select *p){
110590 u16 selFlags = p->selFlags;
110592 p->selFlags |= SF_Expanded;
110596 if( NEVER(p->pSrc==0) || (selFlags & SF_Expanded)!=0 ){
110599 pTabList = p->pSrc;
110600 pEList = p->pEList;
110602 sqlite3WithPush(pParse, findRightmost(p)->pWith, 0);
110623 selectPopWith(pWalker, p);
110680 if( db->mallocFailed || sqliteProcessJoin(pParse, p) ){
110716 assert( (p->selFlags & SF_NestedFrom)==0
110822 if( pNew && (p->selFlags & SF_NestedFrom)!=0 ){
110847 p->pEList = pNew;
110850 if( p->pEList && p->pEList->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
110915 static void selectAddSubqueryTypeInfo(Walker *pWalker, Select *p){
110921 assert( p->selFlags & SF_Resolved );
110922 if( (p->selFlags & SF_HasTypeInfo)==0 ){
110923 p->selFlags |= SF_HasTypeInfo;
110925 pTabList = p->pSrc;
110975 Select *p, /* The SELECT statement being coded. */
110979 if( NEVER(p==0) ) return;
110982 if( p->selFlags & SF_HasTypeInfo ) return;
110983 sqlite3SelectExpand(pParse, p);
110985 sqlite3ResolveSelectNames(pParse, p, pOuterNC);
110987 sqlite3SelectAddTypeInfo(pParse, p);
111174 Select *p, /* The SELECT statement being coded. */
111199 if( p==0 || db->mallocFailed || pParse->nErr ){
111206 SELECTTRACE(1,pParse,p, ("begin processing:\n"));
111208 sqlite3TreeViewSelect(0, p, 0);
111212 assert( p->pOrderBy==0 || pDest->eDest!=SRT_DistFifo );
111213 assert( p->pOrderBy==0 || pDest->eDest!=SRT_Fifo );
111214 assert( p->pOrderBy==0 || pDest->eDest!=SRT_DistQueue );
111215 assert( p->pOrderBy==0 || pDest->eDest!=SRT_Queue );
111223 sqlite3ExprListDelete(db, p->pOrderBy);
111224 p->pOrderBy = 0;
111225 p->selFlags &= ~SF_Distinct;
111227 sqlite3SelectPrep(pParse, p, 0);
111229 sSort.pOrderBy = p->pOrderBy;
111230 pTabList = p->pSrc;
111231 pEList = p->pEList;
111235 isAgg = (p->selFlags & SF_Aggregate)!=0;
111239 SELECTTRACE(0x100,pParse,p, ("after name resolution:\n"));
111240 sqlite3TreeViewSelect(0, p, 0);
111262 for(i=0; !p->pPrior && i<pTabList->nSrc; i++){
111290 pParse->nHeight += sqlite3SelectExprHeight(p);
111293 if( flattenSubquery(pParse, p, i, isAgg, isAggSub) ){
111297 p->selFlags |= SF_Aggregate;
111355 pParse->nHeight -= sqlite3SelectExprHeight(p);
111356 pTabList = p->pSrc;
111358 sSort.pOrderBy = p->pOrderBy;
111361 pEList = p->pEList;
111363 pWhere = p->pWhere;
111364 pGroupBy = p->pGroupBy;
111365 pHaving = p->pHaving;
111366 sDistinct.isTnct = (p->selFlags & SF_Distinct)!=0;
111371 if( p->pPrior ){
111372 rc = multiSelect(pParse, p, pDest);
111375 SELECTTRACE(1,pParse,p,("end compound-select processing\n"));
111397 if( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct
111398 && sqlite3ExprListCompare(sSort.pOrderBy, p->pEList, -1)==0
111400 p->selFlags &= ~SF_Distinct;
111401 p->pGroupBy = sqlite3ExprListDup(db, p->pEList, 0);
111402 pGroupBy = p->pGroupBy;
111438 p->nSelectRow = LARGEST_INT64;
111439 computeLimitRegisters(pParse, p, iEnd);
111440 if( p->iLimit==0 && sSort.addrSortIndex>=0 ){
111447 if( p->selFlags & SF_Distinct ){
111451 (char*)keyInfoFromExprList(pParse, p->pEList,0,0),
111465 p->pEList, wctrlFlags, 0);
111467 if( sqlite3WhereOutputRowCount(pWInfo) < p->nSelectRow ){
111468 p->nSelectRow = sqlite3WhereOutputRowCount(pWInfo);
111489 selectInnerLoop(pParse, p, pEList, -1, &sSort, &sDistinct, pDest,
111519 for(k=p->pEList->nExpr, pItem=p->pEList->a; k>0; k--, pItem++){
111525 if( p->nSelectRow>100 ) p->nSelectRow = 100;
111527 p->nSelectRow = 1;
111643 (sDistinct.isTnct && (p->selFlags&SF_Distinct)==0) ?
111789 selectInnerLoop(pParse, p, p->pEList, -1, &sSort,
111806 if( (pTab = isSimpleCount(p, &sAggInfo))!=0 ){
111893 assert( p->pGroupBy==0 );
111895 if( p->pHaving==0 ){
111932 selectInnerLoop(pParse, p, p->pEList, -1, 0, 0,
111949 generateSortTail(pParse, p, &sSort, pEList->nExpr, pDest);
111975 SELECTTRACE(1,pParse,p,("end processing\n"));
111985 SQLITE_PRIVATE void sqlite3TreeViewSelect(TreeView *pView, const Select *p, u8 moreToFollow){
111989 ((p->selFlags & SF_Distinct) ? " DISTINCT" : ""),
111990 ((p->selFlags & SF_Aggregate) ? " agg_flag" : ""), p
111992 if( p->pSrc && p->pSrc->nSrc ) n++;
111993 if( p->pWhere ) n++;
111994 if( p->pGroupBy ) n++;
111995 if( p->pHaving ) n++;
111996 if( p->pOrderBy ) n++;
111997 if( p->pLimit ) n++;
111998 if( p->pOffset ) n++;
111999 if( p->pPrior ) n++;
112000 sqlite3TreeViewExprList(pView, p->pEList, (n--)>0, "result-set");
112001 if( p->pSrc && p->pSrc->nSrc ){
112005 for(i=0; i<p->pSrc->nSrc; i++){
112006 struct SrcList_item *pItem = &p->pSrc->a[i];
112026 sqlite3TreeViewItem(pView, zLine, i<p->pSrc->nSrc-1);
112034 if( p->pWhere ){
112036 sqlite3TreeViewExpr(pView, p->pWhere, 0);
112039 if( p->pGroupBy ){
112040 sqlite3TreeViewExprList(pView, p->pGroupBy, (n--)>0, "GROUPBY");
112042 if( p->pHaving ){
112044 sqlite3TreeViewExpr(pView, p->pHaving, 0);
112047 if( p->pOrderBy ){
112048 sqlite3TreeViewExprList(pView, p->pOrderBy, (n--)>0, "ORDERBY");
112050 if( p->pLimit ){
112052 sqlite3TreeViewExpr(pView, p->pLimit, 0);
112055 if( p->pOffset ){
112057 sqlite3TreeViewExpr(pView, p->pOffset, 0);
112060 if( p->pPrior ){
112062 switch( p->op ){
112068 sqlite3TreeViewSelect(pView, p->pPrior, 0);
112120 TabResult *p = (TabResult*)pArg; /* Result accumulator */
112128 if( p->nRow==0 && argv!=0 ){
112133 if( p->nData + need > p->nAlloc ){
112135 p->nAlloc = p->nAlloc*2 + need;
112136 azNew = sqlite3_realloc64( p->azResult, sizeof(char*)*p->nAlloc );
112138 p->azResult = azNew;
112144 if( p->nRow==0 ){
112145 p->nColumn = nCol;
112149 p->azResult[p->nData++] = z;
112151 }else if( (int)p->nColumn!=nCol ){
112152 sqlite3_free(p->zErrMsg);
112153 p->zErrMsg = sqlite3_mprintf(
112156 p->rc = SQLITE_ERROR;
112172 p->azResult[p->nData++] = z;
112174 p->nRow++;
112179 p->rc = SQLITE_NOMEM;
112333 HashElem *p;
112335 for(p=sqliteHashFirst(&pTmpSchema->trigHash); p; p=sqliteHashNext(p)){
112336 Trigger *pTrig = (Trigger *)sqliteHashData(p);
112922 Trigger *p;
112928 for(p=pList; p; p=p->pNext){
112929 if( p->op==op && checkColumnOverlap(p->pColumns, pChanges) ){
112930 mask |= p->tr_tm;
113235 Trigger *p, /* Trigger to code */
113243 pPrg = getRowTrigger(pParse, p, pTab, orconf);
113249 int bRecursive = (p->zName && 0==(pParse->db->flags&SQLITE_RecTriggers));
113254 (v, "Call: %s.%s", (p->zName?p->zName:"fkey"), onErrorText(orconf)));
113316 Trigger *p; /* Used to iterate through pTrigger list */
113322 for(p=pTrigger; p; p=p->pNext){
113327 assert( p->pSchema!=0 );
113328 assert( p->pTabSchema!=0 );
113329 assert( p->pSchema==p->pTabSchema
113330 || p->pSchema==pParse->db->aDb[1].pSchema );
113333 if( p->op==op
113334 && p->tr_tm==tr_tm
113335 && checkColumnOverlap(p->pColumns, pChanges)
113337 sqlite3CodeRowTriggerDirect(pParse, p, pTab, reg, orconf, ignoreJump);
113378 Trigger *p;
113381 for(p=pTrigger; p; p=p->pNext){
113382 if( p->op==op && (tr_tm&p->tr_tm)
113383 && checkColumnOverlap(p->pColumns,pChanges)
113386 pPrg = getRowTrigger(pParse, p, pTab, orconf);
114694 sqlite3_vtab *p = pVTab->pVtab;
114695 if( p ){
114696 p->pModule->xDisconnect(p);
114709 static VTable *vtabDisconnectAll(sqlite3 *db, Table *p){
114711 VTable *pVTable = p->pVTable;
114712 p->pVTable = 0;
114720 assert( db==0 || sqlite3SchemaMutexHeld(db, 0, p->pSchema) );
114728 p->pVTable = pRet;
114749 SQLITE_PRIVATE void sqlite3VtabDisconnect(sqlite3 *db, Table *p){
114752 assert( IsVirtual(p) );
114756 for(ppVTab=&p->pVTable; *ppVTab; ppVTab=&(*ppVTab)->pNext){
114788 VTable *p = db->pDisconnect;
114794 if( p ){
114797 VTable *pNext = p->pNext;
114798 sqlite3VtabUnlock(p);
114799 p = pNext;
114800 }while( p );
114818 SQLITE_PRIVATE void sqlite3VtabClear(sqlite3 *db, Table *p){
114819 if( !db || db->pnBytesFreed==0 ) vtabDisconnectAll(0, p);
114820 if( p->azModuleArg ){
114822 for(i=0; i<p->nModuleArg; i++){
114823 if( i!=1 ) sqlite3DbFree(db, p->azModuleArg[i]);
114825 sqlite3DbFree(db, p->azModuleArg);
115017 SQLITE_PRIVATE void sqlite3VtabArgExtend(Parse *pParse, Token *p){
115020 pArg->z = p->z;
115021 pArg->n = p->n;
115023 assert(pArg->z <= p->z);
115024 pArg->n = (int)(&p->z[p->n] - pArg->z);
115356 VTable *p;
115357 for(p=pTab->pVTable; p; p=p->pNext){
115358 assert( p->pVtab );
115359 if( p->pVtab->nRef>0 ){
115363 p = vtabDisconnectAll(db, pTab);
115364 rc = p->pMod->pModule->xDestroy(p->pVtab);
115367 assert( pTab->pVTable==p && p->pNext==0 );
115368 p->pVtab = 0;
115370 sqlite3VtabUnlock(p);
115390 sqlite3_vtab *p = pVTab->pVtab;
115391 if( p ){
115393 x = *(int (**)(sqlite3_vtab *))((char *)p->pModule + offset);
115394 if( x ) x(p);
115412 SQLITE_PRIVATE int sqlite3VtabSync(sqlite3 *db, Vdbe *p){
115423 sqlite3VtabImportErrmsg(p, pVtab);
115678 VtabCtx *p = db->pVtabCtx;
115679 if( !p ){
115682 assert( p->pTab==0 || (p->pTab->tabFlags & TF_Virtual)!=0 );
115683 p->pVTable->bConstraint = (u8)va_arg(ap, int);
116278 WhereOrCost *p;
116279 for(i=pSet->n, p=pSet->a; i>0; i--, p++){
116280 if( rRun<=p->rRun && (prereq & p->prereq)==prereq ){
116283 if( p->rRun<=rRun && (p->prereq & prereq)==p->prereq ){
116288 p = &pSet->a[pSet->n++];
116289 p->nOut = nOut;
116291 p = pSet->a;
116293 if( p->rRun>pSet->a[i].rRun ) p = pSet->a + i;
116295 if( p->rRun<=rRun ) return 0;
116298 p->prereq = prereq;
116299 p->rRun = rRun;
116300 if( p->nOut>nOut ) p->nOut = nOut;
116324 static void whereOrInfoDelete(sqlite3 *db, WhereOrInfo *p){
116325 whereClauseClear(&p->wc);
116326 sqlite3DbFree(db, p);
116332 static void whereAndInfoDelete(sqlite3 *db, WhereAndInfo *p){
116333 whereClauseClear(&p->wc);
116334 sqlite3DbFree(db, p);
116379 static int whereClauseInsert(WhereClause *pWC, Expr *p, u16 wtFlags){
116389 sqlite3ExprDelete(db, p);
116402 if( p && ExprHasProperty(p, EP_Unlikely) ){
116403 pTerm->truthProb = sqlite3LogEst(p->iTable) - 270;
116407 pTerm->pExpr = sqlite3ExprSkipCollate(p);
116483 static Bitmask exprTableUsage(WhereMaskSet *pMaskSet, Expr *p){
116485 if( p==0 ) return 0;
116486 if( p->op==TK_COLUMN ){
116487 mask = getMask(pMaskSet, p->iTable);
116490 mask = exprTableUsage(pMaskSet, p->pRight);
116491 mask |= exprTableUsage(pMaskSet, p->pLeft);
116492 if( ExprHasProperty(p, EP_xIsSelect) ){
116493 mask |= exprSelectTableUsage(pMaskSet, p->x.pSelect);
116495 mask |= exprListTableUsage(pMaskSet, p->x.pList);
116766 WhereTerm *p;
116769 p = whereScanInit(&scan, pWC, iCur, iColumn, op, pIdx);
116770 while( p ){
116771 if( (p->prereqRight & notReady)==0 ){
116772 if( p->prereqRight==0 && (p->eOperator&WO_EQ)!=0 ){
116773 return p;
116775 if( pResult==0 ) pResult = p;
116777 p = whereScanNext(&scan);
117704 Expr *p = sqlite3ExprSkipCollate(pList->a[i].pExpr);
117705 if( p->op==TK_COLUMN
117706 && p->iColumn==pIdx->aiColumn[iCol]
117707 && p->iTable==iBase
117749 Expr *p = sqlite3ExprSkipCollate(pDistinct->a[i].pExpr);
117750 if( p->op==TK_COLUMN && p->iTable==iBase && p->iColumn<0 ) return 1;
117801 static void TRACE_IDX_INPUTS(sqlite3_index_info *p){
117804 for(i=0; i<p->nConstraint; i++){
117807 p->aConstraint[i].iColumn,
117808 p->aConstraint[i].iTermOffset,
117809 p->aConstraint[i].op,
117810 p->aConstraint[i].usable);
117812 for(i=0; i<p->nOrderBy; i++){
117815 p->aOrderBy[i].iColumn,
117816 p->aOrderBy[i].desc);
117819 static void TRACE_IDX_OUTPUTS(sqlite3_index_info *p){
117822 for(i=0; i<p->nConstraint; i++){
117825 p->aConstraintUsage[i].argvIndex,
117826 p->aConstraintUsage[i].omit);
117828 sqlite3DebugPrintf(" idxNum=%d\n", p->idxNum);
117829 sqlite3DebugPrintf(" idxStr=%s\n", p->idxStr);
117830 sqlite3DebugPrintf(" orderByConsumed=%d\n", p->orderByConsumed);
117831 sqlite3DebugPrintf(" estimatedCost=%g\n", p->estimatedCost);
117832 sqlite3DebugPrintf(" estimatedRows=%lld\n", p->estimatedRows);
118169 static int vtabBestIndex(Parse *pParse, Table *pTab, sqlite3_index_info *p){
118174 TRACE_IDX_INPUTS(p);
118175 rc = pVtab->pModule->xBestIndex(pVtab, p);
118176 TRACE_IDX_OUTPUTS(p);
118190 for(i=0; i<p->nConstraint; i++){
118191 if( !p->aConstraint[i].usable && p->aConstraintUsage[i].argvIndex>0 ){
118304 res = sqlite3VdbeRecordCompare(aSample[iSamp].n, aSample[iSamp].p, pRec);
118329 assert( 0==sqlite3VdbeRecordCompare(aSample[i].n, aSample[i].p, pRec)
118339 || sqlite3VdbeRecordCompare(aSample[i].n, aSample[i].p, pRec)>0
118348 assert( sqlite3VdbeRecordCompare(aSample[i].n, aSample[i].p, pRec)<=0
118353 assert( sqlite3VdbeRecordCompare(aSample[i-1].n, aSample[i-1].p, pRec)<0
118462 Index *p = pLoop->u.btree.pIndex;
118466 int nUpper = p->nSample+1;
118468 int iCol = p->aiColumn[nEq];
118469 u8 aff = iCol>=0 ? p->pTable->aCol[iCol].affinity : SQLITE_AFF_INTEGER;
118476 pColl = sqlite3LocateCollSeq(pParse, p->azColl[nEq]);
118483 nUpper = p2 ? 0 : p->nSample;
118489 for(i=0; rc==SQLITE_OK && i<p->nSample; i++){
118490 rc = sqlite3Stat4Column(db, p->aSample[i].p, p->aSample[i].n, nEq, &pVal);
118509 int nAdjust = (sqlite3LogEst(p->nSample) - sqlite3LogEst(nDiff));
118580 Index *p = pLoop->u.btree.pIndex;
118583 if( p->nSample>0 && nEq<p->nSampleCol ){
118617 if( nEq==p->nKeyCol ){
118620 aff = p->pTable->aCol[p->aiColumn[nEq]].affinity;
118625 iUpper = p->nRowEst0;
118629 whereKeyStats(pParse, p, pRec, 0, a);
118636 assert( p->aSortOrder!=0 );
118637 if( p->aSortOrder[nEq] ){
118646 rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, aff, nEq, &bOk);
118649 iLwrIdx = whereKeyStats(pParse, p, pRec, 0, a);
118661 rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, aff, nEq, &bOk);
118664 iUprIdx = whereKeyStats(pParse, p, pRec, 1, a);
118752 Index *p = pBuilder->pNew->u.btree.pIndex;
118761 assert( nEq<=p->nColumn );
118762 assert( p->aSample!=0 );
118763 assert( p->nSample>0 );
118774 if( nEq>=p->nColumn ){
118779 aff = p->pTable->aCol[p->aiColumn[nEq-1]].affinity;
118780 rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, aff, nEq-1, &bOk);
118786 whereKeyStats(pParse, p, pRec, 0, a);
118817 Index *p = pBuilder->pNew->u.btree.pIndex;
118818 i64 nRow0 = sqlite3LogEstToInt(p->aiRowLogEst[0]);
118825 assert( p->aSample!=0 );
120347 static void whereLoopPrint(WhereLoop *p, WhereClause *pWC){
120350 struct SrcList_item *pItem = pWInfo->pTabList->a + p->iTab;
120352 sqlite3DebugPrintf("%c%2d.%0*llx.%0*llx", p->cId,
120353 p->iTab, nb, p->maskSelf, nb, p->prereq);
120356 if( (p->wsFlags & WHERE_VIRTUALTABLE)==0 ){
120358 if( p->u.btree.pIndex && (zName = p->u.btree.pIndex->zName)!=0 ){
120364 sqlite3DebugPrintf(".%-16s %2d", zName, p->u.btree.nEq);
120370 if( p->u.vtab.idxStr ){
120372 p->u.vtab.idxNum, p->u.vtab.idxStr, p->u.vtab.omitMask);
120374 z = sqlite3_mprintf("(%d,%x)", p->u.vtab.idxNum, p->u.vtab.omitMask);
120379 if( p->wsFlags & WHERE_SKIPSCAN ){
120380 sqlite3DebugPrintf(" f %05x %d-%d", p->wsFlags, p->nLTerm,p->nSkip);
120382 sqlite3DebugPrintf(" f %05x N %d", p->wsFlags, p->nLTerm);
120384 sqlite3DebugPrintf(" cost %d,%d,%d\n", p->rSetup, p->rRun, p->nOut);
120385 if( p->nLTerm && (sqlite3WhereTrace & 0x100)!=0 ){
120387 for(i=0; i<p->nLTerm; i++){
120388 whereTermPrint(p->aLTerm[i], i);
120398 static void whereLoopInit(WhereLoop *p){
120399 p->aLTerm = p->aLTermSpace;
120400 p->nLTerm = 0;
120401 p->nLSlot = ArraySize(p->aLTermSpace);
120402 p->wsFlags = 0;
120408 static void whereLoopClearUnion(sqlite3 *db, WhereLoop *p){
120409 if( p->wsFlags & (WHERE_VIRTUALTABLE|WHERE_AUTO_INDEX) ){
120410 if( (p->wsFlags & WHERE_VIRTUALTABLE)!=0 && p->u.vtab.needFree ){
120411 sqlite3_free(p->u.vtab.idxStr);
120412 p->u.vtab.needFree = 0;
120413 p->u.vtab.idxStr = 0;
120414 }else if( (p->wsFlags & WHERE_AUTO_INDEX)!=0 && p->u.btree.pIndex!=0 ){
120415 sqlite3DbFree(db, p->u.btree.pIndex->zColAff);
120416 sqlite3DbFree(db, p->u.btree.pIndex);
120417 p->u.btree.pIndex = 0;
120425 static void whereLoopClear(sqlite3 *db, WhereLoop *p){
120426 if( p->aLTerm!=p->aLTermSpace ) sqlite3DbFree(db, p->aLTerm);
120427 whereLoopClearUnion(db, p);
120428 whereLoopInit(p);
120434 static int whereLoopResize(sqlite3 *db, WhereLoop *p, int n){
120436 if( p->nLSlot>=n ) return SQLITE_OK;
120438 paNew = sqlite3DbMallocRaw(db, sizeof(p->aLTerm[0])*n);
120440 memcpy(paNew, p->aLTerm, sizeof(p->aLTerm[0])*p->nLSlot);
120441 if( p->aLTerm!=p->aLTermSpace ) sqlite3DbFree(db, p->aLTerm);
120442 p->aLTerm = paNew;
120443 p->nLSlot = n;
120469 static void whereLoopDelete(sqlite3 *db, WhereLoop *p){
120470 whereLoopClear(db, p);
120471 sqlite3DbFree(db, p);
120488 WhereLoop *p = pWInfo->pLoops;
120489 pWInfo->pLoops = p->pNextLoop;
120490 whereLoopDelete(db, p);
120550 static void whereLoopAdjustCost(const WhereLoop *p, WhereLoop *pTemplate){
120552 for(; p; p=p->pNextLoop){
120553 if( p->iTab!=pTemplate->iTab ) continue;
120554 if( (p->wsFlags & WHERE_INDEXED)==0 ) continue;
120555 if( whereLoopCheaperProperSubset(p, pTemplate) ){
120559 pTemplate->rRun, pTemplate->nOut, p->rRun, p->nOut-1));
120560 pTemplate->rRun = p->rRun;
120561 pTemplate->nOut = p->nOut - 1;
120562 }else if( whereLoopCheaperProperSubset(pTemplate, p) ){
120566 pTemplate->rRun, pTemplate->nOut, p->rRun, p->nOut+1));
120567 pTemplate->rRun = p->rRun;
120568 pTemplate->nOut = p->nOut + 1;
120590 WhereLoop *p;
120591 for(p=(*ppPrev); p; ppPrev=&p->pNextLoop, p=*ppPrev){
120592 if( p->iTab!=pTemplate->iTab || p->iSortIdx!=pTemplate->iSortIdx ){
120601 assert( p->rSetup==0 || pTemplate->rSetup==0
120602 || p->rSetup==pTemplate->rSetup );
120607 assert( p->rSetup>=pTemplate->rSetup );
120612 if( (p->wsFlags & WHERE_AUTO_INDEX)!=0
120616 && (p->prereq & pTemplate->prereq)==pTemplate->prereq
120626 if( (p->prereq & pTemplate->prereq)==p->prereq /* (1) */
120627 && p->rSetup<=pTemplate->rSetup /* (2a) */
120628 && p->rRun<=pTemplate->rRun /* (2b) */
120629 && p->nOut<=pTemplate->nOut /* (2c) */
120639 if( (p->prereq & pTemplate->prereq)==pTemplate->prereq /* (1) */
120640 && p->rRun>=pTemplate->rRun /* (2a) */
120641 && p->nOut>=pTemplate->nOut /* (2b) */
120643 assert( p->rSetup>=pTemplate->rSetup ); /* SETUP-INVARIANT above */
120675 WhereLoop **ppPrev, *p;
120714 p = *ppPrev;
120723 if( p!=0 ){
120725 whereLoopPrint(p, pBuilder->pWC);
120731 if( p==0 ){
120733 *ppPrev = p = sqlite3DbMallocRaw(db, sizeof(WhereLoop));
120734 if( p==0 ) return SQLITE_NOMEM;
120735 whereLoopInit(p);
120736 p->pNextLoop = 0;
120741 WhereLoop **ppTail = &p->pNextLoop;
120758 whereLoopXfer(db, p, pTemplate);
120759 if( (p->wsFlags & WHERE_VIRTUALTABLE)==0 ){
120760 Index *pIndex = p->u.btree.pIndex;
120762 p->u.btree.pIndex = 0;
121998 Expr *p;
122001 p = pOrderBy->a[i].pExpr;
122002 mTerm = exprTableUsage(&pWInfo->sMaskSet,p);
122003 if( mTerm==0 && !sqlite3ExprIsConstant(p) ) continue;
122804 WhereLoop *p;
122808 for(p=pWInfo->pLoops, i=0; p; p=p->pNextLoop, i++){
122809 p->cId = zLabel[i%sizeof(zLabel)];
122810 whereLoopPrint(p, sWLB.pWC);
123298 static void parserDoubleLinkSelect(Parse *pParse, Select *p){
123299 if( p->pPrior ){
123302 for(pLoop=p; pLoop; pNext=pLoop, pLoop=pLoop->pPrior, cnt++){
123306 if( (p->selFlags & SF_MultiValue)==0 &&
124563 static void yyGrowStack(yyParser *p){
124567 newSize = p->yystksz*2 + 100;
124568 pNew = realloc(p->yystack, newSize*sizeof(pNew[0]));
124570 p->yystack = pNew;
124571 p->yystksz = newSize;
124575 yyTracePrompt, p->yystksz);
124750 void *p, /* The parser to be deleted */
124753 yyParser *pParser = (yyParser*)p;
124768 SQLITE_PRIVATE int sqlite3ParserStackPeak(void *p){
124769 yyParser *pParser = (yyParser*)p;
125631 Select *p = yymsp[0].minor.yy3;
125632 if( p ){
125633 p->pWith = yymsp[-1].minor.yy59;
125634 parserDoubleLinkSelect(pParse, p);
125638 yygotominor.yy3 = p;
125746 Expr *p = sqlite3Expr(pParse->db, TK_ALL, 0);
125747 yygotominor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-1].minor.yy14, p);
126220 Expr *p = yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_EXISTS, 0, 0, 0);
126221 if( p ){
126222 p->x.pSelect = yymsp[-1].minor.yy3;
126223 ExprSetProperty(p, EP_xIsSelect|EP_Subquery);
126224 sqlite3ExprSetHeightAndFlags(pParse, p);
126280 Expr *p = sqlite3ExprAddCollateToken(pParse, 0, &yymsp[-1].minor.yy0, 1);
126281 yygotominor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, p);
126289 Expr *p = sqlite3ExprAddCollateToken(pParse, 0, &yymsp[-1].minor.yy0, 1);
126290 yygotominor.yy14 = sqlite3ExprListAppend(pParse,0, p);
127598 AutoincInfo *p = pParse->pAinc;
127599 pParse->pAinc = p->pNext;
127600 sqlite3DbFree(db, p);
127603 Table *p = pParse->pZombieTab;
127604 pParse->pZombieTab = p->pNextZombie;
127605 sqlite3DeleteTable(db, p);
128669 LookasideSlot *p;
128671 p = (LookasideSlot*)pStart;
128673 p->pNext = db->lookaside.pFree;
128674 db->lookaside.pFree = p;
128675 p = (LookasideSlot*)&((u8*)p)[sz];
128677 db->lookaside.pEnd = p;
128906 static void functionDestroy(sqlite3 *db, FuncDef *p){
128907 FuncDestructor *pDestructor = p->pDestructor;
128928 HashElem *p;
128929 for(p=sqliteHashFirst(&pSchema->tblHash); p; p=sqliteHashNext(p)){
128930 Table *pTab = (Table *)sqliteHashData(p);
129084 FuncDef *pNext, *pHash, *p;
129085 for(p=db->aFunc.a[j]; p; p=pHash){
129086 pHash = p->pHash;
129087 while( p ){
129088 functionDestroy(db, p);
129089 pNext = p->pNext;
129090 sqlite3DbFree(db, p);
129091 p = pNext;
129168 Btree *p = db->aDb[i].pBt;
129169 if( p ){
129170 if( sqlite3BtreeIsInTrans(p) ){
129173 sqlite3BtreeRollback(p, tripCode, !schemaChange);
129408 SQLITE_PRIVATE int sqlite3InvokeBusyHandler(BusyHandler *p){
129410 if( NEVER(p==0) || p->xFunc==0 || p->nBusy<0 ) return 0;
129411 rc = p->xFunc(p->pArg, p->nBusy);
129413 p->nBusy = -1;
129415 p->nBusy++;
129522 FuncDef *p;
129572 p = sqlite3FindFunction(db, zFunctionName, nName, nArg, (u8)enc, 0);
129573 if( p && (p->funcFlags & SQLITE_FUNC_ENCMASK)==enc && p->nArg==nArg ){
129584 p = sqlite3FindFunction(db, zFunctionName, nName, nArg, (u8)enc, 1);
129585 assert(p || db->mallocFailed);
129586 if( !p ){
129592 functionDestroy(db, p);
129597 p->pDestructor = pDestructor;
129598 p->funcFlags = (p->funcFlags & SQLITE_FUNC_ENCMASK) | extraFlags;
129599 testcase( p->funcFlags & SQLITE_DETERMINISTIC );
129600 p->xFunc = xFunc;
129601 p->xStep = xStep;
129602 p->xFinalize = xFinal;
129603 p->pUserData = pUserData;
129604 p->nArg = (u16)nArg;
129616 void *p,
129621 return sqlite3_create_function_v2(db, zFunc, nArg, enc, p, xFunc, xStep,
129630 void *p,
129648 xDestroy(p);
129652 pArg->pUserData = p;
129654 rc = sqlite3CreateFunc(db, zFunc, nArg, enc, p, xFunc, xStep, xFinal, pArg);
129657 xDestroy(p);
129673 void *p,
129687 rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xFunc, xStep, xFinal,0);
130242 CollSeq *p = &aColl[j];
130243 if( p->enc==pColl->enc ){
130244 if( p->xDel ){
130245 p->xDel(p->pUser);
130247 p->xCmp = 0;
131830 sqlite3 *p;
131831 for(p=sqlite3BlockedList; p; p=p->pNextBlocked){
131836 assert( p->pUnlockConnection || p->pBlockingConnection );
131839 for(p2=sqlite3BlockedList; p2!=p; p2=p2->pNextBlocked){
131840 if( p2->xUnlockNotify==p->xUnlockNotify ) seen = 1;
131841 assert( p2->xUnlockNotify==p->xUnlockNotify || !seen );
131842 assert( db==0 || p->pUnlockConnection!=db );
131843 assert( db==0 || p->pBlockingConnection!=db );
131943 sqlite3 *p;
131945 for(p=db->pBlockingConnection; p && p!=db; p=p->pUnlockConnection){}
131946 if( p ){
132011 sqlite3 *p = *pp;
132014 if( p->pBlockingConnection==db ){
132015 p->pBlockingConnection = 0;
132019 if( p->pUnlockConnection==db ){
132020 assert( p->xUnlockNotify );
132021 if( p->xUnlockNotify!=xUnlockNotify && nArg!=0 ){
132069 aArg[nArg++] = p->pUnlockArg;
132070 xUnlockNotify = p->xUnlockNotify;
132071 p->pUnlockConnection = 0;
132072 p->xUnlockNotify = 0;
132073 p->pUnlockArg = 0;
132077 if( p->pBlockingConnection==0 && p->pUnlockConnection==0 ){
132079 *pp = p->pNextBlocked;
132080 p->pNextBlocked = 0;
132082 pp = &p->pNextBlocked;
133214 #define fts3GetVarint32(p, piVal) ( \
133215 (*(u8*)(p)&0x80) ? sqlite3Fts3GetVarint32(p, piVal) : (*piVal=*(u8*)(p), 1) \
133321 SQLITE_PRIVATE int sqlite3Fts3PutVarint(char *p, sqlite_int64 v){
133322 unsigned char *q = (unsigned char *) p;
133329 assert( q - (unsigned char *)p <= FTS3_VARINT_MAX );
133330 return (int) (q - (unsigned char *)p);
133345 SQLITE_PRIVATE int sqlite3Fts3GetVarint(const char *p, sqlite_int64 *v){
133346 const char *pStart = p;
133351 GETVARINT_INIT(a, p, 0, 0x00, 0x80, *v, 1);
133352 GETVARINT_STEP(a, p, 7, 0x7F, 0x4000, *v, 2);
133353 GETVARINT_STEP(a, p, 14, 0x3FFF, 0x200000, *v, 3);
133354 GETVARINT_STEP(a, p, 21, 0x1FFFFF, 0x10000000, *v, 4);
133358 u64 c = *p++;
133363 return (int)(p - pStart);
133370 SQLITE_PRIVATE int sqlite3Fts3GetVarint32(const char *p, int *pi){
133374 GETVARINT_INIT(a, p, 0, 0x00, 0x80, *pi, 1);
133376 a = (*p++);
133380 GETVARINT_STEP(a, p, 7, 0x7F, 0x4000, *pi, 2);
133381 GETVARINT_STEP(a, p, 14, 0x3FFF, 0x200000, *pi, 3);
133382 GETVARINT_STEP(a, p, 21, 0x1FFFFF, 0x10000000, *pi, 4);
133384 *pi = (int)(a | ((u32)(*p & 0x0F) << 28));
133464 char *p;
133469 for(p = (*pp)-2; p>=pStart && *p&0x80; p--);
133470 p++;
133471 *pp = p;
133473 sqlite3Fts3GetVarint(p, &iVal);
133481 Fts3Table *p = (Fts3Table *)pVtab;
133484 assert( p->nPendingData==0 );
133485 assert( p->pSegments==0 );
133488 for(i=0; i<SizeofArray(p->aStmt); i++){
133489 sqlite3_finalize(p->aStmt[i]);
133491 sqlite3_free(p->zSegmentsTbl);
133492 sqlite3_free(p->zReadExprlist);
133493 sqlite3_free(p->zWriteExprlist);
133494 sqlite3_free(p->zContentTbl);
133495 sqlite3_free(p->zLanguageid);
133498 p->pTokenizer->pModule->xDestroy(p->pTokenizer);
133500 sqlite3_free(p);
133546 Fts3Table *p = (Fts3Table *)pVtab;
133548 const char *zDb = p->zDb; /* Name of database (e.g. "main", "temp") */
133549 sqlite3 *db = p->db; /* Database handle */
133552 if( p->zContentTbl==0 ){
133553 fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_content'", zDb, p->zName);
133555 fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_segments'", zDb,p->zName);
133556 fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_segdir'", zDb, p->zName);
133557 fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_docsize'", zDb, p->zName);
133558 fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_stat'", zDb, p->zName);
133577 static void fts3DeclareVtab(int *pRc, Fts3Table *p){
133585 zLanguageid = (p->zLanguageid ? p->zLanguageid : "__langid");
133586 sqlite3_vtab_config(p->db, SQLITE_VTAB_CONSTRAINT_SUPPORT, 1);
133589 zCols = sqlite3_mprintf("%Q, ", p->azColumn[0]);
133590 for(i=1; zCols && i<p->nColumn; i++){
133591 zCols = sqlite3_mprintf("%z%Q, ", zCols, p->azColumn[i]);
133597 zCols, p->zName, zLanguageid
133602 rc = sqlite3_declare_vtab(p->db, zSql);
133614 SQLITE_PRIVATE void sqlite3Fts3CreateStatTable(int *pRc, Fts3Table *p){
133615 fts3DbExec(pRc, p->db,
133618 p->zDb, p->zName
133620 if( (*pRc)==SQLITE_OK ) p->bHasStat = 1;
133632 static int fts3CreateTables(Fts3Table *p){
133635 sqlite3 *db = p->db; /* The database connection */
133637 if( p->zContentTbl==0 ){
133638 const char *zLanguageid = p->zLanguageid;
133643 for(i=0; zContentCols && i<p->nColumn; i++){
133644 char *z = p->azColumn[i];
133655 p->zDb, p->zName, zContentCols
133663 p->zDb, p->zName
133675 p->zDb, p->zName
133677 if( p->bHasDocsize ){
133680 p->zDb, p->zName
133683 assert( p->bHasStat==p->bFts4 );
133684 if( p->bHasStat ){
133685 sqlite3Fts3CreateStatTable(&rc, p);
133697 static void fts3DatabasePageSize(int *pRc, Fts3Table *p){
133703 zSql = sqlite3_mprintf("PRAGMA %Q.page_size", p->zDb);
133707 rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
133710 p->nPgsz = sqlite3_column_int(pStmt, 0);
133713 p->nPgsz = 1024;
133717 assert( p->nPgsz>0 || rc!=SQLITE_OK );
133831 static char *fts3ReadExprList(Fts3Table *p, const char *zFunc, int *pRc){
133837 if( p->zContentTbl==0 ){
133844 for(i=0; i<p->nColumn; i++){
133845 fts3Appendf(pRc, &zRet, ",%s(x.'c%d%q')", zFunction, i, p->azColumn[i]);
133847 if( p->zLanguageid ){
133853 for(i=0; i<p->nColumn; i++){
133854 fts3Appendf(pRc, &zRet, ", x.'%q'", p->azColumn[i]);
133856 if( p->zLanguageid ){
133857 fts3Appendf(pRc, &zRet, ", x.%Q", p->zLanguageid);
133861 p->zDb,
133862 (p->zContentTbl ? p->zContentTbl : p->zName),
133863 (p->zContentTbl ? "" : "_content")
133888 static char *fts3WriteExprList(Fts3Table *p, const char *zFunc, int *pRc){
133900 for(i=0; i<p->nColumn; i++){
133903 if( p->zLanguageid ){
133925 const char *p; /* Iterator pointer */
133928 for(p=*pp; p[0]>='0' && p[0]<='9'; p++){
133929 nInt = nInt * 10 + (p[0] - '0');
133935 if( p==*pp ) return SQLITE_ERROR;
133937 *pp = p;
133967 const char *p;
133969 for(p=zParam; *p; p++){
133970 if( *p==',' ) nIndex++;
133982 const char *p = zParam;
133986 if( fts3GobbleInt(&p, &nPrefix) ) return SQLITE_ERROR;
133994 p++;
134071 char *p = (char *)&azCol[nCol];
134075 memcpy(p, zCol, n);
134076 azCol[i] = p;
134077 p += n;
134112 Fts3Table *p = 0; /* Pointer to allocated vtab */
134346 p = (Fts3Table*)sqlite3_malloc(nByte);
134347 if( p==0 ){
134351 memset(p, 0, nByte);
134352 p->db = db;
134353 p->nColumn = nCol;
134354 p->nPendingData = 0;
134355 p->azColumn = (char **)&p[1];
134356 p->pTokenizer = pTokenizer;
134357 p->nMaxPendingData = FTS3_MAX_PENDING_DATA;
134358 p->bHasDocsize = (isFts4 && bNoDocsize==0);
134359 p->bHasStat = isFts4;
134360 p->bFts4 = isFts4;
134361 p->bDescIdx = bDescIdx;
134362 p->nAutoincrmerge = 0xff; /* 0xff means setting unknown */
134363 p->zContentTbl = zContent;
134364 p->zLanguageid = zLanguageid;
134367 TESTONLY( p->inTransaction = -1 );
134368 TESTONLY( p->mxSavepoint = -1 );
134370 p->aIndex = (struct Fts3Index *)&p->azColumn[nCol];
134371 memcpy(p->aIndex, aIndex, sizeof(struct Fts3Index) * nIndex);
134372 p->nIndex = nIndex;
134374 fts3HashInit(&p->aIndex[i].hPending, FTS3_HASH_STRING, 1);
134376 p->abNotindexed = (u8 *)&p->aIndex[nIndex];
134379 zCsr = (char *)&p->abNotindexed[nCol];
134380 p->zName = zCsr;
134383 p->zDb = zCsr;
134395 p->azColumn[iCol] = zCsr;
134397 assert( zCsr <= &((char *)p)[nByte] );
134402 int n = (int)strlen(p->azColumn[iCol]);
134406 && 0==sqlite3_strnicmp(p->azColumn[iCol], zNot, n)
134408 p->abNotindexed[iCol] = 1;
134426 p->zReadExprlist = fts3ReadExprList(p, zUncompress, &rc);
134427 p->zWriteExprlist = fts3WriteExprList(p, zCompress, &rc);
134434 rc = fts3CreateTables(p);
134441 p->bHasStat = 2;
134446 fts3DatabasePageSize(&rc, p);
134447 p->nNodeSize = p->nPgsz-35;
134450 fts3DeclareVtab(&rc, p);
134463 if( p ){
134464 fts3DisconnectMethod((sqlite3_vtab *)p);
134469 assert( p->pSegments==0 );
134470 *ppVTab = &p->base;
134522 Fts3Table *p = (Fts3Table *)pVTab;
134555 bDocid = (pCons->iColumn<0 || pCons->iColumn==p->nColumn+1);
134574 && pCons->iColumn>=0 && pCons->iColumn<=p->nColumn
134583 && pCons->iColumn==p->nColumn + 2
134626 if( pOrder->iColumn<0 || pOrder->iColumn==p->nColumn+1 ){
134636 assert( p->pSegments==0 );
134691 Fts3Table *p = (Fts3Table *)pCsr->base.pVtab;
134693 zSql = sqlite3_mprintf("SELECT %s WHERE rowid = ?", p->zReadExprlist);
134695 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pCsr->pStmt, 0);
134874 Fts3Table *p, /* Virtual table handle */
134896 rc = sqlite3Fts3ReadBlock(p, *piLeaf, &zBlob, &nBlob, 0);
134898 rc = fts3SelectLeaf(p, zTerm, nTerm, zBlob, nBlob, piLeaf, 0);
134906 rc = sqlite3Fts3ReadBlock(p, piLeaf?*piLeaf:*piLeaf2, &zBlob, &nBlob, 0);
134909 rc = fts3SelectLeaf(p, zTerm, nTerm, zBlob, nBlob, piLeaf, piLeaf2);
134967 char *p = *pp;
134968 memcpy(p, *ppPoslist, n);
134969 p += n;
134970 *pp = p;
135005 char *p = *pp;
135006 memcpy(p, *ppPoslist, n);
135007 p += n;
135008 *pp = p;
135061 char *p = *pp; /* Output pointer */
135062 n = 1 + sqlite3Fts3PutVarint(&p[1], iCol);
135063 *p = 0x01;
135064 *pp = &p[n];
135081 char *p = *pp;
135101 int n = fts3PutColNumber(&p, iCol1);
135117 fts3PutDeltaVarint(&p, &iPrev, (i1<i2) ? i1 : i2);
135129 p1 += fts3PutColNumber(&p, iCol1);
135130 fts3ColumnlistCopy(&p, &p1);
135132 p2 += fts3PutColNumber(&p, iCol2);
135133 fts3ColumnlistCopy(&p, &p2);
135137 *p++ = POS_END;
135138 *pp = p;
135174 char *p = *pp;
135183 assert( p!=0 && *p1!=0 && *p2!=0 );
135195 char *pSave = p;
135201 *p++ = POS_COLUMN;
135202 p += sqlite3Fts3PutVarint(p, iCol1);
135216 fts3PutDeltaVarint(&p, &iPrev, iSave+2); iPrev -= 2;
135218 assert( p );
135230 assert( pp && p );
135231 p = pSave;
135267 if( *pp==p ){
135270 *p++ = 0x00;
135271 *pp = p;
135441 char *p;
135480 p = aOut;
135487 fts3PutDeltaVarint3(&p, bDescDoclist, &iPrev, &bFirstOut, i1);
135488 fts3PoslistMerge(&p, &p1, &p2);
135492 fts3PutDeltaVarint3(&p, bDescDoclist, &iPrev, &bFirstOut, i1);
135493 fts3PoslistCopy(&p, &p1);
135496 fts3PutDeltaVarint3(&p, bDescDoclist, &iPrev, &bFirstOut, i2);
135497 fts3PoslistCopy(&p, &p2);
135503 *pnOut = (int)(p-aOut);
135534 char *p;
135545 p = aOut;
135553 char *pSave = p;
135557 fts3PutDeltaVarint3(&p, bDescDoclist, &iPrev, &bFirstOut, i1);
135558 if( 0==fts3PoslistPhraseMerge(&p, nDist, 0, 1, &p1, &p2) ){
135559 p = pSave;
135574 *pnRight = (int)(p - aOut);
135599 char *p = pList;
135602 if( *p!=0x01 ){
135603 if( *p==0x02 ){
135608 fts3ColumnlistCopy(0, &p);
135611 while( p<pEnd && *p==0x01 ){
135613 p++;
135614 p += sqlite3Fts3GetVarint(p, &iCol);
135615 if( *p==0x02 ){
135624 fts3ColumnlistCopy(0, &p);
135643 static int fts3TermSelectFinishMerge(Fts3Table *p, TermSelect *pTS){
135661 int rc = fts3DoclistOrMerge(p->bDescIdx,
135698 Fts3Table *p, /* FTS table handle */
135742 int rc = fts3DoclistOrMerge(p->bDescIdx, aMerge, nMerge,
135795 Fts3Table *p, /* FTS3 table handle */
135815 if( iLevel<0 && p->aIndex ){
135817 rc = sqlite3Fts3SegReaderPending(p, iIndex, zTerm, nTerm, isPrefix||isScan, &pSeg);
135825 rc = sqlite3Fts3AllSegdirs(p, iLangid, iIndex, iLevel, &pStmt);
135842 rc = fts3SelectLeaf(p, zTerm, nTerm, zRoot, nRoot, &iStartBlock, pi);
135869 Fts3Table *p, /* FTS3 table handle */
135879 assert( iIndex>=0 && iIndex<p->nIndex );
135890 p, iLangid, iIndex, iLevel, zTerm, nTerm, isPrefix, isScan, pCsr
135901 Fts3Table *p, /* FTS virtual table handle */
135907 return fts3SegReaderCursor(p,
135939 Fts3Table *p = (Fts3Table *)pCsr->base.pVtab;
135942 for(i=1; bFound==0 && i<p->nIndex; i++){
135943 if( p->aIndex[i].nPrefix==nTerm ){
135945 rc = sqlite3Fts3SegReaderCursor(p, pCsr->iLangid,
135952 for(i=1; bFound==0 && i<p->nIndex; i++){
135953 if( p->aIndex[i].nPrefix==nTerm+1 ){
135955 rc = sqlite3Fts3SegReaderCursor(p, pCsr->iLangid,
135960 p, pCsr->iLangid, zTerm, nTerm, pSegcsr
135968 rc = sqlite3Fts3SegReaderCursor(p, pCsr->iLangid,
135992 Fts3Table *p, /* Virtual table handle */
136009 | (iColumn<p->nColumn ? FTS3_SEGMENT_COLUMN_FILTER : 0);
136014 rc = sqlite3Fts3SegReaderStart(p, pSegcsr, &filter);
136016 && SQLITE_ROW==(rc = sqlite3Fts3SegReaderStep(p, pSegcsr))
136018 rc = fts3TermSelectMerge(p, &tsc, pSegcsr->aDoclist, pSegcsr->nDoclist);
136022 rc = fts3TermSelectFinishMerge(p, &tsc);
136052 char *p = aList; /* Cursor */
136053 while( p<aEnd ){
136055 while( (*p++)&0x80 ); /* Skip docid varint */
136056 fts3PoslistCopy(0, &p); /* Skip over position list */
136145 Fts3Table *p = (Fts3Table *)pCursor->pVtab;
136158 assert( eSearch>=0 && eSearch<=(FTS3_FULLTEXT_SEARCH+p->nColumn) );
136159 assert( p->pSegments==0 );
136183 pCsr->bDesc = p->bDescIdx;
136198 assert( p->base.zErrMsg==0 );
136199 rc = sqlite3Fts3ExprParse(p->pTokenizer, pCsr->iLangid,
136200 p->azColumn, p->bFts4, p->nColumn, iCol, zQuery, -1, &pCsr->pExpr,
136201 &p->base.zErrMsg
136208 sqlite3Fts3SegmentsClose(p);
136223 p->zReadExprlist, pCsr->iMinDocid, pCsr->iMaxDocid,
136228 p->zReadExprlist, (pCsr->bDesc ? "DESC" : "ASC")
136232 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pCsr->pStmt, 0);
136286 Fts3Table *p = (Fts3Table *)pCursor->pVtab;
136289 assert( iCol>=0 && iCol<=p->nColumn+2 );
136291 if( iCol==p->nColumn+1 ){
136296 }else if( iCol==p->nColumn ){
136300 }else if( iCol==p->nColumn+2 && pCsr->pExpr ){
136308 if( iCol==p->nColumn+2 ){
136310 if( p->zLanguageid ){
136311 iLangid = sqlite3_column_int(pCsr->pStmt, p->nColumn+1);
136365 Fts3Table *p = (Fts3Table*)pVtab;
136366 int rc = sqlite3Fts3PendingTermsFlush(p);
136369 && p->nLeafAdd>(nMinMerge/16)
136370 && p->nAutoincrmerge && p->nAutoincrmerge!=0xff
136375 rc = sqlite3Fts3MaxLevel(p, &mxLevel);
136377 A = p->nLeafAdd * mxLevel;
136379 if( A>(int)nMinMerge ) rc = sqlite3Fts3Incrmerge(p, A, p->nAutoincrmerge);
136381 sqlite3Fts3SegmentsClose(p);
136391 static int fts3SetHasStat(Fts3Table *p){
136393 if( p->bHasStat==2 ){
136395 char *zSql = sqlite3_mprintf(zFmt, p->zDb, p->zName);
136398 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
136402 if( rc==SQLITE_OK ) p->bHasStat = bHasStat;
136416 Fts3Table *p = (Fts3Table*)pVtab;
136418 assert( p->pSegments==0 );
136419 assert( p->nPendingData==0 );
136420 assert( p->inTransaction!=1 );
136421 TESTONLY( p->inTransaction = 1 );
136422 TESTONLY( p->mxSavepoint = -1; );
136423 p->nLeafAdd = 0;
136424 return fts3SetHasStat(p);
136433 TESTONLY( Fts3Table *p = (Fts3Table*)pVtab );
136435 assert( p->nPendingData==0 );
136436 assert( p->inTransaction!=0 );
136437 assert( p->pSegments==0 );
136438 TESTONLY( p->inTransaction = 0 );
136439 TESTONLY( p->mxSavepoint = -1; );
136448 Fts3Table *p = (Fts3Table*)pVtab;
136449 sqlite3Fts3PendingTermsClear(p);
136450 assert( p->inTransaction!=0 );
136451 TESTONLY( p->inTransaction = 0 );
136452 TESTONLY( p->mxSavepoint = -1; );
136463 char *p = &(*ppPoslist)[-2];
136467 while( p>pStart && (c=*p--)==0 );
136472 while( p>pStart && (*p & 0x80) | c ){
136473 c = *p--;
136475 assert( p==pStart || c==0 );
136490 if( p>pStart || (c==0 && *ppPoslist>&p[2]) ){ p = &p[2]; }
136491 while( *p++&0x80 );
136492 *ppPoslist = p;
136603 Fts3Table *p; /* Virtual table handle */
136610 p = (Fts3Table *)pCursor->base.pVtab;
136611 assert( p );
136613 rc = sqlite3Fts3Optimize(p);
136691 Fts3Table *p = (Fts3Table *)pVtab;
136692 sqlite3 *db = p->db; /* Database connection */
136697 rc = fts3SetHasStat(p);
136705 assert( p->nPendingData==0 );
136707 rc = sqlite3Fts3PendingTermsFlush(p);
136710 if( p->zContentTbl==0 ){
136713 p->zDb, p->zName, zName
136717 if( p->bHasDocsize ){
136720 p->zDb, p->zName, zName
136723 if( p->bHasStat ){
136726 p->zDb, p->zName, zName
136731 p->zDb, p->zName, zName
136735 p->zDb, p->zName, zName
136763 TESTONLY( Fts3Table *p = (Fts3Table*)pVtab );
136766 assert( p->inTransaction );
136767 assert( p->mxSavepoint >= iSavepoint );
136768 TESTONLY( p->mxSavepoint = iSavepoint-1 );
136778 Fts3Table *p = (Fts3Table*)pVtab;
136780 assert( p->inTransaction );
136781 assert( p->mxSavepoint >= iSavepoint );
136782 TESTONLY( p->mxSavepoint = iSavepoint );
136783 sqlite3Fts3PendingTermsClear(p);
136818 static void hashDestroy(void *p){
136819 Fts3Hash *pHash = (Fts3Hash *)p;
137003 Fts3Phrase *p, /* Phrase to merge pList/nList into */
137009 assert( iToken!=p->iDoclistToken );
137012 sqlite3_free(p->doclist.aAll);
137013 p->doclist.aAll = 0;
137014 p->doclist.nAll = 0;
137017 else if( p->iDoclistToken<0 ){
137018 p->doclist.aAll = pList;
137019 p->doclist.nAll = nList;
137022 else if( p->doclist.aAll==0 ){
137033 if( p->iDoclistToken<iToken ){
137034 pLeft = p->doclist.aAll;
137035 nLeft = p->doclist.nAll;
137038 nDiff = iToken - p->iDoclistToken;
137040 pRight = p->doclist.aAll;
137041 nRight = p->doclist.nAll;
137044 nDiff = p->iDoclistToken - iToken;
137051 p->doclist.aAll = pRight;
137052 p->doclist.nAll = nRight;
137055 if( iToken>p->iDoclistToken ) p->iDoclistToken = iToken;
137067 Fts3Phrase *p /* Phrase object */
137073 for(iToken=0; rc==SQLITE_OK && iToken<p->nToken; iToken++){
137074 Fts3PhraseToken *pToken = &p->aToken[iToken];
137080 rc = fts3TermSelect(pTab, pToken, p->iColumn, &nThis, &pThis);
137082 rc = fts3EvalPhraseMergeToken(pTab, p, iToken, pThis, nThis);
137213 static int fts3EvalPhraseStart(Fts3Cursor *pCsr, int bOptOk, Fts3Phrase *p){
137226 && p->nToken<=MAX_INCR_PHRASE_TOKENS && p->nToken>0
137227 && p->nToken<=MAX_INCR_PHRASE_TOKENS && p->nToken>0
137232 for(i=0; bIncrOk==1 && i<p->nToken; i++){
137233 Fts3PhraseToken *pToken = &p->aToken[i];
137242 int iCol = (p->iColumn >= pTab->nColumn ? -1 : p->iColumn);
137243 for(i=0; rc==SQLITE_OK && i<p->nToken; i++){
137244 Fts3PhraseToken *pToken = &p->aToken[i];
137250 p->bIncr = 1;
137253 rc = fts3EvalPhraseLoad(pCsr, p);
137254 p->bIncr = 0;
137257 assert( rc!=SQLITE_OK || p->nToken<1 || p->aToken[0].pSegcsr==0 || p->bIncr );
137280 char *p = *ppIter;
137284 assert( p || *piDocid==0 );
137285 assert( !p || (p>aDoclist && p<&aDoclist[nDoclist]) );
137287 if( p==0 ){
137310 fts3GetReverseVarint(&p, aDoclist, &iDelta);
137313 if( p==aDoclist ){
137316 char *pSave = p;
137317 fts3ReversePoslist(aDoclist, &p);
137318 *pnList = (int)(pSave - p);
137320 *ppIter = p;
137335 char *p = *ppIter;
137339 assert( p || *piDocid==0 );
137340 assert( !p || (p>=aDoclist && p<=&aDoclist[nDoclist]) );
137342 if( p==0 ){
137343 p = aDoclist;
137344 p += sqlite3Fts3GetVarint(p, piDocid);
137346 fts3PoslistCopy(0, &p);
137347 if( p>=&aDoclist[nDoclist] ){
137351 p += sqlite3Fts3GetVarint(p, &iVar);
137356 *ppIter = p;
137430 TokenDoclist *p, /* OUT: Docid and doclist for new entry */
137436 assert( p->bIgnore==0 );
137439 p->pList = pPhrase->doclist.pList;
137440 p->nList = pPhrase->doclist.nList;
137441 p->iDocid = pPhrase->doclist.iDocid;
137447 assert( p->bIgnore==0 );
137449 pTab, pToken->pSegcsr, &p->iDocid, &p->pList, &p->nList
137451 if( p->pList==0 ) *pbEof = 1;
137453 p->bIgnore = 1;
137480 Fts3Phrase *p, /* Phrase object to advance to next docid */
137484 Fts3Doclist *pDL = &p->doclist;
137490 assert( p->bIncr==1 );
137492 if( p->nToken==1 && p->bIncr ){
137493 rc = sqlite3Fts3MsrIncrNext(pTab, p->aToken[0].pSegcsr,
137502 assert( p->nToken<=MAX_INCR_PHRASE_TOKENS );
137503 assert( p->iDoclistToken<MAX_INCR_PHRASE_TOKENS );
137511 for(i=0; rc==SQLITE_OK && i<p->nToken && bEof==0; i++){
137512 rc = incrPhraseTokenNext(pTab, p, i, &a[i], &bEof);
137518 assert( rc!=SQLITE_OK || (p->nToken>=1 && a[p->nToken-1].bIgnore==0) );
137522 for(i=0; i<p->nToken; i++){
137526 rc = incrPhraseTokenNext(pTab, p, i, &a[i], &bEof);
137537 int nByte = a[p->nToken-1].nList;
137540 memcpy(aDoclist, a[p->nToken-1].pList, nByte+1);
137542 for(i=0; i<(p->nToken-1); i++){
137547 int nDist = p->nToken-1-i;
137553 if( i==(p->nToken-1) ){
137580 Fts3Phrase *p, /* Phrase object to advance to next docid */
137584 Fts3Doclist *pDL = &p->doclist;
137587 if( p->bIncr ){
137588 rc = fts3EvalIncrPhraseNext(pCsr, p, pbEof);
137738 Fts3Table *p = (Fts3Table*)pCsr->base.pVtab;
137745 rc = sqlite3Fts3SelectDoctotal(p, &pStmt);
137761 pCsr->nRowAvg = (int)(((nByte / nDoc) + p->nPgsz) / p->nPgsz);
138242 Fts3Expr *p;
138247 for(p=pExpr; p->pLeft; p=p->pLeft){
138248 nTmp += p->pRight->pPhrase->doclist.nList;
138250 nTmp += p->pPhrase->doclist.nList;
138259 char *aPoslist = p->pPhrase->doclist.pList;
138260 int nToken = p->pPhrase->nToken;
138262 for(p=p->pParent;res && p && p->eType==FTSQUERY_NEAR; p=p->pParent){
138263 Fts3Phrase *pPhrase = p->pRight->pPhrase;
138264 int nNear = p->nNear;
138270 for(p=pExpr->pLeft; p && res; p=p->pLeft){
138273 assert( p->pParent && p->pParent->pLeft==p );
138274 nNear = p->pParent->nNear;
138276 p->eType==FTSQUERY_NEAR ? p->pRight->pPhrase : p->pPhrase
138335 Fts3Expr *p;
138336 for(p=pExpr; p->pPhrase==0; p=p->pLeft){
138337 if( p->pRight->iDocid==pCsr->iPrevId ){
138338 fts3EvalInvalidatePoslist(p->pRight->pPhrase);
138341 if( p->iDocid==pCsr->iPrevId ){
138342 fts3EvalInvalidatePoslist(p->pPhrase);
138530 char *p = pPhrase->doclist.pList;
138532 assert( *p );
138536 while( 0xFE & (*p | c) ){
138538 c = *p++ & 0x80;
138546 if( *p==0x00 ) break;
138547 p++;
138548 p += fts3GetVarint32(p, &iCol);
138578 Fts3Expr *p; /* Iterator used for several purposes */
138594 for(p=pRoot; p; p=p->pLeft){
138595 Fts3Expr *pE = (p->eType==FTSQUERY_PHRASE?p:p->pRight);
138756 Fts3Expr *p; /* Used to iterate from pExpr to root */
138765 for(p=pExpr->pParent; p; p=p->pParent){
138766 if( p->eType==FTSQUERY_OR ) bOr = 1;
138767 if( p->eType==FTSQUERY_NEAR ) pNear = p;
138768 if( p->bEof ) bTreeEof = 1;
138959 Fts3auxTable *p; /* Virtual table object to return */
138989 p = (Fts3auxTable *)sqlite3_malloc(nByte);
138990 if( !p ) return SQLITE_NOMEM;
138991 memset(p, 0, nByte);
138993 p->pFts3Tab = (Fts3Table *)&p[1];
138994 p->pFts3Tab->zDb = (char *)&p->pFts3Tab[1];
138995 p->pFts3Tab->zName = &p->pFts3Tab->zDb[nDb+1];
138996 p->pFts3Tab->db = db;
138997 p->pFts3Tab->nIndex = 1;
138999 memcpy((char *)p->pFts3Tab->zDb, zDb, nDb);
139000 memcpy((char *)p->pFts3Tab->zName, zFts3, nFts3);
139001 sqlite3Fts3Dequote((char *)p->pFts3Tab->zName);
139003 *ppVtab = (sqlite3_vtab *)p;
139017 Fts3auxTable *p = (Fts3auxTable *)pVtab;
139018 Fts3Table *pFts3 = p->pFts3Tab;
139026 sqlite3_free(p);
139357 Fts3auxCursor *p = (Fts3auxCursor *)pCursor;
139359 assert( p->isEof==0 );
139362 sqlite3_result_text(pCtx, p->csr.zTerm, p->csr.nTerm, SQLITE_TRANSIENT);
139366 if( p->iCol ){
139367 sqlite3_result_int(pCtx, p->iCol-1);
139374 sqlite3_result_int64(pCtx, p->aStat[p->iCol].nDoc);
139378 sqlite3_result_int64(pCtx, p->aStat[p->iCol].nOcc);
139383 sqlite3_result_int(pCtx, p->iLangid);
139723 Fts3Expr *p = 0;
139761 p = fts3ReallocOrFree(p, nSpace + ii*sizeof(Fts3PhraseToken));
139762 if( !p ) goto no_mem;
139768 pToken = &((Fts3Phrase *)(&p[1]))->aToken[ii];
139789 p = fts3ReallocOrFree(p, nSpace + nToken*sizeof(Fts3PhraseToken) + nTemp);
139790 if( !p ) goto no_mem;
139791 memset(p, 0, (char *)&(((Fts3Phrase *)&p[1])->aToken[0])-(char *)p);
139792 p->eType = FTSQUERY_PHRASE;
139793 p->pPhrase = (Fts3Phrase *)&p[1];
139794 p->pPhrase->iColumn = pParse->iDefaultCol;
139795 p->pPhrase->nToken = nToken;
139797 zBuf = (char *)&p->pPhrase->aToken[nToken];
139805 for(jj=0; jj<p->pPhrase->nToken; jj++){
139806 p->pPhrase->aToken[jj].z = zBuf;
139807 zBuf += p->pPhrase->aToken[jj].n;
139812 *ppExpr = p;
139820 sqlite3_free(p);
139999 static int opPrecedence(Fts3Expr *p){
140000 assert( p->eType!=FTSQUERY_PHRASE );
140002 return p->eType;
140003 }else if( p->eType==FTSQUERY_NEAR ){
140005 }else if( p->eType==FTSQUERY_OR ){
140008 assert( p->eType==FTSQUERY_AND );
140066 Fts3Expr *p = 0;
140069 rc = getNextNode(pParse, zIn, nIn, &p, &nByte);
140070 assert( nByte>0 || (rc!=SQLITE_OK && p==0) );
140072 if( p ){
140076 && p->eType==FTSQUERY_PHRASE && pParse->isNot
140081 sqlite3Fts3ExprFree(p);
140086 pNot->pRight = p;
140087 p->pParent = pNot;
140093 p = pPrev;
140095 int eType = p->eType;
140096 isPhrase = (eType==FTSQUERY_PHRASE || p->pLeft);
140104 sqlite3Fts3ExprFree(p);
140115 sqlite3Fts3ExprFree(p);
140137 sqlite3Fts3ExprFree(p);
140145 pPrev->pRight = p;
140146 p->pParent = pPrev;
140148 pRet = p;
140151 insertBinaryOperator(&pRet, pPrev, p);
140155 pPrev = p;
140200 static int fts3ExprCheckDepth(Fts3Expr *p, int nMaxDepth){
140202 if( p ){
140206 rc = fts3ExprCheckDepth(p->pLeft, nMaxDepth-1);
140208 rc = fts3ExprCheckDepth(p->pRight, nMaxDepth-1);
140247 Fts3Expr *p;
140250 for(p=pRoot; p->eType==eType; p=p->pLeft){
140251 assert( p->pParent==0 || p->pParent->pLeft==p );
140252 assert( p->pLeft && p->pRight );
140258 Fts3Expr *pParent = p->pParent; /* Current parent of p */
140260 assert( pParent==0 || pParent->pLeft==p );
140261 p->pParent = 0;
140267 rc = fts3ExprBalance(&p, nMaxDepth-1);
140270 for(iLvl=0; p && iLvl<nMaxDepth; iLvl++){
140272 apLeaf[iLvl] = p;
140273 p = 0;
140277 pFree->pRight = p;
140281 p = pFree;
140283 p->pParent = 0;
140287 if( p ){
140288 sqlite3Fts3ExprFree(p);
140297 for(p=pParent->pRight; p->eType==eType; p=p->pLeft);
140316 p = 0;
140319 if( p==0 ){
140320 p = apLeaf[i];
140321 p->pParent = 0;
140324 pFree->pRight = p;
140329 p = pFree;
140331 p->pParent = 0;
140335 pRoot = p;
140481 static void fts3FreeExprNode(Fts3Expr *p){
140482 assert( p->eType==FTSQUERY_PHRASE || p->pPhrase==0 );
140483 sqlite3Fts3EvalPhraseCleanup(p->pPhrase);
140484 sqlite3_free(p->aMI);
140485 sqlite3_free(p);
140496 Fts3Expr *p;
140498 for(p=pDel; p && (p->pLeft||p->pRight); p=(p->pLeft ? p->pLeft : p->pRight)){
140499 assert( p->pParent==0 || p==p->pParent->pRight || p==p->pParent->pLeft );
140501 while( p ){
140502 Fts3Expr *pParent = p->pParent;
140503 fts3FreeExprNode(p);
140504 if( pParent && p==pParent->pLeft && pParent->pRight ){
140505 p = pParent->pRight;
140506 while( p && (p->pLeft || p->pRight) ){
140507 assert( p==p->pParent->pRight || p==p->pParent->pLeft );
140508 p = (p->pLeft ? p->pLeft : p->pRight);
140511 p = pParent;
140763 void *p = sqlite3_malloc(n);
140764 if( p ){
140765 memset(p, 0, n);
140767 return p;
140769 static void fts3HashFree(void *p){
140770 sqlite3_free(p);
142018 sqlite3_tokenizer_module *p;
142051 p = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash, zName, nName+1);
142053 if( !p ){
142067 if( SQLITE_OK!=p->xCreate(argc-2, azArg, &pTokenizer) ){
142071 pTokenizer->pModule = p;
142077 while( SQLITE_OK==p->xNext(pCsr, &zToken, &nToken, &iStart, &iEnd, &iPos) ){
142085 if( SQLITE_OK!=p->xClose(pCsr) ){
142089 if( SQLITE_OK!=p->xDestroy(pTokenizer) ){
142107 const sqlite3_tokenizer_module *p
142119 sqlite3_bind_blob(pStmt, 2, &p, sizeof(p), SQLITE_STATIC);
142229 void *p = (void *)pHash;
142244 rc = sqlite3_create_function(db, zName, 1, any, p, scalarFunc, 0, 0);
142247 rc = sqlite3_create_function(db, zName, 2, any, p, scalarFunc, 0, 0);
142251 rc = sqlite3_create_function(db, zTest, -1, any, p, testFunc, 0, 0);
142434 unsigned char *p = (unsigned char *)c->pInput;
142440 while( c->iOffset<c->nBytes && simpleDelim(t, p[c->iOffset]) ){
142446 while( c->iOffset<c->nBytes && !simpleDelim(t, p[c->iOffset]) ){
142463 unsigned char ch = p[iStartOffset+i];
142586 sqlite3_tokenizer_module *p;
142589 p = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash, zName, nName+1);
142590 if( !p ){
142595 *pp = p;
143132 #define fts3SegReaderIsPending(p) ((p)->ppNextElem!=0)
143133 #define fts3SegReaderIsRootOnly(p) ((p)->rootOnly!=0)
143247 Fts3Table *p, /* Virtual table handle */
143352 assert( SizeofArray(azSql)==SizeofArray(p->aStmt) );
143355 pStmt = p->aStmt[eStmt];
143359 zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName, p->zWriteExprlist);
143361 zSql = sqlite3_mprintf(azSql[eStmt], p->zReadExprlist);
143363 zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName);
143368 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, NULL);
143371 p->aStmt[eStmt] = pStmt;
143450 Fts3Table *p, /* The FTS3 table */
143457 rc = fts3SqlStmt(p, eStmt, &pStmt, apVal);
143480 static int fts3Writelock(Fts3Table *p){
143483 if( p->nPendingData==0 ){
143485 rc = fts3SqlStmt(p, SQL_DELETE_SEGDIR_LEVEL, &pStmt, 0);
143520 Fts3Table *p, /* FTS3 table handle */
143527 assert( p->nIndex>0 );
143528 assert( iIndex>=0 && iIndex<p->nIndex );
143530 iBase = ((sqlite3_int64)iLangid * p->nIndex + iIndex) * FTS3_SEGDIR_MAXLEVEL;
143552 Fts3Table *p, /* FTS3 table */
143563 assert( iIndex>=0 && iIndex<p->nIndex );
143567 rc = fts3SqlStmt(p, SQL_SELECT_LEVEL_RANGE, &pStmt, 0);
143569 sqlite3_bind_int64(pStmt, 1, getAbsoluteLevel(p, iLangid, iIndex, 0));
143571 getAbsoluteLevel(p, iLangid, iIndex, FTS3_SEGDIR_MAXLEVEL-1)
143576 rc = fts3SqlStmt(p, SQL_SELECT_LEVEL, &pStmt, 0);
143578 sqlite3_bind_int64(pStmt, 1, getAbsoluteLevel(p, iLangid, iIndex,iLevel));
143602 PendingList *p = *pp;
143605 if( !p ){
143606 p = sqlite3_malloc(sizeof(*p) + 100);
143607 if( !p ){
143610 p->nSpace = 100;
143611 p->aData = (char *)&p[1];
143612 p->nData = 0;
143614 else if( p->nData+FTS3_VARINT_MAX+1>p->nSpace ){
143615 int nNew = p->nSpace * 2;
143616 p = sqlite3_realloc(p, sizeof(*p) + nNew);
143617 if( !p ){
143622 p->nSpace = nNew;
143623 p->aData = (char *)&p[1];
143627 p->nData += sqlite3Fts3PutVarint(&p->aData[p->nData], i);
143628 p->aData[p->nData] = '\0';
143629 *pp = p;
143649 PendingList *p = *pp;
143652 assert( !p || p->iLastDocid<=iDocid );
143654 if( !p || p->iLastDocid!=iDocid ){
143655 sqlite3_int64 iDelta = iDocid - (p ? p->iLastDocid : 0);
143656 if( p ){
143657 assert( p->nData<p->nSpace );
143658 assert( p->aData[p->nData]==0 );
143659 p->nData++;
143661 if( SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, iDelta)) ){
143664 p->iLastCol = -1;
143665 p->iLastPos = 0;
143666 p->iLastDocid = iDocid;
143668 if( iCol>0 && p->iLastCol!=iCol ){
143669 if( SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, 1))
143670 || SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, iCol))
143674 p->iLastCol = iCol;
143675 p->iLastPos = 0;
143678 assert( iPos>p->iLastPos || (iPos==0 && p->iLastPos==0) );
143679 rc = fts3PendingListAppendVarint(&p, 2+iPos-p->iLastPos);
143681 p->iLastPos = iPos;
143687 if( p!=*pp ){
143688 *pp = p;
143705 Fts3Table *p,
143717 p->nPendingData -= (pList->nData + nToken + sizeof(Fts3HashElem));
143719 if( fts3PendingListAppend(&pList, p->iPrevDocid, iCol, iPos, &rc) ){
143730 p->nPendingData += (pList->nData + nToken + sizeof(Fts3HashElem));
143743 Fts3Table *p, /* Table into which text will be inserted */
143758 sqlite3_tokenizer *pTokenizer = p->pTokenizer;
143796 p, iCol, iPos, &p->aIndex[0].hPending, zToken, nToken
143801 for(i=1; rc==SQLITE_OK && i<p->nIndex; i++){
143802 struct Fts3Index *pIndex = &p->aIndex[i];
143805 p, iCol, iPos, &pIndex->hPending, zToken, pIndex->nPrefix
143821 Fts3Table *p, /* Full-text table handle */
143833 if( iDocid<=p->iPrevDocid
143834 || p->iPrevLangid!=iLangid
143835 || p->nPendingData>p->nMaxPendingData
143837 int rc = sqlite3Fts3PendingTermsFlush(p);
143840 p->iPrevDocid = iDocid;
143841 p->iPrevLangid = iLangid;
143848 SQLITE_PRIVATE void sqlite3Fts3PendingTermsClear(Fts3Table *p){
143850 for(i=0; i<p->nIndex; i++){
143852 Fts3Hash *pHash = &p->aIndex[i].hPending;
143859 p->nPendingData = 0;
143871 Fts3Table *p,
143877 for(i=2; i<p->nColumn+2; i++){
143879 if( p->abNotindexed[iCol]==0 ){
143881 int rc = fts3PendingTermsAdd(p, iLangid, zText, iCol, &aSz[iCol]);
143885 aSz[p->nColumn] += sqlite3_value_bytes(apVal[i]);
143906 Fts3Table *p, /* Full-text table */
143913 if( p->zContentTbl ){
143914 sqlite3_value *pRowid = apVal[p->nColumn+3];
143933 rc = fts3SqlStmt(p, SQL_CONTENT_INSERT, &pContentInsert, &apVal[1]);
143934 if( rc==SQLITE_OK && p->zLanguageid ){
143936 pContentInsert, p->nColumn+2,
143937 sqlite3_value_int(apVal[p->nColumn+4])
143952 if( SQLITE_NULL!=sqlite3_value_type(apVal[3+p->nColumn]) ){
143959 rc = sqlite3_bind_value(pContentInsert, 1, apVal[3+p->nColumn]);
143969 *piDocid = sqlite3_last_insert_rowid(p->db);
143979 static int fts3DeleteAll(Fts3Table *p, int bContent){
143983 sqlite3Fts3PendingTermsClear(p);
143987 assert( p->zContentTbl==0 || bContent==0 );
143988 if( bContent ) fts3SqlExec(&rc, p, SQL_DELETE_ALL_CONTENT, 0);
143989 fts3SqlExec(&rc, p, SQL_DELETE_ALL_SEGMENTS, 0);
143990 fts3SqlExec(&rc, p, SQL_DELETE_ALL_SEGDIR, 0);
143991 if( p->bHasDocsize ){
143992 fts3SqlExec(&rc, p, SQL_DELETE_ALL_DOCSIZE, 0);
143994 if( p->bHasStat ){
143995 fts3SqlExec(&rc, p, SQL_DELETE_ALL_STAT, 0);
144003 static int langidFromSelect(Fts3Table *p, sqlite3_stmt *pSelect){
144005 if( p->zLanguageid ) iLangid = sqlite3_column_int(pSelect, p->nColumn+1);
144016 Fts3Table *p, /* The FTS table to delete from */
144026 rc = fts3SqlStmt(p, SQL_SELECT_CONTENT_BY_ROWID, &pSelect, &pRowid);
144030 int iLangid = langidFromSelect(p, pSelect);
144031 rc = fts3PendingTermsDocid(p, iLangid, sqlite3_column_int64(pSelect, 0));
144032 for(i=1; rc==SQLITE_OK && i<=p->nColumn; i++){
144034 if( p->abNotindexed[iCol]==0 ){
144036 rc = fts3PendingTermsAdd(p, iLangid, zText, -1, &aSz[iCol]);
144037 aSz[p->nColumn] += sqlite3_column_bytes(pSelect, i);
144076 Fts3Table *p,
144087 assert( p->nIndex>=1 );
144090 rc = fts3SqlStmt(p, SQL_NEXT_SEGMENT_INDEX, &pNextIdx, 0);
144093 pNextIdx, 1, getAbsoluteLevel(p, iLangid, iIndex, iLevel)
144108 fts3LogMerge(16, getAbsoluteLevel(p, iLangid, iIndex, iLevel));
144109 rc = fts3SegmentMerge(p, iLangid, iIndex, iLevel);
144147 Fts3Table *p, /* FTS3 table handle */
144158 if( p->pSegments ){
144159 rc = sqlite3_blob_reopen(p->pSegments, iBlockid);
144161 if( 0==p->zSegmentsTbl ){
144162 p->zSegmentsTbl = sqlite3_mprintf("%s_segments", p->zName);
144163 if( 0==p->zSegmentsTbl ) return SQLITE_NOMEM;
144166 p->db, p->zDb, p->zSegmentsTbl, "block", iBlockid, 0, &p->pSegments
144171 int nByte = sqlite3_blob_bytes(p->pSegments);
144182 rc = sqlite3_blob_read(p->pSegments, aByte, nByte, 0);
144200 SQLITE_PRIVATE void sqlite3Fts3SegmentsClose(Fts3Table *p){
144201 sqlite3_blob_close(p->pSegments);
144202 p->pSegments = 0;
144260 Fts3Table *p,
144303 p, ++pReader->iCurrentBlock, &pReader->aNode, &pReader->nNode,
144309 pReader->pBlob = p->pSegments;
144310 p->pSegments = 0;
144405 char *p = pReader->pOffsetList;
144408 assert( p );
144420 pReader->aDoclist, pReader->nDoclist, &p, &pReader->iDocid,
144426 pReader->pOffsetList = p;
144442 while( *p | c ) c = *p++ & 0x80;
144443 assert( *p==0 );
144445 if( pReader->pBlob==0 || p<&pReader->aNode[pReader->nPopulate] ) break;
144449 p++;
144456 *pnOffsetList = (int)(p - pReader->pOffsetList - 1);
144460 while( p<pEnd && *p==0 ) p++;
144467 if( p>=pEnd ){
144470 rc = fts3SegReaderRequire(pReader, p, FTS3_VARINT_MAX);
144473 pReader->pOffsetList = p + sqlite3Fts3GetVarint(p, &iDelta);
144492 Fts3Table *p = (Fts3Table*)pCsr->base.pVtab;
144496 int pgsz = p->nPgsz;
144498 assert( p->bFts4 );
144509 rc = sqlite3Fts3ReadBlock(p, jj, 0, &nBlob, 0);
144624 Fts3Table *p, /* Virtual table handle */
144638 pHash = &p->aIndex[iIndex].hPending;
144844 Fts3Table *p, /* Virtual table handle */
144850 int rc = fts3SqlStmt(p, SQL_INSERT_SEGMENTS, &pStmt, 0);
144865 SQLITE_PRIVATE int sqlite3Fts3MaxLevel(Fts3Table *p, int *pnMax){
144870 rc = fts3SqlStmt(p, SQL_SELECT_MXLEVEL, &pStmt, 0);
144885 Fts3Table *p, /* Virtual table handle */
144896 int rc = fts3SqlStmt(p, SQL_INSERT_SEGDIR, &pStmt, 0);
144941 Fts3Table *p, /* Virtual table handle */
144964 if( nReq<=p->nNodeSize || !pTree->zTerm ){
144966 if( nReq>p->nNodeSize ){
145019 pNew = (SegmentNode *)sqlite3_malloc(sizeof(SegmentNode) + p->nNodeSize);
145029 rc = fts3NodeAddTerm(p, &pParent, isCopyTerm, zTerm, nTerm);
145041 rc = fts3NodeAddTerm(p, &pNew, isCopyTerm, zTerm, nTerm);
145078 Fts3Table *p, /* Virtual table handle */
145103 rc = fts3WriteSegment(p, iNextFree, &pIter->aData[nStart], nWrite);
145110 p, pTree->pParent, iHeight+1, iFree, iNextFree, piLast, paRoot, pnRoot
145123 SegmentNode *p = pTree->pLeftmost;
145124 fts3NodeFree(p->pParent);
145125 while( p ){
145126 SegmentNode *pRight = p->pRight;
145127 if( p->aData!=(char *)&p[1] ){
145128 sqlite3_free(p->aData);
145130 assert( pRight==0 || p->zMalloc==0 );
145131 sqlite3_free(p->zMalloc);
145132 sqlite3_free(p);
145133 p = pRight;
145147 Fts3Table *p, /* Virtual table handle */
145172 pWriter->aData = (char *)sqlite3_malloc(p->nNodeSize);
145174 pWriter->nSize = p->nNodeSize;
145177 rc = fts3SqlStmt(p, SQL_NEXT_SEGMENTS_ID, &pStmt, 0);
145198 if( nData>0 && nData+nReq>p->nNodeSize ){
145202 rc = fts3WriteSegment(p, pWriter->iFree++, pWriter->aData, nData);
145204 p->nLeafAdd++;
145219 rc = fts3NodeAddTerm(p, &pWriter->pTree, isCopyTerm, zTerm, nPrefix+1);
145289 Fts3Table *p, /* Virtual table handle */
145302 rc = fts3WriteSegment(p, pWriter->iFree++, pWriter->aData, pWriter->nData);
145304 rc = fts3NodeWrite(p, pWriter->pTree, 1,
145308 rc = fts3WriteSegdir(p, iLevel, iIdx,
145313 rc = fts3WriteSegdir(p, iLevel, iIdx,
145316 p->nLeafAdd++;
145343 static int fts3IsEmpty(Fts3Table *p, sqlite3_value *pRowid, int *pisEmpty){
145346 if( p->zContentTbl ){
145351 rc = fts3SqlStmt(p, SQL_IS_EMPTY, &pStmt, &pRowid);
145371 Fts3Table *p,
145378 assert( iIndex>=0 && iIndex<p->nIndex );
145386 rc = fts3SqlStmt(p, SQL_SELECT_SEGDIR_MAX_LEVEL, &pStmt, 0);
145388 sqlite3_bind_int64(pStmt, 1, getAbsoluteLevel(p, iLangid, iIndex, 0));
145390 getAbsoluteLevel(p, iLangid, iIndex, FTS3_SEGDIR_MAXLEVEL-1)
145406 static int fts3SegmentIsMaxLevel(Fts3Table *p, i64 iAbsLevel, int *pbMax){
145415 int rc = fts3SqlStmt(p, SQL_SELECT_SEGDIR_MAX_LEVEL, &pStmt, 0);
145435 Fts3Table *p, /* FTS table handle */
145441 rc = fts3SqlStmt(p, SQL_DELETE_SEGMENTS_RANGE, &pDelete, 0);
145467 Fts3Table *p, /* Virtual table handle */
145479 rc = fts3DeleteSegment(p, apSegment[i]);
145487 rc = fts3SqlStmt(p, SQL_DELETE_SEGDIR_RANGE, &pDelete, 0);
145489 sqlite3_bind_int64(pDelete, 1, getAbsoluteLevel(p, iLangid, iIndex, 0));
145491 getAbsoluteLevel(p, iLangid, iIndex, FTS3_SEGDIR_MAXLEVEL-1)
145495 rc = fts3SqlStmt(p, SQL_DELETE_SEGDIR_LEVEL, &pDelete, 0);
145498 pDelete, 1, getAbsoluteLevel(p, iLangid, iIndex, iLevel)
145533 char *p = pList;
145538 while( p<pEnd && (c | *p)&0xFE ) c = *p++ & 0x80;
145541 nList = (int)(p - pList);
145545 nList -= (int)(p - pList);
145546 pList = p;
145550 p = &pList[1];
145551 p += fts3GetVarint32(p, &iCurrent);
145586 Fts3Table *p, /* Virtual table handle */
145595 p->bDescIdx ? fts3SegReaderDoclistCmpRev : fts3SegReaderDoclistCmp
145617 rc = fts3SegReaderNextDocid(p, apSegment[0], &pList, &nList);
145624 rc = fts3SegReaderNextDocid(p, apSegment[j], 0, 0);
145654 Fts3Table *p, /* Virtual table handle */
145672 int rc = fts3SegReaderNext(p, pSeg, 0);
145686 Fts3Table *p, /* Virtual table handle */
145691 return fts3SegReaderStart(p, pCsr, pFilter->zTerm, pFilter->nTerm);
145695 Fts3Table *p, /* Virtual table handle */
145705 p->bDescIdx ? fts3SegReaderDoclistCmpRev : fts3SegReaderDoclistCmp
145712 rc = fts3SegReaderStart(p, pCsr, zTerm, nTerm);
145726 rc = fts3SegReaderFirstDocid(p, pCsr->apSegment[i]);
145731 assert( iCol<0 || iCol<p->nColumn );
145770 Fts3Table *p, /* Virtual table handle */
145786 p->bDescIdx ? fts3SegReaderDoclistCmpRev : fts3SegReaderDoclistCmp
145803 rc = fts3SegReaderNext(p, pSeg, 0);
145846 && (p->bDescIdx==0 || fts3SegReaderIsPending(apSegment[0])==0)
145865 fts3SegReaderFirstDocid(p, apSegment[i]);
145874 fts3SegReaderNextDocid(p, apSegment[0], &pList, &nList);
145880 fts3SegReaderNextDocid(p, apSegment[j], 0, 0);
145893 if( p->bDescIdx && nDoclist>0 ){
146008 Fts3Table *p, /* FTS table handle */
146015 rc = fts3SqlStmt(p, SQL_SELECT_LEVEL_RANGE2, &pRange, 0);
146051 rc = fts3SqlStmt(p, SQL_UPDATE_LEVEL_IDX, &pUpdate1, 0);
146054 rc = fts3SqlStmt(p, SQL_UPDATE_LEVEL, &pUpdate2, 0);
146110 Fts3Table *p,
146129 assert( iIndex>=0 && iIndex<p->nIndex );
146131 rc = sqlite3Fts3SegReaderCursor(p, iLangid, iIndex, iLevel, 0, 0, 1, 0, &csr);
146135 rc = fts3SegmentMaxLevel(p, iLangid, iIndex, &iMaxLevel);
146157 iNewLevel = getAbsoluteLevel(p, iLangid, iIndex, iLevel+1);
146158 rc = fts3AllocateSegdirIdx(p, iLangid, iIndex, iLevel+1, &iIdx);
146164 assert( iNewLevel>=getAbsoluteLevel(p, iLangid, iIndex, 0) );
146165 assert( iNewLevel<getAbsoluteLevel(p, iLangid, iIndex,FTS3_SEGDIR_MAXLEVEL) );
146171 rc = sqlite3Fts3SegReaderStart(p, &csr, &filter);
146173 rc = sqlite3Fts3SegReaderStep(p, &csr);
146175 rc = fts3SegWriterAdd(p, &pWriter, 1,
146183 p, iLangid, iIndex, iLevel, csr.apSegment, csr.nSegment
146188 rc = fts3SegWriterFlush(p, pWriter, iNewLevel, iIdx);
146191 rc = fts3PromoteSegments(p, iNewLevel, pWriter->nLeafData);
146206 SQLITE_PRIVATE int sqlite3Fts3PendingTermsFlush(Fts3Table *p){
146210 for(i=0; rc==SQLITE_OK && i<p->nIndex; i++){
146211 rc = fts3SegmentMerge(p, p->iPrevLangid, i, FTS3_SEGCURSOR_PENDING);
146214 sqlite3Fts3PendingTermsClear(p);
146219 if( rc==SQLITE_OK && p->bHasStat
146220 && p->nAutoincrmerge==0xff && p->nLeafAdd>0
146223 rc = fts3SqlStmt(p, SQL_SELECT_STAT, &pStmt, 0);
146228 p->nAutoincrmerge = sqlite3_column_int(pStmt, 0);
146229 if( p->nAutoincrmerge==1 ) p->nAutoincrmerge = 8;
146231 p->nAutoincrmerge = 0;
146281 Fts3Table *p, /* Table into which to insert */
146290 pBlob = sqlite3_malloc( 10*p->nColumn );
146295 fts3EncodeIntArray(p->nColumn, aSz, pBlob, &nBlob);
146296 rc = fts3SqlStmt(p, SQL_REPLACE_DOCSIZE, &pStmt, 0);
146302 sqlite3_bind_int64(pStmt, 1, p->iPrevDocid);
146325 Fts3Table *p, /* Table being updated */
146337 const int nStat = p->nColumn+2;
146346 rc = fts3SqlStmt(p, SQL_SELECT_STAT, &pStmt, 0);
146371 for(i=0; i<p->nColumn+1; i++){
146381 rc = fts3SqlStmt(p, SQL_REPLACE_STAT, &pStmt, 0);
146398 static int fts3DoOptimize(Fts3Table *p, int bReturnDone){
146403 rc = fts3SqlStmt(p, SQL_SELECT_ALL_LANGID, &pAllLangid, 0);
146406 sqlite3_bind_int(pAllLangid, 1, p->iPrevLangid);
146407 sqlite3_bind_int(pAllLangid, 2, p->nIndex);
146411 for(i=0; rc==SQLITE_OK && i<p->nIndex; i++){
146412 rc = fts3SegmentMerge(p, iLangid, i, FTS3_SEGCURSOR_ALL);
146423 sqlite3Fts3SegmentsClose(p);
146424 sqlite3Fts3PendingTermsClear(p);
146439 static int fts3DoRebuild(Fts3Table *p){
146442 rc = fts3DeleteAll(p, 0);
146451 char *zSql = sqlite3_mprintf("SELECT %s" , p->zReadExprlist);
146455 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
146460 int nByte = sizeof(u32) * (p->nColumn+1)*3;
146466 aSzIns = &aSz[p->nColumn+1];
146467 aSzDel = &aSzIns[p->nColumn+1];
146473 int iLangid = langidFromSelect(p, pStmt);
146474 rc = fts3PendingTermsDocid(p, iLangid, sqlite3_column_int64(pStmt, 0));
146475 memset(aSz, 0, sizeof(aSz[0]) * (p->nColumn+1));
146476 for(iCol=0; rc==SQLITE_OK && iCol<p->nColumn; iCol++){
146477 if( p->abNotindexed[iCol]==0 ){
146479 rc = fts3PendingTermsAdd(p, iLangid, z, iCol, &aSz[iCol]);
146480 aSz[p->nColumn] += sqlite3_column_bytes(pStmt, iCol+1);
146483 if( p->bHasDocsize ){
146484 fts3InsertDocsize(&rc, p, aSz);
146491 for(iCol=0; iCol<=p->nColumn; iCol++){
146496 if( p->bFts4 ){
146497 fts3UpdateDocTotals(&rc, p, aSzIns, aSzDel, nEntry);
146520 Fts3Table *p, /* FTS3 table handle */
146538 rc = fts3SqlStmt(p, SQL_SELECT_LEVEL, &pStmt, 0);
146658 static int nodeReaderNext(NodeReader *p){
146659 int bFirst = (p->term.n==0); /* True for first term on the node */
146664 assert( p->aNode );
146665 if( p->iChild && bFirst==0 ) p->iChild++;
146666 if( p->iOff>=p->nNode ){
146668 p->aNode = 0;
146671 p->iOff += fts3GetVarint32(&p->aNode[p->iOff], &nPrefix);
146673 p->iOff += fts3GetVarint32(&p->aNode[p->iOff], &nSuffix);
146675 blobGrowBuffer(&p->term, nPrefix+nSuffix, &rc);
146677 memcpy(&p->term.a[nPrefix], &p->aNode[p->iOff], nSuffix);
146678 p->term.n = nPrefix+nSuffix;
146679 p->iOff += nSuffix;
146680 if( p->iChild==0 ){
146681 p->iOff += fts3GetVarint32(&p->aNode[p->iOff], &p->nDoclist);
146682 p->aDoclist = &p->aNode[p->iOff];
146683 p->iOff += p->nDoclist;
146688 assert( p->iOff<=p->nNode );
146696 static void nodeReaderRelease(NodeReader *p){
146697 sqlite3_free(p->term.a);
146707 static int nodeReaderInit(NodeReader *p, const char *aNode, int nNode){
146708 memset(p, 0, sizeof(NodeReader));
146709 p->aNode = aNode;
146710 p->nNode = nNode;
146713 if( p->aNode[0] ){
146715 p->iOff = 1 + sqlite3Fts3GetVarint(&p->aNode[1], &p->iChild);
146717 p->iOff = 1;
146720 return nodeReaderNext(p);
146734 Fts3Table *p, /* Fts3 table handle */
146760 if( pNode->key.n==0 || (pNode->block.n + nSpace)<=p->nNodeSize ){
146767 blobGrowBuffer(pBlk, p->nNodeSize, &rc);
146791 rc = fts3WriteSegment(p, pNode->iBlock, pNode->block.a, pNode->block.n);
146793 assert( pNode->block.nAlloc>=p->nNodeSize );
146885 Fts3Table *p, /* Fts3 table handle */
146910 if( pLeaf->block.n>0 && (pLeaf->block.n + nSpace)>p->nNodeSize ){
146911 rc = fts3WriteSegment(p, pLeaf->iBlock, pLeaf->block.a, pLeaf->block.n);
146927 rc = fts3IncrmergePush(p, pWriter, zTerm, nPrefix+1);
146970 Fts3Table *p, /* FTS3 table handle */
147027 rc = fts3WriteSegment(p, pNode->iBlock, pNode->block.a, pNode->block.n);
147035 rc = fts3WriteSegdir(p,
147085 static int fts3IsAppendable(Fts3Table *p, sqlite3_int64 iEnd, int *pbRes){
147090 rc = fts3SqlStmt(p, SQL_SEGMENT_IS_APPENDABLE, &pCheck, 0);
147117 Fts3Table *p, /* Fts3 table handle */
147127 rc = fts3SqlStmt(p, SQL_SELECT_SEGDIR, &pSelect, 0);
147155 rc = fts3IsAppendable(p, iEnd, &bAppendable);
147162 rc = sqlite3Fts3ReadBlock(p, iLeafEnd, &aLeaf, &nLeaf, 0);
147198 blobGrowBuffer(&pNode->block, MAX(nRoot, p->nNodeSize), &rc);
147219 rc = sqlite3Fts3ReadBlock(p, reader.iChild, &aBlock, &nBlock, 0);
147220 blobGrowBuffer(&pNode->block, MAX(nBlock, p->nNodeSize), &rc);
147249 Fts3Table *p, /* FTS Table handle */
147256 rc = fts3SqlStmt(p, SQL_NEXT_SEGMENT_INDEX, &pOutputIdx, 0);
147294 Fts3Table *p, /* Fts3 table handle */
147307 rc = fts3SqlStmt(p, SQL_MAX_LEAF_NODE_ESTIMATE, &pLeafEst, 0);
147319 rc = fts3SqlStmt(p, SQL_NEXT_SEGMENTS_ID, &pFirstBlock, 0);
147333 rc = fts3WriteSegment(p, pWriter->iEnd, 0, 0);
147359 Fts3Table *p, /* FTS3 table handle */
147366 rc = fts3SqlStmt(p, SQL_DELETE_SEGDIR_ENTRY, &pDelete, 0);
147383 Fts3Table *p, /* FTS3 table handle */
147394 rc = fts3SqlStmt(p, SQL_SELECT_INDEXES, &pSelect, 0);
147416 rc = fts3SqlStmt(p, SQL_SHIFT_SEGDIR_ENTRY, &pUpdate, 0);
147422 assert( p->bIgnoreSavepoint==0 );
147423 p->bIgnoreSavepoint = 1;
147432 p->bIgnoreSavepoint = 0;
147513 Fts3Table *p, /* FTS3 table handle */
147527 rc = fts3SqlStmt(p, SQL_SELECT_SEGDIR, &pFetch, 0);
147547 rc = sqlite3Fts3ReadBlock(p, iBlock, &aBlock, &nBlock, 0);
147552 rc = fts3WriteSegment(p, iNewStart, block.a, block.n);
147560 rc = fts3SqlStmt(p, SQL_DELETE_SEGMENTS_RANGE, &pDel, 0);
147571 rc = fts3SqlStmt(p, SQL_CHOMP_SEGDIR, &pChomp, 0);
147598 Fts3Table *p, /* FTS table handle */
147621 rc = fts3DeleteSegment(p, pSeg);
147623 rc = fts3RemoveSegdirEntry(p, iAbsLevel, pSeg->iIdx);
147632 rc = fts3TruncateSegment(p, iAbsLevel, pSeg->iIdx, zTerm, nTerm);
147638 rc = fts3RepackSegdirLevel(p, iAbsLevel);
147648 static int fts3IncrmergeHintStore(Fts3Table *p, Blob *pHint){
147652 rc = fts3SqlStmt(p, SQL_REPLACE_STAT, &pReplace, 0);
147671 static int fts3IncrmergeHintLoad(Fts3Table *p, Blob *pHint){
147676 rc = fts3SqlStmt(p, SQL_SELECT_STAT, &pSelect, 0);
147754 SQLITE_PRIVATE int sqlite3Fts3Incrmerge(Fts3Table *p, int nMerge, int nMin){
147772 rc = fts3IncrmergeHintLoad(p, &hint);
147774 const i64 nMod = FTS3_SEGDIR_MAXLEVEL * p->nIndex;
147785 rc = fts3SqlStmt(p, SQL_FIND_MERGE_LEVEL, &pFindLevel, 0);
147833 rc = fts3IncrmergeOutputIdx(p, iAbsLevel, &iIdx);
147837 rc = fts3SegmentIsMaxLevel(p, iAbsLevel+1, &bIgnore);
147845 rc = fts3IncrmergeCsr(p, iAbsLevel, nSeg, pCsr);
147848 && SQLITE_OK==(rc = sqlite3Fts3SegReaderStart(p, pCsr, pFilter))
147849 && SQLITE_ROW==(rc = sqlite3Fts3SegReaderStep(p, pCsr))
147854 rc = fts3IncrmergeLoad(p, iAbsLevel, iIdx-1, zKey, nKey, pWriter);
147856 rc = fts3IncrmergeWriter(p, iAbsLevel, iIdx, pCsr, pWriter);
147862 rc = fts3IncrmergeAppend(p, pWriter, pCsr);
147863 if( rc==SQLITE_OK ) rc = sqlite3Fts3SegReaderStep(p, pCsr);
147870 rc = fts3IncrmergeChomp(p, iAbsLevel, pCsr, &nSeg);
147881 fts3IncrmergeRelease(p, pWriter, &rc);
147883 fts3PromoteSegments(p, iAbsLevel+1, pWriter->nLeafData);
147892 rc = fts3IncrmergeHintStore(p, &hint);
147923 Fts3Table *p, /* FTS3 table handle */
147945 if( !p->bHasStat ){
147946 assert( p->bFts4==0 );
147947 sqlite3Fts3CreateStatTable(&rc, p);
147950 rc = sqlite3Fts3Incrmerge(p, nMerge, nMin);
147952 sqlite3Fts3SegmentsClose(p);
147966 Fts3Table *p, /* FTS3 table handle */
147971 p->nAutoincrmerge = fts3Getint(&zParam);
147972 if( p->nAutoincrmerge==1 || p->nAutoincrmerge>FTS3_MERGE_COUNT ){
147973 p->nAutoincrmerge = 8;
147975 if( !p->bHasStat ){
147976 assert( p->bFts4==0 );
147977 sqlite3Fts3CreateStatTable(&rc, p);
147980 rc = fts3SqlStmt(p, SQL_REPLACE_STAT, &pStmt, 0);
147983 sqlite3_bind_int(pStmt, 2, p->nAutoincrmerge);
148024 Fts3Table *p, /* FTS3 table handle */
148042 p, iLangid, iIndex, FTS3_SEGCURSOR_ALL, 0, 0, 0, 1,&csr
148045 rc = sqlite3Fts3SegReaderStart(p, &csr, &filter);
148049 while( SQLITE_ROW==(rc = sqlite3Fts3SegReaderStep(p, &csr)) ){
148097 static int fts3IntegrityCheck(Fts3Table *p, int *pbOk){
148104 rc = fts3SqlStmt(p, SQL_SELECT_ALL_LANGID, &pAllLangid, 0);
148107 sqlite3_bind_int(pAllLangid, 1, p->iPrevLangid);
148108 sqlite3_bind_int(pAllLangid, 2, p->nIndex);
148112 for(i=0; i<p->nIndex; i++){
148113 cksum1 = cksum1 ^ fts3ChecksumIndex(p, iLangid, i, &rc);
148122 sqlite3_tokenizer_module const *pModule = p->pTokenizer->pModule;
148126 zSql = sqlite3_mprintf("SELECT %s" , p->zReadExprlist);
148130 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
148136 int iLang = langidFromSelect(p, pStmt);
148139 for(iCol=0; rc==SQLITE_OK && iCol<p->nColumn; iCol++){
148140 if( p->abNotindexed[iCol]==0 ){
148145 rc = sqlite3Fts3OpenTokenizer(p->pTokenizer, iLang, zText, nText,&pT);
148158 for(i=1; i<p->nIndex; i++){
148159 if( p->aIndex[i].nPrefix<=nToken ){
148161 zToken, p->aIndex[i].nPrefix, iLang, i, iDocid, iCol, iPos
148212 Fts3Table *p /* FTS3 table handle */
148216 rc = fts3IntegrityCheck(p, &bOk);
148229 static int fts3SpecialInsert(Fts3Table *p, sqlite3_value *pVal){
148237 rc = fts3DoOptimize(p, 0);
148239 rc = fts3DoRebuild(p);
148241 rc = fts3DoIntegrityCheck(p);
148243 rc = fts3DoIncrmerge(p, &zVal[6]);
148245 rc = fts3DoAutoincrmerge(p, &zVal[10]);
148248 p->nNodeSize = atoi(&zVal[9]);
148251 p->nMaxPendingData = atoi(&zVal[11]);
148254 p->bNoIncrDoclist = atoi(&zVal[21]);
148307 Fts3Table *p = (Fts3Table *)pCsr->base.pVtab;
148308 sqlite3_tokenizer *pT = p->pTokenizer;
148314 for(i=0; i<p->nColumn && rc==SQLITE_OK; i++){
148315 if( p->abNotindexed[i]==0 ){
148329 if( (pDef->iCol>=p->nColumn || pDef->iCol==i)
148354 Fts3DeferredToken *p,
148365 if( p->pList==0 ){
148369 pRet = (char *)sqlite3_malloc(p->pList->nData);
148372 nSkip = sqlite3Fts3GetVarint(p->pList->aData, &dummy);
148373 *pnData = p->pList->nData - nSkip;
148376 memcpy(pRet, &p->pList->aData[nSkip], *pnData);
148412 Fts3Table *p,
148420 fts3DeleteTerms(&rc, p, pRowid, aSzDel, &bFound);
148423 rc = fts3IsEmpty(p, pRowid, &isEmpty);
148429 rc = fts3DeleteAll(p, 1);
148431 memset(aSzDel, 0, sizeof(u32) * (p->nColumn+1) * 2);
148434 if( p->zContentTbl==0 ){
148435 fts3SqlExec(&rc, p, SQL_DELETE_CONTENT, &pRowid);
148437 if( p->bHasDocsize ){
148438 fts3SqlExec(&rc, p, SQL_DELETE_DOCSIZE, &pRowid);
148466 Fts3Table *p = (Fts3Table *)pVtab;
148476 assert( p->bHasStat==0 || p->bHasStat==1 );
148478 assert( p->pSegments==0 );
148481 || nArg==(2 + p->nColumn + 3) /* INSERT or UPDATE operations */
148490 && sqlite3_value_type(apVal[p->nColumn+2])!=SQLITE_NULL
148492 rc = fts3SpecialInsert(p, apVal[p->nColumn+2]);
148496 if( nArg>1 && sqlite3_value_int(apVal[2 + p->nColumn + 2])<0 ){
148502 aSzDel = sqlite3_malloc( sizeof(aSzDel[0])*(p->nColumn+1)*2 );
148507 aSzIns = &aSzDel[p->nColumn+1];
148508 memset(aSzDel, 0, sizeof(aSzDel[0])*(p->nColumn+1)*2);
148510 rc = fts3Writelock(p);
148522 if( nArg>1 && p->zContentTbl==0 ){
148524 sqlite3_value *pNewRowid = apVal[3+p->nColumn];
148550 if( sqlite3_vtab_on_conflict(p->db)==SQLITE_REPLACE ){
148551 rc = fts3DeleteByRowid(p, pNewRowid, &nChng, aSzDel);
148553 rc = fts3InsertData(p, apVal, pRowid);
148565 rc = fts3DeleteByRowid(p, apVal[0], &nChng, aSzDel);
148571 int iLangid = sqlite3_value_int(apVal[2 + p->nColumn + 2]);
148573 rc = fts3InsertData(p, apVal, pRowid);
148574 if( rc==SQLITE_CONSTRAINT && p->zContentTbl==0 ){
148578 if( rc==SQLITE_OK && (!isRemove || *pRowid!=p->iPrevDocid ) ){
148579 rc = fts3PendingTermsDocid(p, iLangid, *pRowid);
148582 assert( p->iPrevDocid==*pRowid );
148583 rc = fts3InsertTerms(p, iLangid, apVal, aSzIns);
148585 if( p->bHasDocsize ){
148586 fts3InsertDocsize(&rc, p, aSzIns);
148591 if( p->bFts4 ){
148592 fts3UpdateDocTotals(&rc, p, aSzIns, aSzDel, nChng);
148597 sqlite3Fts3SegmentsClose(p);
148606 SQLITE_PRIVATE int sqlite3Fts3Optimize(Fts3Table *p){
148608 rc = sqlite3_exec(p->db, "SAVEPOINT fts3", 0, 0, 0);
148610 rc = fts3DoOptimize(p, 1);
148612 int rc2 = sqlite3_exec(p->db, "RELEASE fts3", 0, 0, 0);
148615 sqlite3_exec(p->db, "ROLLBACK TO fts3", 0, 0, 0);
148616 sqlite3_exec(p->db, "RELEASE fts3", 0, 0, 0);
148619 sqlite3Fts3SegmentsClose(p);
148813 LoadDoclistCtx *p = (LoadDoclistCtx *)ctx;
148817 p->nPhrase++;
148818 p->nToken += pPhrase->nToken;
148986 SnippetIter *p = (SnippetIter *)ctx;
148987 SnippetPhrase *pPhrase = &p->aPhrase[iPhrase];
148992 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pCsr);
149404 MatchInfo *p = (MatchInfo *)pCtx;
149406 p->pCursor, pExpr, &p->aMatchinfo[3*iPhrase*p->nCol]
149421 MatchInfo *p = (MatchInfo *)pCtx;
149422 int iStart = iPhrase * p->nCol * 3;
149425 for(i=0; i<p->nCol && rc==SQLITE_OK; i++){
149427 rc = sqlite3Fts3EvalPhrasePoslist(p->pCursor, pExpr, i, &pCsr);
149429 p->aMatchinfo[iStart+i*3] = fts3ColumnlistCount(&pCsr);
149431 p->aMatchinfo[iStart+i*3] = 0;
149447 MatchInfo *p = (MatchInfo *)pCtx;
149448 Fts3Table *pTab = (Fts3Table *)p->pCursor->base.pVtab;
149450 int iStart = iPhrase * p->nCol;
149457 memset(&p->aMatchinfo[iStart], 0, sizeof(u32) * p->nCol);
149463 if( pEof==0 && pExpr->iDocid==p->pCursor->iPrevId ){
149471 p->aMatchinfo[iStart + iCol] = (u32)nHit;
150000 TermOffsetCtx *p = (TermOffsetCtx *)ctx;
150008 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pList);
150016 TermOffset *pT = &p->aTerm[p->iTerm++];
150314 unicode_tokenizer *p = (unicode_tokenizer *)pTokenizer;
150315 sqlite3_free(p->aiException);
150316 sqlite3_free(p);
150340 unicode_tokenizer *p, /* Tokenizer to add exceptions to */
150366 aNew = sqlite3_realloc(p->aiException, (p->nException+nEntry)*sizeof(int));
150368 nNew = p->nException;
150383 p->aiException = aNew;
150384 p->nException = nNew;
150393 static int unicodeIsException(unicode_tokenizer *p, int iCode){
150394 if( p->nException>0 ){
150395 int *a = p->aiException;
150397 int iHi = p->nException-1;
150418 static int unicodeIsAlnum(unicode_tokenizer *p, int iCode){
150420 return sqlite3FtsUnicodeIsalnum(iCode) ^ unicodeIsException(p, iCode);
150477 sqlite3_tokenizer *p, /* The tokenizer */
150500 UNUSED_PARAMETER(p);
150528 unicode_tokenizer *p = ((unicode_tokenizer *)pCsr->base.pTokenizer);
150541 if( unicodeIsAlnum(p, iCode) ) break;
150561 iOut = sqlite3FtsUnicodeFold(iCode, p->bRemoveDiacritic);
150569 }while( unicodeIsAlnum(p, iCode)
150952 const struct TableEntry *p = &aEntry[iRes];
150953 if( c<(p->iCode + p->nRange) && 0==(0x01 & p->flags & (p->iCode ^ c)) ){
150954 ret = (c + (aiOff[p->flags>>1])) & 0x0000FFFF;
151168 #define RTREE_MINCELLS(p) ((((p)->iNodeSize-4)/(p)->nBytesPerCell)/3)
151169 #define RTREE_REINSERT(p) RTREE_MINCELLS(p)
151338 static int readInt16(u8 *p){
151339 return (p[0]<<8) + p[1];
151341 static void readCoord(u8 *p, RtreeCoord *pCoord){
151343 (((u32)p[0]) << 24) +
151344 (((u32)p[1]) << 16) +
151345 (((u32)p[2]) << 8) +
151346 (((u32)p[3]) << 0)
151349 static i64 readInt64(u8 *p){
151351 (((i64)p[0]) << 56) +
151352 (((i64)p[1]) << 48) +
151353 (((i64)p[2]) << 40) +
151354 (((i64)p[3]) << 32) +
151355 (((i64)p[4]) << 24) +
151356 (((i64)p[5]) << 16) +
151357 (((i64)p[6]) << 8) +
151358 (((i64)p[7]) << 0)
151367 static int writeInt16(u8 *p, int i){
151368 p[0] = (i>> 8)&0xFF;
151369 p[1] = (i>> 0)&0xFF;
151372 static int writeCoord(u8 *p, RtreeCoord *pCoord){
151377 p[0] = (i>>24)&0xFF;
151378 p[1] = (i>>16)&0xFF;
151379 p[2] = (i>> 8)&0xFF;
151380 p[3] = (i>> 0)&0xFF;
151383 static int writeInt64(u8 *p, i64 i){
151384 p[0] = (i>>56)&0xFF;
151385 p[1] = (i>>48)&0xFF;
151386 p[2] = (i>>40)&0xFF;
151387 p[3] = (i>>32)&0xFF;
151388 p[4] = (i>>24)&0xFF;
151389 p[5] = (i>>16)&0xFF;
151390 p[6] = (i>> 8)&0xFF;
151391 p[7] = (i>> 0)&0xFF;
151398 static void nodeReference(RtreeNode *p){
151399 if( p ){
151400 p->nRef++;
151407 static void nodeZero(Rtree *pRtree, RtreeNode *p){
151408 memset(&p->zData[2], 0, pRtree->iNodeSize-2);
151409 p->isDirty = 1;
151425 RtreeNode *p;
151426 for(p=pRtree->aHash[nodeHash(iNode)]; p && p->iNode!=iNode; p=p->pNext);
151427 return p;
151572 u8 *p = &pNode->zData[4 + pRtree->nBytesPerCell*iCell];
151573 p += writeInt64(p, pCell->iRowid);
151575 p += writeCoord(p, &pCell->aCoord[ii]);
151625 sqlite3_stmt *p = pRtree->pWriteNode;
151627 sqlite3_bind_int64(p, 1, pNode->iNode);
151629 sqlite3_bind_null(p, 1);
151631 sqlite3_bind_blob(p, 2, pNode->zData, pRtree->iNodeSize, SQLITE_STATIC);
151632 sqlite3_step(p);
151634 rc = sqlite3_reset(p);
151967 RtreeConstraint *p, /* The constraint to test */
151977 pCellData += 8 + 4*(p->iCoord&0xfe);
151979 assert(p->op==RTREE_LE || p->op==RTREE_LT || p->op==RTREE_GE
151980 || p->op==RTREE_GT || p->op==RTREE_EQ );
151981 switch( p->op ){
151987 if( p->u.rValue>=val ) return;
151988 if( p->op!=RTREE_EQ ) break; /* RTREE_LE and RTREE_LT end here */
151995 if( p->u.rValue<=val ) return;
152011 RtreeConstraint *p, /* The constraint to test */
152018 assert(p->op==RTREE_LE || p->op==RTREE_LT || p->op==RTREE_GE
152019 || p->op==RTREE_GT || p->op==RTREE_EQ );
152020 pCellData += 8 + p->iCoord*4;
152022 switch( p->op ){
152023 case RTREE_LE: if( xN <= p->u.rValue ) return; break;
152024 case RTREE_LT: if( xN < p->u.rValue ) return; break;
152025 case RTREE_GE: if( xN >= p->u.rValue ) return; break;
152026 case RTREE_GT: if( xN > p->u.rValue ) return; break;
152027 default: if( xN == p->u.rValue ) return; break;
152091 static void rtreeSearchPointSwap(RtreeCursor *p, int i, int j){
152092 RtreeSearchPoint t = p->aPoint[i];
152094 p->aPoint[i] = p->aPoint[j];
152095 p->aPoint[j] = t;
152099 nodeRelease(RTREE_OF_CURSOR(p), p->aNode[i]);
152100 p->aNode[i] = 0;
152102 RtreeNode *pTemp = p->aNode[i];
152103 p->aNode[i] = p->aNode[j];
152104 p->aNode[j] = pTemp;
152207 static void tracePoint(RtreeSearchPoint *p, int idx, RtreeCursor *pCur){
152210 p->iLevel, p->id, p->iCell, p->rScore, p->eWithin
152237 static void rtreeSearchPointPop(RtreeCursor *p){
152239 i = 1 - p->bPoint;
152241 if( p->aNode[i] ){
152242 nodeRelease(RTREE_OF_CURSOR(p), p->aNode[i]);
152243 p->aNode[i] = 0;
152245 if( p->bPoint ){
152246 p->anQueue[p->sPoint.iLevel]--;
152247 p->bPoint = 0;
152248 }else if( p->nPoint ){
152249 p->anQueue[p->aPoint[0].iLevel]--;
152250 n = --p->nPoint;
152251 p->aPoint[0] = p->aPoint[n];
152253 p->aNode[1] = p->aNode[n+1];
152254 p->aNode[n+1] = 0;
152259 if( k<n && rtreeSearchPointCompare(&p->aPoint[k], &p->aPoint[j])<0 ){
152260 if( rtreeSearchPointCompare(&p->aPoint[k], &p->aPoint[i])<0 ){
152261 rtreeSearchPointSwap(p, i, k);
152267 if( rtreeSearchPointCompare(&p->aPoint[j], &p->aPoint[i])<0 ){
152268 rtreeSearchPointSwap(p, i, j);
152286 RtreeSearchPoint *p;
152298 while( (p = rtreeSearchPointFirst(pCur))!=0 && p->iLevel>0 ){
152303 while( p->iCell<nCell ){
152305 u8 *pCellData = pNode->zData + (4+pRtree->nBytesPerCell*p->iCell);
152310 rc = rtreeCallbackConstraint(pConstraint, eInt, pCellData, p,
152313 }else if( p->iLevel==1 ){
152320 p->iCell++;
152322 x.iLevel = p->iLevel - 1;
152327 x.id = p->id;
152328 x.iCell = p->iCell - 1;
152330 if( p->iCell>=nCell ){
152335 p = rtreeSearchPointNew(pCur, rScore, x.iLevel);
152336 if( p==0 ) return SQLITE_NOMEM;
152337 p->eWithin = eWithin;
152338 p->id = x.id;
152339 p->iCell = x.iCell;
152343 if( p->iCell>=nCell ){
152348 pCur->atEOF = p==0;
152371 RtreeSearchPoint *p = rtreeSearchPointFirst(pCsr);
152374 if( rc==SQLITE_OK && p ){
152375 *pRowid = nodeGetRowid(RTREE_OF_CURSOR(pCsr), pNode, p->iCell);
152386 RtreeSearchPoint *p = rtreeSearchPointFirst(pCsr);
152392 if( p==0 ) return SQLITE_OK;
152394 sqlite3_result_int64(ctx, nodeGetRowid(pRtree, pNode, p->iCell));
152397 nodeGetCoord(pRtree, pNode, p->iCell, i-1, &c);
152514 RtreeSearchPoint *p; /* Search point for the the leaf */
152519 p = rtreeSearchPointNew(pCsr, RTREE_ZERO, 0);
152520 assert( p!=0 ); /* Always returns pCsr->sPoint */
152522 p->id = iNode;
152523 p->eWithin = PARTLY_WITHIN;
152525 p->iCell = iCell;
152546 RtreeConstraint *p = &pCsr->aConstraint[ii];
152547 p->op = idxStr[ii*2];
152548 p->iCoord = idxStr[ii*2+1]-'0';
152549 if( p->op>=RTREE_MATCH ){
152554 rc = deserializeGeometry(argv[ii], p);
152558 p->pInfo->nCoord = pRtree->nDim*2;
152559 p->pInfo->anQueue = pCsr->anQueue;
152560 p->pInfo->mxLevel = pRtree->iDepth + 1;
152563 p->u.rValue = sqlite3_value_int64(argv[ii]);
152565 p->u.rValue = sqlite3_value_double(argv[ii]);
152650 struct sqlite3_index_constraint *p = &pIdxInfo->aConstraint[ii];
152652 if( p->usable && p->iColumn==0 && p->op==SQLITE_INDEX_CONSTRAINT_EQ ){
152674 if( p->usable && (p->iColumn>0 || p->op==SQLITE_INDEX_CONSTRAINT_MATCH) ){
152676 switch( p->op ){
152683 assert( p->op==SQLITE_INDEX_CONSTRAINT_MATCH );
152688 zIdxStr[iIdx++] = p->iColumn - 1 + '0';
152710 static RtreeDValue cellArea(Rtree *pRtree, RtreeCell *p){
152714 area = (area * (DCOORD(p->aCoord[ii+1]) - DCOORD(p->aCoord[ii])));
152723 static RtreeDValue cellMargin(Rtree *pRtree, RtreeCell *p){
152727 margin += (DCOORD(p->aCoord[ii+1]) - DCOORD(p->aCoord[ii]));
152772 static RtreeDValue cellGrowth(Rtree *pRtree, RtreeCell *p, RtreeCell *pCell){
152775 memcpy(&cell, p, sizeof(RtreeCell));
152783 RtreeCell *p,
152794 x1 = MAX(DCOORD(p->aCoord[jj]), DCOORD(aCell[ii].aCoord[jj]));
152795 x2 = MIN(DCOORD(p->aCoord[jj+1]), DCOORD(aCell[ii].aCoord[jj+1]));
152878 RtreeNode *p = pNode;
152879 while( p->pParent ){
152880 RtreeNode *pParent = p->pParent;
152884 if( nodeParentIndex(pRtree, p, &iCell) ){
152894 p = pParent;
153534 RtreeCell *p = &aCell[aOrder[ii]];
153535 nodeInsertCell(pRtree, pNode, p);
153536 if( p->iRowid==pCell->iRowid ){
153538 rc = rowidWrite(pRtree, p->iRowid, pNode->iNode);
153540 rc = parentWrite(pRtree, p->iRowid, pNode->iNode);
153552 RtreeCell *p = &aCell[aOrder[ii]];
153553 rc = ChooseLeaf(pRtree, p, iHeight, &pInsert);
153556 rc = rtreeInsertCell(pRtree, pInsert, p, iHeight);
153920 sqlite3_stmt *p;
153928 rc = sqlite3_prepare_v2(db, zSql, -1, &p, 0);
153930 if( sqlite3_step(p)==SQLITE_ROW ) nRow = sqlite3_column_int64(p, 0);
153931 rc = sqlite3_finalize(p);
154339 static void rtreeFreeCallback(void *p){
154340 RtreeGeomCallback *pInfo = (RtreeGeomCallback*)p;
154342 sqlite3_free(p);
154506 static void xFree(void *p){
154507 sqlite3_free(p);
154667 static void icuRegexpDelete(void *p){
154668 URegularExpression *pExpr = (URegularExpression *)p;
154691 static void icuRegexpFunc(sqlite3_context *p, int nArg, sqlite3_value **apArg){
154706 pExpr = sqlite3_get_auxdata(p, 0);
154715 sqlite3_set_auxdata(p, 0, pExpr, icuRegexpDelete);
154718 icuFunctionError(p, "uregex_open", status);
154726 icuFunctionError(p, "uregex_setText", status);
154733 icuFunctionError(p, "uregex_matches", status);
154745 sqlite3_result_int(p, res ? 1 : 0);
154774 static void icuCaseFunc16(sqlite3_context *p, int nArg, sqlite3_value **apArg){
154800 if( sqlite3_user_data(p) ){
154807 icuFunctionError(p, "u_strToLower()/u_strToUpper", status);
154811 sqlite3_result_text16(p, zOutput, -1, xFree);
154819 UCollator *p = (UCollator *)pCtx;
154820 ucol_close(p);
154835 UCollator *p = (UCollator *)pCtx;
154836 res = ucol_strcoll(p, (UChar *)zLeft, nLeft/2, (UChar *)zRight, nRight/2);
154860 sqlite3_context *p,
154864 sqlite3 *db = (sqlite3 *)sqlite3_user_data(p);
154881 icuFunctionError(p, "ucol_open", status);
154884 assert(p);
154891 sqlite3_result_error(p, "Error registering collation function", -1);
154928 struct IcuScalar *p = &scalars[i];
154930 db, p->zName, p->nArg, p->enc, p->pContext, p->xFunc, 0, 0
155009 IcuTokenizer *p;
155015 p = (IcuTokenizer *)sqlite3_malloc(sizeof(IcuTokenizer)+n);
155016 if( !p ){
155019 memset(p, 0, sizeof(IcuTokenizer));
155022 p->zLocale = (char *)&p[1];
155023 memcpy(p->zLocale, argv[0], n);
155026 *ppTokenizer = (sqlite3_tokenizer *)p;
155035 IcuTokenizer *p = (IcuTokenizer *)pTokenizer;
155036 sqlite3_free(p);
155052 IcuTokenizer *p = (IcuTokenizer *)pTokenizer;
155103 pCsr->pIter = ubrk_open(UBRK_WORD, p->zLocale, pCsr->aChar, iOut, &status);
155461 static void statClearPage(StatPage *p){
155463 if( p->aCell ){
155464 for(i=0; i<p->nCell; i++){
155465 sqlite3_free(p->aCell[i].aOvfl);
155467 sqlite3_free(p->aCell);
155469 sqlite3PagerUnref(p->pPg);
155470 sqlite3_free(p->zPath);
155471 memset(p, 0, sizeof(StatPage));
155519 static int statDecodePage(Btree *pBt, StatPage *p){
155526 u8 *aData = sqlite3PagerGetData(p->pPg);
155527 u8 *aHdr = &aData[p->iPgno==1 ? 100 : 0];
155529 p->flags = aHdr[0];
155530 p->nCell = get2byte(&aHdr[3]);
155531 p->nMxPayload = 0;
155533 isLeaf = (p->flags==0x0A || p->flags==0x0D);
155534 nHdr = 12 - isLeaf*4 + (p->iPgno==1)*100;
155536 nUnused = get2byte(&aHdr[5]) - nHdr - 2*p->nCell;
155543 p->nUnused = nUnused;
155544 p->iRightChildPg = isLeaf ? 0 : sqlite3Get4byte(&aHdr[8]);
155547 if( p->nCell ){
155554 p->aCell = sqlite3_malloc64((p->nCell+1) * sizeof(StatCell));
155555 if( p->aCell==0 ) return SQLITE_NOMEM;
155556 memset(p->aCell, 0, (p->nCell+1) * sizeof(StatCell));
155558 for(i=0; i<p->nCell; i++){
155559 StatCell *pCell = &p->aCell[i];
155566 if( p->flags==0x05 ){
155572 if( p->flags==0x0D ){
155576 if( nPayload>(u32)p->nMxPayload ) p->nMxPayload = nPayload;
155577 getLocalPayload(nUsable, p->flags, nPayload, &nLocal);
155675 StatPage *p = &pCsr->aPage[pCsr->iPage];
155677 while( p->iCell<p->nCell ){
155678 StatCell *pCell = &p->aCell[p->iCell];
155691 "%s%.3x+%.6x", p->zPath, p->iCell, pCell->iOvfl
155704 if( p->iRightChildPg ) break;
155705 p->iCell++;
155708 if( !p->iRightChildPg || p->iCell>p->nCell ){
155709 statClearPage(p);
155715 assert( p==&pCsr->aPage[pCsr->iPage-1] );
155717 if( p->iCell==p->nCell ){
155718 p[1].iPgno = p->iRightChildPg;
155720 p[1].iPgno = p->aCell[p->iCell].iChildPg;
155722 rc = sqlite3PagerGet(pPager, p[1].iPgno, &p[1].pPg);
155723 p[1].iCell = 0;
155724 p[1].zPath = z = sqlite3_mprintf("%s%.3x/", p->zPath, p->iCell);
155725 p->iCell++;
155735 StatPage *p = &pCsr->aPage[pCsr->iPage];
155737 pCsr->iPageno = p->iPgno;
155739 rc = statDecodePage(pBt, p);
155743 switch( p->flags ){
155756 pCsr->nCell = p->nCell;
155757 pCsr->nUnused = p->nUnused;
155758 pCsr->nMxPayload = p->nMxPayload;
155759 pCsr->zPath = z = sqlite3_mprintf("%s", p->zPath);
155762 for(i=0; i<p->nCell; i++){
155763 nPayload += p->aCell[i].nLocal;
