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
24224 ** a normal expected return code of SQLITE_BUSY or SQLITE_OK
24226 #define IS_LOCK_ERROR(x) ((x != SQLITE_OK) && (x != SQLITE_BUSY))
24749 ** "unix" VFSes. Return SQLITE_OK opon successfully updating the
24766 rc = SQLITE_OK;
24781 rc = SQLITE_OK;
25027 ** SQLITE_OK. The system call failed, and *some* SQLite error should be
25032 return SQLITE_OK;
25581 return SQLITE_OK;
25643 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
25646 int rc = SQLITE_OK;
25795 int rc = SQLITE_OK;
25813 return SQLITE_OK;
25842 ** return SQLITE_OK.
25884 assert( rc==SQLITE_OK );
25898 if( unixFileLock(pFile, &lock) && rc==SQLITE_OK ){
25951 if( rc==SQLITE_OK
25962 if( rc==SQLITE_OK ){
25973 rc==SQLITE_OK ? "ok" : "failed"));
26007 int rc = SQLITE_OK;
26016 return SQLITE_OK;
26157 if( rc==SQLITE_OK ) pFile->eFileLock = eFileLock;
26219 return SQLITE_OK;
26226 int rc = SQLITE_OK;
26273 return SQLITE_OK;
26277 return SQLITE_OK;
26281 return SQLITE_OK;
26326 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
26333 int rc = SQLITE_OK;
26386 int rc = SQLITE_OK;
26400 return SQLITE_OK;
26445 return SQLITE_OK;
26453 return SQLITE_OK;
26472 return SQLITE_OK;
26479 int rc = SQLITE_OK;
26526 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
26529 int rc = SQLITE_OK;
26573 rc = SQLITE_OK;
26611 int rc = SQLITE_OK;
26620 return SQLITE_OK;
26637 rc==SQLITE_OK ? "ok" : "failed"));
26664 return SQLITE_OK;
26670 return SQLITE_OK;
26676 return SQLITE_OK;
26681 return SQLITE_OK;
26689 int rc = SQLITE_OK;
26718 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
26721 int rc = SQLITE_OK;
26790 int rc = SQLITE_OK;
26796 rc = SQLITE_OK;
26832 return SQLITE_OK;
26838 return SQLITE_OK;
26851 return SQLITE_OK;
26867 return SQLITE_OK;
26914 ** Return SQLITE_OK on success, SQLITE_BUSY on failure.
26952 return SQLITE_OK;
26960 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
26963 int rc = SQLITE_OK;
26974 return SQLITE_OK;
26988 if( SQLITE_OK==lrc ){
27033 int rc = SQLITE_OK;
27050 return SQLITE_OK;
27079 ** return SQLITE_OK.
27137 } else if( lrc1 != SQLITE_OK ) {
27170 int failed2 = SQLITE_OK;
27192 if( rc==SQLITE_OK ){
27203 rc==SQLITE_OK ? "ok" : "failed"));
27215 int rc = SQLITE_OK;
27231 return SQLITE_OK;
27259 if( rc==SQLITE_OK && (eFileLock==SHARED_LOCK || pInode->nShared>1) ){
27267 if( rc==SQLITE_OK && pFile->eFileLock>=PENDING_LOCK ){
27270 if( rc==SQLITE_OK && pFile->eFileLock>=RESERVED_LOCK && context->reserved ){
27276 if( rc==SQLITE_OK && (eFileLock==SHARED_LOCK || pInode->nShared>1)){
27280 if( rc==SQLITE_OK && eFileLock==NO_LOCK ){
27300 if( rc==SQLITE_OK ){
27310 if( rc==SQLITE_OK ) pFile->eFileLock = eFileLock;
27318 int rc = SQLITE_OK;
27446 ** Read data from a file into a buffer. Return SQLITE_OK if all
27477 return SQLITE_OK;
27490 return SQLITE_OK;
27561 ** Write data from a buffer into a file. Return SQLITE_OK on success
27612 return SQLITE_OK;
27641 return SQLITE_OK;
27730 rc = SQLITE_OK;
27770 ** SQLITE_OK is returned. If an error occurs, either SQLITE_NOMEM
27784 ** a no-op, replace it with a stub that returns SQLITE_OK but leaves
27787 ** If SQLITE_OK is returned, the caller is responsible for closing
27805 return (fd>=0?SQLITE_OK:unixLogError(SQLITE_CANTOPEN_BKPT, "open", zDirname));
27858 if( rc==SQLITE_OK && dirfd>=0 ){
27862 rc = SQLITE_OK;
27915 return SQLITE_OK;
27943 return SQLITE_OK;
28020 return SQLITE_OK;
28050 return SQLITE_OK;
28054 return SQLITE_OK;
28058 return SQLITE_OK;
28069 SQLITE_OK;
28073 return SQLITE_OK;
28077 return SQLITE_OK;
28085 return SQLITE_OK;
28089 return SQLITE_OK;
28094 int rc = SQLITE_OK;
28117 return SQLITE_OK;
28361 int rc = SQLITE_OK; /* Result code form fcntl() */
28381 rc = (rc!=(-1)) ? SQLITE_OK : SQLITE_BUSY;
28389 if( rc==SQLITE_OK ){
28587 rc = SQLITE_OK;
28588 if( unixShmSystemLock(pShmNode, F_WRLCK, UNIX_SHM_DMS, 1)==SQLITE_OK ){
28593 if( rc==SQLITE_OK ){
28620 return SQLITE_OK;
28640 ** separate process), then *pp is set to NULL and SQLITE_OK returned. If
28647 ** memory and SQLITE_OK returned.
28659 int rc = SQLITE_OK;
28666 if( rc!=SQLITE_OK ) return rc;
28699 ** false, exit early. *pp will be set to NULL and SQLITE_OK returned.
28773 if( pShmNode->isReadonly && rc==SQLITE_OK ) rc = SQLITE_READONLY;
28796 int rc = SQLITE_OK; /* Result code */
28828 rc = SQLITE_OK;
28832 if( rc==SQLITE_OK ){
28852 if( rc==SQLITE_OK ){
28856 rc = SQLITE_OK;
28861 if( rc==SQLITE_OK ){
28878 if( rc==SQLITE_OK ){
28880 if( rc==SQLITE_OK ){
28924 if( p==0 ) return SQLITE_OK;
28952 return SQLITE_OK;
29055 unixLogError(SQLITE_OK, zErr, pFd->zPath);
29078 ** SQLITE_OK is returned if no error occurs (even if the mapping is not
29087 if( pFd->nFetchOut>0 ) return SQLITE_OK;
29092 if( rc!=SQLITE_OK ){
29109 return SQLITE_OK;
29117 ** If such a pointer can be obtained, store it in *pp and return SQLITE_OK.
29118 ** Or, if one cannot but no error occurs, set *pp to 0 and return SQLITE_OK.
29135 if( rc!=SQLITE_OK ) return rc;
29143 return SQLITE_OK;
29181 return SQLITE_OK;
29489 int rc = SQLITE_OK;
29550 if( rc!=SQLITE_OK ){
29593 if( rc!=SQLITE_OK ){
29627 if( (rc==SQLITE_OK) && (pNew->pInode->pSem==NULL) ){
29646 if( rc!=SQLITE_OK ){
29653 if( rc!=SQLITE_OK ){
29733 return SQLITE_OK;
29805 ** to create new files with. If no error occurs, then SQLITE_OK is returned
29831 int rc = SQLITE_OK; /* Return Code */
29855 if( nDb==0 || zPath[nDb]!='-' ) return SQLITE_OK;
29913 int rc = SQLITE_OK; /* Function Return Code */
30004 if( rc!=SQLITE_OK ){
30029 if( rc!=SQLITE_OK ){
30138 if( rc==SQLITE_OK ){
30140 if( rc!=SQLITE_OK ){
30157 if( rc!=SQLITE_OK ){
30173 int rc = SQLITE_OK;
30192 if( rc==SQLITE_OK ){
30203 rc = SQLITE_OK;
30250 return SQLITE_OK;
30291 return SQLITE_OK;
30444 ** On success, return SQLITE_OK. Return SQLITE_ERROR if the time and date
30449 int rc = SQLITE_OK;
30719 return SQLITE_OK;
30772 int rc = SQLITE_OK;
30797 if( proxyCreateLockPath(path) == SQLITE_OK ){
30836 if( rc==SQLITE_OK ){
30838 return SQLITE_OK;
30885 return SQLITE_OK;
30964 int rc = SQLITE_OK;
31019 rc = SQLITE_OK;
31043 return SQLITE_OK;
31051 int rc = SQLITE_OK;
31067 if( rc!=SQLITE_OK ){
31149 if( rc==SQLITE_OK ){
31167 if( rc==SQLITE_OK && createConch ){
31199 if( rc==SQLITE_OK && pFile->openFlags ){
31214 if( rc==SQLITE_OK && !pCtx->lockProxy ){
31217 if( rc!=SQLITE_OK && rc!=SQLITE_NOMEM && tryOldLockPath ){
31226 if( rc==SQLITE_OK ){
31237 if( rc==SQLITE_OK ){
31249 rc==SQLITE_OK?"ok":"failed"));
31260 int rc = SQLITE_OK; /* Subroutine return code */
31274 (rc==SQLITE_OK ? "ok" : "failed")));
31281 ** Make *pConchPath point to the new name. Return SQLITE_OK on success
31319 return SQLITE_OK;
31329 int rc = SQLITE_OK;
31338 return SQLITE_OK;
31381 return SQLITE_OK;
31396 int rc = SQLITE_OK;
31418 if( rc==SQLITE_OK ){
31438 rc = SQLITE_OK;
31442 if( rc==SQLITE_OK && lockPath ){
31446 if( rc==SQLITE_OK ){
31452 if( rc==SQLITE_OK ){
31470 (rc==SQLITE_OK ? "ok" : "failed")));
31494 return SQLITE_OK;
31498 int rc = SQLITE_OK;
31506 rc = SQLITE_OK;
31517 rc = SQLITE_OK;
31547 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
31552 if( rc==SQLITE_OK ){
31591 if( rc==SQLITE_OK ){
31615 if( rc==SQLITE_OK ){
31637 int rc = SQLITE_OK;
31665 return SQLITE_OK;
31780 return SQLITE_OK;
31791 return SQLITE_OK;
33069 ** "win32" VFSes. Return SQLITE_OK opon successfully updating the
33086 rc = SQLITE_OK;
33101 rc = SQLITE_OK;
33153 ** compact it. Upon success, SQLITE_OK will be returned. Upon failure, one
33159 int rc = SQLITE_OK;
33223 assert( rc!=SQLITE_OK || winMemGetHeap()!=NULL );
33224 assert( rc!=SQLITE_OK || winMemGetOwned() );
33225 assert( rc!=SQLITE_OK || sqlite3_memory_used()==0 );
33497 return SQLITE_OK;
33702 ** SQLITE_OK if successful.
33729 return SQLITE_OK;
33842 assert( errcode!=SQLITE_OK );
34079 return SQLITE_OK;
34361 OSTRACE(("SEEK file=%p, rc=SQLITE_OK\n", pFile->h));
34382 OSTRACE(("SEEK file=%p, rc=SQLITE_OK\n", pFile->h));
34443 return rc ? SQLITE_OK
34449 ** Read data from a file into a buffer. Return SQLITE_OK if all
34479 OSTRACE(("READ-MMAP file=%p, rc=SQLITE_OK\n", pFile->h));
34480 return SQLITE_OK;
34519 OSTRACE(("READ file=%p, rc=SQLITE_OK\n", pFile->h));
34520 return SQLITE_OK;
34524 ** Write data from a buffer into a file. Return SQLITE_OK on success
34551 OSTRACE(("WRITE-MMAP file=%p, rc=SQLITE_OK\n", pFile->h));
34552 return SQLITE_OK;
34624 OSTRACE(("WRITE file=%p, rc=SQLITE_OK\n", pFile->h));
34625 return SQLITE_OK;
34633 int rc = SQLITE_OK; /* Return code for this function */
34732 OSTRACE(("SYNC-NOP file=%p, rc=SQLITE_OK\n", pFile->h));
34733 return SQLITE_OK;
34738 OSTRACE(("SYNC file=%p, rc=SQLITE_OK\n", pFile->h));
34739 return SQLITE_OK;
34754 int rc = SQLITE_OK;
34913 int rc = SQLITE_OK; /* Return code from subroutines */
34929 OSTRACE(("LOCK-HELD file=%p, rc=SQLITE_OK\n", pFile->h));
34930 return SQLITE_OK;
35032 rc = SQLITE_OK;
35070 OSTRACE(("TEST-WR-LOCK file=%p, pResOut=%p, *pResOut=%d, rc=SQLITE_OK\n",
35072 return SQLITE_OK;
35089 int rc = SQLITE_OK;
35149 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
35150 return SQLITE_OK;
35154 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
35155 return SQLITE_OK;
35159 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
35160 return SQLITE_OK;
35166 if( rc==SQLITE_OK ){
35177 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
35178 return SQLITE_OK;
35182 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
35183 return SQLITE_OK;
35187 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
35188 return SQLITE_OK;
35192 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
35193 return SQLITE_OK;
35207 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
35208 return SQLITE_OK;
35216 OSTRACE(("FCNTL oldFile=%p, newFile=%p, rc=SQLITE_OK\n",
35218 return SQLITE_OK;
35224 if( rc==SQLITE_OK ){
35233 int rc = SQLITE_OK;
35425 rc = SQLITE_OK;
35551 if( SQLITE_OK!=rc ){
35558 if( winShmSystemLock(pShmNode, _SHM_WRLCK, WIN_SHM_DMS, 1)==SQLITE_OK ){
35560 if( rc!=SQLITE_OK ){
35565 if( rc==SQLITE_OK ){
35592 return SQLITE_OK;
35619 if( p==0 ) return SQLITE_OK;
35643 return SQLITE_OK;
35659 int rc = SQLITE_OK; /* Result code */
35687 rc = SQLITE_OK;
35691 if( rc==SQLITE_OK ){
35711 if( rc==SQLITE_OK ){
35715 rc = SQLITE_OK;
35720 if( rc==SQLITE_OK ){
35737 if( rc==SQLITE_OK ){
35739 if( rc==SQLITE_OK ){
35777 ** separate process), then *pp is set to NULL and SQLITE_OK returned. If
35784 ** memory and SQLITE_OK returned.
35796 int rc = SQLITE_OK;
35800 if( rc!=SQLITE_OK ) return rc;
35820 if( rc!=SQLITE_OK ){
35828 ** zero, exit early. *pp will be set to NULL and SQLITE_OK returned.
35835 if( rc!=SQLITE_OK ){
35955 OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, rc=SQLITE_OK\n",
35957 return SQLITE_OK;
35972 ** SQLITE_OK is returned if no error occurs (even if the mapping is not
35984 if( pFd->nFetchOut>0 ) return SQLITE_OK;
36030 return SQLITE_OK;
36048 return SQLITE_OK;
36055 OSTRACE(("MAP-FILE pid=%lu, pFile=%p, rc=SQLITE_OK\n",
36057 return SQLITE_OK;
36065 ** If such a pointer can be obtained, store it in *pp and return SQLITE_OK.
36066 ** Or, if one cannot but no error occurs, set *pp to 0 and return SQLITE_OK.
36086 if( rc!=SQLITE_OK ){
36099 OSTRACE(("FETCH pid=%lu, pFile=%p, pp=%p, *pp=%p, rc=SQLITE_OK\n",
36101 return SQLITE_OK;
36142 OSTRACE(("UNFETCH pid=%lu, pFile=%p, rc=SQLITE_OK\n",
36144 return SQLITE_OK;
36474 OSTRACE(("TEMP-FILENAME name=%s, rc=SQLITE_OK\n", zBuf));
36475 return SQLITE_OK;
36536 int rc = SQLITE_OK; /* Function Return Code */
36601 if( rc!=SQLITE_OK ){
36749 && (rc = winceCreateLock(zName, pFile))!=SQLITE_OK
36858 rc = SQLITE_OK; /* Deleted OK. */
36886 rc = SQLITE_OK; /* Deleted OK. */
36978 OSTRACE(("ACCESS name=%s, pResOut=%p, *pResOut=%d, rc=SQLITE_OK\n",
36980 return SQLITE_OK;
37096 return SQLITE_OK;
37115 return SQLITE_OK;
37145 return SQLITE_OK;
37206 return SQLITE_OK;
37228 if( winFullPathname(pVfs, zFilename, nFull, zFull)!=SQLITE_OK ){
37354 ** On success, return SQLITE_OK. Return SQLITE_ERROR if the time and date
37392 return SQLITE_OK;
37520 return SQLITE_OK;
37530 return SQLITE_OK;
37702 if( p==0 ) return SQLITE_OK;
37717 return SQLITE_OK;
37733 if( p->u.aHash[h]==i ) return SQLITE_OK;
37762 return SQLITE_OK;
38189 return SQLITE_OK;
38238 if( rc!=SQLITE_OK && rc!=SQLITE_BUSY ){
38272 return (pPgHdr==0 && eCreate) ? SQLITE_NOMEM : SQLITE_OK;
39002 return (p->apHash ? SQLITE_OK : SQLITE_NOMEM);
39123 return SQLITE_OK;
40598 ** * The Pager.errCode variable is set to something other than SQLITE_OK.
41089 # define pagerOpenWalIfPresent(z) SQLITE_OK
41090 # define pagerBeginReadTransaction(z) SQLITE_OK
41154 assert( pPager->errCode==SQLITE_OK );
41159 assert( pPager->errCode==SQLITE_OK );
41166 assert( pPager->errCode==SQLITE_OK );
41178 assert( pPager->errCode==SQLITE_OK );
41197 assert( pPager->errCode==SQLITE_OK );
41209 assert( pPager->errCode==SQLITE_OK );
41222 assert( pPager->errCode!=SQLITE_OK );
41314 ** that is read in *pRes. Return SQLITE_OK if everything worked, or an
41322 if( rc==SQLITE_OK ){
41335 ** Write a 32-bit integer into the given file descriptor. Return SQLITE_OK
41354 int rc = SQLITE_OK;
41361 rc = pPager->noLock ? SQLITE_OK : sqlite3OsUnlock(pPager->fd, eLock);
41381 int rc = SQLITE_OK;
41385 rc = pPager->noLock ? SQLITE_OK : sqlite3OsLock(pPager->fd, eLock);
41386 if( rc==SQLITE_OK && (pPager->eLock!=UNKNOWN_LOCK||eLock==EXCLUSIVE_LOCK) ){
41498 ** zMaster[0] is set to 0 and SQLITE_OK returned.
41512 if( SQLITE_OK!=(rc = sqlite3OsFileSize(pJrnl, &szJ))
41514 || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-16, &len))
41517 || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-12, &cksum))
41518 || SQLITE_OK!=(rc = sqlite3OsRead(pJrnl, aMagic, 8, szJ-8))
41520 || SQLITE_OK!=(rc = sqlite3OsRead(pJrnl, zMaster, len, szJ-16-len))
41532 ** definitely roll back, so just return SQLITE_OK and report a (nul)
41539 return SQLITE_OK;
41588 ** Otherwise, return SQLITE_OK.
41591 int rc = SQLITE_OK; /* Return code */
41603 if( rc==SQLITE_OK && !pPager->noSync ){
41613 if( rc==SQLITE_OK && iLimit>0 ){
41616 if( rc==SQLITE_OK && sz>iLimit ){
41640 int rc = SQLITE_OK; /* Return code */
41730 for(nWrite=0; rc==SQLITE_OK&&nWrite<JOURNAL_HDR_SZ(pPager); nWrite+=nHeader){
41750 ** is set to the value read from the journal header. SQLITE_OK is returned
41799 if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+8, pNRec))
41800 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+12, &pPager->cksumInit))
41801 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+16, pDbSize))
41811 if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+20, &iSectorSize))
41812 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+24, &iPageSize))
41847 testcase( rc!=SQLITE_OK );
41896 return SQLITE_OK;
41938 if( SQLITE_OK==(rc = sqlite3OsFileSize(pPager->jfd, &jrnlSize))
41990 ** bitvecs of all open savepoints. Return SQLITE_OK if successful
41995 int rc = SQLITE_OK; /* Result code */
42002 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
42067 if( rc!=SQLITE_OK && pPager->eState==PAGER_ERROR ){
42090 pPager->errCode = SQLITE_OK;
42120 assert( rc==SQLITE_OK || !MEMDB );
42123 pPager->errCode==SQLITE_OK ||
42179 ** SQLITE_OK is returned if no error occurs. If an error occurs during
42189 int rc = SQLITE_OK; /* Error code from journal finalization operation */
42190 int rc2 = SQLITE_OK; /* Error code from db file unlock operation */
42208 return SQLITE_OK;
42222 rc = SQLITE_OK;
42273 assert( rc2==SQLITE_OK );
42274 }else if( rc==SQLITE_OK && bCommit && pPager->dbFileSize>pPager->dbSize ){
42285 if( rc==SQLITE_OK && bCommit && isOpen(pPager->fd) ){
42287 if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
42299 return (rc==SQLITE_OK?rc2:rc);
42389 ** skipped and SQLITE_OK is returned.
42398 ** and played back, then SQLITE_OK is returned. If an IO error occurs
42455 if( rc!=SQLITE_OK ) return rc;
42457 if( rc!=SQLITE_OK ) return rc;
42470 return SQLITE_OK;
42483 if( pDone && (rc = sqlite3BitvecSet(pDone, pgno))!=SQLITE_OK ){
42584 if( rc!=SQLITE_OK ) return rc;
42673 ** occur, SQLITE_OK is returned.
42702 if( rc!=SQLITE_OK ) goto delmaster_out;
42710 if( rc!=SQLITE_OK ) goto delmaster_out;
42719 if( rc!=SQLITE_OK ) goto delmaster_out;
42726 if( rc!=SQLITE_OK ){
42737 if( rc!=SQLITE_OK ){
42743 if( rc!=SQLITE_OK ){
42787 ** If successful, return SQLITE_OK. If an IO error occurs while modifying
42791 int rc = SQLITE_OK;
42804 if( rc==SQLITE_OK && currentSize!=newSize ){
42814 if( rc==SQLITE_OK ){
42920 ** is then deleted and SQLITE_OK returned, just as if no corruption had
42950 if( rc!=SQLITE_OK ){
42967 if( rc==SQLITE_OK && zMaster[0] ){
42971 if( rc!=SQLITE_OK || !res ){
42988 if( rc!=SQLITE_OK ){
42990 rc = SQLITE_OK;
43029 if( rc!=SQLITE_OK ){
43044 if( rc==SQLITE_OK ){
43056 rc = SQLITE_OK;
43095 if( rc==SQLITE_OK ){
43098 testcase( rc!=SQLITE_OK );
43100 if( rc==SQLITE_OK
43105 if( rc==SQLITE_OK ){
43107 testcase( rc!=SQLITE_OK );
43109 if( rc==SQLITE_OK && zMaster[0] && res ){
43114 testcase( rc!=SQLITE_OK );
43139 ** Otherwise, SQLITE_OK is returned.
43144 int rc = SQLITE_OK; /* Return code */
43160 rc = SQLITE_OK;
43228 ** return an SQLite error code. Otherwise, SQLITE_OK.
43231 int rc = SQLITE_OK;
43243 if( rc==SQLITE_OK ){
43246 if( rc==SQLITE_OK ){
43283 while( pList && rc==SQLITE_OK ){
43347 if( rc==SQLITE_OK && pPager->pBackup ){
43387 if( rc!=SQLITE_OK || changed ){
43401 ** If no error occurs, SQLITE_OK is returned and the size of the database
43429 if( rc!=SQLITE_OK ){
43445 return SQLITE_OK;
43459 ** Return SQLITE_OK or an error code.
43468 int rc = SQLITE_OK;
43480 if( rc==SQLITE_IOERR_DELETE_NOENT ) rc = SQLITE_OK;
43487 if( rc==SQLITE_OK ){
43539 int rc = SQLITE_OK; /* Return code */
43581 while( rc==SQLITE_OK && pPager->journalOff<iHdrOff ){
43594 while( rc==SQLITE_OK && pPager->journalOff<szJ ){
43611 for(ii=0; rc==SQLITE_OK && ii<nJRec && pPager->journalOff<szJ; ii++){
43616 assert( rc!=SQLITE_OK || pPager->journalOff>=szJ );
43629 for(ii=pSavepoint->iSubRec; rc==SQLITE_OK && ii<pPager->nSubRec; ii++){
43637 if( rc==SQLITE_OK ){
43773 ** Write the file descriptor into *pFile. Return SQLITE_OK on success
43799 assert( rc!=SQLITE_OK || isOpen(pFile) );
43863 ** In all other cases, SQLITE_OK is returned.
43871 int rc = SQLITE_OK;
43895 if( rc==SQLITE_OK ){
43900 if( rc==SQLITE_OK ){
43911 if( rc==SQLITE_OK ){
43979 ** zeroed and SQLITE_OK returned. The rationale for this is that this
43988 int rc = SQLITE_OK;
44002 rc = SQLITE_OK;
44025 ** (returning SQLITE_OK immediately).
44032 ** Return SQLITE_OK on success and an error code if we cannot obtain
44128 ** If everything goes as planned, SQLITE_OK is returned. Otherwise,
44132 int rc = SQLITE_OK;
44136 if( rc==SQLITE_OK ){
44146 ** and return SQLITE_OK. Otherwise, return an SQLite error code and set
44187 return SQLITE_OK;
44281 return SQLITE_OK;
44332 ** page currently held in memory before returning SQLITE_OK. If an IO
44345 if( rc!=SQLITE_OK ) return rc;
44385 if( rc==SQLITE_OK && 0==memcmp(aMagic, aJournalMagic, 8) ){
44389 if( rc!=SQLITE_OK && rc!=SQLITE_IOERR_SHORT_READ ){
44408 if( rc!=SQLITE_OK ) return rc;
44414 if( rc!=SQLITE_OK ) return rc;
44422 if( rc!=SQLITE_OK ) return rc;
44429 if( rc!=SQLITE_OK ) return rc;
44443 return SQLITE_OK;
44474 ** If everything is successful, SQLITE_OK is returned. If an IO error
44479 int rc = SQLITE_OK; /* Return code */
44487 ** is not possible for rc to be other than SQLITE_OK if this branch
44491 assert( pPager->tempFile && rc==SQLITE_OK );
44498 assert( rc!=SQLITE_OK || isOpen(pPager->fd) );
44499 if( rc==SQLITE_OK
44508 while( rc==SQLITE_OK && pList ){
44565 ** SQLITE_OK is returned if everything goes according to plan. An
44570 int rc = SQLITE_OK;
44589 ** This function returns SQLITE_OK if everything is successful, an IO
44595 int rc = SQLITE_OK;
44611 if( rc==SQLITE_OK ){
44619 if( rc==SQLITE_OK ){
44624 if( rc==SQLITE_OK ){
44646 ** SQLITE_OK returned. If an IO error occurs while trying to make the
44648 ** made clean for some other reason, but no error occurs, then SQLITE_OK
44653 int rc = SQLITE_OK;
44674 if( NEVER(pPager->errCode) ) return SQLITE_OK;
44682 return SQLITE_OK;
44691 if( rc==SQLITE_OK ){
44731 rc==SQLITE_OK && pPg->pgno>pPager->dbSize && subjRequiresPage(pPg)
44737 if( rc==SQLITE_OK ){
44744 if( rc==SQLITE_OK ){
44777 ** successfully, SQLITE_OK is returned and *ppPager set to point to
44794 int rc = SQLITE_OK; /* Return code */
44857 if( rc==SQLITE_OK && nPathname+8>pVfs->mxPathname ){
44866 if( rc!=SQLITE_OK ){
44944 if( rc==SQLITE_OK ){
44999 if( rc==SQLITE_OK ){
45002 testcase( rc!=SQLITE_OK );
45008 if( rc!=SQLITE_OK ){
45074 return SQLITE_OK;
45079 ** under the pager. Return SQLITE_OK if the database is still were it ought
45087 if( pPager->tempFile ) return SQLITE_OK;
45088 if( pPager->dbSize==0 ) return SQLITE_OK;
45095 rc = SQLITE_OK;
45096 }else if( rc==SQLITE_OK && bHasMoved ){
45118 ** just deleted using OsDelete, *pExists is set to 0 and SQLITE_OK
45129 ** SQLITE_OK returned. If no hot-journal file is present, *pExists is
45130 ** set to 0 and SQLITE_OK returned. If an IO error occurs while trying
45136 int rc = SQLITE_OK; /* Return code */
45152 if( rc==SQLITE_OK && exists ){
45164 if( rc==SQLITE_OK && !locked ){
45168 if( rc==SQLITE_OK ){
45179 if( pagerLockDb(pPager, RESERVED_LOCK)==SQLITE_OK ){
45195 if( rc==SQLITE_OK ){
45199 rc = SQLITE_OK;
45216 rc = SQLITE_OK;
45249 ** If everything is successful, SQLITE_OK is returned. If an IO error
45254 int rc = SQLITE_OK; /* Return code */
45272 if( rc!=SQLITE_OK ){
45283 if( rc!=SQLITE_OK ){
45308 if( rc!=SQLITE_OK ){
45330 if( rc==SQLITE_OK && bExists ){
45335 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
45336 if( rc==SQLITE_OK && fout&SQLITE_OPEN_READONLY ){
45352 assert( rc==SQLITE_OK );
45354 if( rc==SQLITE_OK ){
45362 if( rc!=SQLITE_OK ){
45419 if( rc!=SQLITE_OK && rc!=SQLITE_IOERR_SHORT_READ ){
45446 assert( pPager->pWal==0 || rc==SQLITE_OK );
45451 assert( rc==SQLITE_OK );
45455 if( pPager->eState==PAGER_OPEN && rc==SQLITE_OK ){
45460 if( rc!=SQLITE_OK ){
45487 ** successfully obtained, it is copied to *ppPage and SQLITE_OK returned.
45540 int rc = SQLITE_OK;
45566 if( pPager->errCode!=SQLITE_OK ){
45572 if( rc!=SQLITE_OK ) goto pager_acquire_err;
45582 if( rc==SQLITE_OK && pData ){
45592 assert( rc==SQLITE_OK );
45594 return SQLITE_OK;
45597 if( rc!=SQLITE_OK ){
45605 if( rc!=SQLITE_OK ){
45620 return SQLITE_OK;
45662 if( rc!=SQLITE_OK ) goto pager_acquire_err;
45667 if( rc!=SQLITE_OK ){
45674 return SQLITE_OK;
45677 assert( rc!=SQLITE_OK );
45749 ** Return SQLITE_OK if everything is successful. Otherwise, return
45754 int rc = SQLITE_OK; /* Return code */
45787 SQLITE_OK ){
45797 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
45804 if( rc==SQLITE_OK ){
45814 if( rc!=SQLITE_OK ){
45843 int rc = SQLITE_OK;
45858 if( rc!=SQLITE_OK ){
45877 if( rc==SQLITE_OK && exFlag ){
45882 if( rc==SQLITE_OK ){
45899 assert( rc==SQLITE_OK || pPager->eState==PAGER_READER );
45900 assert( rc!=SQLITE_OK || pPager->eState==PAGER_WRITER_LOCKED );
45917 int rc = SQLITE_OK;
45945 if( rc!=SQLITE_OK ) return rc;
45989 if( rc!=SQLITE_OK ) return rc;
45991 if( rc!=SQLITE_OK ) return rc;
45993 if( rc!=SQLITE_OK ) return rc;
46007 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
46009 if( rc!=SQLITE_OK ){
46045 ** this routine returns SQLITE_OK.
46053 ** as appropriate. Otherwise, SQLITE_OK.
46056 int rc = SQLITE_OK;
46100 for(ii=0; ii<nPage && rc==SQLITE_OK; ii++){
46106 if( rc==SQLITE_OK ){
46128 if( rc==SQLITE_OK && needSync ){
46205 int rc = SQLITE_OK;
46237 assert( pPgHdr==0 || rc==SQLITE_OK );
46242 ** above is always successful - hence the ALWAYS on rc==SQLITE_OK.
46244 if( !DIRECT_MODE && ALWAYS(rc==SQLITE_OK) ){
46248 if( rc==SQLITE_OK ){
46257 if( rc==SQLITE_OK ){
46261 if( rc==SQLITE_OK ){
46285 ** function returns SQLITE_OK. Otherwise, an IO error code is returned.
46288 int rc = SQLITE_OK;
46293 if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
46295 if( rc==SQLITE_OK && !pPager->noSync ){
46309 ** successful, or the connection is in WAL mode, SQLITE_OK is returned.
46314 int rc = SQLITE_OK;
46357 int rc = SQLITE_OK; /* Return code */
46373 if( pPager->eState<PAGER_WRITER_CACHEMOD ) return SQLITE_OK;
46392 assert( rc==SQLITE_OK );
46397 if( rc==SQLITE_OK ){
46444 if( rc==SQLITE_OK ){
46451 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
46458 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
46472 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
46475 if( rc!=SQLITE_OK ){
46491 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
46503 if( rc==SQLITE_OK && !pagerUseWal(pPager) ){
46523 ** moves into the error state. Otherwise, SQLITE_OK is returned.
46526 int rc = SQLITE_OK; /* Return code */
46556 return SQLITE_OK;
46591 int rc = SQLITE_OK; /* Return code */
46600 if( pPager->eState<=PAGER_READER ) return SQLITE_OK;
46606 if( rc==SQLITE_OK ) rc = rc2;
46623 assert( pPager->eState==PAGER_READER || rc!=SQLITE_OK );
46624 assert( rc==SQLITE_OK || rc==SQLITE_FULL || rc==SQLITE_CORRUPT
46729 ** returned. Otherwise, SQLITE_OK.
46732 int rc = SQLITE_OK; /* Return code */
46808 ** savepoint. If no errors occur, SQLITE_OK is returned.
46816 if( rc==SQLITE_OK && iSavepoint<pPager->nSavepoint ){
46837 assert( rc==SQLITE_OK );
46969 ** occurs. Otherwise, it returns SQLITE_OK.
47011 && SQLITE_OK!=(rc = subjournalPage(pPg))
47084 SQLITE_OK ){
47096 return SQLITE_OK;
47225 int rc = SQLITE_OK;
47232 assert( rc==SQLITE_OK );
47235 if( rc==SQLITE_OK ){
47238 if( rc==SQLITE_OK && state==PAGER_READER ){
47313 int rc = SQLITE_OK;
47346 if( rc!=SQLITE_OK ){
47362 int rc = SQLITE_OK;
47379 if( rc==SQLITE_OK ){
47398 ** return SQLITE_OK. If an error occurs or the VFS used by the pager does
47403 ** the WAL file is already open, set *pbOpen to 1 and return SQLITE_OK
47410 int rc = SQLITE_OK; /* Return code */
47425 if( rc==SQLITE_OK ){
47446 int rc = SQLITE_OK;
47457 if( rc==SQLITE_OK ){
47462 if( rc==SQLITE_OK && logexists ){
47470 if( rc==SQLITE_OK && pPager->pWal ){
47472 if( rc==SQLITE_OK ){
48015 ** page and SQLITE_OK is returned. If an error (an OOM or VFS error) occurs,
48019 int rc = SQLITE_OK;
48047 rc = SQLITE_OK;
48053 assert( iPage==0 || *ppPage || rc!=SQLITE_OK );
48277 if( pWal->exclusiveMode ) return SQLITE_OK;
48282 VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && rc!=SQLITE_BUSY); )
48293 if( pWal->exclusiveMode ) return SQLITE_OK;
48298 VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && rc!=SQLITE_BUSY); )
48348 assert( rc==SQLITE_OK || iHash>0 );
48350 if( rc==SQLITE_OK ){
48482 if( rc==SQLITE_OK ){
48588 if( rc!=SQLITE_OK ){
48606 if( rc!=SQLITE_OK ){
48665 if( rc!=SQLITE_OK ) break;
48669 if( rc!=SQLITE_OK ) break;
48687 if( rc==SQLITE_OK ){
48749 ** If the log file is successfully opened, SQLITE_OK is returned and
48800 if( rc==SQLITE_OK && flags&SQLITE_OPEN_READONLY ){
48804 if( rc!=SQLITE_OK ){
49016 ** return SQLITE_OK. Otherwise, return an error code. If this routine
49029 int rc = SQLITE_OK; /* Return Code */
49059 for(i=0; rc==SQLITE_OK && i<nSegment; i++){
49065 if( rc==SQLITE_OK ){
49091 if( rc!=SQLITE_OK ){
49180 if( pInfo->nBackfill>=pWal->hdr.mxFrame ) return SQLITE_OK;
49184 if( rc!=SQLITE_OK ){
49203 if( rc==SQLITE_OK ){
49216 && (rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_READ_LOCK(0), 1))==SQLITE_OK
49229 if( rc==SQLITE_OK ){
49232 if( rc==SQLITE_OK && nSize<nReq ){
49239 while( rc==SQLITE_OK && 0==walIteratorNext(pIter, &iDbpage, &iFrame) ){
49246 if( rc!=SQLITE_OK ) break;
49250 if( rc!=SQLITE_OK ) break;
49254 if( rc==SQLITE_OK ){
49259 if( rc==SQLITE_OK && sync_flags ){
49263 if( rc==SQLITE_OK ){
49275 rc = SQLITE_OK;
49283 if( rc==SQLITE_OK && eMode!=SQLITE_CHECKPOINT_PASSIVE ){
49290 if( rc==SQLITE_OK ){
49310 if( rx==SQLITE_OK && (sz > nMax ) ){
49328 int rc = SQLITE_OK;
49341 if( rc==SQLITE_OK ){
49348 if( rc==SQLITE_OK ){
49355 ** fsyned (rc==SQLITE_OK) and if we are not in persistent-wal
49360 ** completed and fsynced (rc==SQLITE_OK) and we are in persistent
49456 ** If the wal-index header is successfully read, return SQLITE_OK.
49469 if( rc!=SQLITE_OK ){
49487 if( SQLITE_OK==(rc = walLockShared(pWal, WAL_WRITE_LOCK)) ){
49491 }else if( SQLITE_OK==(rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1)) ){
49493 if( SQLITE_OK==(rc = walIndexPage(pWal, 0, &page0)) ){
49531 ** On success return SQLITE_OK. On a permanent failure (such an
49581 int rc = SQLITE_OK; /* Return code */
49632 }else if( SQLITE_OK==(rc = walLockShared(pWal, WAL_RECOVER_LOCK)) ){
49639 if( rc!=SQLITE_OK ){
49651 if( rc==SQLITE_OK ){
49670 return SQLITE_OK;
49698 if( rc==SQLITE_OK ){
49775 testcase( rc==SQLITE_OK );
49796 ** Return SQLITE_OK if successful, or an error code if an error occurs. If an
49819 return SQLITE_OK;
49856 if( rc!=SQLITE_OK ){
49890 return SQLITE_OK;
49895 ** (which is nOut bytes in size). Return SQLITE_OK if successful, or an
49982 return SQLITE_OK;
49991 ** other than SQLITE_OK, it is not invoked again and the error code is
49995 ** function returns SQLITE_OK.
49998 int rc = SQLITE_OK;
50009 ALWAYS(rc==SQLITE_OK) && iFrame<=iMax;
50028 assert( rc==SQLITE_OK );
50053 int rc = SQLITE_OK;
50086 ** SQLITE_OK is returned if no error is encountered (regardless of whether
50091 int rc = SQLITE_OK;
50101 if( rc==SQLITE_OK ){
50139 testcase( rc==SQLITE_OK );
50250 if( SQLITE_OK!=(rc = walRestartLog(pWal)) ){
50281 if( rc!=SQLITE_OK ){
50368 for(p=pList; p && rc==SQLITE_OK; p=p->pDirty){
50372 while( rc==SQLITE_OK && nExtra>0 ){
50378 if( rc==SQLITE_OK ){
50449 if( rc==SQLITE_OK ){
50453 rc = SQLITE_OK;
50458 if( rc==SQLITE_OK ){
50466 if( rc==SQLITE_OK ){
50474 if( rc==SQLITE_OK || rc==SQLITE_BUSY ){
50495 return (rc==SQLITE_OK && eMode!=eMode2 ? SQLITE_BUSY : rc);
50553 SQLITE_OK ){
51370 if( sqlite3_mutex_try(p->pBt->mutex)==SQLITE_OK ){
51650 return SQLITE_OK;
51666 #define querySharedCacheTableLock(a,b,c) SQLITE_OK
51667 #define setSharedCacheTableLock(a,b,c) SQLITE_OK
51797 ** SQLITE_OK if the lock may be obtained (by calling
51818 return SQLITE_OK;
51850 return SQLITE_OK;
51867 ** already been called and returned SQLITE_OK).
51869 ** SQLITE_OK is returned if the lock is added successfully. SQLITE_NOMEM
51890 assert( SQLITE_OK==querySharedCacheTableLock(p, iTable, eLock) );
51923 return SQLITE_OK;
52096 int rc = SQLITE_OK;
52104 if( rc==SQLITE_OK && pgno<=sqlite3BitvecSize(pBt->pHasContent) ){
52159 assert( rc==SQLITE_OK ); /* KeySize() cannot fail */
52171 if( rc==SQLITE_OK ){
52182 if( rc==SQLITE_OK ){
52204 if( SQLITE_OK!=rc ){
52213 return SQLITE_OK;
52280 if( rc==SQLITE_OK ){
52294 SQLITE_OK)
52317 return SQLITE_OK;
52329 return SQLITE_OK;
52362 ** If *pRC is initially non-zero (non-SQLITE_OK) then this routine is
52386 if( rc!=SQLITE_OK ){
52401 if( rc==SQLITE_OK ){
52416 ** An error code is returned if something goes wrong, otherwise SQLITE_OK.
52446 return SQLITE_OK;
52451 #define ptrmapGet(w,x,y,z) SQLITE_OK
52740 return SQLITE_OK;
52746 ** of the first byte of allocated space. Return either SQLITE_OK or
52817 return SQLITE_OK;
52844 return SQLITE_OK;
52933 return SQLITE_OK;
52971 return SQLITE_OK;
52977 ** Return SQLITE_OK on success. If we see that the page does
52979 ** SQLITE_CORRUPT. Note that a return of SQLITE_OK does not
53088 return SQLITE_OK;
53166 return SQLITE_OK;
53219 if( rc==SQLITE_OK && (*ppPage)->isInit==0 ){
53221 if( rc!=SQLITE_OK ){
53317 int rc = SQLITE_OK; /* Result code from this function */
53449 if( rc==SQLITE_OK ){
53453 if( rc!=SQLITE_OK ){
53554 if( rc!=SQLITE_OK ){
53670 sqlite3BtreeRollback(p, SQLITE_OK);
53702 return SQLITE_OK;
53726 return SQLITE_OK;
53740 return SQLITE_OK;
53762 return SQLITE_OK;
53802 int rc = SQLITE_OK;
53910 int rc = SQLITE_OK;
53950 ** SQLITE_OK is returned on success. If the file is not a
53965 if( rc!=SQLITE_OK ) return rc;
53967 if( rc!=SQLITE_OK ) return rc;
54003 ** return SQLITE_OK and return without populating BtShared.pPage1.
54012 if( rc!=SQLITE_OK ){
54016 return SQLITE_OK;
54043 ** zero and return SQLITE_OK. The caller will call this function
54094 return SQLITE_OK;
54158 return SQLITE_OK;
54187 return SQLITE_OK;
54192 ** consisting of a single page and no schema objects). Return SQLITE_OK
54242 int rc = SQLITE_OK;
54291 if( SQLITE_OK!=rc ) goto trans_begun;
54297 ** lockBtree() returns something other than SQLITE_OK. lockBtree()
54298 ** may return SQLITE_OK but leave pBt->pPage1 set to 0 if after
54303 while( pBt->pPage1==0 && SQLITE_OK==(rc = lockBtree(pBt)) );
54305 if( rc==SQLITE_OK && wrflag ){
54310 if( rc==SQLITE_OK ){
54316 if( rc!=SQLITE_OK ){
54322 if( rc==SQLITE_OK ){
54355 if( rc==SQLITE_OK ){
54364 if( rc==SQLITE_OK && wrflag ){
54394 if( rc!=SQLITE_OK ){
54481 return SQLITE_OK;
54516 if( rc!=SQLITE_OK ){
54531 if( rc!=SQLITE_OK ){
54538 if( rc!=SQLITE_OK ){
54550 if( rc!=SQLITE_OK ){
54554 if( rc!=SQLITE_OK ){
54560 if( rc==SQLITE_OK ){
54572 ** SQLITE_OK. If there is no work to do (and therefore no point in
54604 if( rc!=SQLITE_OK ){
54621 if( rc!=SQLITE_OK ){
54634 if( rc!=SQLITE_OK ){
54652 if( rc!=SQLITE_OK ){
54662 if( rc!=SQLITE_OK ){
54675 return SQLITE_OK;
54707 ** SQLITE_OK is returned. Otherwise an SQLite error code.
54726 if( rc==SQLITE_OK ){
54730 if( rc==SQLITE_OK ){
54746 ** If SQLITE_OK is returned, then *pnTrunc is set to the number of pages
54752 int rc = SQLITE_OK;
54780 for(iFree=nOrig; iFree>nFin && rc==SQLITE_OK; iFree--){
54783 if( (rc==SQLITE_DONE || rc==SQLITE_OK) && nFree>0 ){
54791 if( rc!=SQLITE_OK ){
54801 # define setChildPtrmaps(x) SQLITE_OK
54831 int rc = SQLITE_OK;
54838 if( rc!=SQLITE_OK ){
54921 if( p->inTrans==TRANS_NONE ) return SQLITE_OK;
54934 if( rc!=SQLITE_OK && bCleanup==0 ){
54944 return SQLITE_OK;
54954 if( rc==SQLITE_OK ){
55010 if( tripCode==SQLITE_OK ){
55013 rc = SQLITE_OK;
55025 if( rc2!=SQLITE_OK ){
55032 if( btreeGetPage(pBt, 1, &pPage1, 0)==SQLITE_OK ){
55100 int rc = SQLITE_OK;
55107 if( rc==SQLITE_OK ){
55203 return SQLITE_OK;
55270 return SQLITE_OK;
55343 ** This routine cannot fail. It always returns SQLITE_OK.
55354 return SQLITE_OK;
55365 ** Failure is not possible. This function always returns SQLITE_OK.
55374 return SQLITE_OK;
55404 int rc = SQLITE_OK;
55427 if( rc==SQLITE_OK && eType==PTRMAP_OVERFLOW2 && pgno==ovfl ){
55436 if( rc==SQLITE_OK ){
55438 assert( rc==SQLITE_OK || pPage==0 );
55439 if( rc==SQLITE_OK ){
55450 return (rc==SQLITE_DONE ? SQLITE_OK : rc);
55462 ** SQLITE_OK is returned on success, otherwise an error code.
55474 if( rc!=SQLITE_OK ){
55482 return SQLITE_OK;
55523 int rc = SQLITE_OK;
55566 if( rc==SQLITE_OK && amt>0 ){
55593 if( rc==SQLITE_OK ){
55609 for( ; rc==SQLITE_OK && amt>0 && nextPage; iIdx++){
55682 if( rc==SQLITE_OK ){
55696 if( rc==SQLITE_OK && amt>0 ){
55710 ** Return SQLITE_OK on success or an error code if anything goes
55727 ** Return SQLITE_OK on success or an error code if anything goes
55742 if( rc==SQLITE_OK ){
55841 return SQLITE_OK;
55921 int rc = SQLITE_OK;
55929 assert( pCur->skipNext!=SQLITE_OK );
55939 return SQLITE_OK;
55943 if( rc!=SQLITE_OK ){
55994 int rc = SQLITE_OK;
55999 while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
56019 int rc = SQLITE_OK;
56024 while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
56029 if( rc==SQLITE_OK ){
56037 /* Move the cursor to the first entry in the table. Return SQLITE_OK
56047 if( rc==SQLITE_OK ){
56060 /* Move the cursor to the last entry in the table. Return SQLITE_OK
56082 return SQLITE_OK;
56086 if( rc==SQLITE_OK ){
56094 if( rc==SQLITE_OK ){
56155 return SQLITE_OK;
56159 return SQLITE_OK;
56184 return SQLITE_OK;
56232 rc = SQLITE_OK;
56297 rc = SQLITE_OK;
56313 rc = SQLITE_OK;
56375 if( rc!=SQLITE_OK ){
56381 return SQLITE_OK;
56389 return SQLITE_OK;
56423 return SQLITE_OK;
56432 rc = SQLITE_OK;
56438 return SQLITE_OK;
56472 if( rc!=SQLITE_OK ){
56479 return SQLITE_OK;
56487 return SQLITE_OK;
56508 return SQLITE_OK;
56520 rc = SQLITE_OK;
56535 ** SQLITE_OK is returned on success. Any other return value indicates
56670 if( rc!=SQLITE_OK ){
56688 if( rc!=SQLITE_OK ){
56692 if( rc!=SQLITE_OK ){
56768 if( rc==SQLITE_OK ){
56770 if( rc!=SQLITE_OK ){
56816 if( rc==SQLITE_OK ){
56832 if( rc!=SQLITE_OK ){
56843 if( rc==SQLITE_OK ){
56853 assert( rc!=SQLITE_OK || sqlite3PagerIswriteable((*ppPage)->pDbPage) );
56926 if( rc!=SQLITE_OK ){
56952 if( rc==SQLITE_OK ){
56971 if( pPage==0 && SQLITE_OK!=(rc = btreeGetPage(pBt, iPage, &pPage, 0)) ){
56975 if( rc!=SQLITE_OK ){
56992 if( (*pRC)==SQLITE_OK ){
57011 return SQLITE_OK; /* No overflow pages. Return without doing anything */
57059 return SQLITE_OK;
57161 if( pBt->autoVacuum && rc==SQLITE_OK ){
57221 return SQLITE_OK;
57328 if( rc!=SQLITE_OK ){
57464 if( rc==SQLITE_OK ){
57586 if( (*pRC)==SQLITE_OK ){
57612 if( rc!=SQLITE_OK ){
57683 int rc = SQLITE_OK; /* The return code */
58016 if( rc!=SQLITE_OK ){
58138 if( rc!=SQLITE_OK ) goto balance_cleanup;
58319 ** page and SQLITE_OK is returned. In this case the caller is required
58337 if( rc==SQLITE_OK ){
58367 return SQLITE_OK;
58381 int rc = SQLITE_OK;
58402 if( rc==SQLITE_OK ){
58418 if( rc==SQLITE_OK ){
58484 }while( rc==SQLITE_OK );
58534 assert( pCur->skipNext!=SQLITE_OK );
58621 assert( rc!=SQLITE_OK || pPage->nCell>0 || pPage->nOverflow>0 );
58644 if( rc==SQLITE_OK && pPage->nOverflow ){
58765 if( rc==SQLITE_OK && pCur->iPage>iCellDepth ){
58772 if( rc==SQLITE_OK ){
58838 if( rc!=SQLITE_OK ){
58857 if( rc!=SQLITE_OK ){
58863 if( rc!=SQLITE_OK ){
58870 if( rc!=SQLITE_OK ){
58880 if( rc!=SQLITE_OK ){
58884 if( rc!=SQLITE_OK ){
58888 if( rc!=SQLITE_OK ){
58929 return SQLITE_OK;
59011 if( SQLITE_OK==rc ){
59097 if( rc!=SQLITE_OK ){
59108 if( rc!=SQLITE_OK ){
59113 if( rc!=SQLITE_OK ){
59120 if( rc!=SQLITE_OK ){
59181 assert( SQLITE_OK==querySharedCacheTableLock(p, MASTER_ROOT, READ_LOCK) );
59212 if( rc==SQLITE_OK ){
59231 ** SQLITE_OK is returned if the operation is successfully executed.
59241 return SQLITE_OK;
59248 while( rc==SQLITE_OK ){
59268 ** If all pages in the tree have been visited, return SQLITE_OK to the
59276 return SQLITE_OK;
59398 if( rc!=SQLITE_OK ){
59873 int rc = SQLITE_OK;
59937 ** sqlite_master table. Otherwise SQLITE_OK.
59944 assert( rc==SQLITE_OK || rc==SQLITE_LOCKED_SHAREDCACHE );
59957 int rc = SQLITE_OK;
59966 if( rc==SQLITE_OK ){
59993 if( rc!=SQLITE_OK ){
60007 ** saveAllCursors can only return SQLITE_OK.
60010 assert( rc==SQLITE_OK );
60057 if( rc==SQLITE_OK ){
60061 if( rc==SQLITE_OK ){
60063 if( rc==SQLITE_OK ){
60292 return (rc!=SQLITE_OK && rc!=SQLITE_BUSY && ALWAYS(rc!=SQLITE_LOCKED));
60318 int rc = SQLITE_OK;
60350 if( rc==SQLITE_OK && newPgsz!=nSrcPgsz ) rc = SQLITE_READONLY;
60358 for(iOff=iEnd-(i64)nSrcPgsz; rc==SQLITE_OK && iOff<iEnd; iOff+=nDestPgsz){
60362 if( SQLITE_OK==(rc = sqlite3PagerGet(pDestPager, iDest, &pDestPg))
60363 && SQLITE_OK==(rc = sqlite3PagerWrite(pDestPg))
60393 ** Return SQLITE_OK if everything is successful, or an SQLite error
60399 if( rc==SQLITE_OK && iCurrent>iSize ){
60447 rc = SQLITE_OK;
60451 if( SQLITE_OK==rc && p->bDestLocked==0
60452 && SQLITE_OK==(rc = sqlite3BtreeBeginTrans(p->pDest, 2))
60462 if( rc==SQLITE_OK && 0==sqlite3BtreeIsInReadTrans(p->pSrc) ){
60472 if( SQLITE_OK==rc && destMode==PAGER_JOURNALMODE_WAL && pgszSrc!=pgszDest ){
60487 if( rc==SQLITE_OK ){
60494 if( rc==SQLITE_OK ){
60514 if( rc==SQLITE_OK || rc==SQLITE_DONE ){
60517 if( rc==SQLITE_OK ){
60525 if( rc==SQLITE_OK ){
60583 for(iPg=nDestTruncate; rc==SQLITE_OK && iPg<=(Pgno)nDstPage; iPg++){
60587 if( rc==SQLITE_OK ){
60593 if( rc==SQLITE_OK ){
60601 rc==SQLITE_OK && iOff<iEnd;
60607 if( rc==SQLITE_OK ){
60613 if( rc==SQLITE_OK ){
60618 if( rc==SQLITE_OK ){
60627 if( SQLITE_OK==rc
60628 && SQLITE_OK==(rc = sqlite3BtreeCommitPhaseTwo(p->pDest, 0))
60644 assert( rc2==SQLITE_OK );
60669 if( p==0 ) return SQLITE_OK;
60690 sqlite3BtreeRollback(p->pDest, SQLITE_OK);
60693 rc = (p->rc==SQLITE_DONE) ? SQLITE_OK : p->rc;
60754 if( rc!=SQLITE_OK ){
60801 if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
60824 assert( b.rc!=SQLITE_OK );
60826 if( rc==SQLITE_OK ){
60905 ** SQLITE_OK is returned if the conversion is successful (or not required).
60917 return SQLITE_OK;
60924 /* MemTranslate() may return SQLITE_OK or SQLITE_NOMEM. If NOMEM is returned,
60928 assert(rc==SQLITE_OK || rc==SQLITE_NOMEM);
60929 assert(rc==SQLITE_OK || pMem->enc!=desiredEnc);
60981 return SQLITE_OK;
60990 ** Return SQLITE_OK on success or SQLITE_NOMEM if malloc fails.
61010 return SQLITE_OK;
61038 return SQLITE_OK;
61049 return SQLITE_OK; /* Nothing to do */
61057 return SQLITE_OK;
61074 int rc = SQLITE_OK;
61114 ** Return SQLITE_ERROR if the finalizer reports an error. SQLITE_OK
61118 int rc = SQLITE_OK;
61301 return SQLITE_OK;
61314 return SQLITE_OK;
61339 return SQLITE_OK;
61494 int rc = SQLITE_OK;
61562 return SQLITE_OK;
61622 return SQLITE_OK;
61647 int rc = SQLITE_OK; /* Return code */
61666 }else if( SQLITE_OK==(rc = sqlite3VdbeMemGrow(pMem, amt+2, 0)) ){
61672 if( rc==SQLITE_OK ){
61712 if( sqlite3VdbeMemMakeWriteable(pVal)!=SQLITE_OK ){
61829 int rc = SQLITE_OK;
61833 return SQLITE_OK;
61870 if( SQLITE_OK==sqlite3ValueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal)
62019 int rc = SQLITE_OK;
62041 if( rc==SQLITE_OK ){
62082 ** Unless an error is encountered, SQLITE_OK is returned. It is not an
62115 ** SQLITE_OK. If no value can be extracted, but no other error occurs
62116 ** (e.g. OOM), return SQLITE_OK and set *ppVal to NULL. Or, if an error
62174 return SQLITE_OK;
62355 return (pNew ? SQLITE_OK : SQLITE_NOMEM);
63545 int rc = SQLITE_OK; /* Return code */
63550 assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY || p->rc==SQLITE_NOMEM );
63596 p->rc = SQLITE_OK;
63642 if( j==nSub && SQLITE_OK==sqlite3VdbeMemGrow(pSub, nByte, nSub!=0) ){
63704 p->rc = SQLITE_OK;
63824 p->rc = SQLITE_OK;
64144 int rc = SQLITE_OK;
64149 ** SQLITE_OK so p is not used.
64168 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
64178 if( rc!=SQLITE_OK ){
64202 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
64214 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
64220 if( rc==SQLITE_OK ){
64265 }while( rc==SQLITE_OK && res );
64266 if( rc==SQLITE_OK ){
64273 if( rc!=SQLITE_OK ){
64297 if( rc!=SQLITE_OK ){
64311 && SQLITE_OK!=(rc = sqlite3OsSync(pMaster, SQLITE_SYNC_NORMAL))
64329 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
64337 if( rc!=SQLITE_OK ){
64418 ** Otherwise SQLITE_OK.
64422 int rc = SQLITE_OK;
64438 int rc2 = SQLITE_OK;
64444 if( rc2==SQLITE_OK ){
64447 if( rc==SQLITE_OK ){
64455 if( rc==SQLITE_OK ){
64459 if( rc==SQLITE_OK ){
64479 ** violations, return SQLITE_ERROR. Otherwise, SQLITE_OK.
64496 return SQLITE_OK;
64539 return SQLITE_OK;
64585 if( p->rc==SQLITE_OK ){
64599 if( p->rc==SQLITE_OK || (p->errorAction==OE_Fail && !isSpecialError) ){
64601 if( rc!=SQLITE_OK ){
64617 }else if( rc!=SQLITE_OK ){
64619 sqlite3RollbackAll(db, SQLITE_OK);
64627 sqlite3RollbackAll(db, SQLITE_OK);
64631 if( p->rc==SQLITE_OK || p->errorAction==OE_Fail ){
64645 ** error code is SQLITE_OK or SQLITE_CONSTRAINT, then promote the
64651 if( p->rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT ){
64702 return (p->rc==SQLITE_BUSY ? SQLITE_BUSY : SQLITE_OK);
64708 ** in p->rc. This routine sets that result back to SQLITE_OK.
64711 p->rc = SQLITE_OK;
64745 if( sqlite3GlobalConfig.xSqllog && v->rc==SQLITE_OK && v->zSql && v->pc>=0 ){
64852 int rc = SQLITE_OK;
64989 return SQLITE_OK;
66057 ** Return SQLITE_OK if everything works, or an error code otherwise.
66079 assert( rc==SQLITE_OK ); /* pCur is always valid so KeySize cannot fail */
66121 return SQLITE_OK;
66135 ** or greater than pUnpacked. Return SQLITE_OK on success.
66154 assert( rc==SQLITE_OK ); /* pCur is always valid so KeySize cannot fail */
66168 return SQLITE_OK;
66335 rc = SQLITE_OK;
66359 rc = SQLITE_OK;
66377 int rc = SQLITE_OK;
66613 int rc = SQLITE_OK;
66620 if( db->xWalCallback && nEntry>0 && rc==SQLITE_OK ){
66729 assert( p->rc==SQLITE_OK );
66731 if( p->rc!=SQLITE_OK ){
66768 int rc = SQLITE_OK; /* Result from sqlite3Step() */
66769 int rc2 = SQLITE_OK; /* Result from sqlite3Reprepare() */
66782 && (rc2 = rc = sqlite3Reprepare(v))==SQLITE_OK ){
66787 if( rc2!=SQLITE_OK ){
67286 ** out of range, then SQLITE_RANGE is returned. Othewise SQLITE_OK.
67316 sqlite3Error(p->db, SQLITE_OK, 0);
67332 return SQLITE_OK;
67351 if( rc==SQLITE_OK ){
67355 if( rc==SQLITE_OK && encoding!=0 ){
67385 if( rc==SQLITE_OK ){
67398 if( rc==SQLITE_OK ){
67408 if( rc==SQLITE_OK ){
67468 if( rc==SQLITE_OK ){
67536 return SQLITE_OK;
67550 ** SQLITE_OK is returned.
68134 if( SQLITE_OK==sqlite3VdbeMemGrow(pMem, nByte, 0) ){
68256 if( sqlite3Atoi64(pMem->z, &pMem->u.i, pMem->n, pMem->enc)==SQLITE_OK ){
68516 int rc = SQLITE_OK; /* Value to return */
68544 assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY );
68546 p->rc = SQLITE_OK;
68591 for(pc=p->pc; rc==SQLITE_OK; pc++){
68874 ** or sqlite3_finalize(). For a normal halt, this should be SQLITE_OK (0).
68902 if( pOp->p1==SQLITE_OK && p->pFrame ){
68951 assert( rc==SQLITE_BUSY || rc==SQLITE_OK || rc==SQLITE_ERROR );
68955 assert( rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT );
68956 assert( rc==SQLITE_OK || db->nDeferredCons>0 || db->nDeferredImmCons>0 );
69016 if( SQLITE_OK
69259 if( SQLITE_OK!=(rc = sqlite3VdbeCheckFk(p, 0)) ){
69282 if( NEVER(rc!=SQLITE_OK) ){
70389 assert( rc==SQLITE_OK ); /* True because of CursorMoveto() call above */
70399 assert( rc==SQLITE_OK ); /* DataSize() cannot fail */
70453 if( rc!=SQLITE_OK ){
70525 assert( rc==SQLITE_OK );
70552 if( rc!=SQLITE_OK ){
70827 if( rc!=SQLITE_OK ) goto abort_due_to_error;
70883 if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){
70904 if( rc!=SQLITE_OK ){
70942 if( rc!=SQLITE_OK ) goto abort_due_to_error;
70995 }else if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){
71008 if( p->rc==SQLITE_OK ){
71081 if( rc!=SQLITE_OK ){
71096 if( rc==SQLITE_OK ){
71366 ** sqlite3BtreeCursor() may return is SQLITE_OK. */
71367 assert( rc==SQLITE_OK );
71422 if( rc==SQLITE_OK ){
71425 if( rc==SQLITE_OK ){
71435 if( rc==SQLITE_OK ){
71655 if( rc!=SQLITE_OK ){
71688 if( rc!=SQLITE_OK ){
71702 if( rc!=SQLITE_OK ) goto abort_due_to_error;
71712 if( rc!=SQLITE_OK ) goto abort_due_to_error;
71879 if( rc!=SQLITE_OK ){
72024 if( rc!=SQLITE_OK ){
72032 assert( rc==SQLITE_OK ); /* Cannot fail following BtreeLast() */
72084 0, &res))==SQLITE_OK)
72097 if( rc==SQLITE_OK && res==0 ){
72213 if( rc==SQLITE_OK && db->xUpdateCallback && pOp->p4.z ){
72263 if( NEVER(rc!=SQLITE_OK) ) goto abort_due_to_error;
72269 if( rc==SQLITE_OK && db->xUpdateCallback && pOp->p4.z && pC->isTable ){
72335 assert( rc!=SQLITE_OK || (pOut->flags & MEM_Blob) );
72391 if( NEVER(rc!=SQLITE_OK) ) goto abort_due_to_error;
72396 assert( rc==SQLITE_OK ); /* True because of CursorMoveto() call above */
72403 assert( rc==SQLITE_OK ); /* DataSize() cannot fail */
72465 assert( rc==SQLITE_OK ); /* Always so because of CursorMoveto() above */
72755 if( rc==SQLITE_OK ){
72800 if( rc==SQLITE_OK && res==0 ){
72835 if( rc!=SQLITE_OK ){
72986 if( rc==SQLITE_OK && iMoved!=0 ){
73145 initData.rc = SQLITE_OK;
73148 if( rc==SQLITE_OK ) rc = initData.rc;
73773 rc = SQLITE_OK;
73854 if( rc==SQLITE_OK ){
73867 if( rc==SQLITE_OK ){
73921 rc = SQLITE_OK;
74045 if( SQLITE_OK==rc ){
74122 if( rc==SQLITE_OK ){
74227 if( rc==SQLITE_OK ){
74261 if( rc==SQLITE_OK ){
74329 if( rc==SQLITE_OK && pOp->p1 ){
74335 rc = SQLITE_OK;
74591 ** If successful, SQLITE_OK is returned and subsequent calls to
74637 rc = SQLITE_OK;
74641 if( rc==SQLITE_OK ){
74649 assert( rc!=SQLITE_OK || zErr==0 );
74702 int rc = SQLITE_OK;
74867 if( rc==SQLITE_OK && db->mallocFailed==0 ){
74898 rc = SQLITE_OK;
75005 if( rc!=SQLITE_OK ){
75013 assert( rc==SQLITE_OK || p->pStmt==0 );
75191 ** and return SQLITE_OK. Otherwise, if an error occurs, return an SQLite
75226 if( rc!=SQLITE_OK ) return rc;
75267 if( rc!=SQLITE_OK ) return rc;
75276 return SQLITE_OK;
75300 return SQLITE_OK;
75305 ** Advance iterator pIter to the next key in its PMA. Return SQLITE_OK if
75318 return SQLITE_OK;
75322 if( rc==SQLITE_OK ){
75343 int rc = SQLITE_OK;
75374 if( rc==SQLITE_OK ){
75383 if( rc==SQLITE_OK ){
75394 ** Otherwise, return SQLITE_OK and set *pRes to a negative, zero or positive
75479 return SQLITE_OK;
75509 return SQLITE_OK;
75566 ** set *ppFile to point to the malloc'd file-handle and return SQLITE_OK.
75613 ** Sort the linked list of records headed at pCsr->pRecord. Return SQLITE_OK
75647 return SQLITE_OK;
75674 ** Write nData bytes of data to the file-write object. Return SQLITE_OK
75704 ** Return SQLITE_OK if flushing the buffered data succeeds or is not
75727 ** SQLITE_OK if successful, or an SQLite error code if an error occurs.
75738 ** SQLITE_OK if successful, or an SQLite error code otherwise.
75750 int rc = SQLITE_OK; /* Return code */
75764 if( rc==SQLITE_OK && pSorter->pTemp1==0 ){
75766 assert( rc!=SQLITE_OK || pSorter->pTemp1 );
75771 if( rc==SQLITE_OK ){
75800 int rc = SQLITE_OK; /* Return Code */
75826 if( rc==SQLITE_OK && pSorter->mxPmaSize>0 && (
75837 assert( rc!=SQLITE_OK || (nExpect==pSorter->iWriteOff) );
75852 int rc = SQLITE_OK; /* Return code */
75861 assert( rc!=SQLITE_OK || pSorter->iReadOff<=pSorter->iWriteOff );
75862 if( rc!=SQLITE_OK || pSorter->iReadOff>=pSorter->iWriteOff ) break;
75866 for(i=pSorter->nTree-1; rc==SQLITE_OK && i>0; i--){
75900 if( rc!=SQLITE_OK ) return rc;
75917 rc==SQLITE_OK && iNew*SORTER_MAX_MERGE_COUNT<pSorter->nPMA;
75936 assert( rc!=SQLITE_OK || pSorter->aIter[ pSorter->aTree[1] ].pFile );
75937 if( rc!=SQLITE_OK || pSorter->nPMA<=SORTER_MAX_MERGE_COUNT ){
75947 if( rc==SQLITE_OK ){
75951 while( rc==SQLITE_OK && bEof==0 ){
75960 if( rc==SQLITE_OK ) rc = rc2;
75975 }while( rc==SQLITE_OK );
75994 if( rc==SQLITE_OK ){
76048 rc = SQLITE_OK;
76089 return SQLITE_OK;
76113 return SQLITE_OK;
76168 int rc = SQLITE_OK;
76172 if( rc==SQLITE_OK ){
76178 if( rc!=SQLITE_OK ){
76200 return SQLITE_OK;
76212 int rc = SQLITE_OK;
76233 int rc = SQLITE_OK;
76238 if( rc==SQLITE_OK ){
76255 int rc = SQLITE_OK;
76274 rc = SQLITE_OK;
76283 int rc = SQLITE_OK;
76341 return SQLITE_OK;
76350 return SQLITE_OK;
76479 return SQLITE_OK;
76529 return SQLITE_OK;
76547 return SQLITE_OK;
76555 return SQLITE_OK;
76569 return SQLITE_OK;
76578 return SQLITE_OK;
77513 if( auth!=SQLITE_OK ){
78550 int rc = SQLITE_OK;
81339 v, OP_Halt, SQLITE_OK, OE_Ignore, 0, pExpr->u.zToken,0);
83040 if( SQLITE_OK!=isSystemTable(pParse, pTab->zName) ){
83043 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){ goto
83377 if( SQLITE_OK!=isSystemTable(pParse, pTab->zName) ){
84787 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
85175 if( rc==SQLITE_OK ) initAvgEq(pPrevIdx);
85184 int rc = SQLITE_OK; /* Result codes from subroutines */
85195 if( rc==SQLITE_OK && sqlite3FindTable(db, "sqlite_stat3", zDb) ){
85267 if( rc==SQLITE_OK ){
85321 int rc = SQLITE_OK;
85413 if( rc!=SQLITE_OK ){
85427 }else if( rc==SQLITE_OK ){
85447 if( rc==SQLITE_OK && aNew->zName==0 ){
85453 if( rc==SQLITE_OK ){
85489 if( rc==SQLITE_OK ){
85604 SQLITE_OK!=(rc = resolveAttachExpr(&sName, pFilename)) ||
85605 SQLITE_OK!=(rc = resolveAttachExpr(&sName, pDbname)) ||
85606 SQLITE_OK!=(rc = resolveAttachExpr(&sName, pKey))
85621 if(rc!=SQLITE_OK ){
85920 ** should return either SQLITE_OK, SQLITE_DENY, or SQLITE_IGNORE. If
85921 ** SQLITE_OK is returned, it means that access is allowed. SQLITE_DENY
85940 return SQLITE_OK;
85979 }else if( rc!=SQLITE_IGNORE && rc!=SQLITE_OK ){
86047 ** either SQLITE_OK (zero) or SQLITE_IGNORE or SQLITE_DENY. If SQLITE_DENY
86065 return SQLITE_OK;
86069 return SQLITE_OK;
86075 }else if( rc!=SQLITE_OK && rc!=SQLITE_IGNORE ){
86435 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
86877 return SQLITE_OK;
86963 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
87003 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
87668 ** Resize an Index object to hold N columns total. Return SQLITE_OK
87674 if( pIdx->nColumn>=N ) return SQLITE_OK;
87689 return SQLITE_OK;
88929 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
89022 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
89429 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
89946 if( rc!=SQLITE_OK ){
90214 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
90435 return SQLITE_OK;
90506 return SQLITE_OK;
91153 assert( rcauth==SQLITE_OK || rcauth==SQLITE_DENY || rcauth==SQLITE_IGNORE );
91214 if( rcauth==SQLITE_OK && pWhere==0 && !pTrigger && !IsVirtual(pTab)
93256 assert( rc==SQLITE_NOMEM || rc==SQLITE_OK );
96815 sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_OK, 0);
96862 int rc = SQLITE_OK; /* Return code */
96872 sqlite3Error(db, SQLITE_OK, 0);
96873 while( rc==SQLITE_OK && zSql[0] ){
96879 assert( rc==SQLITE_OK || pStmt==0 );
96880 if( rc!=SQLITE_OK ){
96953 if( rc!=SQLITE_OK && ALWAYS(rc==sqlite3_errcode(db)) && pzErrMsg ){
97863 ** Return SQLITE_OK on success and SQLITE_ERROR if something goes wrong.
98006 return SQLITE_OK;
98047 return SQLITE_OK;
98097 int rc = SQLITE_OK;
98166 if( sqlite3_initialize()==SQLITE_OK )
98800 return SQLITE_OK;
98813 if( db->temp_store==ts ) return SQLITE_OK;
98814 if( invalidateTempStorage( pParse ) != SQLITE_OK ){
98818 return SQLITE_OK;
98977 ** connection. If it returns SQLITE_OK, then assume that the VFS
98986 if( rc==SQLITE_OK ){
99305 if( rc==SQLITE_OK && (eAuto==1 || eAuto==2) ){
99316 { OP_Halt, SQLITE_OK, OE_Abort, 0}, /* 3 */
99413 rc = SQLITE_OK;
99415 if( rc==SQLITE_OK ){
99468 if( rc!=SQLITE_OK || res==0 ){
99518 if( rc!=SQLITE_OK || res==0 ){
99570 if( res!=SQLITE_OK ){
100490 if( zRight && sqlite3DecOrHexToI64(zRight, &N)==SQLITE_OK ){
100520 SQLITE_FCNTL_LOCKSTATE, &j)==SQLITE_OK ){
100670 if( SQLITE_OK!=rc ){
100780 initData.rc = SQLITE_OK;
100799 return SQLITE_OK;
100808 if( rc!=SQLITE_OK ){
100922 if( rc==SQLITE_OK ) rc = initData.rc;
100925 if( rc==SQLITE_OK ){
100934 if( rc==SQLITE_OK || (db->flags&SQLITE_RecoveryMode)){
100944 rc = SQLITE_OK;
100979 rc = SQLITE_OK;
100981 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
100994 if( rc==SQLITE_OK && ALWAYS(db->nDb>1)
101004 if( rc==SQLITE_OK && commit_internal ){
101016 int rc = SQLITE_OK;
101022 if( rc!=SQLITE_OK ){
101056 if( rc!=SQLITE_OK ) return;
101134 int rc = SQLITE_OK; /* Result code */
101215 if( pParse->rc==SQLITE_DONE ) pParse->rc = SQLITE_OK;
101228 if( rc==SQLITE_OK && pParse->pVdbe && pParse->explain ){
101254 if( pParse->pVdbe && (rc!=SQLITE_OK || db->mallocFailed) ){
101307 assert( rc==SQLITE_OK || *ppStmt==0 );
101314 ** If the statement is successfully recompiled, return SQLITE_OK. Otherwise,
101344 return SQLITE_OK;
101365 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
101377 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
101400 int rc = SQLITE_OK;
101451 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
101463 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
102990 ** Return SQLITE_OK on success. If a memory allocation error occurs,
103082 return SQLITE_OK;
103530 int rc = SQLITE_OK; /* Success code from a subroutine */
103628 testcase( rc!=SQLITE_OK );
103701 testcase( rc!=SQLITE_OK );
103785 testcase( rc!=SQLITE_OK );
104427 return SQLITE_OK;
105106 ** pFrom->pIndex and return SQLITE_OK.
105124 return SQLITE_OK;
105256 ** Whether or not a match is found, SQLITE_OK is returned if no error
105258 ** parser and some error code other than SQLITE_OK returned.
105361 return SQLITE_OK;
106775 if( rc==SQLITE_OK && pDest->eDest==SRT_Output ){
107017 res.rc = SQLITE_OK;
107040 if( rc!=SQLITE_OK ){
107257 if( !zName || SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
107574 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
107959 if( SQLITE_OK==sqlite3ResolveExprNames(&sNC, pWhen)
109022 if( SQLITE_OK!=sqlite3_prepare(db, zSql, -1, &pStmt, 0) ){
109040 if( rc!=SQLITE_OK ) return rc;
109044 if( rc!=SQLITE_OK ){
109096 int rc = SQLITE_OK; /* Return code from service routines */
109157 if( rc!=SQLITE_OK ) goto end_of_vacuum;
109180 if( rc!=SQLITE_OK ) goto end_of_vacuum;
109187 if( rc!=SQLITE_OK ) goto end_of_vacuum;
109189 if( rc!=SQLITE_OK ) goto end_of_vacuum;
109218 if( rc!=SQLITE_OK ) goto end_of_vacuum;
109222 if( rc!=SQLITE_OK ) goto end_of_vacuum;
109226 if( rc!=SQLITE_OK ) goto end_of_vacuum;
109239 if( rc!=SQLITE_OK ) goto end_of_vacuum;
109247 if( rc!=SQLITE_OK ) goto end_of_vacuum;
109253 if( rc!=SQLITE_OK ) goto end_of_vacuum;
109303 if( NEVER(rc!=SQLITE_OK) ) goto end_of_vacuum;
109307 if( rc!=SQLITE_OK ) goto end_of_vacuum;
109309 if( rc!=SQLITE_OK ) goto end_of_vacuum;
109315 assert( rc==SQLITE_OK );
109391 int rc = SQLITE_OK;
109418 if( rc!=SQLITE_OK && xDestroy ) xDestroy(pAux);
109862 if( SQLITE_OK!=rc ){
109941 return SQLITE_OK;
109955 if( rc!=SQLITE_OK ){
109965 ** more v-table. Return SQLITE_NOMEM if a malloc fails, or SQLITE_OK otherwise.
109982 return SQLITE_OK;
110004 int rc = SQLITE_OK;
110028 ** create a valid sqlite3_vtab if it returns SQLITE_OK. */
110029 if( rc==SQLITE_OK && ALWAYS(sqlite3GetVTable(db, pTab)) ){
110031 if( rc==SQLITE_OK ){
110047 int rc = SQLITE_OK;
110067 if( SQLITE_OK==sqlite3RunParser(pParse, zCreateTable, &zErr)
110109 int rc = SQLITE_OK;
110116 assert( rc==SQLITE_OK );
110120 if( rc==SQLITE_OK ){
110162 ** SQLITE_OK if all xSync operations are successful.
110168 int rc = SQLITE_OK;
110172 for(i=0; rc==SQLITE_OK && i<db->nVTrans; i++){
110190 return SQLITE_OK;
110199 return SQLITE_OK;
110211 int rc = SQLITE_OK;
110223 return SQLITE_OK;
110233 return SQLITE_OK;
110240 if( rc==SQLITE_OK ){
110242 if( rc==SQLITE_OK ){
110260 ** If any virtual table method returns an error code other than SQLITE_OK,
110263 ** SQLITE_OK is returned.
110266 int rc = SQLITE_OK;
110272 for(i=0; rc==SQLITE_OK && i<db->nVTrans; i++){
110420 int rc = SQLITE_OK;
110442 if( rc!=SQLITE_OK ) sqlite3Error(db, rc, 0);
112773 if( rc!=SQLITE_OK ){
112805 ** Return SQLITE_OK on success.
112949 ** SQLITE_OK.
112963 int rc = SQLITE_OK;
112977 if( pUpper && rc==SQLITE_OK ){
112985 for(i=0; rc==SQLITE_OK && i<p->nSample; i++){
112987 if( rc==SQLITE_OK && p1 ){
112991 if( rc==SQLITE_OK && p2 ){
113071 int rc = SQLITE_OK;
113131 if( rc==SQLITE_OK && bOk ){
113146 if( rc==SQLITE_OK && bOk ){
113156 if( rc==SQLITE_OK ){
113168 return SQLITE_OK;
113208 ** Write the estimated row count into *pnRow and return SQLITE_OK.
113247 return SQLITE_OK;
113253 if( rc!=SQLITE_OK ) return rc;
113273 ** Write the estimated row count into *pnRow and return SQLITE_OK.
113291 int rc = SQLITE_OK; /* Subfunction return code */
113297 for(i=0; rc==SQLITE_OK && i<pList->nExpr; i++){
113304 if( rc==SQLITE_OK ){
114789 if( p->nLSlot>=n ) return SQLITE_OK;
114797 return SQLITE_OK;
114816 return SQLITE_OK;
115042 return SQLITE_OK;
115059 return SQLITE_OK;
115112 return SQLITE_OK;
115190 int rc = SQLITE_OK; /* Return code */
115237 && (rc = whereLoopResize(db, pNew, pNew->nLTerm+1))==SQLITE_OK
115249 for(; rc==SQLITE_OK && pTerm!=0; pTerm = whereScanNext(&scan)){
115354 if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
115355 if( rc!=SQLITE_OK ) break; /* Jump out of the pTerm loop */
115526 int rc = SQLITE_OK; /* Return code */
115588 for(pTerm=pWC->a; rc==SQLITE_OK && pTerm<pWCEnd; pTerm++){
115617 for(; rc==SQLITE_OK && pProbe; pProbe=pProbe->pNext, iSortIdx++){
115726 int rc = SQLITE_OK;
115878 int rc = SQLITE_OK;
115886 if( pWInfo->wctrlFlags & WHERE_AND_ONLY ) return SQLITE_OK;
115893 for(pTerm=pWC->a; pTerm<pWCEnd && rc==SQLITE_OK; pTerm++){
115929 assert( rc==SQLITE_OK || sCur.n==0 );
115955 for(i=0; rc==SQLITE_OK && i<sSum.n; i++){
115990 int rc = SQLITE_OK;
116009 if( rc==SQLITE_OK ){
116365 ** Return SQLITE_OK on success or SQLITE_NOMEM of a memory allocation
116695 return SQLITE_OK;
121683 pParse->rc = SQLITE_OK;
121731 if( pParse->rc!=SQLITE_OK ){
121739 if( zSql[i]==0 && nErr==0 && pParse->rc==SQLITE_OK ){
121756 if( pParse->rc!=SQLITE_OK && pParse->rc!=SQLITE_DONE && pParse->zErrMsg==0 ){
121803 if( nErr>0 && pParse->rc==SQLITE_OK ){
122308 if( rc!=SQLITE_OK ){
122318 if( sqlite3GlobalConfig.isInit ) return SQLITE_OK;
122343 if( rc==SQLITE_OK ){
122353 if( rc==SQLITE_OK ){
122358 /* If rc is not SQLITE_OK at this point, then either the malloc
122361 if( rc!=SQLITE_OK ){
122387 if( rc==SQLITE_OK ){
122391 if( rc==SQLITE_OK ){
122423 if ( rc==SQLITE_OK ){
122490 return SQLITE_OK;
122504 int rc = SQLITE_OK;
122711 ** Return SQLITE_OK on success.
122771 return SQLITE_OK;
122798 return SQLITE_OK;
122842 rc = SQLITE_OK;
123014 return SQLITE_OK;
123054 return SQLITE_OK;
123101 sqlite3RollbackAll(db, SQLITE_OK);
123167 sqlite3Error(db, SQLITE_OK, 0); /* Deallocates any cached error strings. */
123191 ** Rollback all database files. If tripCode is not SQLITE_OK, then
123249 case SQLITE_OK: zName = "SQLITE_OK"; break;
123354 /* SQLITE_OK */ "not an error",
123478 return SQLITE_OK;
123519 return SQLITE_OK;
123579 if( rc==SQLITE_OK ){
123583 if( rc!=SQLITE_OK ){
123630 return SQLITE_OK;
123675 assert( rc!=SQLITE_OK );
123729 int rc = SQLITE_OK;
123854 return SQLITE_OK;
123880 return SQLITE_OK;
123916 return SQLITE_OK;
123967 ** returned (i.e. SQLITE_IOERR). Otherwise, SQLITE_OK.
123980 int rc = SQLITE_OK; /* Return code */
123988 for(i=0; i<db->nDb && rc==SQLITE_OK; i++){
123995 rc = SQLITE_OK;
124000 return (rc==SQLITE_OK && bBusy) ? SQLITE_BUSY : rc;
124242 sqlite3Error(db, SQLITE_OK, 0);
124243 return SQLITE_OK;
124361 ** If successful, SQLITE_OK is returned. In this case *ppVfs is set to point to
124378 char **pzErrMsg /* OUT: Error message (if rc!=SQLITE_OK) */
124380 int rc = SQLITE_OK;
124571 if( rc!=SQLITE_OK ){
124725 if( rc!=SQLITE_OK ){
124735 if( rc!=SQLITE_OK ){
124763 sqlite3Error(db, SQLITE_OK, 0);
124770 if( rc==SQLITE_OK ){
124773 if( rc!=SQLITE_OK ){
124786 if( !db->mallocFailed && rc==SQLITE_OK ){
124793 if( !db->mallocFailed && rc==SQLITE_OK ){
124799 if( !db->mallocFailed && rc==SQLITE_OK ){
124805 if( !db->mallocFailed && rc==SQLITE_OK){
124839 }else if( rc!=SQLITE_OK ){
124898 if( rc==SQLITE_OK && !DbHasProperty(*ppDb, 0, DB_SchemaLoaded) ){
124960 int rc = SQLITE_OK;
124989 return SQLITE_OK;
125007 return SQLITE_OK;
125017 return SQLITE_OK;
125109 if( SQLITE_OK!=rc ){
125176 if( SQLITE_OK==rc && !pTab ){
125213 return SQLITE_OK;
125235 rc = SQLITE_OK;
125549 ** Return SQLITE_OK if SQLite has been initialized and SQLITE_ERROR if
125605 if( z && sqlite3DecOrHexToI64(z, &v)==SQLITE_OK ){
125796 int rc = SQLITE_OK;
126331 /* TODO(shess) Only used for SQLITE_OK and SQLITE_DONE at this time.
126377 ** This method should return either SQLITE_OK (0), or an SQLite error
126378 ** code. If SQLITE_OK is returned, then *ppTokenizer should be set
126414 ** method should either return SQLITE_OK and set the values of the
127014 # define sqlite3Fts3DeferToken(x,y,z) SQLITE_OK
127015 # define sqlite3Fts3CacheDeferredDoclists(x) SQLITE_OK
127017 # define sqlite3Fts3DeferredTokenList(x,y,z) SQLITE_OK
127354 return SQLITE_OK;
127389 int rc = SQLITE_OK; /* Return code */
127403 ** memory associated with the Fts3Table structure and return SQLITE_OK.
127406 return (rc==SQLITE_OK ? fts3DisconnectMethod(pVtab) : rc);
127420 if( *pRc==SQLITE_OK ){
127462 if( (*pRc)==SQLITE_OK ) p->bHasStat = 1;
127475 int rc = SQLITE_OK; /* Return code */
127540 if( *pRc==SQLITE_OK ){
127550 if( rc==SQLITE_OK ){
127556 rc = SQLITE_OK;
127559 assert( p->nPgsz>0 || rc!=SQLITE_OK );
127604 if( *pRc==SQLITE_OK ){
127668 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op (and
127725 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op (and
127761 ** the output value undefined. Otherwise SQLITE_OK is returned.
127775 return SQLITE_OK;
127788 ** If no error occurs, SQLITE_OK is returned and *apIndex set to point to
127830 return SQLITE_OK;
127866 int rc = SQLITE_OK; /* Return code */
127878 if( rc==SQLITE_OK ){
127940 int rc = SQLITE_OK; /* Return code */
128000 for(i=3; rc==SQLITE_OK && i<argc; i++){
128118 if( rc==SQLITE_OK && zContent ){
128130 if( rc==SQLITE_OK && zLanguageid ){
128143 if( rc!=SQLITE_OK ) goto fts3_init_out;
128154 if( rc!=SQLITE_OK ) goto fts3_init_out;
128163 if( rc!=SQLITE_OK ) goto fts3_init_out;
128248 if( rc==SQLITE_OK && (zCompress==0)!=(zUncompress==0) ){
128255 if( rc!=SQLITE_OK ) goto fts3_init_out;
128289 if( rc!=SQLITE_OK ){
128377 return SQLITE_OK;
128464 return SQLITE_OK;
128476 ** allocation succeeds, zero it and return SQLITE_OK. Otherwise,
128484 return SQLITE_OK;
128501 return SQLITE_OK;
128513 ** Otherwise, set *ppStmt to point to pCsr->pStmt and return SQLITE_OK.
128516 int rc = SQLITE_OK;
128532 ** SQLITE_OK on success.
128535 int rc = SQLITE_OK;
128540 if( rc==SQLITE_OK ){
128544 return SQLITE_OK;
128547 if( rc==SQLITE_OK && ((Fts3Table *)pCsr->base.pVtab)->zContentTbl==0 ){
128558 if( rc!=SQLITE_OK && pContext ){
128577 ** If an OOM error occurs, SQLITE_NOMEM is returned. Otherwise, SQLITE_OK.
128587 int rc = SQLITE_OK; /* Return code */
128698 ** If an error occurs, an error code other than SQLITE_OK is returned.
128716 assert( !piLeaf2 || !piLeaf || rc!=SQLITE_OK || (*piLeaf<=*piLeaf2) );
128718 if( rc==SQLITE_OK && iHeight>1 ){
128724 if( rc==SQLITE_OK ){
128732 if( rc==SQLITE_OK ){
128735 if( rc==SQLITE_OK ){
129249 ** containing the output doclist and SQLITE_OK is returned. In this case
129332 return SQLITE_OK;
129451 ** other doclists (except the aaOutput[0] one) and return SQLITE_OK.
129478 if( rc!=SQLITE_OK ){
129494 return SQLITE_OK;
129508 ** This function returns SQLITE_OK if the merge is successful, or an
129545 if( rc!=SQLITE_OK ){
129563 return SQLITE_OK;
129584 return SQLITE_OK;
129591 ** This function returns SQLITE_OK if successful, or an SQLite error code
129605 int rc = SQLITE_OK; /* Error code */
129618 if( rc==SQLITE_OK && pSeg ){
129624 if( rc==SQLITE_OK ){
129628 while( rc==SQLITE_OK && SQLITE_ROW==(rc = sqlite3_step(pStmt)) ){
129643 if( rc!=SQLITE_OK ) goto finished;
129652 if( rc!=SQLITE_OK ) goto finished;
129698 ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
129715 ** zTerm/nTerm is a prefix. If successful, return SQLITE_OK and write
129722 ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
129758 if( rc==SQLITE_OK ){
129815 while( SQLITE_OK==rc
129821 if( rc==SQLITE_OK ){
129824 if( rc==SQLITE_OK ){
129870 ** Return SQLITE_OK if nothing goes wrong. SQLITE_OK is returned
129883 rc = SQLITE_OK;
130002 if( rc!=SQLITE_OK ){
130008 if( rc!=SQLITE_OK ) return rc;
130031 if( rc==SQLITE_OK ){
130035 if( rc!=SQLITE_OK ) return rc;
130057 return SQLITE_OK;
130076 int rc = SQLITE_OK; /* Return Code */
130099 if( rc==SQLITE_OK ){
130160 if( rc==SQLITE_OK
130168 assert( rc==SQLITE_OK || mxLevel==0 );
130180 ** to 0 or 1). Return SQLITE_OK if successful, or an SQLite error code
130184 int rc = SQLITE_OK;
130191 if( rc==SQLITE_OK ){
130194 if( rc==SQLITE_OK ) p->bHasStat = bHasStat;
130232 return SQLITE_OK;
130245 return SQLITE_OK;
130273 ** output variable *ppCsr and SQLITE_OK is returned. Otherwise, an error
130294 return SQLITE_OK;
130333 }else if( SQLITE_OK==fts3CursorSeek(pContext, pCsr) ){
130353 if( SQLITE_OK==fts3CursorSeek(pContext, pCsr) ){
130386 case SQLITE_OK:
130408 if( SQLITE_OK==fts3FunctionArg(pContext, "matchinfo", apVal[0], &pCsr) ){
130476 if( rc==SQLITE_OK ){
130516 int rc = SQLITE_OK;
130539 return SQLITE_OK;
130554 return SQLITE_OK;
130620 int rc = SQLITE_OK;
130639 if( rc!=SQLITE_OK ) return rc;
130643 if( rc!=SQLITE_OK ) return rc;
130657 if( rc==SQLITE_OK ){
130673 if( rc==SQLITE_OK ){
130682 if( SQLITE_OK==rc
130684 && SQLITE_OK==(rc = sqlite3Fts3InitHashTable(db, pHash, "fts3_tokenizer"))
130686 && SQLITE_OK==(rc = sqlite3_overload_function(db, "snippet", -1))
130687 && SQLITE_OK==(rc = sqlite3_overload_function(db, "offsets", 1))
130688 && SQLITE_OK==(rc = sqlite3_overload_function(db, "matchinfo", 1))
130689 && SQLITE_OK==(rc = sqlite3_overload_function(db, "matchinfo", 2))
130690 && SQLITE_OK==(rc = sqlite3_overload_function(db, "optimize", 1))
130705 if( rc==SQLITE_OK ){
130710 if( rc==SQLITE_OK ){
130718 assert( rc!=SQLITE_OK );
130748 if( pExpr && SQLITE_OK==*pRc ){
130758 if( rc!=SQLITE_OK ){
130839 ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
130847 int rc = SQLITE_OK;
130849 for(iToken=0; rc==SQLITE_OK && iToken<p->nToken; iToken++){
130857 if( rc==SQLITE_OK ){
130875 ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
130893 if( rc!=SQLITE_OK ) return rc;
130899 return SQLITE_OK;
130919 return SQLITE_OK;
130968 return SQLITE_OK;
130987 ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
130991 int rc = SQLITE_OK; /* Error code */
131019 for(i=0; rc==SQLITE_OK && i<p->nToken; i++){
131033 SQLITE_OK || p->nToken<1 || p->aToken[0].pSegcsr==0 || p->bIncr );
131200 ** SQLITE_OK.
131209 int rc = SQLITE_OK;
131252 ** SQLITE_OK.
131259 int rc = SQLITE_OK;
131287 for(i=0; rc==SQLITE_OK && i<p->nToken && bEof==0; i++){
131294 assert( rc!=SQLITE_OK || a[p->nToken-1].bIgnore==0 );
131295 assert( rc!=SQLITE_OK || bMaxSet );
131299 while( rc==SQLITE_OK && bEof==0
131348 ** SQLITE_OK.
131359 int rc = SQLITE_OK;
131379 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
131398 if( pExpr && SQLITE_OK==*pRc ){
131440 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
131452 if( *pRc==SQLITE_OK ){
131456 for(i=0; *pRc==SQLITE_OK && i<pPhrase->nToken; i++){
131489 ** write this value to *pnPage and return SQLITE_OK. Otherwise, return
131520 if( rc!=SQLITE_OK ) return rc;
131538 if( rc!=SQLITE_OK ) return rc;
131542 return SQLITE_OK;
131555 ** If no error occurs, SQLITE_OK is returned and sqlite3Fts3DeferToken()
131567 int rc = SQLITE_OK; /* Return code */
131581 return SQLITE_OK;
131593 if( nOvfl==0 || nToken<2 ) return SQLITE_OK;
131597 assert( rc!=SQLITE_OK || nDocSize>0 );
131622 for(ii=0; ii<nToken && rc==SQLITE_OK; ii++){
131659 assert( rc==SQLITE_OK || pList==0 );
131660 if( rc==SQLITE_OK ){
131690 int rc = SQLITE_OK;
131699 if( rc==SQLITE_OK && nToken>1 && pTab->bFts4 ){
131719 if( rc==SQLITE_OK ){
131721 for(ii=0; rc==SQLITE_OK && ii<nOr; ii++){
131803 ** This function is a no-op if *pRc is other than SQLITE_OK when it is called.
131848 if( *pRc==SQLITE_OK ){
131876 while( !pLeft->bEof && !pRight->bEof && *pRc==SQLITE_OK ){
131925 assert( *pRc!=SQLITE_OK || pRight->bStart );
131954 ** If *pRc is not SQLITE_OK, or if pExpr is not the root node of a NEAR
131991 if( *pRc==SQLITE_OK
132049 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
132060 if( *pRc==SQLITE_OK ){
132152 ** If *pRc is not SQLITE_OK when this function is called, it immediately
132157 ** 1. *pRc is SQLITE_OK when this function returns, and
132168 if( rc==SQLITE_OK ){
132178 if( rc==SQLITE_OK ){
132188 return (rc==SQLITE_OK && bMiss);
132196 int rc = SQLITE_OK; /* Return Code */
132217 if( rc==SQLITE_OK && (
132232 ** If *pRc is other than SQLITE_OK when this function is called, it is
132241 if( pExpr && *pRc==SQLITE_OK ){
132318 ** SQLITE_OK is returned if the aMI[] array is successfully allocated and
132325 int rc = SQLITE_OK; /* Return code */
132357 while( pCsr->isEof==0 && rc==SQLITE_OK ){
132375 if( rc==SQLITE_OK && pCsr->isEof==0 ){
132390 ** do {...} while( pRoot->iDocid<iDocid && rc==SQLITE_OK );
132396 }while( pRoot->iDocid!=iDocid && rc==SQLITE_OK );
132413 ** If no error occurs, SQLITE_OK is returned and the values for each column
132439 int rc = SQLITE_OK;
132450 if( rc==SQLITE_OK ){
132498 return SQLITE_OK;
132523 if( bOr==0 ) return SQLITE_OK;
132529 int rc = SQLITE_OK;
132532 while( rc==SQLITE_OK && !pExpr->bEof ){
132537 assert( rc!=SQLITE_OK || pPhrase->bIncr==0 );
132538 if( rc!=SQLITE_OK ) return rc;
132546 int rc = SQLITE_OK;
132548 if( rc!=SQLITE_OK ) return rc;
132598 if( pIter==0 ) return SQLITE_OK;
132614 return SQLITE_OK;
132764 if( rc!=SQLITE_OK ) return rc;
132782 return SQLITE_OK;
132805 return SQLITE_OK;
132879 return SQLITE_OK;
132895 return SQLITE_OK;
132911 return SQLITE_OK;
132927 return SQLITE_OK;
132942 if( pCsr->aStat[pCsr->iCol].nDoc>0 ) return SQLITE_OK;
132959 return SQLITE_OK;
133017 rc = SQLITE_OK;
133111 if( rc==SQLITE_OK ){
133115 if( rc==SQLITE_OK ) rc = fts3auxNextMethod(pCursor);
133165 return SQLITE_OK;
133177 return SQLITE_OK;
133181 ** Register the fts3aux module with database connection db. Return SQLITE_OK
133361 assert( rc==SQLITE_OK || pCsr==0 );
133362 if( rc==SQLITE_OK ){
133366 if( rc!=SQLITE_OK ){
133391 ** Return SQLITE_OK if successful, or SQLITE_NOMEM if a memory allocation
133416 if( rc==SQLITE_OK ){
133422 if( rc==SQLITE_OK ){
133458 rc = SQLITE_OK;
133488 ** If successful, SQLITE_OK is returned and *ppExpr set to point at the
133530 if( rc==SQLITE_OK ){
133532 for(ii=0; rc==SQLITE_OK; ii++){
133536 if( rc==SQLITE_OK ){
133587 rc = SQLITE_OK;
133607 ** Returns an SQLite error code. SQLITE_OK if everything works, SQLITE_NOMEM
133690 return SQLITE_OK;
133718 if( rc==SQLITE_OK && !*ppExpr ){ rc = SQLITE_DONE; }
133824 ** If successful, SQLITE_OK is returned, *ppExpr is set to point to the
133840 int rc = SQLITE_OK;
133843 while( rc==SQLITE_OK ){
133848 assert( nByte>0 || (rc!=SQLITE_OK && p==0) );
133849 if( rc==SQLITE_OK ){
133937 assert( rc!=SQLITE_OK || (nByte>0 && nByte<=nIn) );
133947 rc = SQLITE_OK;
133965 if( rc!=SQLITE_OK ){
133979 int rc = SQLITE_OK;
133985 if( rc==SQLITE_OK ){
133996 ** If successful, SQLITE_OK is returned and (*pp) set to point to the
134005 int rc = SQLITE_OK; /* Return code */
134014 if( rc==SQLITE_OK && (eType==FTSQUERY_AND || eType==FTSQUERY_OR) ){
134023 if( rc==SQLITE_OK ){
134046 if( rc!=SQLITE_OK ) break;
134093 if( rc==SQLITE_OK ){
134133 if( rc!=SQLITE_OK ){
134175 return SQLITE_OK;
134181 assert( rc==SQLITE_OK || *ppExpr==0 );
134184 if( rc==SQLITE_OK && sParse.nNest ){
134196 ** of the parsed expression tree and SQLITE_OK is returned. If an error
134232 if( rc==SQLITE_OK && *ppExpr ){
134234 if( rc==SQLITE_OK ){
134239 if( rc!=SQLITE_OK ){
134317 if( rc!=SQLITE_OK ){
134433 assert( rc==SQLITE_NOMEM || rc==SQLITE_OK );
134457 assert( rc==SQLITE_OK || pExpr==0 );
134465 if( rc!=SQLITE_OK && rc!=SQLITE_NOMEM ){
134492 if( rc==SQLITE_OK ){
134958 return SQLITE_OK;
134966 return SQLITE_OK;
135001 return SQLITE_OK;
135012 return SQLITE_OK;
135519 return SQLITE_OK;
135740 assert( rc!=SQLITE_OK || *ppTok );
135741 if( rc!=SQLITE_OK ){
135839 if( SQLITE_OK!=p->xCreate(argc-2, azArg, &pTokenizer) ){
135849 while( SQLITE_OK==p->xNext(pCsr, &zToken, &nToken, &iStart, &iEnd, &iPos) ){
135857 if( SQLITE_OK!=p->xClose(pCsr) ){
135861 if( SQLITE_OK!=p->xDestroy(pTokenizer) ){
135886 if( rc!=SQLITE_OK ){
135909 if( rc!=SQLITE_OK ){
135959 assert( rc==SQLITE_OK );
135968 assert( rc==SQLITE_OK );
135970 assert( rc==SQLITE_OK );
136000 int rc = SQLITE_OK;
136015 if( SQLITE_OK==rc ){
136018 if( SQLITE_OK==rc ){
136022 if( SQLITE_OK==rc ){
136025 if( SQLITE_OK==rc ){
136135 return SQLITE_OK;
136143 return SQLITE_OK;
136178 return SQLITE_OK;
136189 return SQLITE_OK;
136244 return SQLITE_OK;
136368 return SQLITE_OK;
136378 ** array of dequoted strings and SQLITE_OK is returned. The caller is
136388 int rc = SQLITE_OK; /* Return code */
136449 if( rc!=SQLITE_OK ) return rc;
136454 if( rc==SQLITE_OK ){
136464 assert( (rc==SQLITE_OK)==(pMod!=0) );
136465 if( rc==SQLITE_OK ){
136470 if( rc==SQLITE_OK ){
136477 if( rc==SQLITE_OK ){
136502 return SQLITE_OK;
136524 return SQLITE_OK;
136531 return SQLITE_OK;
136548 return SQLITE_OK;
136579 return SQLITE_OK;
136596 if( rc!=SQLITE_OK ){
136598 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
136631 if( rc==SQLITE_OK ){
136637 if( rc!=SQLITE_OK ) return rc;
136678 return SQLITE_OK;
136690 return SQLITE_OK;
136694 ** Register the fts3tok module with database connection db. Return SQLITE_OK
136816 sqlite3_log(SQLITE_OK, "%d-way merge from level %d", nMerge, (int)iAbsLevel);
136887 ** until SegmentReaderNext() returns something other than SQLITE_OK
137010 ** *pp is set to the requested statement handle and SQLITE_OK returned.
137121 int rc = SQLITE_OK;
137142 assert( rc==SQLITE_OK || pStmt==0 );
137149 for(i=0; rc==SQLITE_OK && i<nParam; i++){
137167 if( rc==SQLITE_OK ){
137172 if( rc==SQLITE_OK ) rc = FTS_CORRUPT_VTAB;
137175 SQLITE_OK;
137190 if( rc==SQLITE_OK ){
137196 if( rc==SQLITE_OK ) rc = FTS_CORRUPT_VTAB;
137217 ** Returns SQLITE_OK if the statement is successfully executed, or an
137230 if( rc==SQLITE_OK ){
137253 int rc = SQLITE_OK;
137258 if( rc==SQLITE_OK ){
137309 ** return SQLITE_OK. If an error occurs while preparing the statement,
137340 if( rc==SQLITE_OK ){
137349 if( rc==SQLITE_OK ){
137359 ** Append a single varint to a PendingList buffer. SQLITE_OK is returned
137402 return SQLITE_OK;
137412 ** it is set to SQLITE_OK.
137422 int rc = SQLITE_OK;
137433 if( SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, iDelta)) ){
137441 if( SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, 1))
137442 || SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, iCol))
137452 if( rc==SQLITE_OK ){
137485 int rc = SQLITE_OK;
137501 if( rc==SQLITE_OK ){
137512 ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error code.
137543 return SQLITE_OK;
137547 if( rc!=SQLITE_OK ){
137552 while( SQLITE_OK==rc
137553 && SQLITE_OK==(rc = xNext(pCsr, &zToken, &nToken, &iStart, &iEnd, &iPos))
137573 for(i=1; rc==SQLITE_OK && i<p->nIndex; i++){
137584 return (rc==SQLITE_DONE ? SQLITE_OK : rc);
137610 if( rc!=SQLITE_OK ) return rc;
137614 return SQLITE_OK;
137654 if( rc!=SQLITE_OK ){
137660 return SQLITE_OK;
137694 return SQLITE_OK;
137706 if( rc==SQLITE_OK && p->zLanguageid ){
137712 if( rc!=SQLITE_OK ) return rc;
137732 if( rc!=SQLITE_OK ) return rc;
137752 int rc = SQLITE_OK; /* Return code */
137799 if( rc==SQLITE_OK ){
137804 for(i=1; rc==SQLITE_OK && i<=p->nColumn; i++){
137812 if( rc!=SQLITE_OK ){
137844 ** If successful, *piIdx is set to the allocated index slot and SQLITE_OK
137863 if( rc==SQLITE_OK ){
137873 if( rc==SQLITE_OK ){
137904 ** an SQLite error code is returned. Otherwise, SQLITE_OK is returned. If
137942 if( rc==SQLITE_OK ){
137956 if( rc!=SQLITE_OK ){
137989 if( rc==SQLITE_OK ){
138002 int rc = SQLITE_OK;
138006 while( pReader->pBlob && rc==SQLITE_OK
138028 ** segment. If successful, SQLITE_OK is returned. If there is no next term,
138062 return SQLITE_OK;
138071 return SQLITE_OK;
138078 if( rc!=SQLITE_OK ) return rc;
138090 if( rc!=SQLITE_OK ) return rc;
138113 if( rc!=SQLITE_OK ) return rc;
138131 return SQLITE_OK;
138139 int rc = SQLITE_OK;
138152 if( rc==SQLITE_OK ){
138176 int rc = SQLITE_OK;
138219 if( rc!=SQLITE_OK ) return rc;
138243 if( rc==SQLITE_OK ){
138255 return SQLITE_OK;
138267 int rc = SQLITE_OK;
138273 for(ii=0; rc==SQLITE_OK && ii<pMsr->nSegment; ii++){
138282 if( rc!=SQLITE_OK ) break;
138351 return SQLITE_OK;
138404 int rc = SQLITE_OK; /* Return Code */
138620 if( rc==SQLITE_OK ){
138631 ** *pnMax to this value and return SQLITE_OK. Otherwise, if an error occurs,
138640 if( rc==SQLITE_OK ){
138666 if( rc==SQLITE_OK ){
138776 return SQLITE_OK;
138841 ** If successful, SQLITE_OK is returned and output variable *piLast is
138856 int rc = SQLITE_OK;
138868 for(pIter=pTree->pLeftmost; pIter && rc==SQLITE_OK; pIter=pIter->pRight){
138876 if( rc==SQLITE_OK ){
138913 ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error code.
138947 if( rc!=SQLITE_OK ) return rc;
138953 if( rc!=SQLITE_OK ) return rc;
138972 if( rc!=SQLITE_OK ) return rc;
138989 if( rc!=SQLITE_OK ) return rc;
139048 return SQLITE_OK;
139054 ** to the segment using fts3SegWriterAdd(). If successful, SQLITE_OK is
139072 if( rc==SQLITE_OK ){
139076 if( rc==SQLITE_OK ){
139109 ** document pRowid, or false otherwise, and SQLITE_OK is returned. If an
139118 rc = SQLITE_OK;
139121 if( rc==SQLITE_OK ){
139137 ** Return SQLITE_OK if successful, or an SQLite error code if not.
139156 if( rc!=SQLITE_OK ) return rc;
139171 SQLITE_OK
139185 if( rc!=SQLITE_OK ) return rc;
139207 int rc = SQLITE_OK; /* Return code */
139211 if( rc==SQLITE_OK ){
139233 ** SQLITE_OK is returned if successful, otherwise an SQLite error code.
139243 int rc = SQLITE_OK; /* Return Code */
139247 for(i=0; rc==SQLITE_OK && i<nReader; i++){
139250 if( rc!=SQLITE_OK ){
139257 if( rc==SQLITE_OK ){
139265 if( rc==SQLITE_OK ){
139272 if( rc==SQLITE_OK ){
139334 ** If successful, return SQLITE_OK. Otherwise, if an OOM error is encountered
139351 return SQLITE_OK;
139369 return SQLITE_OK;
139388 while( rc==SQLITE_OK
139396 if( rc!=SQLITE_OK ) return rc;
139401 if( rc!=SQLITE_OK ) return rc;
139419 return SQLITE_OK;
139442 if( rc!=SQLITE_OK ) return rc;
139451 return SQLITE_OK;
139482 if( rc!=SQLITE_OK ) return rc;
139496 if( rc!=SQLITE_OK ) return rc;
139503 return SQLITE_OK;
139534 return SQLITE_OK;
139542 int rc = SQLITE_OK;
139558 if( pCsr->nSegment==0 ) return SQLITE_OK;
139574 if( rc!=SQLITE_OK ) return rc;
139579 /* If all the seg-readers are at EOF, we're finished. return SQLITE_OK. */
139580 assert( rc==SQLITE_OK );
139624 if( rc==SQLITE_OK ) rc = SQLITE_ROW;
139710 }while( rc==SQLITE_OK );
139781 int rc = SQLITE_OK;
139786 if( rc==SQLITE_OK ){
139819 if( rc==SQLITE_OK ){
139822 if( rc==SQLITE_OK ){
139826 if( rc==SQLITE_OK ){
139844 if( rc!=SQLITE_OK ){
139850 if( rc==SQLITE_OK ){
139855 if( rc==SQLITE_OK ){
139875 ** Otherwise, if successful, SQLITE_OK is returned. If an error occurs,
139901 if( rc!=SQLITE_OK || csr.nSegment==0 ) goto finished;
139905 if( rc!=SQLITE_OK ) goto finished;
139930 if( rc!=SQLITE_OK ) goto finished;
139941 while( SQLITE_OK==rc ){
139947 if( rc!=SQLITE_OK ) goto finished;
139954 if( rc!=SQLITE_OK ) goto finished;
139958 if( rc==SQLITE_OK ){
139976 int rc = SQLITE_OK;
139979 for(i=0; rc==SQLITE_OK && i<p->nIndex; i++){
139981 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
139988 if( rc==SQLITE_OK && p->bHasStat
139993 if( rc==SQLITE_OK ){
140130 if( rc!=SQLITE_OK ){
140173 if( rc==SQLITE_OK ){
140179 for(i=0; rc==SQLITE_OK && i<p->nIndex; i++){
140183 rc = SQLITE_OK;
140188 if( rc==SQLITE_OK ) rc = rc2;
140194 return (rc==SQLITE_OK && bReturnDone && bSeenDone) ? SQLITE_DONE : rc;
140211 if( rc==SQLITE_OK ){
140227 if( rc==SQLITE_OK ){
140239 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
140244 for(iCol=0; rc==SQLITE_OK && iCol<p->nColumn; iCol++){
140254 if( rc!=SQLITE_OK ){
140271 if( rc==SQLITE_OK ){
140308 if( rc==SQLITE_OK ){
140313 for(i=0; rc==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW && i<nSeg; i++){
140325 if( rc==SQLITE_OK ) rc = rc2;
140395 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
140404 if( *pRc==SQLITE_OK && nMin>pBlob->nAlloc ){
140421 ** Otherwise return SQLITE_OK. If there is no next entry on the node
140430 int rc = SQLITE_OK; /* Return code */
140444 if( rc==SQLITE_OK ){
140471 ** If successful, SQLITE_OK is returned and the NodeReader object set to
140514 int rc = SQLITE_OK;
140536 if( rc==SQLITE_OK ){
140544 if( rc==SQLITE_OK ){
140570 if( rc!=SQLITE_OK || iNextPtr==0 ) return rc;
140600 ** returned. Otherwise, SQLITE_OK.
140610 int rc = SQLITE_OK; /* Return code */
140621 if( rc!=SQLITE_OK ) return rc;
140643 return SQLITE_OK;
140650 ** Return SQLITE_OK if successful, or an SQLite error code otherwise.
140661 int rc = SQLITE_OK; /* Return code */
140694 if( rc==SQLITE_OK ){
140711 if( rc==SQLITE_OK ){
140729 ** If *pRc is not SQLITE_OK when this function is called, then no attempt
140733 ** Otherwise, if *pRc is initially SQLITE_OK and an error occurs while
140781 if( rc==SQLITE_OK ){
140794 if( pNode->block.n>0 && rc==SQLITE_OK ){
140802 if( rc==SQLITE_OK ){
140859 if( rc==SQLITE_OK ){
140896 if( rc==SQLITE_OK ){
140926 if( rc==SQLITE_OK && bAppendable ){
140931 if( rc==SQLITE_OK ){
140934 rc==SQLITE_OK && reader.aNode;
140947 if( rc==SQLITE_OK && bAppendable ){
140967 if( rc==SQLITE_OK ){
140972 for(i=nHeight; i>=0 && rc==SQLITE_OK; i--){
140977 while( reader.aNode && rc==SQLITE_OK ) rc = nodeReaderNext(&reader);
140979 if( rc==SQLITE_OK ){
140989 if( rc==SQLITE_OK ){
141001 if( rc==SQLITE_OK ) rc = rc2;
141010 ** one before returning SQLITE_OK. Or, if there are no segments at all
141025 if( rc==SQLITE_OK ){
141076 if( rc==SQLITE_OK ){
141084 if( rc!=SQLITE_OK ) return rc;
141088 if( rc==SQLITE_OK ){
141096 if( rc!=SQLITE_OK ) return rc;
141102 if( rc!=SQLITE_OK ) return rc;
141112 return SQLITE_OK;
141135 if( rc==SQLITE_OK ){
141163 if( rc==SQLITE_OK ){
141180 if( rc==SQLITE_OK ) rc = rc2;
141183 if( rc==SQLITE_OK ){
141186 if( rc==SQLITE_OK ){
141192 for(i=0; rc==SQLITE_OK && i<nIdx; i++){
141235 int rc = SQLITE_OK; /* Return code */
141240 if( rc!=SQLITE_OK ) return rc;
141245 rc==SQLITE_OK && reader.aNode;
141258 if( rc!=SQLITE_OK ) break;
141277 ** SQLITE_OK is returned if the segment is updated successfully. Or an
141287 int rc = SQLITE_OK; /* Return code */
141296 if( rc==SQLITE_OK ){
141307 if( rc==SQLITE_OK ) rc = rc2;
141310 while( rc==SQLITE_OK && iBlock ){
141316 if( rc==SQLITE_OK ){
141319 if( rc==SQLITE_OK ){
141326 if( rc==SQLITE_OK && iNewStart ){
141329 if( rc==SQLITE_OK ){
141337 if( rc==SQLITE_OK ){
141340 if( rc==SQLITE_OK ){
141373 int rc = SQLITE_OK;
141375 for(i=pCsr->nSegment-1; i>=0 && rc==SQLITE_OK; i--){
141390 if( rc==SQLITE_OK ){
141405 if( rc==SQLITE_OK && nRem!=pCsr->nSegment ){
141421 if( rc==SQLITE_OK ){
141436 ** table and return SQLITE_OK. Otherwise, if an error occurs, return an
141445 if( rc==SQLITE_OK ){
141453 if( rc==SQLITE_OK ){
141460 if( rc==SQLITE_OK ) rc = rc2;
141467 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
141472 ** If successful, leave *pRc set to SQLITE_OK and return. If an error occurs,
141482 if( *pRc==SQLITE_OK ){
141493 ** If no error occurs, return SQLITE_OK. If the hint blob in *pHint does
141509 return SQLITE_OK;
141541 while( rc==SQLITE_OK && nRem>0 ){
141568 if( rc==SQLITE_OK && hint.n ){
141600 if( rc==SQLITE_OK ){
141612 if( rc==SQLITE_OK ){
141615 if( SQLITE_OK==rc && pCsr->nSegment==nSeg
141616 && SQLITE_OK==(rc = sqlite3Fts3SegReaderStart(p, pCsr, pFilter))
141627 if( rc==SQLITE_OK && pWriter->nLeafEst ){
141631 if( rc==SQLITE_OK ) rc = sqlite3Fts3SegReaderStep(p, pCsr);
141632 if( pWriter->nWork>=nRem && rc==SQLITE_ROW ) rc = SQLITE_OK;
141636 if( rc==SQLITE_OK ){
141659 if( bDirtyHint && rc==SQLITE_OK ){
141712 rc = SQLITE_OK;
141717 if( rc==SQLITE_OK ){
141737 int rc = SQLITE_OK;
141787 ** If successful, the checksum value is returned and *pRc set to SQLITE_OK.
141802 assert( *pRc==SQLITE_OK );
141812 if( rc==SQLITE_OK ){
141816 if( rc==SQLITE_OK ){
141859 ** to true and return SQLITE_OK. Or if the contents do not match, set *pbOk
141866 int rc = SQLITE_OK; /* Return code */
141873 if( rc==SQLITE_OK ){
141876 while( rc==SQLITE_OK && sqlite3_step(pAllLangid)==SQLITE_ROW ){
141884 if( rc==SQLITE_OK ) rc = rc2;
141889 if( rc==SQLITE_OK ){
141902 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
141907 for(iCol=0; rc==SQLITE_OK && iCol<p->nColumn; iCol++){
141914 while( rc==SQLITE_OK ){
141921 if( rc==SQLITE_OK ){
141936 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
141950 ** the FTS index are correct, return SQLITE_OK. Or, if the contents of the
141985 if( rc==SQLITE_OK && bOk==0 ) rc = SQLITE_CORRUPT_VTAB;
142017 rc = SQLITE_OK;
142020 rc = SQLITE_OK;
142023 rc = SQLITE_OK;
142069 int rc = SQLITE_OK; /* Return code */
142082 for(i=0; i<p->nColumn && rc==SQLITE_OK; i++){
142088 while( rc==SQLITE_OK ){
142095 for(pDef=pCsr->pDeferred; pDef && rc==SQLITE_OK; pDef=pDef->pNext){
142107 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
142111 for(pDef=pCsr->pDeferred; pDef && rc==SQLITE_OK; pDef=pDef->pNext){
142134 return SQLITE_OK;
142145 return SQLITE_OK;
142170 return SQLITE_OK;
142185 int rc = SQLITE_OK; /* Return code */
142189 if( bFound && rc==SQLITE_OK ){
142192 if( rc==SQLITE_OK ){
142235 int rc = SQLITE_OK; /* Return Code */
142279 if( rc!=SQLITE_OK ) goto update_out;
142326 if( rc!=SQLITE_OK ){
142338 if( nArg>1 && rc==SQLITE_OK ){
142346 if( rc==SQLITE_OK && (!isRemove || *pRowid!=p->iPrevDocid ) ){
142349 if( rc==SQLITE_OK ){
142377 if( rc==SQLITE_OK ){
142379 if( rc==SQLITE_OK || rc==SQLITE_DONE ){
142381 if( rc2!=SQLITE_OK ) rc = rc2;
142543 if( rc==SQLITE_OK && eType!=FTSQUERY_NOT ){
142558 ** If the callback function returns anything other than SQLITE_OK,
142560 ** Otherwise, SQLITE_OK is returned after a callback has been made for
142578 int rc = SQLITE_OK;
142618 return SQLITE_OK;
142760 assert( rc==SQLITE_OK || pCsr==0 );
142771 assert( rc!=SQLITE_OK || (
142816 if( rc!=SQLITE_OK ){
142868 return SQLITE_OK;
142907 return SQLITE_OK;
142969 if( rc!=SQLITE_OK ){
142972 while( rc==SQLITE_OK && iCurrent<(nSnippet+nDesired) ){
142977 if( rc!=SQLITE_OK && rc!=SQLITE_DONE ){ return rc; }
142987 return SQLITE_OK;
143023 return SQLITE_OK;
143030 if( rc!=SQLITE_OK ){
143034 while( rc==SQLITE_OK ){
143053 if( rc!=SQLITE_OK ){
143076 if( rc==SQLITE_OK && (iPos>0 || iFragment>0) ){
143079 if( rc!=SQLITE_OK || iCurrent<iPos ) continue;
143093 if( rc==SQLITE_OK && isHighlight ) rc = fts3StringAppend(pOut, zOpen, -1);
143094 if( rc==SQLITE_OK ) rc = fts3StringAppend(pOut, &zDoc[iBegin], iFin-iBegin);
143095 if( rc==SQLITE_OK && isHighlight ) rc = fts3StringAppend(pOut, zClose, -1);
143181 int rc = SQLITE_OK;
143186 for(i=0; i<p->nCol && rc==SQLITE_OK; i++){
143212 return SQLITE_OK;
143255 if( rc!=SQLITE_OK ) return rc;
143266 return SQLITE_OK;
143296 return SQLITE_OK;
143326 ** array before returning. SQLITE_OK is returned in this case.
143360 if( rc!=SQLITE_OK ) return rc;
143396 return SQLITE_OK;
143412 ** Return SQLITE_OK if successful, or an SQLite error code if an error
143413 ** occurs. If a value other than SQLITE_OK is returned, the state the
143422 int rc = SQLITE_OK;
143427 for(i=0; rc==SQLITE_OK && zArg[i]; i++){
143452 if( rc==SQLITE_OK ){
143468 if( rc==SQLITE_OK ){
143483 if( rc==SQLITE_OK ){
143493 if( rc!=SQLITE_OK ) break;
143497 if( rc!=SQLITE_OK ) break;
143500 if( rc!=SQLITE_OK ) break;
143525 int rc = SQLITE_OK;
143597 int rc = SQLITE_OK;
143648 if( rc!=SQLITE_OK ){
143669 for(i=0; i<nSnippet && rc==SQLITE_OK; i++){
143677 if( rc!=SQLITE_OK ){
143757 if( rc!=SQLITE_OK ) goto offsets_out;
143809 if( rc!=SQLITE_OK ) goto offsets_out;
143812 while( rc==SQLITE_OK ){
143835 while( rc==SQLITE_OK && iCurrent<iMinPos ){
143838 if( rc==SQLITE_OK ){
143850 rc = SQLITE_OK;
143854 if( rc!=SQLITE_OK ) goto offsets_out;
143861 if( rc!=SQLITE_OK ){
143906 if( rc!=SQLITE_OK ){
144025 return SQLITE_OK;
144094 return SQLITE_OK;
144140 int rc = SQLITE_OK;
144147 for(i=0; rc==SQLITE_OK && i<nArg; i++){
144169 if( rc!=SQLITE_OK ){
144208 return SQLITE_OK;
144219 return SQLITE_OK;
144287 return SQLITE_OK;
145192 int rc2 = SQLITE_OK;
145206 return SQLITE_OK;
145230 if( rc==SQLITE_OK ) rc = rc2;
145249 if( pNode && rc==SQLITE_OK ){
145255 if( rc==SQLITE_OK ){
145302 ** is successful, return SQLITE_OK.
145331 int rc = SQLITE_OK;
145343 if( pNode->iNode==0 && rc==SQLITE_OK ){
145356 int rc = SQLITE_OK;
145367 if( rc==SQLITE_OK ){
145492 return SQLITE_OK;
145515 if( rc==SQLITE_OK ){
145533 rc = SQLITE_OK;
145570 return SQLITE_OK;
145757 return SQLITE_OK;
145773 return SQLITE_OK;
145999 int rc = SQLITE_OK;
146058 return SQLITE_OK;
146066 int rc = SQLITE_OK;
146081 int rc = SQLITE_OK;
146083 if( rc==SQLITE_OK && p ){
146097 int rc = SQLITE_OK;
146101 if( p==0 ) return SQLITE_OK;
146117 return SQLITE_OK;
146123 ** return SQLITE_OK. If there is no such record in the table, set
146124 ** *ppLeaf to 0 and return SQLITE_OK. If an error occurs, set *ppLeaf
146193 return SQLITE_OK;
146208 int rc = SQLITE_OK;
146227 if( rc==SQLITE_OK && pLeaf!=0 ){
146244 if( rc==SQLITE_OK && argc>0 ){
146264 if( rc!=SQLITE_OK ){
146280 if( rc==SQLITE_OK ){
146349 int rc = SQLITE_OK;
146380 return SQLITE_OK;
146533 for(ii=0; rc==SQLITE_OK && ii<(pRtree->iDepth-iHeight); ii++){
146605 return SQLITE_OK;
146867 return SQLITE_OK;
146899 int rc = SQLITE_OK;
146949 if( rc!=SQLITE_OK ){
146958 if( SQLITE_OK!=(rc = nodeWrite(pRtree, pRight))
146959 || (0==pLeft->iNode && SQLITE_OK!=(rc = nodeWrite(pRtree, pLeft)))
146969 if( rc!=SQLITE_OK ){
146976 if( rc==SQLITE_OK ){
146980 if( rc!=SQLITE_OK ){
146994 if( rc!=SQLITE_OK ){
147002 if( rc!=SQLITE_OK ){
147010 if( rc==SQLITE_OK ){
147014 if( rc==SQLITE_OK ){
147038 int rc = SQLITE_OK;
147040 while( rc==SQLITE_OK && pChild->iNode!=1 && pChild->pParent==0 ){
147041 int rc2 = SQLITE_OK; /* sqlite3_reset() return code */
147060 if( rc==SQLITE_OK ) rc = rc2;
147061 if( rc==SQLITE_OK && !pChild->pParent ) rc = SQLITE_CORRUPT_VTAB;
147079 if( rc==SQLITE_OK ){
147085 if( rc==SQLITE_OK ){
147088 if( rc!=SQLITE_OK ){
147095 if( SQLITE_OK!=(rc = sqlite3_reset(pRtree->pDeleteNode)) ){
147102 if( SQLITE_OK!=(rc = sqlite3_reset(pRtree->pDeleteParent)) ){
147115 return SQLITE_OK;
147120 int rc = SQLITE_OK;
147133 if( rc==SQLITE_OK ){
147149 if( SQLITE_OK!=(rc = fixLeafParent(pRtree, pNode)) ){
147190 int rc = SQLITE_OK;
147242 for(ii=0; rc==SQLITE_OK && ii<(nCell-(RTREE_MINCELLS(pRtree)+1)); ii++){
147253 if( rc==SQLITE_OK ){
147256 for(; rc==SQLITE_OK && ii<nCell; ii++){
147263 if( rc==SQLITE_OK ){
147267 if( rc==SQLITE_OK ){
147287 int rc = SQLITE_OK;
147305 if( rc==SQLITE_OK ){
147318 int rc = SQLITE_OK;
147321 for(ii=0; rc==SQLITE_OK && ii<nCell; ii++){
147330 if( rc==SQLITE_OK ){
147334 if( rc==SQLITE_OK ){
147371 if( rc==SQLITE_OK ){
147376 if( rc==SQLITE_OK ){
147379 if( rc==SQLITE_OK ){
147383 if( rc==SQLITE_OK ){
147389 if( rc==SQLITE_OK ){
147403 if( rc==SQLITE_OK && pRtree->iDepth>0 && NCELL(pRoot)==1 ){
147408 if( rc==SQLITE_OK ){
147412 if( rc==SQLITE_OK ) rc = rc2;
147413 if( rc==SQLITE_OK ){
147422 if( rc==SQLITE_OK ){
147430 if( rc==SQLITE_OK ){
147479 int rc = SQLITE_OK;
147561 if( rc==SQLITE_OK && nData>1 ){
147571 if( rc==SQLITE_OK ){
147574 if( rc==SQLITE_OK ){
147579 if( rc==SQLITE_OK ){
147628 if( rc==SQLITE_OK ){
147632 rc = SQLITE_OK;
147635 if( rc==SQLITE_OK ){
147681 int rc = SQLITE_OK;
147719 if( rc!=SQLITE_OK ){
147735 for(i=0; i<N_STATEMENT && rc==SQLITE_OK; i++){
147752 ** is written to *piVal and SQLITE_OK returned. Otherwise, an SQLite error
147760 if( rc==SQLITE_OK ){
147773 ** to. If successful, pRtree->iNodeSize is populated and SQLITE_OK returned.
147797 if( rc==SQLITE_OK ){
147811 if( rc!=SQLITE_OK ){
147837 int rc = SQLITE_OK;
147883 if( rc==SQLITE_OK ){
147902 }else if( SQLITE_OK!=(rc = sqlite3_declare_vtab(db, zSql)) ){
147909 if( rc==SQLITE_OK ){
148012 if( rc==SQLITE_OK ){
148015 if( rc==SQLITE_OK ){
148023 if( rc==SQLITE_OK ){
148588 if( rc!=SQLITE_OK ){
148623 int rc = SQLITE_OK;
148626 for(i=0; rc==SQLITE_OK && i<(int)(sizeof(scalars)/sizeof(scalars[0])); i++){
148727 return SQLITE_OK;
148736 return SQLITE_OK;
148811 return SQLITE_OK;
148822 return SQLITE_OK;
148887 return SQLITE_OK;
