Lines Matching defs:SQLITE_OK
387 ** ^Calls to sqlite3_close() and sqlite3_close_v2() return [SQLITE_OK] if
408 ** [sqlite3_backup] objects then it returns [SQLITE_OK] and the deallocation
513 #define SQLITE_OK 0 /* Successful result */
1003 ** file control returns [SQLITE_OK], then the parser assumes that the
1006 ** any result code other than [SQLITE_OK] or [SQLITE_NOTFOUND], that means
1392 ** ^The sqlite3_initialize() routine returns [SQLITE_OK] on success.
1395 ** as a mutex) it returns an [error code] other than [SQLITE_OK].
1432 ** must return [SQLITE_OK] on success and some other [error code] upon
1465 ** ^When a configuration option is set, sqlite3_config() returns [SQLITE_OK].
1484 ** ^Calls to sqlite3_db_config() return SQLITE_OK if and only if
2539 ** return [SQLITE_OK] to allow the action, [SQLITE_IGNORE] to disallow the
2543 ** any value other than [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY]
2547 ** When the callback returns [SQLITE_OK], that means the operation
2564 ** been read if [SQLITE_OK] had been returned. The [SQLITE_IGNORE]
2618 ** return either [SQLITE_OK] or one of these two constants in order
2760 ** [SQLITE_OK] is returned. Otherwise an [error code] is returned.)^ ^The
3250 ** ^On success, the sqlite3_prepare() family of routines return [SQLITE_OK];
3519 ** ^The sqlite3_bind_* routines return [SQLITE_OK] on success or an
4043 ** SQLITE_OK. ^If the most recent evaluation of statement S failed, then
4079 ** then [sqlite3_reset(S)] returns [SQLITE_OK].
5091 ** ^(This routine returns [SQLITE_OK] if shared cache was enabled or disabled
5293 ** [SQLITE_OK] on success and [SQLITE_ERROR] if something goes wrong.
5723 ** ^(On success, [SQLITE_OK] is returned and the new [BLOB handle] is written
5848 ** ^(On success, sqlite3_blob_read() returns SQLITE_OK.
5886 ** ^(On success, sqlite3_blob_write() returns SQLITE_OK.
6019 ** SQLITE_BUSY. ^The sqlite3_mutex_try() interface returns [SQLITE_OK]
6113 ** called, but only if the prior call to xMutexInit returned SQLITE_OK.
6302 ** ^The sqlite3_status() routine returns SQLITE_OK on success and a
6427 ** ^The sqlite3_db_status() routine returns SQLITE_OK on success and a
6906 ** are still more pages to be copied, then the function returns [SQLITE_OK].
6910 ** then an [error code] is returned. ^As well as [SQLITE_OK] and
6969 ** ^The value returned by sqlite3_backup_finish is [SQLITE_OK] if no
7090 ** returns SQLITE_OK.
7227 ** The callback function should normally return [SQLITE_OK]. ^If an error
7337 ** populated even if sqlite3_wal_checkpoint_v2() returns other than SQLITE_OK.
7366 ** databases, SQLITE_OK is returned.
7369 ** mode, SQLITE_OK is returned and both *pnLog and *pnCkpt set to -1. If
7443 ** return SQLITE_OK. Or, if this is not possible, it may return
10296 #define sqlite3_mutex_try(X) SQLITE_OK
10301 #define sqlite3MutexInit() SQLITE_OK
12534 # define sqlite3FaultSim(X) SQLITE_OK
12744 # define sqlite3AuthCheck(a,b,c,d,e) SQLITE_OK
12963 # define sqlite3VtabSync(X,Y) SQLITE_OK
12970 # define sqlite3VtabSavepoint(X, Y, Z) SQLITE_OK
14340 #define sqlite3VdbeMemExpandBlob(x) SQLITE_OK
14341 #define ExpandBlob(P) SQLITE_OK
14424 return SQLITE_OK;
14437 int rc = SQLITE_OK; /* Return code */
15063 ** return this value and set *pRc to SQLITE_OK.
15071 int *pRc /* OUT: Error code. SQLITE_OK or ERROR */
15118 *pRc = SQLITE_OK;
15190 if( rc==SQLITE_OK ){
15796 int rc = SQLITE_OK;
15904 return SQLITE_OK;
15907 return SQLITE_OK;
15929 assert( rc==SQLITE_OK || pFile->pMethods==0 );
16006 if( rc!=SQLITE_OK ){
16015 int rc = SQLITE_OK;
16109 return SQLITE_OK;
16122 return SQLITE_OK;
16250 static int sqlite3MemInit(void *NotUsed){ return SQLITE_OK; }
16514 return SQLITE_OK;
16539 return SQLITE_OK;
16768 return SQLITE_OK;
17673 return SQLITE_OK;
18293 return SQLITE_OK;
18402 int rc = SQLITE_OK;
18436 int rc = SQLITE_OK;
18486 ** Obtain the mutex p. If successful, return SQLITE_OK. Otherwise, if another
18490 int rc = SQLITE_OK;
18562 static int noopMutexInit(void){ return SQLITE_OK; }
18563 static int noopMutexEnd(void){ return SQLITE_OK; }
18572 return SQLITE_OK;
18625 static int debugMutexInit(void){ return SQLITE_OK; }
18626 static int debugMutexEnd(void){ return SQLITE_OK; }
18671 ** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK
18687 return SQLITE_OK;
18816 static int pthreadMutexInit(void){ return SQLITE_OK; }
18817 static int pthreadMutexEnd(void){ return SQLITE_OK; }
18939 ** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK
19007 rc = SQLITE_OK;
19012 rc = SQLITE_OK;
19025 rc = SQLITE_OK;
19032 if( rc==SQLITE_OK && p->trace ){
19496 return SQLITE_OK;
19511 return SQLITE_OK;
19619 ** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK
19679 rc = SQLITE_OK;
19851 return SQLITE_OK;
21938 if( rc!=SQLITE_OK ){
22038 return SQLITE_OK;
22051 int rc = SQLITE_OK;
22068 if( rc==SQLITE_OK ){
22280 ** SQLITE_OK if no test callback is installed.
22285 return xCallback ? xCallback(iTest) : SQLITE_OK;
22369 ** should be called with err_code set to SQLITE_OK and zFormat set
24217 ** a normal expected return code of SQLITE_BUSY or SQLITE_OK
24219 #define IS_LOCK_ERROR(x) ((x != SQLITE_OK) && (x != SQLITE_BUSY))
24731 ** "unix" VFSes. Return SQLITE_OK opon successfully updating the
24748 rc = SQLITE_OK;
24763 rc = SQLITE_OK;
25009 ** SQLITE_OK. The system call failed, and *some* SQLite error should be
25014 return SQLITE_OK;
25563 return SQLITE_OK;
25625 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
25628 int rc = SQLITE_OK;
25777 int rc = SQLITE_OK;
25795 return SQLITE_OK;
25824 ** return SQLITE_OK.
25866 assert( rc==SQLITE_OK );
25880 if( unixFileLock(pFile, &lock) && rc==SQLITE_OK ){
25933 if( rc==SQLITE_OK
25944 if( rc==SQLITE_OK ){
25955 rc==SQLITE_OK ? "ok" : "failed"));
25989 int rc = SQLITE_OK;
25998 return SQLITE_OK;
26139 if( rc==SQLITE_OK ) pFile->eFileLock = eFileLock;
26201 return SQLITE_OK;
26208 int rc = SQLITE_OK;
26255 return SQLITE_OK;
26259 return SQLITE_OK;
26263 return SQLITE_OK;
26308 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
26315 int rc = SQLITE_OK;
26368 int rc = SQLITE_OK;
26382 return SQLITE_OK;
26427 return SQLITE_OK;
26435 return SQLITE_OK;
26454 return SQLITE_OK;
26461 int rc = SQLITE_OK;
26508 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
26511 int rc = SQLITE_OK;
26555 rc = SQLITE_OK;
26593 int rc = SQLITE_OK;
26602 return SQLITE_OK;
26619 rc==SQLITE_OK ? "ok" : "failed"));
26646 return SQLITE_OK;
26652 return SQLITE_OK;
26658 return SQLITE_OK;
26663 return SQLITE_OK;
26671 int rc = SQLITE_OK;
26700 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
26703 int rc = SQLITE_OK;
26772 int rc = SQLITE_OK;
26778 rc = SQLITE_OK;
26814 return SQLITE_OK;
26820 return SQLITE_OK;
26833 return SQLITE_OK;
26849 return SQLITE_OK;
26896 ** Return SQLITE_OK on success, SQLITE_BUSY on failure.
26934 return SQLITE_OK;
26942 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
26945 int rc = SQLITE_OK;
26956 return SQLITE_OK;
26970 if( SQLITE_OK==lrc ){
27015 int rc = SQLITE_OK;
27032 return SQLITE_OK;
27061 ** return SQLITE_OK.
27119 } else if( lrc1 != SQLITE_OK ) {
27152 int failed2 = SQLITE_OK;
27174 if( rc==SQLITE_OK ){
27185 rc==SQLITE_OK ? "ok" : "failed"));
27197 int rc = SQLITE_OK;
27213 return SQLITE_OK;
27241 if( rc==SQLITE_OK && (eFileLock==SHARED_LOCK || pInode->nShared>1) ){
27249 if( rc==SQLITE_OK && pFile->eFileLock>=PENDING_LOCK ){
27252 if( rc==SQLITE_OK && pFile->eFileLock>=RESERVED_LOCK && context->reserved ){
27258 if( rc==SQLITE_OK && (eFileLock==SHARED_LOCK || pInode->nShared>1)){
27262 if( rc==SQLITE_OK && eFileLock==NO_LOCK ){
27282 if( rc==SQLITE_OK ){
27292 if( rc==SQLITE_OK ) pFile->eFileLock = eFileLock;
27300 int rc = SQLITE_OK;
27428 ** Read data from a file into a buffer. Return SQLITE_OK if all
27459 return SQLITE_OK;
27472 return SQLITE_OK;
27543 ** Write data from a buffer into a file. Return SQLITE_OK on success
27594 return SQLITE_OK;
27623 return SQLITE_OK;
27712 rc = SQLITE_OK;
27752 ** SQLITE_OK is returned. If an error occurs, either SQLITE_NOMEM
27766 ** a no-op, replace it with a stub that returns SQLITE_OK but leaves
27769 ** If SQLITE_OK is returned, the caller is responsible for closing
27787 return (fd>=0?SQLITE_OK:unixLogError(SQLITE_CANTOPEN_BKPT, "open", zDirname));
27840 if( rc==SQLITE_OK && dirfd>=0 ){
27844 rc = SQLITE_OK;
27897 return SQLITE_OK;
27925 return SQLITE_OK;
28000 return SQLITE_OK;
28030 return SQLITE_OK;
28034 return SQLITE_OK;
28038 return SQLITE_OK;
28049 return SQLITE_OK;
28053 return SQLITE_OK;
28057 return SQLITE_OK;
28065 return SQLITE_OK;
28069 return SQLITE_OK;
28074 int rc = SQLITE_OK;
28097 return SQLITE_OK;
28341 int rc = SQLITE_OK; /* Result code form fcntl() */
28361 rc = (rc!=(-1)) ? SQLITE_OK : SQLITE_BUSY;
28369 if( rc==SQLITE_OK ){
28567 rc = SQLITE_OK;
28568 if( unixShmSystemLock(pShmNode, F_WRLCK, UNIX_SHM_DMS, 1)==SQLITE_OK ){
28573 if( rc==SQLITE_OK ){
28600 return SQLITE_OK;
28620 ** separate process), then *pp is set to NULL and SQLITE_OK returned. If
28627 ** memory and SQLITE_OK returned.
28639 int rc = SQLITE_OK;
28646 if( rc!=SQLITE_OK ) return rc;
28679 ** false, exit early. *pp will be set to NULL and SQLITE_OK returned.
28753 if( pShmNode->isReadonly && rc==SQLITE_OK ) rc = SQLITE_READONLY;
28776 int rc = SQLITE_OK; /* Result code */
28808 rc = SQLITE_OK;
28812 if( rc==SQLITE_OK ){
28832 if( rc==SQLITE_OK ){
28836 rc = SQLITE_OK;
28841 if( rc==SQLITE_OK ){
28858 if( rc==SQLITE_OK ){
28860 if( rc==SQLITE_OK ){
28904 if( p==0 ) return SQLITE_OK;
28932 return SQLITE_OK;
29035 unixLogError(SQLITE_OK, zErr, pFd->zPath);
29058 ** SQLITE_OK is returned if no error occurs (even if the mapping is not
29067 if( pFd->nFetchOut>0 ) return SQLITE_OK;
29072 if( rc!=SQLITE_OK ){
29089 return SQLITE_OK;
29097 ** If such a pointer can be obtained, store it in *pp and return SQLITE_OK.
29098 ** Or, if one cannot but no error occurs, set *pp to 0 and return SQLITE_OK.
29115 if( rc!=SQLITE_OK ) return rc;
29123 return SQLITE_OK;
29161 return SQLITE_OK;
29469 int rc = SQLITE_OK;
29530 if( rc!=SQLITE_OK ){
29573 if( rc!=SQLITE_OK ){
29607 if( (rc==SQLITE_OK) && (pNew->pInode->pSem==NULL) ){
29626 if( rc!=SQLITE_OK ){
29633 if( rc!=SQLITE_OK ){
29713 return SQLITE_OK;
29785 ** to create new files with. If no error occurs, then SQLITE_OK is returned
29811 int rc = SQLITE_OK; /* Return Code */
29835 if( nDb==0 || zPath[nDb]!='-' ) return SQLITE_OK;
29893 int rc = SQLITE_OK; /* Function Return Code */
29984 if( rc!=SQLITE_OK ){
30009 if( rc!=SQLITE_OK ){
30118 if( rc==SQLITE_OK ){
30120 if( rc!=SQLITE_OK ){
30137 if( rc!=SQLITE_OK ){
30153 int rc = SQLITE_OK;
30172 if( rc==SQLITE_OK ){
30183 rc = SQLITE_OK;
30230 return SQLITE_OK;
30271 return SQLITE_OK;
30424 ** On success, return SQLITE_OK. Return SQLITE_ERROR if the time and date
30429 int rc = SQLITE_OK;
30699 return SQLITE_OK;
30752 int rc = SQLITE_OK;
30777 if( proxyCreateLockPath(path) == SQLITE_OK ){
30816 if( rc==SQLITE_OK ){
30818 return SQLITE_OK;
30865 return SQLITE_OK;
30944 int rc = SQLITE_OK;
30999 rc = SQLITE_OK;
31023 return SQLITE_OK;
31031 int rc = SQLITE_OK;
31047 if( rc!=SQLITE_OK ){
31129 if( rc==SQLITE_OK ){
31147 if( rc==SQLITE_OK && createConch ){
31179 if( rc==SQLITE_OK && pFile->openFlags ){
31194 if( rc==SQLITE_OK && !pCtx->lockProxy ){
31197 if( rc!=SQLITE_OK && rc!=SQLITE_NOMEM && tryOldLockPath ){
31206 if( rc==SQLITE_OK ){
31217 if( rc==SQLITE_OK ){
31229 rc==SQLITE_OK?"ok":"failed"));
31240 int rc = SQLITE_OK; /* Subroutine return code */
31254 (rc==SQLITE_OK ? "ok" : "failed")));
31261 ** Make *pConchPath point to the new name. Return SQLITE_OK on success
31299 return SQLITE_OK;
31309 int rc = SQLITE_OK;
31318 return SQLITE_OK;
31361 return SQLITE_OK;
31376 int rc = SQLITE_OK;
31398 if( rc==SQLITE_OK ){
31418 rc = SQLITE_OK;
31422 if( rc==SQLITE_OK && lockPath ){
31426 if( rc==SQLITE_OK ){
31432 if( rc==SQLITE_OK ){
31450 (rc==SQLITE_OK ? "ok" : "failed")));
31474 return SQLITE_OK;
31478 int rc = SQLITE_OK;
31486 rc = SQLITE_OK;
31497 rc = SQLITE_OK;
31527 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
31532 if( rc==SQLITE_OK ){
31571 if( rc==SQLITE_OK ){
31595 if( rc==SQLITE_OK ){
31617 int rc = SQLITE_OK;
31645 return SQLITE_OK;
31760 return SQLITE_OK;
31771 return SQLITE_OK;
33049 ** "win32" VFSes. Return SQLITE_OK opon successfully updating the
33066 rc = SQLITE_OK;
33081 rc = SQLITE_OK;
33133 ** compact it. Upon success, SQLITE_OK will be returned. Upon failure, one
33139 int rc = SQLITE_OK;
33203 assert( rc!=SQLITE_OK || winMemGetHeap()!=NULL );
33204 assert( rc!=SQLITE_OK || winMemGetOwned() );
33205 assert( rc!=SQLITE_OK || sqlite3_memory_used()==0 );
33477 return SQLITE_OK;
33682 ** SQLITE_OK if successful.
33709 return SQLITE_OK;
33822 assert( errcode!=SQLITE_OK );
34059 return SQLITE_OK;
34341 OSTRACE(("SEEK file=%p, rc=SQLITE_OK\n", pFile->h));
34362 OSTRACE(("SEEK file=%p, rc=SQLITE_OK\n", pFile->h));
34423 return rc ? SQLITE_OK
34429 ** Read data from a file into a buffer. Return SQLITE_OK if all
34459 OSTRACE(("READ-MMAP file=%p, rc=SQLITE_OK\n", pFile->h));
34460 return SQLITE_OK;
34499 OSTRACE(("READ file=%p, rc=SQLITE_OK\n", pFile->h));
34500 return SQLITE_OK;
34504 ** Write data from a buffer into a file. Return SQLITE_OK on success
34531 OSTRACE(("WRITE-MMAP file=%p, rc=SQLITE_OK\n", pFile->h));
34532 return SQLITE_OK;
34604 OSTRACE(("WRITE file=%p, rc=SQLITE_OK\n", pFile->h));
34605 return SQLITE_OK;
34613 int rc = SQLITE_OK; /* Return code for this function */
34712 OSTRACE(("SYNC-NOP file=%p, rc=SQLITE_OK\n", pFile->h));
34713 return SQLITE_OK;
34718 OSTRACE(("SYNC file=%p, rc=SQLITE_OK\n", pFile->h));
34719 return SQLITE_OK;
34734 int rc = SQLITE_OK;
34893 int rc = SQLITE_OK; /* Return code from subroutines */
34909 OSTRACE(("LOCK-HELD file=%p, rc=SQLITE_OK\n", pFile->h));
34910 return SQLITE_OK;
35012 rc = SQLITE_OK;
35050 OSTRACE(("TEST-WR-LOCK file=%p, pResOut=%p, *pResOut=%d, rc=SQLITE_OK\n",
35052 return SQLITE_OK;
35069 int rc = SQLITE_OK;
35129 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
35130 return SQLITE_OK;
35134 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
35135 return SQLITE_OK;
35139 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
35140 return SQLITE_OK;
35146 if( rc==SQLITE_OK ){
35157 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
35158 return SQLITE_OK;
35162 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
35163 return SQLITE_OK;
35167 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
35168 return SQLITE_OK;
35172 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
35173 return SQLITE_OK;
35187 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
35188 return SQLITE_OK;
35196 OSTRACE(("FCNTL oldFile=%p, newFile=%p, rc=SQLITE_OK\n",
35198 return SQLITE_OK;
35204 if( rc==SQLITE_OK ){
35213 int rc = SQLITE_OK;
35405 rc = SQLITE_OK;
35531 if( SQLITE_OK!=rc ){
35538 if( winShmSystemLock(pShmNode, _SHM_WRLCK, WIN_SHM_DMS, 1)==SQLITE_OK ){
35540 if( rc!=SQLITE_OK ){
35545 if( rc==SQLITE_OK ){
35572 return SQLITE_OK;
35599 if( p==0 ) return SQLITE_OK;
35623 return SQLITE_OK;
35639 int rc = SQLITE_OK; /* Result code */
35667 rc = SQLITE_OK;
35671 if( rc==SQLITE_OK ){
35691 if( rc==SQLITE_OK ){
35695 rc = SQLITE_OK;
35700 if( rc==SQLITE_OK ){
35717 if( rc==SQLITE_OK ){
35719 if( rc==SQLITE_OK ){
35757 ** separate process), then *pp is set to NULL and SQLITE_OK returned. If
35764 ** memory and SQLITE_OK returned.
35776 int rc = SQLITE_OK;
35780 if( rc!=SQLITE_OK ) return rc;
35800 if( rc!=SQLITE_OK ){
35808 ** zero, exit early. *pp will be set to NULL and SQLITE_OK returned.
35815 if( rc!=SQLITE_OK ){
35935 OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, rc=SQLITE_OK\n",
35937 return SQLITE_OK;
35952 ** SQLITE_OK is returned if no error occurs (even if the mapping is not
35964 if( pFd->nFetchOut>0 ) return SQLITE_OK;
36010 return SQLITE_OK;
36028 return SQLITE_OK;
36035 OSTRACE(("MAP-FILE pid=%lu, pFile=%p, rc=SQLITE_OK\n",
36037 return SQLITE_OK;
36045 ** If such a pointer can be obtained, store it in *pp and return SQLITE_OK.
36046 ** Or, if one cannot but no error occurs, set *pp to 0 and return SQLITE_OK.
36066 if( rc!=SQLITE_OK ){
36079 OSTRACE(("FETCH pid=%lu, pFile=%p, pp=%p, *pp=%p, rc=SQLITE_OK\n",
36081 return SQLITE_OK;
36122 OSTRACE(("UNFETCH pid=%lu, pFile=%p, rc=SQLITE_OK\n",
36124 return SQLITE_OK;
36454 OSTRACE(("TEMP-FILENAME name=%s, rc=SQLITE_OK\n", zBuf));
36455 return SQLITE_OK;
36516 int rc = SQLITE_OK; /* Function Return Code */
36581 if( rc!=SQLITE_OK ){
36729 && (rc = winceCreateLock(zName, pFile))!=SQLITE_OK
36838 rc = SQLITE_OK; /* Deleted OK. */
36866 rc = SQLITE_OK; /* Deleted OK. */
36958 OSTRACE(("ACCESS name=%s, pResOut=%p, *pResOut=%d, rc=SQLITE_OK\n",
36960 return SQLITE_OK;
37076 return SQLITE_OK;
37095 return SQLITE_OK;
37125 return SQLITE_OK;
37186 return SQLITE_OK;
37208 if( winFullPathname(pVfs, zFilename, nFull, zFull)!=SQLITE_OK ){
37334 ** On success, return SQLITE_OK. Return SQLITE_ERROR if the time and date
37372 return SQLITE_OK;
37500 return SQLITE_OK;
37510 return SQLITE_OK;
37682 if( p==0 ) return SQLITE_OK;
37697 return SQLITE_OK;
37713 if( p->u.aHash[h]==i ) return SQLITE_OK;
37742 return SQLITE_OK;
38169 return SQLITE_OK;
38218 if( rc!=SQLITE_OK && rc!=SQLITE_BUSY ){
38252 return (pPgHdr==0 && eCreate) ? SQLITE_NOMEM : SQLITE_OK;
38982 return (p->apHash ? SQLITE_OK : SQLITE_NOMEM);
39103 return SQLITE_OK;
40578 ** * The Pager.errCode variable is set to something other than SQLITE_OK.
41069 # define pagerOpenWalIfPresent(z) SQLITE_OK
41070 # define pagerBeginReadTransaction(z) SQLITE_OK
41134 assert( pPager->errCode==SQLITE_OK );
41139 assert( pPager->errCode==SQLITE_OK );
41146 assert( pPager->errCode==SQLITE_OK );
41158 assert( pPager->errCode==SQLITE_OK );
41177 assert( pPager->errCode==SQLITE_OK );
41189 assert( pPager->errCode==SQLITE_OK );
41202 assert( pPager->errCode!=SQLITE_OK );
41294 ** that is read in *pRes. Return SQLITE_OK if everything worked, or an
41302 if( rc==SQLITE_OK ){
41315 ** Write a 32-bit integer into the given file descriptor. Return SQLITE_OK
41334 int rc = SQLITE_OK;
41341 rc = pPager->noLock ? SQLITE_OK : sqlite3OsUnlock(pPager->fd, eLock);
41361 int rc = SQLITE_OK;
41365 rc = pPager->noLock ? SQLITE_OK : sqlite3OsLock(pPager->fd, eLock);
41366 if( rc==SQLITE_OK && (pPager->eLock!=UNKNOWN_LOCK||eLock==EXCLUSIVE_LOCK) ){
41478 ** zMaster[0] is set to 0 and SQLITE_OK returned.
41492 if( SQLITE_OK!=(rc = sqlite3OsFileSize(pJrnl, &szJ))
41494 || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-16, &len))
41497 || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-12, &cksum))
41498 || SQLITE_OK!=(rc = sqlite3OsRead(pJrnl, aMagic, 8, szJ-8))
41500 || SQLITE_OK!=(rc = sqlite3OsRead(pJrnl, zMaster, len, szJ-16-len))
41512 ** definitely roll back, so just return SQLITE_OK and report a (nul)
41519 return SQLITE_OK;
41568 ** Otherwise, return SQLITE_OK.
41571 int rc = SQLITE_OK; /* Return code */
41583 if( rc==SQLITE_OK && !pPager->noSync ){
41593 if( rc==SQLITE_OK && iLimit>0 ){
41596 if( rc==SQLITE_OK && sz>iLimit ){
41620 int rc = SQLITE_OK; /* Return code */
41710 for(nWrite=0; rc==SQLITE_OK&&nWrite<JOURNAL_HDR_SZ(pPager); nWrite+=nHeader){
41730 ** is set to the value read from the journal header. SQLITE_OK is returned
41779 if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+8, pNRec))
41780 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+12, &pPager->cksumInit))
41781 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+16, pDbSize))
41791 if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+20, &iSectorSize))
41792 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+24, &iPageSize))
41827 testcase( rc!=SQLITE_OK );
41876 return SQLITE_OK;
41918 if( SQLITE_OK==(rc = sqlite3OsFileSize(pPager->jfd, &jrnlSize))
41970 ** bitvecs of all open savepoints. Return SQLITE_OK if successful
41975 int rc = SQLITE_OK; /* Result code */
41982 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
42047 if( rc!=SQLITE_OK && pPager->eState==PAGER_ERROR ){
42070 pPager->errCode = SQLITE_OK;
42100 assert( rc==SQLITE_OK || !MEMDB );
42103 pPager->errCode==SQLITE_OK ||
42159 ** SQLITE_OK is returned if no error occurs. If an error occurs during
42169 int rc = SQLITE_OK; /* Error code from journal finalization operation */
42170 int rc2 = SQLITE_OK; /* Error code from db file unlock operation */
42188 return SQLITE_OK;
42202 rc = SQLITE_OK;
42253 assert( rc2==SQLITE_OK );
42254 }else if( rc==SQLITE_OK && bCommit && pPager->dbFileSize>pPager->dbSize ){
42265 if( rc==SQLITE_OK && bCommit && isOpen(pPager->fd) ){
42267 if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
42279 return (rc==SQLITE_OK?rc2:rc);
42369 ** skipped and SQLITE_OK is returned.
42378 ** and played back, then SQLITE_OK is returned. If an IO error occurs
42435 if( rc!=SQLITE_OK ) return rc;
42437 if( rc!=SQLITE_OK ) return rc;
42450 return SQLITE_OK;
42463 if( pDone && (rc = sqlite3BitvecSet(pDone, pgno))!=SQLITE_OK ){
42564 if( rc!=SQLITE_OK ) return rc;
42653 ** occur, SQLITE_OK is returned.
42682 if( rc!=SQLITE_OK ) goto delmaster_out;
42690 if( rc!=SQLITE_OK ) goto delmaster_out;
42699 if( rc!=SQLITE_OK ) goto delmaster_out;
42706 if( rc!=SQLITE_OK ){
42717 if( rc!=SQLITE_OK ){
42723 if( rc!=SQLITE_OK ){
42767 ** If successful, return SQLITE_OK. If an IO error occurs while modifying
42771 int rc = SQLITE_OK;
42784 if( rc==SQLITE_OK && currentSize!=newSize ){
42794 if( rc==SQLITE_OK ){
42900 ** is then deleted and SQLITE_OK returned, just as if no corruption had
42930 if( rc!=SQLITE_OK ){
42947 if( rc==SQLITE_OK && zMaster[0] ){
42951 if( rc!=SQLITE_OK || !res ){
42968 if( rc!=SQLITE_OK ){
42970 rc = SQLITE_OK;
43009 if( rc!=SQLITE_OK ){
43024 if( rc==SQLITE_OK ){
43036 rc = SQLITE_OK;
43075 if( rc==SQLITE_OK ){
43078 testcase( rc!=SQLITE_OK );
43080 if( rc==SQLITE_OK
43085 if( rc==SQLITE_OK ){
43087 testcase( rc!=SQLITE_OK );
43089 if( rc==SQLITE_OK && zMaster[0] && res ){
43094 testcase( rc!=SQLITE_OK );
43119 ** Otherwise, SQLITE_OK is returned.
43124 int rc = SQLITE_OK; /* Return code */
43140 rc = SQLITE_OK;
43208 ** return an SQLite error code. Otherwise, SQLITE_OK.
43211 int rc = SQLITE_OK;
43223 if( rc==SQLITE_OK ){
43226 if( rc==SQLITE_OK ){
43263 while( pList && rc==SQLITE_OK ){
43327 if( rc==SQLITE_OK && pPager->pBackup ){
43367 if( rc!=SQLITE_OK || changed ){
43381 ** If no error occurs, SQLITE_OK is returned and the size of the database
43409 if( rc!=SQLITE_OK ){
43425 return SQLITE_OK;
43439 ** Return SQLITE_OK or an error code.
43448 int rc = SQLITE_OK;
43460 if( rc==SQLITE_IOERR_DELETE_NOENT ) rc = SQLITE_OK;
43467 if( rc==SQLITE_OK ){
43519 int rc = SQLITE_OK; /* Return code */
43561 while( rc==SQLITE_OK && pPager->journalOff<iHdrOff ){
43574 while( rc==SQLITE_OK && pPager->journalOff<szJ ){
43591 for(ii=0; rc==SQLITE_OK && ii<nJRec && pPager->journalOff<szJ; ii++){
43596 assert( rc!=SQLITE_OK || pPager->journalOff>=szJ );
43609 for(ii=pSavepoint->iSubRec; rc==SQLITE_OK && ii<pPager->nSubRec; ii++){
43617 if( rc==SQLITE_OK ){
43753 ** Write the file descriptor into *pFile. Return SQLITE_OK on success
43779 assert( rc!=SQLITE_OK || isOpen(pFile) );
43843 ** In all other cases, SQLITE_OK is returned.
43851 int rc = SQLITE_OK;
43875 if( rc==SQLITE_OK ){
43880 if( rc==SQLITE_OK ){
43891 if( rc==SQLITE_OK ){
43959 ** zeroed and SQLITE_OK returned. The rationale for this is that this
43968 int rc = SQLITE_OK;
43982 rc = SQLITE_OK;
44005 ** (returning SQLITE_OK immediately).
44012 ** Return SQLITE_OK on success and an error code if we cannot obtain
44108 ** If everything goes as planned, SQLITE_OK is returned. Otherwise,
44112 int rc = SQLITE_OK;
44116 if( rc==SQLITE_OK ){
44126 ** and return SQLITE_OK. Otherwise, return an SQLite error code and set
44167 return SQLITE_OK;
44261 return SQLITE_OK;
44312 ** page currently held in memory before returning SQLITE_OK. If an IO
44325 if( rc!=SQLITE_OK ) return rc;
44365 if( rc==SQLITE_OK && 0==memcmp(aMagic, aJournalMagic, 8) ){
44369 if( rc!=SQLITE_OK && rc!=SQLITE_IOERR_SHORT_READ ){
44388 if( rc!=SQLITE_OK ) return rc;
44394 if( rc!=SQLITE_OK ) return rc;
44402 if( rc!=SQLITE_OK ) return rc;
44409 if( rc!=SQLITE_OK ) return rc;
44423 return SQLITE_OK;
44454 ** If everything is successful, SQLITE_OK is returned. If an IO error
44459 int rc = SQLITE_OK; /* Return code */
44467 ** is not possible for rc to be other than SQLITE_OK if this branch
44471 assert( pPager->tempFile && rc==SQLITE_OK );
44478 assert( rc!=SQLITE_OK || isOpen(pPager->fd) );
44479 if( rc==SQLITE_OK
44488 while( rc==SQLITE_OK && pList ){
44545 ** SQLITE_OK is returned if everything goes according to plan. An
44550 int rc = SQLITE_OK;
44569 ** This function returns SQLITE_OK if everything is successful, an IO
44575 int rc = SQLITE_OK;
44591 if( rc==SQLITE_OK ){
44599 if( rc==SQLITE_OK ){
44604 if( rc==SQLITE_OK ){
44626 ** SQLITE_OK returned. If an IO error occurs while trying to make the
44628 ** made clean for some other reason, but no error occurs, then SQLITE_OK
44633 int rc = SQLITE_OK;
44654 if( NEVER(pPager->errCode) ) return SQLITE_OK;
44662 return SQLITE_OK;
44671 if( rc==SQLITE_OK ){
44711 rc==SQLITE_OK && pPg->pgno>pPager->dbSize && subjRequiresPage(pPg)
44717 if( rc==SQLITE_OK ){
44724 if( rc==SQLITE_OK ){
44757 ** successfully, SQLITE_OK is returned and *ppPager set to point to
44774 int rc = SQLITE_OK; /* Return code */
44837 if( rc==SQLITE_OK && nPathname+8>pVfs->mxPathname ){
44846 if( rc!=SQLITE_OK ){
44924 if( rc==SQLITE_OK ){
44979 if( rc==SQLITE_OK ){
44982 testcase( rc!=SQLITE_OK );
44988 if( rc!=SQLITE_OK ){
45054 return SQLITE_OK;
45059 ** under the pager. Return SQLITE_OK if the database is still were it ought
45067 if( pPager->tempFile ) return SQLITE_OK;
45068 if( pPager->dbSize==0 ) return SQLITE_OK;
45075 rc = SQLITE_OK;
45076 }else if( rc==SQLITE_OK && bHasMoved ){
45098 ** just deleted using OsDelete, *pExists is set to 0 and SQLITE_OK
45109 ** SQLITE_OK returned. If no hot-journal file is present, *pExists is
45110 ** set to 0 and SQLITE_OK returned. If an IO error occurs while trying
45116 int rc = SQLITE_OK; /* Return code */
45132 if( rc==SQLITE_OK && exists ){
45144 if( rc==SQLITE_OK && !locked ){
45148 if( rc==SQLITE_OK ){
45159 if( pagerLockDb(pPager, RESERVED_LOCK)==SQLITE_OK ){
45175 if( rc==SQLITE_OK ){
45179 rc = SQLITE_OK;
45196 rc = SQLITE_OK;
45229 ** If everything is successful, SQLITE_OK is returned. If an IO error
45234 int rc = SQLITE_OK; /* Return code */
45252 if( rc!=SQLITE_OK ){
45263 if( rc!=SQLITE_OK ){
45288 if( rc!=SQLITE_OK ){
45310 if( rc==SQLITE_OK && bExists ){
45315 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
45316 if( rc==SQLITE_OK && fout&SQLITE_OPEN_READONLY ){
45332 assert( rc==SQLITE_OK );
45334 if( rc==SQLITE_OK ){
45342 if( rc!=SQLITE_OK ){
45399 if( rc!=SQLITE_OK && rc!=SQLITE_IOERR_SHORT_READ ){
45426 assert( pPager->pWal==0 || rc==SQLITE_OK );
45431 assert( rc==SQLITE_OK );
45435 if( pPager->eState==PAGER_OPEN && rc==SQLITE_OK ){
45440 if( rc!=SQLITE_OK ){
45467 ** successfully obtained, it is copied to *ppPage and SQLITE_OK returned.
45520 int rc = SQLITE_OK;
45546 if( pPager->errCode!=SQLITE_OK ){
45552 if( rc!=SQLITE_OK ) goto pager_acquire_err;
45562 if( rc==SQLITE_OK && pData ){
45572 assert( rc==SQLITE_OK );
45574 return SQLITE_OK;
45577 if( rc!=SQLITE_OK ){
45585 if( rc!=SQLITE_OK ){
45600 return SQLITE_OK;
45642 if( rc!=SQLITE_OK ) goto pager_acquire_err;
45647 if( rc!=SQLITE_OK ){
45654 return SQLITE_OK;
45657 assert( rc!=SQLITE_OK );
45729 ** Return SQLITE_OK if everything is successful. Otherwise, return
45734 int rc = SQLITE_OK; /* Return code */
45767 if( rc==SQLITE_OK ){
45777 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
45784 if( rc==SQLITE_OK ){
45794 if( rc!=SQLITE_OK
45823 int rc = SQLITE_OK;
45838 if( rc!=SQLITE_OK ){
45857 if( rc==SQLITE_OK && exFlag ){
45862 if( rc==SQLITE_OK ){
45879 assert( rc==SQLITE_OK || pPager->eState==PAGER_READER );
45880 assert( rc!=SQLITE_OK || pPager->eState==PAGER_WRITER_LOCKED );
45897 int rc = SQLITE_OK;
45925 if( rc!=SQLITE_OK ) return rc;
45969 if( rc!=SQLITE_OK ) return rc;
45971 if( rc!=SQLITE_OK ) return rc;
45973 if( rc!=SQLITE_OK ) return rc;
45987 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
45989 if( rc!=SQLITE_OK ){
46025 ** this routine returns SQLITE_OK.
46033 ** as appropriate. Otherwise, SQLITE_OK.
46036 int rc = SQLITE_OK;
46080 for(ii=0; ii<nPage && rc==SQLITE_OK; ii++){
46086 if( rc==SQLITE_OK ){
46108 if( rc==SQLITE_OK && needSync ){
46185 int rc = SQLITE_OK;
46217 assert( pPgHdr==0 || rc==SQLITE_OK );
46222 ** above is always successful - hence the ALWAYS on rc==SQLITE_OK.
46224 if( !DIRECT_MODE && ALWAYS(rc==SQLITE_OK) ){
46228 if( rc==SQLITE_OK ){
46237 if( rc==SQLITE_OK ){
46241 if( rc==SQLITE_OK ){
46265 ** function returns SQLITE_OK. Otherwise, an IO error code is returned.
46268 int rc = SQLITE_OK;
46273 if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
46275 if( rc==SQLITE_OK && !pPager->noSync ){
46289 ** successful, or the connection is in WAL mode, SQLITE_OK is returned.
46294 int rc = SQLITE_OK;
46337 int rc = SQLITE_OK; /* Return code */
46353 if( pPager->eState<PAGER_WRITER_CACHEMOD ) return SQLITE_OK;
46372 assert( rc==SQLITE_OK );
46377 if( rc==SQLITE_OK ){
46424 if( rc==SQLITE_OK ){
46431 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
46438 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
46452 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
46455 if( rc!=SQLITE_OK ){
46471 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
46483 if( rc==SQLITE_OK && !pagerUseWal(pPager) ){
46503 ** moves into the error state. Otherwise, SQLITE_OK is returned.
46506 int rc = SQLITE_OK; /* Return code */
46536 return SQLITE_OK;
46571 int rc = SQLITE_OK; /* Return code */
46580 if( pPager->eState<=PAGER_READER ) return SQLITE_OK;
46586 if( rc==SQLITE_OK ) rc = rc2;
46603 assert( pPager->eState==PAGER_READER || rc!=SQLITE_OK );
46604 assert( rc==SQLITE_OK || rc==SQLITE_FULL || rc==SQLITE_CORRUPT
46709 ** returned. Otherwise, SQLITE_OK.
46712 int rc = SQLITE_OK; /* Return code */
46788 ** savepoint. If no errors occur, SQLITE_OK is returned.
46796 if( rc==SQLITE_OK && iSavepoint<pPager->nSavepoint ){
46817 assert( rc==SQLITE_OK );
46949 ** occurs. Otherwise, it returns SQLITE_OK.
46991 && SQLITE_OK!=(rc = subjournalPage(pPg))
47064 if( rc!=SQLITE_OK ){
47076 return SQLITE_OK;
47205 int rc = SQLITE_OK;
47212 assert( rc==SQLITE_OK );
47215 if( rc==SQLITE_OK ){
47218 if( rc==SQLITE_OK && state==PAGER_READER ){
47293 int rc = SQLITE_OK;
47326 if( rc!=SQLITE_OK ){
47342 int rc = SQLITE_OK;
47359 if( rc==SQLITE_OK ){
47378 ** return SQLITE_OK. If an error occurs or the VFS used by the pager does
47383 ** the WAL file is already open, set *pbOpen to 1 and return SQLITE_OK
47390 int rc = SQLITE_OK; /* Return code */
47405 if( rc==SQLITE_OK ){
47426 int rc = SQLITE_OK;
47437 if( rc==SQLITE_OK ){
47442 if( rc==SQLITE_OK && logexists ){
47450 if( rc==SQLITE_OK && pPager->pWal ){
47452 if( rc==SQLITE_OK ){
47995 ** page and SQLITE_OK is returned. If an error (an OOM or VFS error) occurs,
47999 int rc = SQLITE_OK;
48027 rc = SQLITE_OK;
48033 assert( iPage==0 || *ppPage || rc!=SQLITE_OK );
48257 if( pWal->exclusiveMode ) return SQLITE_OK;
48262 VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && rc!=SQLITE_BUSY); )
48273 if( pWal->exclusiveMode ) return SQLITE_OK;
48278 VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && rc!=SQLITE_BUSY); )
48328 assert( rc==SQLITE_OK || iHash>0 );
48330 if( rc==SQLITE_OK ){
48462 if( rc==SQLITE_OK ){
48568 if( rc!=SQLITE_OK ){
48586 if( rc!=SQLITE_OK ){
48645 if( rc!=SQLITE_OK ) break;
48649 if( rc!=SQLITE_OK ) break;
48667 if( rc==SQLITE_OK ){
48729 ** If the log file is successfully opened, SQLITE_OK is returned and
48780 if( rc==SQLITE_OK && flags&SQLITE_OPEN_READONLY ){
48784 if( rc!=SQLITE_OK ){
48996 ** return SQLITE_OK. Otherwise, return an error code. If this routine
49009 int rc = SQLITE_OK; /* Return Code */
49039 for(i=0; rc==SQLITE_OK && i<nSegment; i++){
49045 if( rc==SQLITE_OK ){
49071 if( rc!=SQLITE_OK ){
49160 if( pInfo->nBackfill>=pWal->hdr.mxFrame ) return SQLITE_OK;
49164 if( rc!=SQLITE_OK ){
49183 if( rc==SQLITE_OK ){
49196 && (rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_READ_LOCK(0), 1))==SQLITE_OK
49209 if( rc==SQLITE_OK ){
49212 if( rc==SQLITE_OK && nSize<nReq ){
49219 while( rc==SQLITE_OK && 0==walIteratorNext(pIter, &iDbpage, &iFrame) ){
49226 if( rc!=SQLITE_OK ) break;
49230 if( rc!=SQLITE_OK ) break;
49234 if( rc==SQLITE_OK ){
49239 if( rc==SQLITE_OK && sync_flags ){
49243 if( rc==SQLITE_OK ){
49255 rc = SQLITE_OK;
49263 if( rc==SQLITE_OK && eMode!=SQLITE_CHECKPOINT_PASSIVE ){
49270 if( rc==SQLITE_OK ){
49290 if( rx==SQLITE_OK && (sz > nMax ) ){
49308 int rc = SQLITE_OK;
49321 if( rc==SQLITE_OK ){
49328 if( rc==SQLITE_OK ){
49335 ** fsyned (rc==SQLITE_OK) and if we are not in persistent-wal
49340 ** completed and fsynced (rc==SQLITE_OK) and we are in persistent
49436 ** If the wal-index header is successfully read, return SQLITE_OK.
49449 if( rc!=SQLITE_OK ){
49467 if( SQLITE_OK==(rc = walLockShared(pWal, WAL_WRITE_LOCK)) ){
49471 }else if( SQLITE_OK==(rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1)) ){
49473 if( SQLITE_OK==(rc = walIndexPage(pWal, 0, &page0)) ){
49511 ** On success return SQLITE_OK. On a permanent failure (such an
49561 int rc = SQLITE_OK; /* Return code */
49612 }else if( SQLITE_OK==(rc = walLockShared(pWal, WAL_RECOVER_LOCK)) ){
49619 if( rc!=SQLITE_OK ){
49631 if( rc==SQLITE_OK ){
49650 return SQLITE_OK;
49678 if( rc==SQLITE_OK ){
49755 testcase( rc==SQLITE_OK );
49776 ** Return SQLITE_OK if successful, or an error code if an error occurs. If an
49799 return SQLITE_OK;
49836 if( rc!=SQLITE_OK ){
49870 return SQLITE_OK;
49875 ** (which is nOut bytes in size). Return SQLITE_OK if successful, or an
49962 return SQLITE_OK;
49971 ** other than SQLITE_OK, it is not invoked again and the error code is
49975 ** function returns SQLITE_OK.
49978 int rc = SQLITE_OK;
49989 ALWAYS(rc==SQLITE_OK) && iFrame<=iMax;
50008 assert( rc==SQLITE_OK );
50033 int rc = SQLITE_OK;
50066 ** SQLITE_OK is returned if no error is encountered (regardless of whether
50071 int rc = SQLITE_OK;
50081 if( rc==SQLITE_OK ){
50119 testcase( rc==SQLITE_OK );
50230 if( SQLITE_OK!=(rc = walRestartLog(pWal)) ){
50261 if( rc!=SQLITE_OK ){
50348 for(p=pList; p && rc==SQLITE_OK; p=p->pDirty){
50352 while( rc==SQLITE_OK && nExtra>0 ){
50358 if( rc==SQLITE_OK ){
50429 if( rc==SQLITE_OK ){
50433 rc = SQLITE_OK;
50438 if( rc==SQLITE_OK ){
50446 if( rc==SQLITE_OK ){
50454 if( rc==SQLITE_OK || rc==SQLITE_BUSY ){
50475 return (rc==SQLITE_OK && eMode!=eMode2 ? SQLITE_BUSY : rc);
50533 if( walLockShared(pWal, WAL_READ_LOCK(pWal->readLock))!=SQLITE_OK ){
51350 if( sqlite3_mutex_try(p->pBt->mutex)==SQLITE_OK ){
51630 return SQLITE_OK;
51646 #define querySharedCacheTableLock(a,b,c) SQLITE_OK
51647 #define setSharedCacheTableLock(a,b,c) SQLITE_OK
51777 ** SQLITE_OK if the lock may be obtained (by calling
51798 return SQLITE_OK;
51830 return SQLITE_OK;
51847 ** already been called and returned SQLITE_OK).
51849 ** SQLITE_OK is returned if the lock is added successfully. SQLITE_NOMEM
51870 assert( SQLITE_OK==querySharedCacheTableLock(p, iTable, eLock) );
51903 return SQLITE_OK;
52076 int rc = SQLITE_OK;
52084 if( rc==SQLITE_OK && pgno<=sqlite3BitvecSize(pBt->pHasContent) ){
52139 assert( rc==SQLITE_OK ); /* KeySize() cannot fail */
52151 if( rc==SQLITE_OK ){
52162 if( rc==SQLITE_OK ){
52184 if( SQLITE_OK!=rc ){
52193 return SQLITE_OK;
52260 if( rc==SQLITE_OK ){
52274 SQLITE_OK)
52297 return SQLITE_OK;
52309 return SQLITE_OK;
52342 ** If *pRC is initially non-zero (non-SQLITE_OK) then this routine is
52366 if( rc!=SQLITE_OK ){
52381 if( rc==SQLITE_OK ){
52396 ** An error code is returned if something goes wrong, otherwise SQLITE_OK.
52426 return SQLITE_OK;
52431 #define ptrmapGet(w,x,y,z) SQLITE_OK
52720 return SQLITE_OK;
52726 ** of the first byte of allocated space. Return either SQLITE_OK or
52797 return SQLITE_OK;
52824 return SQLITE_OK;
52913 return SQLITE_OK;
52951 return SQLITE_OK;
52957 ** Return SQLITE_OK on success. If we see that the page does
52959 ** SQLITE_CORRUPT. Note that a return of SQLITE_OK does not
53068 return SQLITE_OK;
53146 return SQLITE_OK;
53199 if( rc==SQLITE_OK && (*ppPage)->isInit==0 ){
53201 if( rc!=SQLITE_OK ){
53297 int rc = SQLITE_OK; /* Result code from this function */
53429 if( rc==SQLITE_OK ){
53433 if( rc!=SQLITE_OK ){
53534 if( rc!=SQLITE_OK ){
53650 sqlite3BtreeRollback(p, SQLITE_OK);
53682 return SQLITE_OK;
53706 return SQLITE_OK;
53720 return SQLITE_OK;
53742 return SQLITE_OK;
53782 int rc = SQLITE_OK;
53890 int rc = SQLITE_OK;
53930 ** SQLITE_OK is returned on success. If the file is not a
53945 if( rc!=SQLITE_OK ) return rc;
53947 if( rc!=SQLITE_OK ) return rc;
53983 ** return SQLITE_OK and return without populating BtShared.pPage1.
53992 if( rc!=SQLITE_OK ){
53996 return SQLITE_OK;
54023 ** zero and return SQLITE_OK. The caller will call this function
54074 return SQLITE_OK;
54138 return SQLITE_OK;
54167 return SQLITE_OK;
54172 ** consisting of a single page and no schema objects). Return SQLITE_OK
54222 int rc = SQLITE_OK;
54271 if( SQLITE_OK!=rc ) goto trans_begun;
54277 ** lockBtree() returns something other than SQLITE_OK. lockBtree()
54278 ** may return SQLITE_OK but leave pBt->pPage1 set to 0 if after
54283 while( pBt->pPage1==0 && SQLITE_OK==(rc = lockBtree(pBt)) );
54285 if( rc==SQLITE_OK && wrflag ){
54290 if( rc==SQLITE_OK ){
54296 if( rc!=SQLITE_OK ){
54302 if( rc==SQLITE_OK ){
54335 if( rc==SQLITE_OK ){
54344 if( rc==SQLITE_OK && wrflag ){
54374 if( rc!=SQLITE_OK ){
54461 return SQLITE_OK;
54496 if( rc!=SQLITE_OK ){
54511 if( rc!=SQLITE_OK ){
54518 if( rc!=SQLITE_OK ){
54530 if( rc!=SQLITE_OK ){
54534 if( rc!=SQLITE_OK ){
54540 if( rc==SQLITE_OK ){
54552 ** SQLITE_OK. If there is no work to do (and therefore no point in
54584 if( rc!=SQLITE_OK ){
54601 if( rc!=SQLITE_OK ){
54614 if( rc!=SQLITE_OK ){
54632 if( rc!=SQLITE_OK ){
54642 if( rc!=SQLITE_OK ){
54655 return SQLITE_OK;
54687 ** SQLITE_OK is returned. Otherwise an SQLite error code.
54706 if( rc==SQLITE_OK ){
54710 if( rc==SQLITE_OK ){
54726 ** If SQLITE_OK is returned, then *pnTrunc is set to the number of pages
54732 int rc = SQLITE_OK;
54760 for(iFree=nOrig; iFree>nFin && rc==SQLITE_OK; iFree--){
54763 if( (rc==SQLITE_DONE || rc==SQLITE_OK) && nFree>0 ){
54771 if( rc!=SQLITE_OK ){
54781 # define setChildPtrmaps(x) SQLITE_OK
54811 int rc = SQLITE_OK;
54818 if( rc!=SQLITE_OK ){
54901 if( p->inTrans==TRANS_NONE ) return SQLITE_OK;
54914 if( rc!=SQLITE_OK && bCleanup==0 ){
54924 return SQLITE_OK;
54934 if( rc==SQLITE_OK ){
54990 if( tripCode==SQLITE_OK ){
54993 rc = SQLITE_OK;
55005 if( rc2!=SQLITE_OK ){
55012 if( btreeGetPage(pBt, 1, &pPage1, 0)==SQLITE_OK ){
55080 int rc = SQLITE_OK;
55087 if( rc==SQLITE_OK ){
55183 return SQLITE_OK;
55250 return SQLITE_OK;
55323 ** This routine cannot fail. It always returns SQLITE_OK.
55334 return SQLITE_OK;
55345 ** Failure is not possible. This function always returns SQLITE_OK.
55354 return SQLITE_OK;
55384 int rc = SQLITE_OK;
55407 if( rc==SQLITE_OK && eType==PTRMAP_OVERFLOW2 && pgno==ovfl ){
55416 if( rc==SQLITE_OK ){
55418 assert( rc==SQLITE_OK || pPage==0 );
55419 if( rc==SQLITE_OK ){
55430 return (rc==SQLITE_DONE ? SQLITE_OK : rc);
55442 ** SQLITE_OK is returned on success, otherwise an error code.
55454 if( rc!=SQLITE_OK ){
55462 return SQLITE_OK;
55503 int rc = SQLITE_OK;
55546 if( rc==SQLITE_OK && amt>0 ){
55573 if( rc==SQLITE_OK ){
55589 for( ; rc==SQLITE_OK && amt>0 && nextPage; iIdx++){
55662 if( rc==SQLITE_OK ){
55676 if( rc==SQLITE_OK && amt>0 ){
55690 ** Return SQLITE_OK on success or an error code if anything goes
55707 ** Return SQLITE_OK on success or an error code if anything goes
55722 if( rc==SQLITE_OK ){
55821 return SQLITE_OK;
55901 int rc = SQLITE_OK;
55909 assert( pCur->skipNext!=SQLITE_OK );
55919 return SQLITE_OK;
55923 if( rc!=SQLITE_OK ){
55974 int rc = SQLITE_OK;
55979 while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
55999 int rc = SQLITE_OK;
56004 while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
56009 if( rc==SQLITE_OK ){
56017 /* Move the cursor to the first entry in the table. Return SQLITE_OK
56027 if( rc==SQLITE_OK ){
56040 /* Move the cursor to the last entry in the table. Return SQLITE_OK
56062 return SQLITE_OK;
56066 if( rc==SQLITE_OK ){
56074 if( rc==SQLITE_OK ){
56135 return SQLITE_OK;
56139 return SQLITE_OK;
56164 return SQLITE_OK;
56212 rc = SQLITE_OK;
56277 rc = SQLITE_OK;
56293 rc = SQLITE_OK;
56355 if( rc!=SQLITE_OK ){
56361 return SQLITE_OK;
56369 return SQLITE_OK;
56403 return SQLITE_OK;
56412 rc = SQLITE_OK;
56418 return SQLITE_OK;
56452 if( rc!=SQLITE_OK ){
56459 return SQLITE_OK;
56467 return SQLITE_OK;
56488 return SQLITE_OK;
56500 rc = SQLITE_OK;
56515 ** SQLITE_OK is returned on success. Any other return value indicates
56650 if( rc!=SQLITE_OK ){
56668 if( rc!=SQLITE_OK ){
56672 if( rc!=SQLITE_OK ){
56748 if( rc==SQLITE_OK ){
56750 if( rc!=SQLITE_OK ){
56796 if( rc==SQLITE_OK ){
56812 if( rc!=SQLITE_OK ){
56823 if( rc==SQLITE_OK ){
56833 assert( rc!=SQLITE_OK || sqlite3PagerIswriteable((*ppPage)->pDbPage) );
56906 if( rc!=SQLITE_OK ){
56932 if( rc==SQLITE_OK ){
56951 if( pPage==0 && SQLITE_OK!=(rc = btreeGetPage(pBt, iPage, &pPage, 0)) ){
56955 if( rc!=SQLITE_OK ){
56972 if( (*pRC)==SQLITE_OK ){
56991 return SQLITE_OK; /* No overflow pages. Return without doing anything */
57039 return SQLITE_OK;
57141 if( pBt->autoVacuum && rc==SQLITE_OK ){
57201 return SQLITE_OK;
57308 if( rc!=SQLITE_OK ){
57444 if( rc==SQLITE_OK ){
57566 if( (*pRC)==SQLITE_OK ){
57592 if( rc!=SQLITE_OK ){
57663 int rc = SQLITE_OK; /* The return code */
57996 if( rc!=SQLITE_OK ){
58118 if( rc!=SQLITE_OK ) goto balance_cleanup;
58299 ** page and SQLITE_OK is returned. In this case the caller is required
58317 if( rc==SQLITE_OK ){
58347 return SQLITE_OK;
58361 int rc = SQLITE_OK;
58382 if( rc==SQLITE_OK ){
58398 if( rc==SQLITE_OK ){
58464 }while( rc==SQLITE_OK );
58514 assert( pCur->skipNext!=SQLITE_OK );
58601 assert( rc!=SQLITE_OK || pPage->nCell>0 || pPage->nOverflow>0 );
58624 if( rc==SQLITE_OK && pPage->nOverflow ){
58745 if( rc==SQLITE_OK && pCur->iPage>iCellDepth ){
58752 if( rc==SQLITE_OK ){
58818 if( rc!=SQLITE_OK ){
58837 if( rc!=SQLITE_OK ){
58843 if( rc!=SQLITE_OK ){
58850 if( rc!=SQLITE_OK ){
58860 if( rc!=SQLITE_OK ){
58864 if( rc!=SQLITE_OK ){
58868 if( rc!=SQLITE_OK ){
58909 return SQLITE_OK;
58991 if( SQLITE_OK==rc ){
59077 if( rc!=SQLITE_OK ){
59088 if( rc!=SQLITE_OK ){
59093 if( rc!=SQLITE_OK ){
59100 if( rc!=SQLITE_OK ){
59161 assert( SQLITE_OK==querySharedCacheTableLock(p, MASTER_ROOT, READ_LOCK) );
59192 if( rc==SQLITE_OK ){
59211 ** SQLITE_OK is returned if the operation is successfully executed.
59221 return SQLITE_OK;
59228 while( rc==SQLITE_OK ){
59248 ** If all pages in the tree have been visited, return SQLITE_OK to the
59256 return SQLITE_OK;
59378 if( rc!=SQLITE_OK ){
59853 int rc = SQLITE_OK;
59917 ** sqlite_master table. Otherwise SQLITE_OK.
59924 assert( rc==SQLITE_OK || rc==SQLITE_LOCKED_SHAREDCACHE );
59937 int rc = SQLITE_OK;
59946 if( rc==SQLITE_OK ){
59973 if( rc!=SQLITE_OK ){
59987 ** saveAllCursors can only return SQLITE_OK.
59990 assert( rc==SQLITE_OK );
60037 if( rc==SQLITE_OK ){
60041 if( rc==SQLITE_OK ){
60043 if( rc==SQLITE_OK ){
60272 return (rc!=SQLITE_OK && rc!=SQLITE_BUSY && ALWAYS(rc!=SQLITE_LOCKED));
60298 int rc = SQLITE_OK;
60330 if( rc==SQLITE_OK && newPgsz!=nSrcPgsz ) rc = SQLITE_READONLY;
60338 for(iOff=iEnd-(i64)nSrcPgsz; rc==SQLITE_OK && iOff<iEnd; iOff+=nDestPgsz){
60342 if( SQLITE_OK==(rc = sqlite3PagerGet(pDestPager, iDest, &pDestPg))
60343 && SQLITE_OK==(rc = sqlite3PagerWrite(pDestPg))
60373 ** Return SQLITE_OK if everything is successful, or an SQLite error
60379 if( rc==SQLITE_OK && iCurrent>iSize ){
60427 rc = SQLITE_OK;
60431 if( SQLITE_OK==rc && p->bDestLocked==0
60432 && SQLITE_OK==(rc = sqlite3BtreeBeginTrans(p->pDest, 2))
60442 if( rc==SQLITE_OK && 0==sqlite3BtreeIsInReadTrans(p->pSrc) ){
60452 if( SQLITE_OK==rc && destMode==PAGER_JOURNALMODE_WAL && pgszSrc!=pgszDest ){
60467 if( rc==SQLITE_OK ){
60474 if( rc==SQLITE_OK ){
60494 if( rc==SQLITE_OK || rc==SQLITE_DONE ){
60497 if( rc==SQLITE_OK ){
60505 if( rc==SQLITE_OK ){
60563 for(iPg=nDestTruncate; rc==SQLITE_OK && iPg<=(Pgno)nDstPage; iPg++){
60567 if( rc==SQLITE_OK ){
60573 if( rc==SQLITE_OK ){
60581 rc==SQLITE_OK && iOff<iEnd;
60587 if( rc==SQLITE_OK ){
60593 if( rc==SQLITE_OK ){
60598 if( rc==SQLITE_OK ){
60607 if( SQLITE_OK==rc
60608 && SQLITE_OK==(rc = sqlite3BtreeCommitPhaseTwo(p->pDest, 0))
60624 assert( rc2==SQLITE_OK );
60649 if( p==0 ) return SQLITE_OK;
60670 sqlite3BtreeRollback(p->pDest, SQLITE_OK);
60673 rc = (p->rc==SQLITE_DONE) ? SQLITE_OK : p->rc;
60734 if( rc!=SQLITE_OK ){
60781 if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
60804 assert( b.rc!=SQLITE_OK );
60806 if( rc==SQLITE_OK ){
60885 ** SQLITE_OK is returned if the conversion is successful (or not required).
60897 return SQLITE_OK;
60904 /* MemTranslate() may return SQLITE_OK or SQLITE_NOMEM. If NOMEM is returned,
60908 assert(rc==SQLITE_OK || rc==SQLITE_NOMEM);
60909 assert(rc==SQLITE_OK || pMem->enc!=desiredEnc);
60961 return SQLITE_OK;
60970 ** Return SQLITE_OK on success or SQLITE_NOMEM if malloc fails.
60990 return SQLITE_OK;
61018 return SQLITE_OK;
61029 return SQLITE_OK; /* Nothing to do */
61037 return SQLITE_OK;
61054 int rc = SQLITE_OK;
61094 ** Return SQLITE_ERROR if the finalizer reports an error. SQLITE_OK
61098 int rc = SQLITE_OK;
61281 return SQLITE_OK;
61294 return SQLITE_OK;
61319 return SQLITE_OK;
61474 int rc = SQLITE_OK;
61542 return SQLITE_OK;
61602 return SQLITE_OK;
61627 int rc = SQLITE_OK; /* Return code */
61646 }else if( SQLITE_OK==(rc = sqlite3VdbeMemGrow(pMem, amt+2, 0)) ){
61652 if( rc==SQLITE_OK ){
61692 if( sqlite3VdbeMemMakeWriteable(pVal)!=SQLITE_OK ){
61809 int rc = SQLITE_OK;
61813 return SQLITE_OK;
61850 if( SQLITE_OK==sqlite3ValueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal)
61999 int rc = SQLITE_OK;
62021 if( rc==SQLITE_OK ){
62062 ** Unless an error is encountered, SQLITE_OK is returned. It is not an
62095 ** SQLITE_OK. If no value can be extracted, but no other error occurs
62096 ** (e.g. OOM), return SQLITE_OK and set *ppVal to NULL. Or, if an error
62154 return SQLITE_OK;
62335 return (pNew ? SQLITE_OK : SQLITE_NOMEM);
63525 int rc = SQLITE_OK; /* Return code */
63530 assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY || p->rc==SQLITE_NOMEM );
63576 p->rc = SQLITE_OK;
63622 if( j==nSub && SQLITE_OK==sqlite3VdbeMemGrow(pSub, nByte, nSub!=0) ){
63684 p->rc = SQLITE_OK;
63804 p->rc = SQLITE_OK;
64124 int rc = SQLITE_OK;
64129 ** SQLITE_OK so p is not used.
64148 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
64158 if( rc!=SQLITE_OK ){
64182 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
64194 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
64200 if( rc==SQLITE_OK ){
64245 }while( rc==SQLITE_OK && res );
64246 if( rc==SQLITE_OK ){
64253 if( rc!=SQLITE_OK ){
64277 if( rc!=SQLITE_OK ){
64291 && SQLITE_OK!=(rc = sqlite3OsSync(pMaster, SQLITE_SYNC_NORMAL))
64309 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
64317 if( rc!=SQLITE_OK ){
64398 ** Otherwise SQLITE_OK.
64402 int rc = SQLITE_OK;
64418 int rc2 = SQLITE_OK;
64424 if( rc2==SQLITE_OK ){
64427 if( rc==SQLITE_OK ){
64435 if( rc==SQLITE_OK ){
64439 if( rc==SQLITE_OK ){
64459 ** violations, return SQLITE_ERROR. Otherwise, SQLITE_OK.
64476 return SQLITE_OK;
64519 return SQLITE_OK;
64565 if( p->rc==SQLITE_OK ){
64579 if( p->rc==SQLITE_OK || (p->errorAction==OE_Fail && !isSpecialError) ){
64581 if( rc!=SQLITE_OK ){
64597 }else if( rc!=SQLITE_OK ){
64599 sqlite3RollbackAll(db, SQLITE_OK);
64607 sqlite3RollbackAll(db, SQLITE_OK);
64611 if( p->rc==SQLITE_OK || p->errorAction==OE_Fail ){
64625 ** error code is SQLITE_OK or SQLITE_CONSTRAINT, then promote the
64631 if( p->rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT ){
64682 return (p->rc==SQLITE_BUSY ? SQLITE_BUSY : SQLITE_OK);
64688 ** in p->rc. This routine sets that result back to SQLITE_OK.
64691 p->rc = SQLITE_OK;
64725 if( sqlite3GlobalConfig.xSqllog && v->rc==SQLITE_OK && v->zSql && v->pc>=0 ){
64832 int rc = SQLITE_OK;
64969 return SQLITE_OK;
66037 ** Return SQLITE_OK if everything works, or an error code otherwise.
66059 assert( rc==SQLITE_OK ); /* pCur is always valid so KeySize cannot fail */
66101 return SQLITE_OK;
66115 ** or greater than pUnpacked. Return SQLITE_OK on success.
66134 assert( rc==SQLITE_OK ); /* pCur is always valid so KeySize cannot fail */
66148 return SQLITE_OK;
66315 rc = SQLITE_OK;
66339 rc = SQLITE_OK;
66357 int rc = SQLITE_OK;
66593 int rc = SQLITE_OK;
66600 if( db->xWalCallback && nEntry>0 && rc==SQLITE_OK ){
66709 assert( p->rc==SQLITE_OK );
66711 if( p->rc!=SQLITE_OK ){
66748 int rc = SQLITE_OK; /* Result from sqlite3Step() */
66749 int rc2 = SQLITE_OK; /* Result from sqlite3Reprepare() */
66762 && (rc2 = rc = sqlite3Reprepare(v))==SQLITE_OK ){
66767 if( rc2!=SQLITE_OK ){
67266 ** out of range, then SQLITE_RANGE is returned. Othewise SQLITE_OK.
67296 sqlite3Error(p->db, SQLITE_OK, 0);
67312 return SQLITE_OK;
67331 if( rc==SQLITE_OK ){
67335 if( rc==SQLITE_OK && encoding!=0 ){
67365 if( rc==SQLITE_OK ){
67378 if( rc==SQLITE_OK ){
67388 if( rc==SQLITE_OK ){
67448 if( rc==SQLITE_OK ){
67516 return SQLITE_OK;
67530 ** SQLITE_OK is returned.
68114 if( SQLITE_OK==sqlite3VdbeMemGrow(pMem, nByte, 0) ){
68236 if( sqlite3Atoi64(pMem->z, &pMem->u.i, pMem->n, pMem->enc)==SQLITE_OK ){
68496 int rc = SQLITE_OK; /* Value to return */
68524 assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY );
68526 p->rc = SQLITE_OK;
68571 for(pc=p->pc; rc==SQLITE_OK; pc++){
68854 ** or sqlite3_finalize(). For a normal halt, this should be SQLITE_OK (0).
68882 if( pOp->p1==SQLITE_OK && p->pFrame ){
68931 assert( rc==SQLITE_BUSY || rc==SQLITE_OK || rc==SQLITE_ERROR );
68935 assert( rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT );
68936 assert( rc==SQLITE_OK || db->nDeferredCons>0 || db->nDeferredImmCons>0 );
68996 if( SQLITE_OK!=sqlite3VdbeChangeEncoding(pOut, encoding) ) goto no_mem;
69239 if( SQLITE_OK!=(rc = sqlite3VdbeCheckFk(p, 0)) ){
69262 if( NEVER(rc!=SQLITE_OK) ){
70369 assert( rc==SQLITE_OK ); /* True because of CursorMoveto() call above */
70379 assert( rc==SQLITE_OK ); /* DataSize() cannot fail */
70433 if( rc!=SQLITE_OK ){
70505 assert( rc==SQLITE_OK );
70532 if( rc!=SQLITE_OK ){
70807 if( rc!=SQLITE_OK ) goto abort_due_to_error;
70863 if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){
70884 if( rc!=SQLITE_OK ){
70922 if( rc!=SQLITE_OK ) goto abort_due_to_error;
70975 }else if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){
70988 if( p->rc==SQLITE_OK ){
71061 if( rc!=SQLITE_OK ){
71076 if( rc==SQLITE_OK ){
71346 ** sqlite3BtreeCursor() may return is SQLITE_OK. */
71347 assert( rc==SQLITE_OK );
71402 if( rc==SQLITE_OK ){
71405 if( rc==SQLITE_OK ){
71415 if( rc==SQLITE_OK ){
71635 if( rc!=SQLITE_OK ){
71668 if( rc!=SQLITE_OK ){
71682 if( rc!=SQLITE_OK ) goto abort_due_to_error;
71692 if( rc!=SQLITE_OK ) goto abort_due_to_error;
71859 if( rc!=SQLITE_OK ){
72004 if( rc!=SQLITE_OK ){
72012 assert( rc==SQLITE_OK ); /* Cannot fail following BtreeLast() */
72064 0, &res))==SQLITE_OK)
72077 if( rc==SQLITE_OK && res==0 ){
72193 if( rc==SQLITE_OK && db->xUpdateCallback && pOp->p4.z ){
72243 if( NEVER(rc!=SQLITE_OK) ) goto abort_due_to_error;
72249 if( rc==SQLITE_OK && db->xUpdateCallback && pOp->p4.z && pC->isTable ){
72315 assert( rc!=SQLITE_OK || (pOut->flags & MEM_Blob) );
72371 if( NEVER(rc!=SQLITE_OK) ) goto abort_due_to_error;
72376 assert( rc==SQLITE_OK ); /* True because of CursorMoveto() call above */
72383 assert( rc==SQLITE_OK ); /* DataSize() cannot fail */
72445 assert( rc==SQLITE_OK ); /* Always so because of CursorMoveto() above */
72735 if( rc==SQLITE_OK ){
72780 if( rc==SQLITE_OK && res==0 ){
72815 if( rc!=SQLITE_OK ){
72966 if( rc==SQLITE_OK && iMoved!=0 ){
73125 initData.rc = SQLITE_OK;
73128 if( rc==SQLITE_OK ) rc = initData.rc;
73753 rc = SQLITE_OK;
73834 if( rc==SQLITE_OK ){
73847 if( rc==SQLITE_OK ){
73901 rc = SQLITE_OK;
74025 if( SQLITE_OK==rc ){
74102 if( rc==SQLITE_OK ){
74207 if( rc==SQLITE_OK ){
74241 if( rc==SQLITE_OK ){
74309 if( rc==SQLITE_OK && pOp->p1 ){
74315 rc = SQLITE_OK;
74571 ** If successful, SQLITE_OK is returned and subsequent calls to
74617 rc = SQLITE_OK;
74621 if( rc==SQLITE_OK ){
74629 assert( rc!=SQLITE_OK || zErr==0 );
74682 int rc = SQLITE_OK;
74847 if( rc==SQLITE_OK && db->mallocFailed==0 ){
74878 rc = SQLITE_OK;
74985 if( rc!=SQLITE_OK ){
74993 assert( rc==SQLITE_OK || p->pStmt==0 );
75171 ** and return SQLITE_OK. Otherwise, if an error occurs, return an SQLite
75206 if( rc!=SQLITE_OK ) return rc;
75247 if( rc!=SQLITE_OK ) return rc;
75256 return SQLITE_OK;
75280 return SQLITE_OK;
75285 ** Advance iterator pIter to the next key in its PMA. Return SQLITE_OK if
75298 return SQLITE_OK;
75302 if( rc==SQLITE_OK ){
75323 int rc = SQLITE_OK;
75354 if( rc==SQLITE_OK ){
75363 if( rc==SQLITE_OK ){
75374 ** Otherwise, return SQLITE_OK and set *pRes to a negative, zero or positive
75459 return SQLITE_OK;
75489 return SQLITE_OK;
75546 ** set *ppFile to point to the malloc'd file-handle and return SQLITE_OK.
75593 ** Sort the linked list of records headed at pCsr->pRecord. Return SQLITE_OK
75627 return SQLITE_OK;
75654 ** Write nData bytes of data to the file-write object. Return SQLITE_OK
75684 ** Return SQLITE_OK if flushing the buffered data succeeds or is not
75707 ** SQLITE_OK if successful, or an SQLite error code if an error occurs.
75718 ** SQLITE_OK if successful, or an SQLite error code otherwise.
75730 int rc = SQLITE_OK; /* Return code */
75744 if( rc==SQLITE_OK && pSorter->pTemp1==0 ){
75746 assert( rc!=SQLITE_OK || pSorter->pTemp1 );
75751 if( rc==SQLITE_OK ){
75780 int rc = SQLITE_OK; /* Return Code */
75806 if( rc==SQLITE_OK && pSorter->mxPmaSize>0 && (
75817 assert( rc!=SQLITE_OK || (nExpect==pSorter->iWriteOff) );
75832 int rc = SQLITE_OK; /* Return code */
75841 assert( rc!=SQLITE_OK || pSorter->iReadOff<=pSorter->iWriteOff );
75842 if( rc!=SQLITE_OK || pSorter->iReadOff>=pSorter->iWriteOff ) break;
75846 for(i=pSorter->nTree-1; rc==SQLITE_OK && i>0; i--){
75880 if( rc!=SQLITE_OK ) return rc;
75897 rc==SQLITE_OK && iNew*SORTER_MAX_MERGE_COUNT<pSorter->nPMA;
75916 assert( rc!=SQLITE_OK || pSorter->aIter[ pSorter->aTree[1] ].pFile );
75917 if( rc!=SQLITE_OK || pSorter->nPMA<=SORTER_MAX_MERGE_COUNT ){
75927 if( rc==SQLITE_OK ){
75931 while( rc==SQLITE_OK && bEof==0 ){
75940 if( rc==SQLITE_OK ) rc = rc2;
75955 }while( rc==SQLITE_OK );
75974 if( rc==SQLITE_OK ){
76028 rc = SQLITE_OK;
76069 return SQLITE_OK;
76093 return SQLITE_OK;
76148 int rc = SQLITE_OK;
76152 if( rc==SQLITE_OK ){
76158 if( rc!=SQLITE_OK ){
76180 return SQLITE_OK;
76192 int rc = SQLITE_OK;
76213 int rc = SQLITE_OK;
76218 if( rc==SQLITE_OK ){
76235 int rc = SQLITE_OK;
76254 rc = SQLITE_OK;
76263 int rc = SQLITE_OK;
76321 return SQLITE_OK;
76330 return SQLITE_OK;
76459 return SQLITE_OK;
76509 return SQLITE_OK;
76527 return SQLITE_OK;
76535 return SQLITE_OK;
76549 return SQLITE_OK;
76558 return SQLITE_OK;
77493 if( auth!=SQLITE_OK ){
78530 int rc = SQLITE_OK;
81319 v, OP_Halt, SQLITE_OK, OE_Ignore, 0, pExpr->u.zToken,0);
83020 if( SQLITE_OK!=isSystemTable(pParse, pTab->zName) ){
83023 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){ goto
83357 if( SQLITE_OK!=isSystemTable(pParse, pTab->zName) ){
84767 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
85155 if( rc==SQLITE_OK ) initAvgEq(pPrevIdx);
85164 int rc = SQLITE_OK; /* Result codes from subroutines */
85175 if( rc==SQLITE_OK && sqlite3FindTable(db, "sqlite_stat3", zDb) ){
85247 if( rc==SQLITE_OK ){
85301 int rc = SQLITE_OK;
85393 if( rc!=SQLITE_OK ){
85407 }else if( rc==SQLITE_OK ){
85427 if( rc==SQLITE_OK && aNew->zName==0 ){
85433 if( rc==SQLITE_OK ){
85469 if( rc==SQLITE_OK ){
85584 SQLITE_OK!=(rc = resolveAttachExpr(&sName, pFilename)) ||
85585 SQLITE_OK!=(rc = resolveAttachExpr(&sName, pDbname)) ||
85586 SQLITE_OK!=(rc = resolveAttachExpr(&sName, pKey))
85601 if(rc!=SQLITE_OK ){
85900 ** should return either SQLITE_OK, SQLITE_DENY, or SQLITE_IGNORE. If
85901 ** SQLITE_OK is returned, it means that access is allowed. SQLITE_DENY
85920 return SQLITE_OK;
85959 }else if( rc!=SQLITE_IGNORE && rc!=SQLITE_OK ){
86027 ** either SQLITE_OK (zero) or SQLITE_IGNORE or SQLITE_DENY. If SQLITE_DENY
86045 return SQLITE_OK;
86049 return SQLITE_OK;
86055 }else if( rc!=SQLITE_OK && rc!=SQLITE_IGNORE ){
86415 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
86857 return SQLITE_OK;
86943 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
86983 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
87648 ** Resize an Index object to hold N columns total. Return SQLITE_OK
87654 if( pIdx->nColumn>=N ) return SQLITE_OK;
87669 return SQLITE_OK;
88909 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
89002 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
89409 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
89926 if( rc!=SQLITE_OK ){
90194 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
90415 return SQLITE_OK;
90486 return SQLITE_OK;
91133 assert( rcauth==SQLITE_OK || rcauth==SQLITE_DENY || rcauth==SQLITE_IGNORE );
91194 if( rcauth==SQLITE_OK && pWhere==0 && !pTrigger && !IsVirtual(pTab)
93236 assert( rc==SQLITE_NOMEM || rc==SQLITE_OK );
96795 sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_OK, 0);
96842 int rc = SQLITE_OK; /* Return code */
96852 sqlite3Error(db, SQLITE_OK, 0);
96853 while( rc==SQLITE_OK && zSql[0] ){
96859 assert( rc==SQLITE_OK || pStmt==0 );
96860 if( rc!=SQLITE_OK ){
96933 if( rc!=SQLITE_OK && ALWAYS(rc==sqlite3_errcode(db)) && pzErrMsg ){
97843 ** Return SQLITE_OK on success and SQLITE_ERROR if something goes wrong.
97986 return SQLITE_OK;
98027 return SQLITE_OK;
98077 int rc = SQLITE_OK;
98146 if( sqlite3_initialize()==SQLITE_OK )
98780 return SQLITE_OK;
98793 if( db->temp_store==ts ) return SQLITE_OK;
98794 if( invalidateTempStorage( pParse ) != SQLITE_OK ){
98798 return SQLITE_OK;
98957 ** connection. If it returns SQLITE_OK, then assume that the VFS
98966 if( rc==SQLITE_OK ){
99285 if( rc==SQLITE_OK && (eAuto==1 || eAuto==2) ){
99296 { OP_Halt, SQLITE_OK, OE_Abort, 0}, /* 3 */
99393 rc = SQLITE_OK;
99395 if( rc==SQLITE_OK ){
99448 if( rc!=SQLITE_OK || res==0 ){
99498 if( rc!=SQLITE_OK || res==0 ){
99550 if( res!=SQLITE_OK ){
100470 if( zRight && sqlite3DecOrHexToI64(zRight, &N)==SQLITE_OK ){
100500 SQLITE_FCNTL_LOCKSTATE, &j)==SQLITE_OK ){
100650 if( SQLITE_OK!=rc ){
100760 initData.rc = SQLITE_OK;
100779 return SQLITE_OK;
100788 if( rc!=SQLITE_OK ){
100902 if( rc==SQLITE_OK ) rc = initData.rc;
100905 if( rc==SQLITE_OK ){
100914 if( rc==SQLITE_OK || (db->flags&SQLITE_RecoveryMode)){
100924 rc = SQLITE_OK;
100959 rc = SQLITE_OK;
100961 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
100974 if( rc==SQLITE_OK && ALWAYS(db->nDb>1)
100984 if( rc==SQLITE_OK && commit_internal ){
100996 int rc = SQLITE_OK;
101002 if( rc!=SQLITE_OK ){
101036 if( rc!=SQLITE_OK ) return;
101114 int rc = SQLITE_OK; /* Result code */
101195 if( pParse->rc==SQLITE_DONE ) pParse->rc = SQLITE_OK;
101208 if( rc==SQLITE_OK && pParse->pVdbe && pParse->explain ){
101234 if( pParse->pVdbe && (rc!=SQLITE_OK || db->mallocFailed) ){
101287 assert( rc==SQLITE_OK || *ppStmt==0 );
101294 ** If the statement is successfully recompiled, return SQLITE_OK. Otherwise,
101324 return SQLITE_OK;
101345 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
101357 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
101380 int rc = SQLITE_OK;
101431 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
101443 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
102970 ** Return SQLITE_OK on success. If a memory allocation error occurs,
103062 return SQLITE_OK;
103510 int rc = SQLITE_OK; /* Success code from a subroutine */
103608 testcase( rc!=SQLITE_OK );
103681 testcase( rc!=SQLITE_OK );
103765 testcase( rc!=SQLITE_OK );
104407 return SQLITE_OK;
105086 ** pFrom->pIndex and return SQLITE_OK.
105104 return SQLITE_OK;
105236 ** Whether or not a match is found, SQLITE_OK is returned if no error
105238 ** parser and some error code other than SQLITE_OK returned.
105341 return SQLITE_OK;
106755 if( rc==SQLITE_OK && pDest->eDest==SRT_Output ){
106997 res.rc = SQLITE_OK;
107020 if( rc!=SQLITE_OK ){
107237 if( !zName || SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
107554 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
107939 if( SQLITE_OK==sqlite3ResolveExprNames(&sNC, pWhen)
109002 if( SQLITE_OK!=sqlite3_prepare(db, zSql, -1, &pStmt, 0) ){
109020 if( rc!=SQLITE_OK ) return rc;
109024 if( rc!=SQLITE_OK ){
109076 int rc = SQLITE_OK; /* Return code from service routines */
109137 if( rc!=SQLITE_OK ) goto end_of_vacuum;
109160 if( rc!=SQLITE_OK ) goto end_of_vacuum;
109167 if( rc!=SQLITE_OK ) goto end_of_vacuum;
109169 if( rc!=SQLITE_OK ) goto end_of_vacuum;
109198 if( rc!=SQLITE_OK ) goto end_of_vacuum;
109202 if( rc!=SQLITE_OK ) goto end_of_vacuum;
109206 if( rc!=SQLITE_OK ) goto end_of_vacuum;
109219 if( rc!=SQLITE_OK ) goto end_of_vacuum;
109227 if( rc!=SQLITE_OK ) goto end_of_vacuum;
109233 if( rc!=SQLITE_OK ) goto end_of_vacuum;
109283 if( NEVER(rc!=SQLITE_OK) ) goto end_of_vacuum;
109287 if( rc!=SQLITE_OK ) goto end_of_vacuum;
109289 if( rc!=SQLITE_OK ) goto end_of_vacuum;
109295 assert( rc==SQLITE_OK );
109371 int rc = SQLITE_OK;
109398 if( rc!=SQLITE_OK && xDestroy ) xDestroy(pAux);
109842 if( SQLITE_OK!=rc ){
109921 return SQLITE_OK;
109935 if( rc!=SQLITE_OK ){
109945 ** more v-table. Return SQLITE_NOMEM if a malloc fails, or SQLITE_OK otherwise.
109962 return SQLITE_OK;
109984 int rc = SQLITE_OK;
110008 ** create a valid sqlite3_vtab if it returns SQLITE_OK. */
110009 if( rc==SQLITE_OK && ALWAYS(sqlite3GetVTable(db, pTab)) ){
110011 if( rc==SQLITE_OK ){
110027 int rc = SQLITE_OK;
110047 if( SQLITE_OK==sqlite3RunParser(pParse, zCreateTable, &zErr)
110089 int rc = SQLITE_OK;
110096 assert( rc==SQLITE_OK );
110100 if( rc==SQLITE_OK ){
110142 ** SQLITE_OK if all xSync operations are successful.
110148 int rc = SQLITE_OK;
110152 for(i=0; rc==SQLITE_OK && i<db->nVTrans; i++){
110170 return SQLITE_OK;
110179 return SQLITE_OK;
110191 int rc = SQLITE_OK;
110203 return SQLITE_OK;
110213 return SQLITE_OK;
110220 if( rc==SQLITE_OK ){
110222 if( rc==SQLITE_OK ){
110240 ** If any virtual table method returns an error code other than SQLITE_OK,
110243 ** SQLITE_OK is returned.
110246 int rc = SQLITE_OK;
110252 for(i=0; rc==SQLITE_OK && i<db->nVTrans; i++){
110400 int rc = SQLITE_OK;
110422 if( rc!=SQLITE_OK ) sqlite3Error(db, rc, 0);
112753 if( rc!=SQLITE_OK ){
112785 ** Return SQLITE_OK on success.
112929 ** SQLITE_OK.
112943 int rc = SQLITE_OK;
112957 if( pUpper && rc==SQLITE_OK ){
112965 for(i=0; rc==SQLITE_OK && i<p->nSample; i++){
112967 if( rc==SQLITE_OK && p1 ){
112971 if( rc==SQLITE_OK && p2 ){
113051 int rc = SQLITE_OK;
113111 if( rc==SQLITE_OK && bOk ){
113126 if( rc==SQLITE_OK && bOk ){
113136 if( rc==SQLITE_OK ){
113148 return SQLITE_OK;
113188 ** Write the estimated row count into *pnRow and return SQLITE_OK.
113227 return SQLITE_OK;
113233 if( rc!=SQLITE_OK ) return rc;
113253 ** Write the estimated row count into *pnRow and return SQLITE_OK.
113271 int rc = SQLITE_OK; /* Subfunction return code */
113277 for(i=0; rc==SQLITE_OK && i<pList->nExpr; i++){
113284 if( rc==SQLITE_OK ){
114769 if( p->nLSlot>=n ) return SQLITE_OK;
114777 return SQLITE_OK;
114796 return SQLITE_OK;
115022 return SQLITE_OK;
115039 return SQLITE_OK;
115092 return SQLITE_OK;
115170 int rc = SQLITE_OK; /* Return code */
115217 && (rc = whereLoopResize(db, pNew, pNew->nLTerm+1))==SQLITE_OK
115229 for(; rc==SQLITE_OK && pTerm!=0; pTerm = whereScanNext(&scan)){
115334 if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
115335 if( rc!=SQLITE_OK ) break; /* Jump out of the pTerm loop */
115506 int rc = SQLITE_OK; /* Return code */
115568 for(pTerm=pWC->a; rc==SQLITE_OK && pTerm<pWCEnd; pTerm++){
115597 for(; rc==SQLITE_OK && pProbe; pProbe=pProbe->pNext, iSortIdx++){
115706 int rc = SQLITE_OK;
115858 int rc = SQLITE_OK;
115866 if( pWInfo->wctrlFlags & WHERE_AND_ONLY ) return SQLITE_OK;
115873 for(pTerm=pWC->a; pTerm<pWCEnd && rc==SQLITE_OK; pTerm++){
115909 assert( rc==SQLITE_OK || sCur.n==0 );
115935 for(i=0; rc==SQLITE_OK && i<sSum.n; i++){
115970 int rc = SQLITE_OK;
115989 if( rc==SQLITE_OK ){
116345 ** Return SQLITE_OK on success or SQLITE_NOMEM of a memory allocation
116675 return SQLITE_OK;
121663 pParse->rc = SQLITE_OK;
121711 if( pParse->rc!=SQLITE_OK ){
121719 if( zSql[i]==0 && nErr==0 && pParse->rc==SQLITE_OK ){
121736 if( pParse->rc!=SQLITE_OK && pParse->rc!=SQLITE_DONE && pParse->zErrMsg==0 ){
121783 if( nErr>0 && pParse->rc==SQLITE_OK ){
122288 if( rc!=SQLITE_OK ){
122298 if( sqlite3GlobalConfig.isInit ) return SQLITE_OK;
122323 if( rc==SQLITE_OK ){
122333 if( rc==SQLITE_OK ){
122338 /* If rc is not SQLITE_OK at this point, then either the malloc
122341 if( rc!=SQLITE_OK ){
122367 if( rc==SQLITE_OK ){
122371 if( rc==SQLITE_OK ){
122403 if ( rc==SQLITE_OK ){
122470 return SQLITE_OK;
122484 int rc = SQLITE_OK;
122691 ** Return SQLITE_OK on success.
122751 return SQLITE_OK;
122778 return SQLITE_OK;
122822 rc = SQLITE_OK;
122994 return SQLITE_OK;
123034 return SQLITE_OK;
123081 sqlite3RollbackAll(db, SQLITE_OK);
123147 sqlite3Error(db, SQLITE_OK, 0); /* Deallocates any cached error strings. */
123171 ** Rollback all database files. If tripCode is not SQLITE_OK, then
123229 case SQLITE_OK: zName = "SQLITE_OK"; break;
123334 /* SQLITE_OK */ "not an error",
123458 return SQLITE_OK;
123499 return SQLITE_OK;
123559 if( rc==SQLITE_OK ){
123563 if( rc!=SQLITE_OK ){
123610 return SQLITE_OK;
123655 assert( rc!=SQLITE_OK );
123709 int rc = SQLITE_OK;
123834 return SQLITE_OK;
123860 return SQLITE_OK;
123896 return SQLITE_OK;
123947 ** returned (i.e. SQLITE_IOERR). Otherwise, SQLITE_OK.
123960 int rc = SQLITE_OK; /* Return code */
123968 for(i=0; i<db->nDb && rc==SQLITE_OK; i++){
123975 rc = SQLITE_OK;
123980 return (rc==SQLITE_OK && bBusy) ? SQLITE_BUSY : rc;
124222 sqlite3Error(db, SQLITE_OK, 0);
124223 return SQLITE_OK;
124341 ** If successful, SQLITE_OK is returned. In this case *ppVfs is set to point to
124358 char **pzErrMsg /* OUT: Error message (if rc!=SQLITE_OK) */
124360 int rc = SQLITE_OK;
124551 if( rc!=SQLITE_OK ){
124705 if( rc!=SQLITE_OK ){
124715 if( rc!=SQLITE_OK ){
124743 sqlite3Error(db, SQLITE_OK, 0);
124750 if( rc==SQLITE_OK ){
124753 if( rc!=SQLITE_OK ){
124766 if( !db->mallocFailed && rc==SQLITE_OK ){
124773 if( !db->mallocFailed && rc==SQLITE_OK ){
124779 if( !db->mallocFailed && rc==SQLITE_OK ){
124785 if( !db->mallocFailed && rc==SQLITE_OK){
124819 }else if( rc!=SQLITE_OK ){
124878 if( rc==SQLITE_OK && !DbHasProperty(*ppDb, 0, DB_SchemaLoaded) ){
124940 int rc = SQLITE_OK;
124969 return SQLITE_OK;
124987 return SQLITE_OK;
124997 return SQLITE_OK;
125089 if( SQLITE_OK!=rc ){
125156 if( SQLITE_OK==rc && !pTab ){
125193 return SQLITE_OK;
125215 rc = SQLITE_OK;
125529 ** Return SQLITE_OK if SQLite has been initialized and SQLITE_ERROR if
125585 if( z && sqlite3DecOrHexToI64(z, &v)==SQLITE_OK ){
125776 int rc = SQLITE_OK;
126311 /* TODO(shess) Only used for SQLITE_OK and SQLITE_DONE at this time.
126357 ** This method should return either SQLITE_OK (0), or an SQLite error
126358 ** code. If SQLITE_OK is returned, then *ppTokenizer should be set
126394 ** method should either return SQLITE_OK and set the values of the
126994 # define sqlite3Fts3DeferToken(x,y,z) SQLITE_OK
126995 # define sqlite3Fts3CacheDeferredDoclists(x) SQLITE_OK
126997 # define sqlite3Fts3DeferredTokenList(x,y,z) SQLITE_OK
127334 return SQLITE_OK;
127369 int rc = SQLITE_OK; /* Return code */
127383 ** memory associated with the Fts3Table structure and return SQLITE_OK.
127386 return (rc==SQLITE_OK ? fts3DisconnectMethod(pVtab) : rc);
127400 if( *pRc==SQLITE_OK ){
127442 if( (*pRc)==SQLITE_OK ) p->bHasStat = 1;
127455 int rc = SQLITE_OK; /* Return code */
127520 if( *pRc==SQLITE_OK ){
127530 if( rc==SQLITE_OK ){
127536 rc = SQLITE_OK;
127539 assert( p->nPgsz>0 || rc!=SQLITE_OK );
127584 if( *pRc==SQLITE_OK ){
127648 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op (and
127705 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op (and
127741 ** the output value undefined. Otherwise SQLITE_OK is returned.
127755 return SQLITE_OK;
127768 ** If no error occurs, SQLITE_OK is returned and *apIndex set to point to
127810 return SQLITE_OK;
127846 int rc = SQLITE_OK; /* Return code */
127858 if( rc==SQLITE_OK ){
127920 int rc = SQLITE_OK; /* Return code */
127980 for(i=3; rc==SQLITE_OK && i<argc; i++){
128098 if( rc==SQLITE_OK && zContent ){
128110 if( rc==SQLITE_OK && zLanguageid ){
128123 if( rc!=SQLITE_OK ) goto fts3_init_out;
128134 if( rc!=SQLITE_OK ) goto fts3_init_out;
128143 if( rc!=SQLITE_OK ) goto fts3_init_out;
128228 if( rc==SQLITE_OK && (zCompress==0)!=(zUncompress==0) ){
128235 if( rc!=SQLITE_OK ) goto fts3_init_out;
128269 if( rc!=SQLITE_OK ){
128357 return SQLITE_OK;
128444 return SQLITE_OK;
128456 ** allocation succeeds, zero it and return SQLITE_OK. Otherwise,
128464 return SQLITE_OK;
128481 return SQLITE_OK;
128493 ** Otherwise, set *ppStmt to point to pCsr->pStmt and return SQLITE_OK.
128496 int rc = SQLITE_OK;
128512 ** SQLITE_OK on success.
128515 int rc = SQLITE_OK;
128520 if( rc==SQLITE_OK ){
128524 return SQLITE_OK;
128527 if( rc==SQLITE_OK && ((Fts3Table *)pCsr->base.pVtab)->zContentTbl==0 ){
128538 if( rc!=SQLITE_OK && pContext ){
128557 ** If an OOM error occurs, SQLITE_NOMEM is returned. Otherwise, SQLITE_OK.
128567 int rc = SQLITE_OK; /* Return code */
128678 ** If an error occurs, an error code other than SQLITE_OK is returned.
128696 assert( !piLeaf2 || !piLeaf || rc!=SQLITE_OK || (*piLeaf<=*piLeaf2) );
128698 if( rc==SQLITE_OK && iHeight>1 ){
128704 if( rc==SQLITE_OK ){
128712 if( rc==SQLITE_OK ){
128715 if( rc==SQLITE_OK ){
129229 ** containing the output doclist and SQLITE_OK is returned. In this case
129312 return SQLITE_OK;
129431 ** other doclists (except the aaOutput[0] one) and return SQLITE_OK.
129458 if( rc!=SQLITE_OK ){
129474 return SQLITE_OK;
129488 ** This function returns SQLITE_OK if the merge is successful, or an
129525 if( rc!=SQLITE_OK ){
129543 return SQLITE_OK;
129564 return SQLITE_OK;
129571 ** This function returns SQLITE_OK if successful, or an SQLite error code
129585 int rc = SQLITE_OK; /* Error code */
129598 if( rc==SQLITE_OK && pSeg ){
129604 if( rc==SQLITE_OK ){
129608 while( rc==SQLITE_OK && SQLITE_ROW==(rc = sqlite3_step(pStmt)) ){
129623 if( rc!=SQLITE_OK ) goto finished;
129632 if( rc!=SQLITE_OK ) goto finished;
129678 ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
129695 ** zTerm/nTerm is a prefix. If successful, return SQLITE_OK and write
129702 ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
129738 if( rc==SQLITE_OK ){
129795 while( SQLITE_OK==rc
129801 if( rc==SQLITE_OK ){
129804 if( rc==SQLITE_OK ){
129850 ** Return SQLITE_OK if nothing goes wrong. SQLITE_OK is returned
129863 rc = SQLITE_OK;
129982 if( rc!=SQLITE_OK ){
129988 if( rc!=SQLITE_OK ) return rc;
130011 if( rc==SQLITE_OK ){
130015 if( rc!=SQLITE_OK ) return rc;
130037 return SQLITE_OK;
130056 int rc = SQLITE_OK; /* Return Code */
130079 if( rc==SQLITE_OK ){
130140 if( rc==SQLITE_OK
130148 assert( rc==SQLITE_OK || mxLevel==0 );
130160 ** to 0 or 1). Return SQLITE_OK if successful, or an SQLite error code
130164 int rc = SQLITE_OK;
130171 if( rc==SQLITE_OK ){
130174 if( rc==SQLITE_OK ) p->bHasStat = bHasStat;
130212 return SQLITE_OK;
130225 return SQLITE_OK;
130253 ** output variable *ppCsr and SQLITE_OK is returned. Otherwise, an error
130274 return SQLITE_OK;
130313 }else if( SQLITE_OK==fts3CursorSeek(pContext, pCsr) ){
130333 if( SQLITE_OK==fts3CursorSeek(pContext, pCsr) ){
130366 case SQLITE_OK:
130388 if( SQLITE_OK==fts3FunctionArg(pContext, "matchinfo", apVal[0], &pCsr) ){
130456 if( rc==SQLITE_OK ){
130496 int rc = SQLITE_OK;
130519 return SQLITE_OK;
130534 return SQLITE_OK;
130600 int rc = SQLITE_OK;
130619 if( rc!=SQLITE_OK ) return rc;
130623 if( rc!=SQLITE_OK ) return rc;
130637 if( rc==SQLITE_OK ){
130653 if( rc==SQLITE_OK ){
130662 if( SQLITE_OK==rc
130663 && SQLITE_OK==(rc = sqlite3Fts3InitHashTable(db, pHash, "fts3_tokenizer"))
130664 && SQLITE_OK==(rc = sqlite3_overload_function(db, "snippet", -1))
130665 && SQLITE_OK==(rc = sqlite3_overload_function(db, "offsets", 1))
130666 && SQLITE_OK==(rc = sqlite3_overload_function(db, "matchinfo", 1))
130667 && SQLITE_OK==(rc = sqlite3_overload_function(db, "matchinfo", 2))
130668 && SQLITE_OK==(rc = sqlite3_overload_function(db, "optimize", 1))
130673 if( rc==SQLITE_OK ){
130678 if( rc==SQLITE_OK ){
130686 assert( rc!=SQLITE_OK );
130716 if( pExpr && SQLITE_OK==*pRc ){
130726 if( rc!=SQLITE_OK ){
130807 ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
130815 int rc = SQLITE_OK;
130817 for(iToken=0; rc==SQLITE_OK && iToken<p->nToken; iToken++){
130825 if( rc==SQLITE_OK ){
130843 ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
130861 if( rc!=SQLITE_OK ) return rc;
130867 return SQLITE_OK;
130887 return SQLITE_OK;
130936 return SQLITE_OK;
130955 ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
130959 int rc = SQLITE_OK; /* Error code */
130987 for(i=0; rc==SQLITE_OK && i<p->nToken; i++){
131001 assert( rc!=SQLITE_OK || p->nToken<1 || p->aToken[0].pSegcsr==0 || p->bIncr );
131168 ** SQLITE_OK.
131177 int rc = SQLITE_OK;
131220 ** SQLITE_OK.
131227 int rc = SQLITE_OK;
131255 for(i=0; rc==SQLITE_OK && i<p->nToken && bEof==0; i++){
131262 assert( rc!=SQLITE_OK || a[p->nToken-1].bIgnore==0 );
131263 assert( rc!=SQLITE_OK || bMaxSet );
131267 while( rc==SQLITE_OK && bEof==0
131316 ** SQLITE_OK.
131327 int rc = SQLITE_OK;
131347 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
131366 if( pExpr && SQLITE_OK==*pRc ){
131408 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
131420 if( *pRc==SQLITE_OK ){
131424 for(i=0; *pRc==SQLITE_OK && i<pPhrase->nToken; i++){
131457 ** write this value to *pnPage and return SQLITE_OK. Otherwise, return
131488 if( rc!=SQLITE_OK ) return rc;
131506 if( rc!=SQLITE_OK ) return rc;
131510 return SQLITE_OK;
131523 ** If no error occurs, SQLITE_OK is returned and sqlite3Fts3DeferToken()
131535 int rc = SQLITE_OK; /* Return code */
131549 return SQLITE_OK;
131561 if( nOvfl==0 || nToken<2 ) return SQLITE_OK;
131565 assert( rc!=SQLITE_OK || nDocSize>0 );
131590 for(ii=0; ii<nToken && rc==SQLITE_OK; ii++){
131627 assert( rc==SQLITE_OK || pList==0 );
131628 if( rc==SQLITE_OK ){
131658 int rc = SQLITE_OK;
131667 if( rc==SQLITE_OK && nToken>1 && pTab->bFts4 ){
131687 if( rc==SQLITE_OK ){
131689 for(ii=0; rc==SQLITE_OK && ii<nOr; ii++){
131771 ** This function is a no-op if *pRc is other than SQLITE_OK when it is called.
131816 if( *pRc==SQLITE_OK ){
131844 while( !pLeft->bEof && !pRight->bEof && *pRc==SQLITE_OK ){
131893 assert( *pRc!=SQLITE_OK || pRight->bStart );
131922 ** If *pRc is not SQLITE_OK, or if pExpr is not the root node of a NEAR
131959 if( *pRc==SQLITE_OK
132017 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
132028 if( *pRc==SQLITE_OK ){
132120 ** If *pRc is not SQLITE_OK when this function is called, it immediately
132125 ** 1. *pRc is SQLITE_OK when this function returns, and
132136 if( rc==SQLITE_OK ){
132146 if( rc==SQLITE_OK ){
132156 return (rc==SQLITE_OK && bMiss);
132164 int rc = SQLITE_OK; /* Return Code */
132185 if( rc==SQLITE_OK && (
132200 ** If *pRc is other than SQLITE_OK when this function is called, it is
132209 if( pExpr && *pRc==SQLITE_OK ){
132286 ** SQLITE_OK is returned if the aMI[] array is successfully allocated and
132293 int rc = SQLITE_OK; /* Return code */
132325 while( pCsr->isEof==0 && rc==SQLITE_OK ){
132343 if( rc==SQLITE_OK && pCsr->isEof==0 ){
132358 ** do {...} while( pRoot->iDocid<iDocid && rc==SQLITE_OK );
132364 }while( pRoot->iDocid!=iDocid && rc==SQLITE_OK );
132381 ** If no error occurs, SQLITE_OK is returned and the values for each column
132407 int rc = SQLITE_OK;
132418 if( rc==SQLITE_OK ){
132466 return SQLITE_OK;
132491 if( bOr==0 ) return SQLITE_OK;
132497 int rc = SQLITE_OK;
132500 while( rc==SQLITE_OK && !pExpr->bEof ){
132505 assert( rc!=SQLITE_OK || pPhrase->bIncr==0 );
132506 if( rc!=SQLITE_OK ) return rc;
132514 int rc = SQLITE_OK;
132516 if( rc!=SQLITE_OK ) return rc;
132566 if( pIter==0 ) return SQLITE_OK;
132582 return SQLITE_OK;
132732 if( rc!=SQLITE_OK ) return rc;
132750 return SQLITE_OK;
132773 return SQLITE_OK;
132847 return SQLITE_OK;
132863 return SQLITE_OK;
132879 return SQLITE_OK;
132895 return SQLITE_OK;
132910 if( pCsr->aStat[pCsr->iCol].nDoc>0 ) return SQLITE_OK;
132927 return SQLITE_OK;
132985 rc = SQLITE_OK;
133079 if( rc==SQLITE_OK ){
133083 if( rc==SQLITE_OK ) rc = fts3auxNextMethod(pCursor);
133133 return SQLITE_OK;
133145 return SQLITE_OK;
133149 ** Register the fts3aux module with database connection db. Return SQLITE_OK
133329 assert( rc==SQLITE_OK || pCsr==0 );
133330 if( rc==SQLITE_OK ){
133334 if( rc!=SQLITE_OK ){
133359 ** Return SQLITE_OK if successful, or SQLITE_NOMEM if a memory allocation
133384 if( rc==SQLITE_OK ){
133390 if( rc==SQLITE_OK ){
133426 rc = SQLITE_OK;
133456 ** If successful, SQLITE_OK is returned and *ppExpr set to point at the
133498 if( rc==SQLITE_OK ){
133500 for(ii=0; rc==SQLITE_OK; ii++){
133504 if( rc==SQLITE_OK ){
133555 rc = SQLITE_OK;
133575 ** Returns an SQLite error code. SQLITE_OK if everything works, SQLITE_NOMEM
133658 return SQLITE_OK;
133686 if( rc==SQLITE_OK && !*ppExpr ){ rc = SQLITE_DONE; }
133792 ** If successful, SQLITE_OK is returned, *ppExpr is set to point to the
133808 int rc = SQLITE_OK;
133811 while( rc==SQLITE_OK ){
133816 assert( nByte>0 || (rc!=SQLITE_OK && p==0) );
133817 if( rc==SQLITE_OK ){
133905 assert( rc!=SQLITE_OK || (nByte>0 && nByte<=nIn) );
133915 rc = SQLITE_OK;
133933 if( rc!=SQLITE_OK ){
133947 int rc = SQLITE_OK;
133953 if( rc==SQLITE_OK ){
133964 ** If successful, SQLITE_OK is returned and (*pp) set to point to the
133973 int rc = SQLITE_OK; /* Return code */
133982 if( rc==SQLITE_OK && (eType==FTSQUERY_AND || eType==FTSQUERY_OR) ){
133991 if( rc==SQLITE_OK ){
134014 if( rc!=SQLITE_OK ) break;
134061 if( rc==SQLITE_OK ){
134101 if( rc!=SQLITE_OK ){
134143 return SQLITE_OK;
134149 assert( rc==SQLITE_OK || *ppExpr==0 );
134152 if( rc==SQLITE_OK && sParse.nNest ){
134164 ** of the parsed expression tree and SQLITE_OK is returned. If an error
134200 if( rc==SQLITE_OK && *ppExpr ){
134202 if( rc==SQLITE_OK ){
134207 if( rc!=SQLITE_OK ){
134285 if( rc!=SQLITE_OK ){
134401 assert( rc==SQLITE_NOMEM || rc==SQLITE_OK );
134425 assert( rc==SQLITE_OK || pExpr==0 );
134433 if( rc!=SQLITE_OK && rc!=SQLITE_NOMEM ){
134460 if( rc==SQLITE_OK ){
134926 return SQLITE_OK;
134934 return SQLITE_OK;
134969 return SQLITE_OK;
134980 return SQLITE_OK;
135487 return SQLITE_OK;
135708 assert( rc!=SQLITE_OK || *ppTok );
135709 if( rc!=SQLITE_OK ){
135807 if( SQLITE_OK!=p->xCreate(argc-2, azArg, &pTokenizer) ){
135817 while( SQLITE_OK==p->xNext(pCsr, &zToken, &nToken, &iStart, &iEnd, &iPos) ){
135825 if( SQLITE_OK!=p->xClose(pCsr) ){
135829 if( SQLITE_OK!=p->xDestroy(pTokenizer) ){
135854 if( rc!=SQLITE_OK ){
135877 if( rc!=SQLITE_OK ){
135927 assert( rc==SQLITE_OK );
135936 assert( rc==SQLITE_OK );
135938 assert( rc==SQLITE_OK );
135968 int rc = SQLITE_OK;
135983 if( SQLITE_OK==rc ){
135986 if( SQLITE_OK==rc ){
135990 if( SQLITE_OK==rc ){
135993 if( SQLITE_OK==rc ){
136103 return SQLITE_OK;
136111 return SQLITE_OK;
136146 return SQLITE_OK;
136157 return SQLITE_OK;
136212 return SQLITE_OK;
136336 return SQLITE_OK;
136346 ** array of dequoted strings and SQLITE_OK is returned. The caller is
136356 int rc = SQLITE_OK; /* Return code */
136417 if( rc!=SQLITE_OK ) return rc;
136422 if( rc==SQLITE_OK ){
136432 assert( (rc==SQLITE_OK)==(pMod!=0) );
136433 if( rc==SQLITE_OK ){
136438 if( rc==SQLITE_OK ){
136445 if( rc==SQLITE_OK ){
136470 return SQLITE_OK;
136492 return SQLITE_OK;
136499 return SQLITE_OK;
136516 return SQLITE_OK;
136547 return SQLITE_OK;
136564 if( rc!=SQLITE_OK ){
136566 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
136599 if( rc==SQLITE_OK ){
136605 if( rc!=SQLITE_OK ) return rc;
136646 return SQLITE_OK;
136658 return SQLITE_OK;
136662 ** Register the fts3tok module with database connection db. Return SQLITE_OK
136784 sqlite3_log(SQLITE_OK, "%d-way merge from level %d", nMerge, (int)iAbsLevel);
136855 ** until SegmentReaderNext() returns something other than SQLITE_OK
136978 ** *pp is set to the requested statement handle and SQLITE_OK returned.
137089 int rc = SQLITE_OK;
137110 assert( rc==SQLITE_OK || pStmt==0 );
137117 for(i=0; rc==SQLITE_OK && i<nParam; i++){
137135 if( rc==SQLITE_OK ){
137140 if( rc==SQLITE_OK ) rc = FTS_CORRUPT_VTAB;
137143 rc = SQLITE_OK;
137158 if( rc==SQLITE_OK ){
137164 if( rc==SQLITE_OK ) rc = FTS_CORRUPT_VTAB;
137185 ** Returns SQLITE_OK if the statement is successfully executed, or an
137198 if( rc==SQLITE_OK ){
137221 int rc = SQLITE_OK;
137226 if( rc==SQLITE_OK ){
137277 ** return SQLITE_OK. If an error occurs while preparing the statement,
137308 if( rc==SQLITE_OK ){
137317 if( rc==SQLITE_OK ){
137327 ** Append a single varint to a PendingList buffer. SQLITE_OK is returned
137370 return SQLITE_OK;
137380 ** it is set to SQLITE_OK.
137390 int rc = SQLITE_OK;
137401 if( SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, iDelta)) ){
137409 if( SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, 1))
137410 || SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, iCol))
137420 if( rc==SQLITE_OK ){
137453 int rc = SQLITE_OK;
137469 if( rc==SQLITE_OK ){
137480 ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error code.
137511 return SQLITE_OK;
137515 if( rc!=SQLITE_OK ){
137520 while( SQLITE_OK==rc
137521 && SQLITE_OK==(rc = xNext(pCsr, &zToken, &nToken, &iStart, &iEnd, &iPos))
137541 for(i=1; rc==SQLITE_OK && i<p->nIndex; i++){
137552 return (rc==SQLITE_DONE ? SQLITE_OK : rc);
137578 if( rc!=SQLITE_OK ) return rc;
137582 return SQLITE_OK;
137622 if( rc!=SQLITE_OK ){
137628 return SQLITE_OK;
137662 return SQLITE_OK;
137674 if( rc==SQLITE_OK && p->zLanguageid ){
137680 if( rc!=SQLITE_OK ) return rc;
137700 if( rc!=SQLITE_OK ) return rc;
137720 int rc = SQLITE_OK; /* Return code */
137767 if( rc==SQLITE_OK ){
137772 for(i=1; rc==SQLITE_OK && i<=p->nColumn; i++){
137780 if( rc!=SQLITE_OK ){
137812 ** If successful, *piIdx is set to the allocated index slot and SQLITE_OK
137831 if( rc==SQLITE_OK ){
137841 if( rc==SQLITE_OK ){
137872 ** an SQLite error code is returned. Otherwise, SQLITE_OK is returned. If
137910 if( rc==SQLITE_OK ){
137924 if( rc!=SQLITE_OK ){
137957 if( rc==SQLITE_OK ){
137970 int rc = SQLITE_OK;
137974 while( pReader->pBlob && rc==SQLITE_OK
137996 ** segment. If successful, SQLITE_OK is returned. If there is no next term,
138030 return SQLITE_OK;
138039 return SQLITE_OK;
138046 if( rc!=SQLITE_OK ) return rc;
138058 if( rc!=SQLITE_OK ) return rc;
138081 if( rc!=SQLITE_OK ) return rc;
138099 return SQLITE_OK;
138107 int rc = SQLITE_OK;
138120 if( rc==SQLITE_OK ){
138144 int rc = SQLITE_OK;
138187 if( rc!=SQLITE_OK ) return rc;
138211 if( rc==SQLITE_OK ){
138223 return SQLITE_OK;
138235 int rc = SQLITE_OK;
138241 for(ii=0; rc==SQLITE_OK && ii<pMsr->nSegment; ii++){
138250 if( rc!=SQLITE_OK ) break;
138319 return SQLITE_OK;
138372 int rc = SQLITE_OK; /* Return Code */
138588 if( rc==SQLITE_OK ){
138599 ** *pnMax to this value and return SQLITE_OK. Otherwise, if an error occurs,
138608 if( rc==SQLITE_OK ){
138634 if( rc==SQLITE_OK ){
138744 return SQLITE_OK;
138809 ** If successful, SQLITE_OK is returned and output variable *piLast is
138824 int rc = SQLITE_OK;
138836 for(pIter=pTree->pLeftmost; pIter && rc==SQLITE_OK; pIter=pIter->pRight){
138844 if( rc==SQLITE_OK ){
138881 ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error code.
138915 if( rc!=SQLITE_OK ) return rc;
138921 if( rc!=SQLITE_OK ) return rc;
138940 if( rc!=SQLITE_OK ) return rc;
138957 if( rc!=SQLITE_OK ) return rc;
139016 return SQLITE_OK;
139022 ** to the segment using fts3SegWriterAdd(). If successful, SQLITE_OK is
139040 if( rc==SQLITE_OK ){
139044 if( rc==SQLITE_OK ){
139077 ** document pRowid, or false otherwise, and SQLITE_OK is returned. If an
139086 rc = SQLITE_OK;
139089 if( rc==SQLITE_OK ){
139105 ** Return SQLITE_OK if successful, or an SQLite error code if not.
139124 if( rc!=SQLITE_OK ) return rc;
139139 ** iAbsLevel is indeed the largest level, or 0 otherwise, and SQLITE_OK
139153 if( rc!=SQLITE_OK ) return rc;
139175 int rc = SQLITE_OK; /* Return code */
139179 if( rc==SQLITE_OK ){
139201 ** SQLITE_OK is returned if successful, otherwise an SQLite error code.
139211 int rc = SQLITE_OK; /* Return Code */
139215 for(i=0; rc==SQLITE_OK && i<nReader; i++){
139218 if( rc!=SQLITE_OK ){
139225 if( rc==SQLITE_OK ){
139233 if( rc==SQLITE_OK ){
139240 if( rc==SQLITE_OK ){
139302 ** If successful, return SQLITE_OK. Otherwise, if an OOM error is encountered
139319 return SQLITE_OK;
139337 return SQLITE_OK;
139356 while( rc==SQLITE_OK
139364 if( rc!=SQLITE_OK ) return rc;
139369 if( rc!=SQLITE_OK ) return rc;
139387 return SQLITE_OK;
139410 if( rc!=SQLITE_OK ) return rc;
139419 return SQLITE_OK;
139450 if( rc!=SQLITE_OK ) return rc;
139464 if( rc!=SQLITE_OK ) return rc;
139471 return SQLITE_OK;
139502 return SQLITE_OK;
139510 int rc = SQLITE_OK;
139526 if( pCsr->nSegment==0 ) return SQLITE_OK;
139542 if( rc!=SQLITE_OK ) return rc;
139547 /* If all the seg-readers are at EOF, we're finished. return SQLITE_OK. */
139548 assert( rc==SQLITE_OK );
139592 if( rc==SQLITE_OK ) rc = SQLITE_ROW;
139678 }while( rc==SQLITE_OK );
139749 int rc = SQLITE_OK;
139754 if( rc==SQLITE_OK ){
139787 if( rc==SQLITE_OK ){
139790 if( rc==SQLITE_OK ){
139794 if( rc==SQLITE_OK ){
139812 if( rc!=SQLITE_OK ){
139818 if( rc==SQLITE_OK ){
139823 if( rc==SQLITE_OK ){
139843 ** Otherwise, if successful, SQLITE_OK is returned. If an error occurs,
139869 if( rc!=SQLITE_OK || csr.nSegment==0 ) goto finished;
139873 if( rc!=SQLITE_OK ) goto finished;
139898 if( rc!=SQLITE_OK ) goto finished;
139909 while( SQLITE_OK==rc ){
139915 if( rc!=SQLITE_OK ) goto finished;
139922 if( rc!=SQLITE_OK ) goto finished;
139926 if( rc==SQLITE_OK ){
139944 int rc = SQLITE_OK;
139947 for(i=0; rc==SQLITE_OK && i<p->nIndex; i++){
139949 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
139956 if( rc==SQLITE_OK && p->bHasStat
139961 if( rc==SQLITE_OK ){
140098 if( rc!=SQLITE_OK ){
140141 if( rc==SQLITE_OK ){
140147 for(i=0; rc==SQLITE_OK && i<p->nIndex; i++){
140151 rc = SQLITE_OK;
140156 if( rc==SQLITE_OK ) rc = rc2;
140162 return (rc==SQLITE_OK && bReturnDone && bSeenDone) ? SQLITE_DONE : rc;
140179 if( rc==SQLITE_OK ){
140195 if( rc==SQLITE_OK ){
140207 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
140212 for(iCol=0; rc==SQLITE_OK && iCol<p->nColumn; iCol++){
140222 if( rc!=SQLITE_OK ){
140239 if( rc==SQLITE_OK ){
140276 if( rc==SQLITE_OK ){
140281 for(i=0; rc==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW && i<nSeg; i++){
140293 if( rc==SQLITE_OK ) rc = rc2;
140363 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
140372 if( *pRc==SQLITE_OK && nMin>pBlob->nAlloc ){
140389 ** Otherwise return SQLITE_OK. If there is no next entry on the node
140398 int rc = SQLITE_OK; /* Return code */
140412 if( rc==SQLITE_OK ){
140439 ** If successful, SQLITE_OK is returned and the NodeReader object set to
140482 int rc = SQLITE_OK;
140504 if( rc==SQLITE_OK ){
140512 if( rc==SQLITE_OK ){
140538 if( rc!=SQLITE_OK || iNextPtr==0 ) return rc;
140568 ** returned. Otherwise, SQLITE_OK.
140578 int rc = SQLITE_OK; /* Return code */
140589 if( rc!=SQLITE_OK ) return rc;
140611 return SQLITE_OK;
140618 ** Return SQLITE_OK if successful, or an SQLite error code otherwise.
140629 int rc = SQLITE_OK; /* Return code */
140662 if( rc==SQLITE_OK ){
140679 if( rc==SQLITE_OK ){
140697 ** If *pRc is not SQLITE_OK when this function is called, then no attempt
140701 ** Otherwise, if *pRc is initially SQLITE_OK and an error occurs while
140749 if( rc==SQLITE_OK ){
140762 if( pNode->block.n>0 && rc==SQLITE_OK ){
140770 if( rc==SQLITE_OK ){
140827 if( rc==SQLITE_OK ){
140864 if( rc==SQLITE_OK ){
140894 if( rc==SQLITE_OK && bAppendable ){
140899 if( rc==SQLITE_OK ){
140902 rc==SQLITE_OK && reader.aNode;
140915 if( rc==SQLITE_OK && bAppendable ){
140935 if( rc==SQLITE_OK ){
140940 for(i=nHeight; i>=0 && rc==SQLITE_OK; i--){
140945 while( reader.aNode && rc==SQLITE_OK ) rc = nodeReaderNext(&reader);
140947 if( rc==SQLITE_OK ){
140957 if( rc==SQLITE_OK ){
140969 if( rc==SQLITE_OK ) rc = rc2;
140978 ** one before returning SQLITE_OK. Or, if there are no segments at all
140993 if( rc==SQLITE_OK ){
141044 if( rc==SQLITE_OK ){
141052 if( rc!=SQLITE_OK ) return rc;
141056 if( rc==SQLITE_OK ){
141064 if( rc!=SQLITE_OK ) return rc;
141070 if( rc!=SQLITE_OK ) return rc;
141080 return SQLITE_OK;
141103 if( rc==SQLITE_OK ){
141131 if( rc==SQLITE_OK ){
141148 if( rc==SQLITE_OK ) rc = rc2;
141151 if( rc==SQLITE_OK ){
141154 if( rc==SQLITE_OK ){
141160 for(i=0; rc==SQLITE_OK && i<nIdx; i++){
141203 int rc = SQLITE_OK; /* Return code */
141208 if( rc!=SQLITE_OK ) return rc;
141213 rc==SQLITE_OK && reader.aNode;
141226 if( rc!=SQLITE_OK ) break;
141245 ** SQLITE_OK is returned if the segment is updated successfully. Or an
141255 int rc = SQLITE_OK; /* Return code */
141264 if( rc==SQLITE_OK ){
141275 if( rc==SQLITE_OK ) rc = rc2;
141278 while( rc==SQLITE_OK && iBlock ){
141284 if( rc==SQLITE_OK ){
141287 if( rc==SQLITE_OK ){
141294 if( rc==SQLITE_OK && iNewStart ){
141297 if( rc==SQLITE_OK ){
141305 if( rc==SQLITE_OK ){
141308 if( rc==SQLITE_OK ){
141341 int rc = SQLITE_OK;
141343 for(i=pCsr->nSegment-1; i>=0 && rc==SQLITE_OK; i--){
141358 if( rc==SQLITE_OK ){
141373 if( rc==SQLITE_OK && nRem!=pCsr->nSegment ){
141389 if( rc==SQLITE_OK ){
141404 ** table and return SQLITE_OK. Otherwise, if an error occurs, return an
141413 if( rc==SQLITE_OK ){
141421 if( rc==SQLITE_OK ){
141428 if( rc==SQLITE_OK ) rc = rc2;
141435 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
141440 ** If successful, leave *pRc set to SQLITE_OK and return. If an error occurs,
141450 if( *pRc==SQLITE_OK ){
141461 ** If no error occurs, return SQLITE_OK. If the hint blob in *pHint does
141477 return SQLITE_OK;
141509 while( rc==SQLITE_OK && nRem>0 ){
141536 if( rc==SQLITE_OK && hint.n ){
141568 if( rc==SQLITE_OK ){
141580 if( rc==SQLITE_OK ){
141583 if( SQLITE_OK==rc && pCsr->nSegment==nSeg
141584 && SQLITE_OK==(rc = sqlite3Fts3SegReaderStart(p, pCsr, pFilter))
141595 if( rc==SQLITE_OK && pWriter->nLeafEst ){
141599 if( rc==SQLITE_OK ) rc = sqlite3Fts3SegReaderStep(p, pCsr);
141600 if( pWriter->nWork>=nRem && rc==SQLITE_ROW ) rc = SQLITE_OK;
141604 if( rc==SQLITE_OK ){
141627 if( bDirtyHint && rc==SQLITE_OK ){
141680 rc = SQLITE_OK;
141685 if( rc==SQLITE_OK ){
141705 int rc = SQLITE_OK;
141755 ** If successful, the checksum value is returned and *pRc set to SQLITE_OK.
141770 assert( *pRc==SQLITE_OK );
141780 if( rc==SQLITE_OK ){
141784 if( rc==SQLITE_OK ){
141827 ** to true and return SQLITE_OK. Or if the contents do not match, set *pbOk
141834 int rc = SQLITE_OK; /* Return code */
141841 if( rc==SQLITE_OK ){
141844 while( rc==SQLITE_OK && sqlite3_step(pAllLangid)==SQLITE_ROW ){
141852 if( rc==SQLITE_OK ) rc = rc2;
141857 if( rc==SQLITE_OK ){
141870 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
141875 for(iCol=0; rc==SQLITE_OK && iCol<p->nColumn; iCol++){
141882 while( rc==SQLITE_OK ){
141889 if( rc==SQLITE_OK ){
141904 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
141918 ** the FTS index are correct, return SQLITE_OK. Or, if the contents of the
141953 if( rc==SQLITE_OK && bOk==0 ) rc = SQLITE_CORRUPT_VTAB;
141985 rc = SQLITE_OK;
141988 rc = SQLITE_OK;
141991 rc = SQLITE_OK;
142037 int rc = SQLITE_OK; /* Return code */
142050 for(i=0; i<p->nColumn && rc==SQLITE_OK; i++){
142056 while( rc==SQLITE_OK ){
142063 for(pDef=pCsr->pDeferred; pDef && rc==SQLITE_OK; pDef=pDef->pNext){
142075 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
142079 for(pDef=pCsr->pDeferred; pDef && rc==SQLITE_OK; pDef=pDef->pNext){
142102 return SQLITE_OK;
142113 return SQLITE_OK;
142138 return SQLITE_OK;
142153 int rc = SQLITE_OK; /* Return code */
142157 if( bFound && rc==SQLITE_OK ){
142160 if( rc==SQLITE_OK ){
142203 int rc = SQLITE_OK; /* Return Code */
142247 if( rc!=SQLITE_OK ) goto update_out;
142294 if( rc!=SQLITE_OK ){
142306 if( nArg>1 && rc==SQLITE_OK ){
142314 if( rc==SQLITE_OK && (!isRemove || *pRowid!=p->iPrevDocid ) ){
142317 if( rc==SQLITE_OK ){
142345 if( rc==SQLITE_OK ){
142347 if( rc==SQLITE_OK || rc==SQLITE_DONE ){
142349 if( rc2!=SQLITE_OK ) rc = rc2;
142511 if( rc==SQLITE_OK && eType!=FTSQUERY_NOT ){
142526 ** If the callback function returns anything other than SQLITE_OK,
142528 ** Otherwise, SQLITE_OK is returned after a callback has been made for
142546 int rc = SQLITE_OK;
142586 return SQLITE_OK;
142728 assert( rc==SQLITE_OK || pCsr==0 );
142739 assert( rc!=SQLITE_OK || (
142784 if( rc!=SQLITE_OK ){
142836 return SQLITE_OK;
142875 return SQLITE_OK;
142937 if( rc!=SQLITE_OK ){
142940 while( rc==SQLITE_OK && iCurrent<(nSnippet+nDesired) ){
142945 if( rc!=SQLITE_OK && rc!=SQLITE_DONE ){ return rc; }
142955 return SQLITE_OK;
142991 return SQLITE_OK;
142998 if( rc!=SQLITE_OK ){
143002 while( rc==SQLITE_OK ){
143021 if( rc!=SQLITE_OK ){
143044 if( rc==SQLITE_OK && (iPos>0 || iFragment>0) ){
143047 if( rc!=SQLITE_OK || iCurrent<iPos ) continue;
143061 if( rc==SQLITE_OK && isHighlight ) rc = fts3StringAppend(pOut, zOpen, -1);
143062 if( rc==SQLITE_OK ) rc = fts3StringAppend(pOut, &zDoc[iBegin], iFin-iBegin);
143063 if( rc==SQLITE_OK && isHighlight ) rc = fts3StringAppend(pOut, zClose, -1);
143149 int rc = SQLITE_OK;
143154 for(i=0; i<p->nCol && rc==SQLITE_OK; i++){
143180 return SQLITE_OK;
143223 if( rc!=SQLITE_OK ) return rc;
143234 return SQLITE_OK;
143264 return SQLITE_OK;
143294 ** array before returning. SQLITE_OK is returned in this case.
143328 if( rc!=SQLITE_OK ) return rc;
143364 return SQLITE_OK;
143380 ** Return SQLITE_OK if successful, or an SQLite error code if an error
143381 ** occurs. If a value other than SQLITE_OK is returned, the state the
143390 int rc = SQLITE_OK;
143395 for(i=0; rc==SQLITE_OK && zArg[i]; i++){
143420 if( rc==SQLITE_OK ){
143436 if( rc==SQLITE_OK ){
143451 if( rc==SQLITE_OK ){
143461 if( rc!=SQLITE_OK ) break;
143465 if( rc!=SQLITE_OK ) break;
143468 if( rc!=SQLITE_OK ) break;
143493 int rc = SQLITE_OK;
143565 int rc = SQLITE_OK;
143616 if( rc!=SQLITE_OK ){
143637 for(i=0; i<nSnippet && rc==SQLITE_OK; i++){
143645 if( rc!=SQLITE_OK ){
143725 if( rc!=SQLITE_OK ) goto offsets_out;
143777 if( rc!=SQLITE_OK ) goto offsets_out;
143780 while( rc==SQLITE_OK ){
143803 while( rc==SQLITE_OK && iCurrent<iMinPos ){
143806 if( rc==SQLITE_OK ){
143818 rc = SQLITE_OK;
143822 if( rc!=SQLITE_OK ) goto offsets_out;
143829 if( rc!=SQLITE_OK ){
143874 if( rc!=SQLITE_OK ){
143993 return SQLITE_OK;
144062 return SQLITE_OK;
144108 int rc = SQLITE_OK;
144115 for(i=0; rc==SQLITE_OK && i<nArg; i++){
144137 if( rc!=SQLITE_OK ){
144176 return SQLITE_OK;
144187 return SQLITE_OK;
144255 return SQLITE_OK;
145160 int rc2 = SQLITE_OK;
145174 return SQLITE_OK;
145198 if( rc==SQLITE_OK ) rc = rc2;
145217 if( pNode && rc==SQLITE_OK ){
145223 if( rc==SQLITE_OK ){
145270 ** is successful, return SQLITE_OK.
145299 int rc = SQLITE_OK;
145311 if( pNode->iNode==0 && rc==SQLITE_OK ){
145324 int rc = SQLITE_OK;
145335 if( rc==SQLITE_OK ){
145460 return SQLITE_OK;
145483 if( rc==SQLITE_OK ){
145501 rc = SQLITE_OK;
145538 return SQLITE_OK;
145725 return SQLITE_OK;
145741 return SQLITE_OK;
145967 int rc = SQLITE_OK;
146026 return SQLITE_OK;
146034 int rc = SQLITE_OK;
146049 int rc = SQLITE_OK;
146051 if( rc==SQLITE_OK && p ){
146065 int rc = SQLITE_OK;
146069 if( p==0 ) return SQLITE_OK;
146085 return SQLITE_OK;
146091 ** return SQLITE_OK. If there is no such record in the table, set
146092 ** *ppLeaf to 0 and return SQLITE_OK. If an error occurs, set *ppLeaf
146161 return SQLITE_OK;
146176 int rc = SQLITE_OK;
146195 if( rc==SQLITE_OK && pLeaf!=0 ){
146212 if( rc==SQLITE_OK && argc>0 ){
146232 if( rc!=SQLITE_OK ){
146248 if( rc==SQLITE_OK ){
146317 int rc = SQLITE_OK;
146348 return SQLITE_OK;
146501 for(ii=0; rc==SQLITE_OK && ii<(pRtree->iDepth-iHeight); ii++){
146573 return SQLITE_OK;
146835 return SQLITE_OK;
146867 int rc = SQLITE_OK;
146917 if( rc!=SQLITE_OK ){
146926 if( SQLITE_OK!=(rc = nodeWrite(pRtree, pRight))
146927 || (0==pLeft->iNode && SQLITE_OK!=(rc = nodeWrite(pRtree, pLeft)))
146937 if( rc!=SQLITE_OK ){
146944 if( rc==SQLITE_OK ){
146948 if( rc!=SQLITE_OK ){
146962 if( rc!=SQLITE_OK ){
146970 if( rc!=SQLITE_OK ){
146978 if( rc==SQLITE_OK ){
146982 if( rc==SQLITE_OK ){
147006 int rc = SQLITE_OK;
147008 while( rc==SQLITE_OK && pChild->iNode!=1 && pChild->pParent==0 ){
147009 int rc2 = SQLITE_OK; /* sqlite3_reset() return code */
147028 if( rc==SQLITE_OK ) rc = rc2;
147029 if( rc==SQLITE_OK && !pChild->pParent ) rc = SQLITE_CORRUPT_VTAB;
147047 if( rc==SQLITE_OK ){
147053 if( rc==SQLITE_OK ){
147056 if( rc!=SQLITE_OK ){
147063 if( SQLITE_OK!=(rc = sqlite3_reset(pRtree->pDeleteNode)) ){
147070 if( SQLITE_OK!=(rc = sqlite3_reset(pRtree->pDeleteParent)) ){
147083 return SQLITE_OK;
147088 int rc = SQLITE_OK;
147101 if( rc==SQLITE_OK ){
147117 if( SQLITE_OK!=(rc = fixLeafParent(pRtree, pNode)) ){
147158 int rc = SQLITE_OK;
147210 for(ii=0; rc==SQLITE_OK && ii<(nCell-(RTREE_MINCELLS(pRtree)+1)); ii++){
147221 if( rc==SQLITE_OK ){
147224 for(; rc==SQLITE_OK && ii<nCell; ii++){
147231 if( rc==SQLITE_OK ){
147235 if( rc==SQLITE_OK ){
147255 int rc = SQLITE_OK;
147273 if( rc==SQLITE_OK ){
147286 int rc = SQLITE_OK;
147289 for(ii=0; rc==SQLITE_OK && ii<nCell; ii++){
147298 if( rc==SQLITE_OK ){
147302 if( rc==SQLITE_OK ){
147339 if( rc==SQLITE_OK ){
147344 if( rc==SQLITE_OK ){
147347 if( rc==SQLITE_OK ){
147351 if( rc==SQLITE_OK ){
147357 if( rc==SQLITE_OK ){
147371 if( rc==SQLITE_OK && pRtree->iDepth>0 && NCELL(pRoot)==1 ){
147376 if( rc==SQLITE_OK ){
147380 if( rc==SQLITE_OK ) rc = rc2;
147381 if( rc==SQLITE_OK ){
147390 if( rc==SQLITE_OK ){
147398 if( rc==SQLITE_OK ){
147447 int rc = SQLITE_OK;
147529 if( rc==SQLITE_OK && nData>1 ){
147539 if( rc==SQLITE_OK ){
147542 if( rc==SQLITE_OK ){
147547 if( rc==SQLITE_OK ){
147596 if( rc==SQLITE_OK ){
147600 rc = SQLITE_OK;
147603 if( rc==SQLITE_OK ){
147649 int rc = SQLITE_OK;
147687 if( rc!=SQLITE_OK ){
147703 for(i=0; i<N_STATEMENT && rc==SQLITE_OK; i++){
147720 ** is written to *piVal and SQLITE_OK returned. Otherwise, an SQLite error
147728 if( rc==SQLITE_OK ){
147741 ** to. If successful, pRtree->iNodeSize is populated and SQLITE_OK returned.
147765 if( rc==SQLITE_OK ){
147779 if( rc!=SQLITE_OK ){
147805 int rc = SQLITE_OK;
147851 if( rc==SQLITE_OK ){
147870 }else if( SQLITE_OK!=(rc = sqlite3_declare_vtab(db, zSql)) ){
147877 if( rc==SQLITE_OK ){
147980 if( rc==SQLITE_OK ){
147983 if( rc==SQLITE_OK ){
147991 if( rc==SQLITE_OK ){
148556 if( rc!=SQLITE_OK ){
148591 int rc = SQLITE_OK;
148594 for(i=0; rc==SQLITE_OK && i<(int)(sizeof(scalars)/sizeof(scalars[0])); i++){
148695 return SQLITE_OK;
148704 return SQLITE_OK;
148779 return SQLITE_OK;
148790 return SQLITE_OK;
148855 return SQLITE_OK;
