Lines Matching refs:SQLITE_OK
843 ** ^Calls to sqlite3_close() and sqlite3_close_v2() return SQLITE_OK if
864 ** [sqlite3_backup] objects then it returns SQLITE_OK but the deallocation
960 ** KEYWORDS: SQLITE_OK {error code} {error codes}
971 #define SQLITE_OK 0 /* Successful result */
1011 ** [SQLITE_OK | result codes]. However, experience has shown that many of
1025 ** The SQLITE_OK result code will never be extended. It will always
1441 ** file control returns [SQLITE_OK], then the parser assumes that the
1444 ** any result code other than [SQLITE_OK] or [SQLITE_NOTFOUND], that means
1805 ** ^The sqlite3_initialize() routine returns [SQLITE_OK] on success.
1808 ** as a mutex) it returns an [error code] other than [SQLITE_OK].
1845 ** must return [SQLITE_OK] on success and some other [error code] upon
1878 ** ^When a configuration option is set, sqlite3_config() returns [SQLITE_OK].
1897 ** ^Calls to sqlite3_db_config() return SQLITE_OK if and only if
2945 ** return [SQLITE_OK] to allow the action, [SQLITE_IGNORE] to disallow the
2949 ** any value other than [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY]
2953 ** When the callback returns [SQLITE_OK], that means the operation
2970 ** been read if [SQLITE_OK] had been returned. The [SQLITE_IGNORE]
3024 ** return either [SQLITE_OK] or one of these two constants in order
3164 ** [SQLITE_OK] is returned. Otherwise an [error code] is returned.)^ ^The
3629 ** ^On success, the sqlite3_prepare() family of routines return [SQLITE_OK];
3899 ** ^The sqlite3_bind_* routines return [SQLITE_OK] on success or an
4423 ** SQLITE_OK. ^If the most recent evaluation of statement S failed, then
4459 ** then [sqlite3_reset(S)] returns [SQLITE_OK].
5420 ** ^(This routine returns [SQLITE_OK] if shared cache was enabled or disabled
5622 ** [SQLITE_OK] on success and [SQLITE_ERROR] if something goes wrong.
6025 ** ^(On success, [SQLITE_OK] is returned and the new [BLOB handle] is written
6147 ** ^(On success, sqlite3_blob_read() returns SQLITE_OK.
6185 ** ^(On success, sqlite3_blob_write() returns SQLITE_OK.
6316 ** SQLITE_BUSY. ^The sqlite3_mutex_try() interface returns [SQLITE_OK]
6410 ** called, but only if the prior call to xMutexInit returned SQLITE_OK.
6592 ** ^The sqlite3_status() routine returns SQLITE_OK on success and a
6717 ** ^The sqlite3_db_status() routine returns SQLITE_OK on success and a
7179 ** are still more pages to be copied, then the function returns [SQLITE_OK].
7183 ** then an [error code] is returned. ^As well as [SQLITE_OK] and
7242 ** ^The value returned by sqlite3_backup_finish is [SQLITE_OK] if no
7363 ** returns SQLITE_OK.
7500 ** The callback function should normally return [SQLITE_OK]. ^If an error
7600 ** populated even if sqlite3_wal_checkpoint_v2() returns other than SQLITE_OK.
7629 ** databases, SQLITE_OK is returned.
7632 ** mode, SQLITE_OK is returned and both *pnLog and *pnCkpt set to -1. If
7706 ** return SQLITE_OK. Or, if this is not possible, it may return
9894 #define sqlite3_mutex_try(X) SQLITE_OK
9899 #define sqlite3MutexInit() SQLITE_OK
12188 # define sqlite3AuthCheck(a,b,c,d,e) SQLITE_OK
12387 # define sqlite3VtabSync(X,Y) SQLITE_OK
12394 # define sqlite3VtabSavepoint(X, Y, Z) SQLITE_OK
13720 #define sqlite3VdbeMemExpandBlob(x) SQLITE_OK
13721 #define ExpandBlob(P) SQLITE_OK
13804 return SQLITE_OK;
13817 int rc = SQLITE_OK; /* Return code */
14262 if( sqlite3OsCurrentTimeInt64(db->pVfs, &p->iJD)==SQLITE_OK ){
14429 ** return this value and set *pRc to SQLITE_OK.
14437 int *pRc /* OUT: Error code. SQLITE_OK or ERROR */
14479 *pRc = SQLITE_OK;
14551 if( rc==SQLITE_OK ){
15157 int rc = SQLITE_OK;
15251 return SQLITE_OK;
15254 return SQLITE_OK;
15276 assert( rc==SQLITE_OK || pFile->pMethods==0 );
15353 if( rc!=SQLITE_OK ){
15362 int rc = SQLITE_OK;
15456 return SQLITE_OK;
15469 return SQLITE_OK;
15597 static int sqlite3MemInit(void *NotUsed){ return SQLITE_OK; }
15845 return SQLITE_OK;
15870 return SQLITE_OK;
16099 return SQLITE_OK;
17004 return SQLITE_OK;
17629 return SQLITE_OK;
17738 int rc = SQLITE_OK;
17772 int rc = SQLITE_OK;
17822 ** Obtain the mutex p. If successful, return SQLITE_OK. Otherwise, if another
17826 int rc = SQLITE_OK;
17898 static int noopMutexInit(void){ return SQLITE_OK; }
17899 static int noopMutexEnd(void){ return SQLITE_OK; }
17908 return SQLITE_OK;
17961 static int debugMutexInit(void){ return SQLITE_OK; }
17962 static int debugMutexEnd(void){ return SQLITE_OK; }
18007 ** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK
18023 return SQLITE_OK;
18152 static int pthreadMutexInit(void){ return SQLITE_OK; }
18153 static int pthreadMutexEnd(void){ return SQLITE_OK; }
18269 ** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK
18337 rc = SQLITE_OK;
18342 rc = SQLITE_OK;
18355 rc = SQLITE_OK;
18362 if( rc==SQLITE_OK && p->trace ){
18553 return SQLITE_OK;
18568 return SQLITE_OK;
18664 ** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK
18707 rc = SQLITE_OK;
18713 if( rc==SQLITE_OK && p->trace ){
18873 return SQLITE_OK;
20903 if( rc!=SQLITE_OK ){
21003 return SQLITE_OK;
21016 int rc = SQLITE_OK;
21033 if( rc==SQLITE_OK ){
21343 ** should be called with err_code set to SQLITE_OK and zFormat set
23073 ** a normal expected return code of SQLITE_BUSY or SQLITE_OK
23075 #define IS_LOCK_ERROR(x) ((x != SQLITE_OK) && (x != SQLITE_BUSY))
23569 ** "unix" VFSes. Return SQLITE_OK opon successfully updating the
23586 rc = SQLITE_OK;
23601 rc = SQLITE_OK;
23828 ** SQLITE_OK. The system call failed, and *some* SQLite error should be
23833 return SQLITE_OK;
24392 return SQLITE_OK;
24444 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
24447 int rc = SQLITE_OK;
24596 int rc = SQLITE_OK;
24614 return SQLITE_OK;
24643 ** return SQLITE_OK.
24685 assert( rc==SQLITE_OK );
24699 if( unixFileLock(pFile, &lock) && rc==SQLITE_OK ){
24752 if( rc==SQLITE_OK
24763 if( rc==SQLITE_OK ){
24774 rc==SQLITE_OK ? "ok" : "failed"));
24808 int rc = SQLITE_OK;
24817 return SQLITE_OK;
24958 if( rc==SQLITE_OK ) pFile->eFileLock = eFileLock;
25007 return SQLITE_OK;
25014 int rc = SQLITE_OK;
25061 return SQLITE_OK;
25065 return SQLITE_OK;
25069 return SQLITE_OK;
25114 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
25121 int rc = SQLITE_OK;
25174 int rc = SQLITE_OK;
25188 return SQLITE_OK;
25233 return SQLITE_OK;
25241 return SQLITE_OK;
25260 return SQLITE_OK;
25267 int rc = SQLITE_OK;
25314 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
25317 int rc = SQLITE_OK;
25361 rc = SQLITE_OK;
25399 int rc = SQLITE_OK;
25408 return SQLITE_OK;
25425 rc==SQLITE_OK ? "ok" : "failed"));
25452 return SQLITE_OK;
25458 return SQLITE_OK;
25464 return SQLITE_OK;
25469 return SQLITE_OK;
25477 int rc = SQLITE_OK;
25506 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
25509 int rc = SQLITE_OK;
25580 int rc = SQLITE_OK;
25586 rc = SQLITE_OK;
25622 return SQLITE_OK;
25628 return SQLITE_OK;
25641 return SQLITE_OK;
25657 return SQLITE_OK;
25704 ** Return SQLITE_OK on success, SQLITE_BUSY on failure.
25742 return SQLITE_OK;
25750 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
25753 int rc = SQLITE_OK;
25764 return SQLITE_OK;
25778 if( SQLITE_OK==lrc ){
25823 int rc = SQLITE_OK;
25840 return SQLITE_OK;
25869 ** return SQLITE_OK.
25927 } else if( lrc1 != SQLITE_OK ) {
25960 int failed2 = SQLITE_OK;
25982 if( rc==SQLITE_OK ){
25993 rc==SQLITE_OK ? "ok" : "failed"));
26005 int rc = SQLITE_OK;
26021 return SQLITE_OK;
26049 if( rc==SQLITE_OK && (eFileLock==SHARED_LOCK || pInode->nShared>1) ){
26057 if( rc==SQLITE_OK && pFile->eFileLock>=PENDING_LOCK ){
26060 if( rc==SQLITE_OK && pFile->eFileLock>=RESERVED_LOCK && context->reserved ){
26066 if( rc==SQLITE_OK && (eFileLock==SHARED_LOCK || pInode->nShared>1)){
26070 if( rc==SQLITE_OK && eFileLock==NO_LOCK ){
26090 if( rc==SQLITE_OK ){
26100 if( rc==SQLITE_OK ) pFile->eFileLock = eFileLock;
26108 int rc = SQLITE_OK;
26235 ** Read data from a file into a buffer. Return SQLITE_OK if all
26266 return SQLITE_OK;
26279 return SQLITE_OK;
26349 ** Write data from a buffer into a file. Return SQLITE_OK on success
26400 return SQLITE_OK;
26429 return SQLITE_OK;
26518 rc = SQLITE_OK;
26558 ** SQLITE_OK is returned. If an error occurs, either SQLITE_NOMEM
26572 ** a no-op, replace it with a stub that returns SQLITE_OK but leaves
26575 ** If SQLITE_OK is returned, the caller is responsible for closing
26593 return (fd>=0?SQLITE_OK:unixLogError(SQLITE_CANTOPEN_BKPT, "open", zDirname));
26646 if( rc==SQLITE_OK && dirfd>=0 ){
26650 rc = SQLITE_OK;
26701 return SQLITE_OK;
26729 return SQLITE_OK;
26802 return SQLITE_OK;
26832 return SQLITE_OK;
26836 return SQLITE_OK;
26840 return SQLITE_OK;
26851 return SQLITE_OK;
26855 return SQLITE_OK;
26859 return SQLITE_OK;
26867 return SQLITE_OK;
26879 return SQLITE_OK;
26889 return SQLITE_OK;
27116 int rc = SQLITE_OK; /* Result code form fcntl() */
27136 rc = (rc!=(-1)) ? SQLITE_OK : SQLITE_BUSY;
27144 if( rc==SQLITE_OK ){
27325 rc = SQLITE_OK;
27326 if( unixShmSystemLock(pShmNode, F_WRLCK, UNIX_SHM_DMS, 1)==SQLITE_OK ){
27331 if( rc==SQLITE_OK ){
27358 return SQLITE_OK;
27378 ** separate process), then *pp is set to NULL and SQLITE_OK returned. If
27385 ** memory and SQLITE_OK returned.
27397 int rc = SQLITE_OK;
27402 if( rc!=SQLITE_OK ) return rc;
27432 ** false, exit early. *pp will be set to NULL and SQLITE_OK returned.
27501 if( pShmNode->isReadonly && rc==SQLITE_OK ) rc = SQLITE_READONLY;
27524 int rc = SQLITE_OK; /* Result code */
27556 rc = SQLITE_OK;
27560 if( rc==SQLITE_OK ){
27580 if( rc==SQLITE_OK ){
27584 rc = SQLITE_OK;
27589 if( rc==SQLITE_OK ){
27606 if( rc==SQLITE_OK ){
27608 if( rc==SQLITE_OK ){
27652 if( p==0 ) return SQLITE_OK;
27680 return SQLITE_OK;
27796 unixLogError(SQLITE_OK, zErr, pFd->zPath);
27820 ** SQLITE_OK is returned if no error occurs (even if the mapping is not
27830 if( pFd->nFetchOut>0 ) return SQLITE_OK;
27835 if( rc!=SQLITE_OK ){
27853 return SQLITE_OK;
27860 ** If such a pointer can be obtained, store it in *pp and return SQLITE_OK.
27861 ** Or, if one cannot but no error occurs, set *pp to 0 and return SQLITE_OK.
27878 if( rc!=SQLITE_OK ) return rc;
27886 return SQLITE_OK;
27918 return SQLITE_OK;
28226 int rc = SQLITE_OK;
28285 if( rc!=SQLITE_OK ){
28328 if( rc!=SQLITE_OK ){
28362 if( (rc==SQLITE_OK) && (pNew->pInode->pSem==NULL) ){
28381 if( rc!=SQLITE_OK ){
28388 if( rc!=SQLITE_OK ){
28466 return SQLITE_OK;
28538 ** to create new files with. If no error occurs, then SQLITE_OK is returned
28564 int rc = SQLITE_OK; /* Return Code */
28588 if( nDb==0 || zPath[nDb]!='-' ) return SQLITE_OK;
28646 int rc = SQLITE_OK; /* Function Return Code */
28727 if( rc!=SQLITE_OK ){
28752 if( rc!=SQLITE_OK ){
28855 if( rc==SQLITE_OK ){
28857 if( rc!=SQLITE_OK ){
28874 if( rc!=SQLITE_OK ){
28890 int rc = SQLITE_OK;
28905 if( rc==SQLITE_OK ){
28916 rc = SQLITE_OK;
28963 return SQLITE_OK;
29004 return SQLITE_OK;
29157 ** On success, return SQLITE_OK. Return SQLITE_ERROR if the time and date
29162 int rc = SQLITE_OK;
29432 return SQLITE_OK;
29485 int rc = SQLITE_OK;
29510 if( proxyCreateLockPath(path) == SQLITE_OK ){
29549 if( rc==SQLITE_OK ){
29551 return SQLITE_OK;
29598 return SQLITE_OK;
29677 int rc = SQLITE_OK;
29732 rc = SQLITE_OK;
29756 return SQLITE_OK;
29764 int rc = SQLITE_OK;
29780 if( rc!=SQLITE_OK ){
29862 if( rc==SQLITE_OK ){
29880 if( rc==SQLITE_OK && createConch ){
29912 if( rc==SQLITE_OK && pFile->openFlags ){
29927 if( rc==SQLITE_OK && !pCtx->lockProxy ){
29930 if( rc!=SQLITE_OK && rc!=SQLITE_NOMEM && tryOldLockPath ){
29939 if( rc==SQLITE_OK ){
29950 if( rc==SQLITE_OK ){
29962 rc==SQLITE_OK?"ok":"failed"));
29973 int rc = SQLITE_OK; /* Subroutine return code */
29987 (rc==SQLITE_OK ? "ok" : "failed")));
29994 ** Make *pConchPath point to the new name. Return SQLITE_OK on success
30032 return SQLITE_OK;
30042 int rc = SQLITE_OK;
30051 return SQLITE_OK;
30094 return SQLITE_OK;
30109 int rc = SQLITE_OK;
30131 if( rc==SQLITE_OK ){
30151 rc = SQLITE_OK;
30155 if( rc==SQLITE_OK && lockPath ){
30159 if( rc==SQLITE_OK ){
30165 if( rc==SQLITE_OK ){
30183 (rc==SQLITE_OK ? "ok" : "failed")));
30207 return SQLITE_OK;
30211 int rc = SQLITE_OK;
30219 rc = SQLITE_OK;
30230 rc = SQLITE_OK;
30260 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
30265 if( rc==SQLITE_OK ){
30304 if( rc==SQLITE_OK ){
30328 if( rc==SQLITE_OK ){
30350 int rc = SQLITE_OK;
30378 return SQLITE_OK;
30493 return SQLITE_OK;
30504 return SQLITE_OK;
31631 ** "win32" VFSes. Return SQLITE_OK opon successfully updating the
31648 rc = SQLITE_OK;
31663 rc = SQLITE_OK;
31939 return SQLITE_OK;
32141 ** SQLITE_OK if successful.
32168 return SQLITE_OK;
32281 assert( errcode!=SQLITE_OK );
32488 return SQLITE_OK;
32770 OSTRACE(("SEEK file=%p, rc=SQLITE_OK\n", pFile->h));
32791 OSTRACE(("SEEK file=%p, rc=SQLITE_OK\n", pFile->h));
32825 if( rc!=SQLITE_OK ) return rc;
32852 return rc ? SQLITE_OK
32858 ** Read data from a file into a buffer. Return SQLITE_OK if all
32888 OSTRACE(("READ-MMAP file=%p, rc=SQLITE_OK\n", pFile->h));
32889 return SQLITE_OK;
32928 OSTRACE(("READ file=%p, rc=SQLITE_OK\n", pFile->h));
32929 return SQLITE_OK;
32933 ** Write data from a buffer into a file. Return SQLITE_OK on success
32960 OSTRACE(("WRITE-MMAP file=%p, rc=SQLITE_OK\n", pFile->h));
32961 return SQLITE_OK;
33032 OSTRACE(("WRITE file=%p, rc=SQLITE_OK\n", pFile->h));
33033 return SQLITE_OK;
33041 int rc = SQLITE_OK; /* Return code for this function */
33140 return SQLITE_OK;
33145 OSTRACE(("SYNC file=%p, rc=SQLITE_OK\n", pFile->h));
33146 return SQLITE_OK;
33161 int rc = SQLITE_OK;
33320 int rc = SQLITE_OK; /* Return code from subroutines */
33336 OSTRACE(("LOCK-HELD file=%p, rc=SQLITE_OK\n", pFile->h));
33337 return SQLITE_OK;
33431 rc = SQLITE_OK;
33469 OSTRACE(("TEST-WR-LOCK file=%p, pResOut=%p, *pResOut=%d, rc=SQLITE_OK\n",
33471 return SQLITE_OK;
33488 int rc = SQLITE_OK;
33546 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
33547 return SQLITE_OK;
33551 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
33552 return SQLITE_OK;
33556 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
33557 return SQLITE_OK;
33563 if( rc==SQLITE_OK ){
33574 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
33575 return SQLITE_OK;
33579 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
33580 return SQLITE_OK;
33584 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
33585 return SQLITE_OK;
33589 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
33590 return SQLITE_OK;
33604 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
33605 return SQLITE_OK;
33613 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
33614 return SQLITE_OK;
33624 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
33625 return SQLITE_OK;
33804 rc = SQLITE_OK;
33929 if( SQLITE_OK!=rc ){
33936 if( winShmSystemLock(pShmNode, _SHM_WRLCK, WIN_SHM_DMS, 1)==SQLITE_OK ){
33938 if( rc!=SQLITE_OK ){
33943 if( rc==SQLITE_OK ){
33970 return SQLITE_OK;
33997 if( p==0 ) return SQLITE_OK;
34021 return SQLITE_OK;
34037 int rc = SQLITE_OK; /* Result code */
34065 rc = SQLITE_OK;
34069 if( rc==SQLITE_OK ){
34089 if( rc==SQLITE_OK ){
34093 rc = SQLITE_OK;
34098 if( rc==SQLITE_OK ){
34115 if( rc==SQLITE_OK ){
34117 if( rc==SQLITE_OK ){
34155 ** separate process), then *pp is set to NULL and SQLITE_OK returned. If
34162 ** memory and SQLITE_OK returned.
34174 int rc = SQLITE_OK;
34178 if( rc!=SQLITE_OK ) return rc;
34198 if( rc!=SQLITE_OK ){
34206 ** zero, exit early. *pp will be set to NULL and SQLITE_OK returned.
34213 if( rc!=SQLITE_OK ){
34333 OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, rc=SQLITE_OK\n",
34335 return SQLITE_OK;
34350 ** SQLITE_OK is returned if no error occurs (even if the mapping is not
34362 if( pFd->nFetchOut>0 ) return SQLITE_OK;
34408 return SQLITE_OK;
34425 return SQLITE_OK;
34432 OSTRACE(("MAP-FILE pid=%lu, pFile=%p, rc=SQLITE_OK\n",
34434 return SQLITE_OK;
34442 ** If such a pointer can be obtained, store it in *pp and return SQLITE_OK.
34443 ** Or, if one cannot but no error occurs, set *pp to 0 and return SQLITE_OK.
34463 if( rc!=SQLITE_OK ){
34476 OSTRACE(("FETCH pid=%lu, pFile=%p, pp=%p, *pp=%p, rc=SQLITE_OK\n",
34478 return SQLITE_OK;
34519 OSTRACE(("UNFETCH pid=%lu, pFile=%p, rc=SQLITE_OK\n",
34521 return SQLITE_OK;
34662 OSTRACE(("TEMP-FILENAME name=%s, rc=SQLITE_OK\n", zBuf));
34663 return SQLITE_OK;
34724 int rc = SQLITE_OK; /* Function Return Code */
34790 if( rc!=SQLITE_OK ){
34935 && (rc = winceCreateLock(zName, pFile))!=SQLITE_OK
35041 rc = SQLITE_OK; /* Deleted OK. */
35069 rc = SQLITE_OK; /* Deleted OK. */
35162 OSTRACE(("ACCESS name=%s, pResOut=%p, *pResOut=%d, rc=SQLITE_OK\n",
35164 return SQLITE_OK;
35238 return SQLITE_OK;
35257 return SQLITE_OK;
35287 return SQLITE_OK;
35352 return SQLITE_OK;
35480 ** On success, return SQLITE_OK. Return SQLITE_ERROR if the time and date
35518 return SQLITE_OK;
35615 return SQLITE_OK;
35625 return SQLITE_OK;
35797 if( p==0 ) return SQLITE_OK;
35812 return SQLITE_OK;
35828 if( p->u.aHash[h]==i ) return SQLITE_OK;
35857 return SQLITE_OK;
36315 if( rc!=SQLITE_OK && rc!=SQLITE_BUSY ){
36349 return (pPgHdr==0 && eCreate) ? SQLITE_NOMEM : SQLITE_OK;
37078 return (p->apHash ? SQLITE_OK : SQLITE_NOMEM);
37200 return SQLITE_OK;
38664 ** * The Pager.errCode variable is set to something other than SQLITE_OK.
39146 # define pagerOpenWalIfPresent(z) SQLITE_OK
39147 # define pagerBeginReadTransaction(z) SQLITE_OK
39211 assert( pPager->errCode==SQLITE_OK );
39216 assert( pPager->errCode==SQLITE_OK );
39223 assert( pPager->errCode==SQLITE_OK );
39235 assert( pPager->errCode==SQLITE_OK );
39254 assert( pPager->errCode==SQLITE_OK );
39266 assert( pPager->errCode==SQLITE_OK );
39279 assert( pPager->errCode!=SQLITE_OK );
39370 ** that is read in *pRes. Return SQLITE_OK if everything worked, or an
39378 if( rc==SQLITE_OK ){
39391 ** Write a 32-bit integer into the given file descriptor. Return SQLITE_OK
39410 int rc = SQLITE_OK;
39437 int rc = SQLITE_OK;
39442 if( rc==SQLITE_OK && (pPager->eLock!=UNKNOWN_LOCK||eLock==EXCLUSIVE_LOCK) ){
39554 ** zMaster[0] is set to 0 and SQLITE_OK returned.
39568 if( SQLITE_OK!=(rc = sqlite3OsFileSize(pJrnl, &szJ))
39570 || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-16, &len))
39572 || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-12, &cksum))
39573 || SQLITE_OK!=(rc = sqlite3OsRead(pJrnl, aMagic, 8, szJ-8))
39575 || SQLITE_OK!=(rc = sqlite3OsRead(pJrnl, zMaster, len, szJ-16-len))
39587 ** definitely roll back, so just return SQLITE_OK and report a (nul)
39594 return SQLITE_OK;
39643 ** Otherwise, return SQLITE_OK.
39646 int rc = SQLITE_OK; /* Return code */
39658 if( rc==SQLITE_OK && !pPager->noSync ){
39668 if( rc==SQLITE_OK && iLimit>0 ){
39671 if( rc==SQLITE_OK && sz>iLimit ){
39695 int rc = SQLITE_OK; /* Return code */
39785 for(nWrite=0; rc==SQLITE_OK&&nWrite<JOURNAL_HDR_SZ(pPager); nWrite+=nHeader){
39805 ** is set to the value read from the journal header. SQLITE_OK is returned
39854 if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+8, pNRec))
39855 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+12, &pPager->cksumInit))
39856 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+16, pDbSize))
39866 if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+20, &iSectorSize))
39867 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+24, &iPageSize))
39902 testcase( rc!=SQLITE_OK );
39951 return SQLITE_OK;
39994 if( SQLITE_OK==(rc = sqlite3OsFileSize(pPager->jfd, &jrnlSize))
40046 ** bitvecs of all open savepoints. Return SQLITE_OK if successful
40051 int rc = SQLITE_OK; /* Result code */
40058 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
40123 if( rc!=SQLITE_OK && pPager->eState==PAGER_ERROR ){
40146 pPager->errCode = SQLITE_OK;
40175 assert( rc==SQLITE_OK || !MEMDB );
40178 pPager->errCode==SQLITE_OK ||
40234 ** SQLITE_OK is returned if no error occurs. If an error occurs during
40244 int rc = SQLITE_OK; /* Error code from journal finalization operation */
40245 int rc2 = SQLITE_OK; /* Error code from db file unlock operation */
40263 return SQLITE_OK;
40277 rc = SQLITE_OK;
40328 assert( rc2==SQLITE_OK );
40329 }else if( rc==SQLITE_OK && bCommit && pPager->dbFileSize>pPager->dbSize ){
40349 return (rc==SQLITE_OK?rc2:rc);
40439 ** skipped and SQLITE_OK is returned.
40448 ** and played back, then SQLITE_OK is returned. If an IO error occurs
40505 if( rc!=SQLITE_OK ) return rc;
40507 if( rc!=SQLITE_OK ) return rc;
40520 return SQLITE_OK;
40533 if( pDone && (rc = sqlite3BitvecSet(pDone, pgno))!=SQLITE_OK ){
40634 if( rc!=SQLITE_OK ) return rc;
40723 ** occur, SQLITE_OK is returned.
40752 if( rc!=SQLITE_OK ) goto delmaster_out;
40760 if( rc!=SQLITE_OK ) goto delmaster_out;
40769 if( rc!=SQLITE_OK ) goto delmaster_out;
40776 if( rc!=SQLITE_OK ){
40787 if( rc!=SQLITE_OK ){
40793 if( rc!=SQLITE_OK ){
40837 ** If successful, return SQLITE_OK. If an IO error occurs while modifying
40841 int rc = SQLITE_OK;
40854 if( rc==SQLITE_OK && currentSize!=newSize ){
40864 if( rc==SQLITE_OK ){
40970 ** is then deleted and SQLITE_OK returned, just as if no corruption had
41000 if( rc!=SQLITE_OK ){
41017 if( rc==SQLITE_OK && zMaster[0] ){
41021 if( rc!=SQLITE_OK || !res ){
41038 if( rc!=SQLITE_OK ){
41040 rc = SQLITE_OK;
41079 if( rc!=SQLITE_OK ){
41094 if( rc==SQLITE_OK ){
41106 rc = SQLITE_OK;
41145 if( rc==SQLITE_OK ){
41148 testcase( rc!=SQLITE_OK );
41150 if( rc==SQLITE_OK
41155 if( rc==SQLITE_OK ){
41157 testcase( rc!=SQLITE_OK );
41159 if( rc==SQLITE_OK && zMaster[0] && res ){
41164 testcase( rc!=SQLITE_OK );
41189 ** Otherwise, SQLITE_OK is returned.
41194 int rc = SQLITE_OK; /* Return code */
41203 return SQLITE_OK;
41216 rc = SQLITE_OK;
41284 ** return an SQLite error code. Otherwise, SQLITE_OK.
41287 int rc = SQLITE_OK;
41299 if( rc==SQLITE_OK ){
41302 if( rc==SQLITE_OK ){
41339 while( pList && rc==SQLITE_OK ){
41403 if( rc==SQLITE_OK && pPager->pBackup ){
41443 if( rc!=SQLITE_OK || changed ){
41457 ** If no error occurs, SQLITE_OK is returned and the size of the database
41485 if( rc!=SQLITE_OK ){
41501 return SQLITE_OK;
41515 ** Return SQLITE_OK or an error code.
41524 int rc = SQLITE_OK;
41536 if( rc==SQLITE_IOERR_DELETE_NOENT ) rc = SQLITE_OK;
41543 if( rc==SQLITE_OK ){
41595 int rc = SQLITE_OK; /* Return code */
41637 while( rc==SQLITE_OK && pPager->journalOff<iHdrOff ){
41650 while( rc==SQLITE_OK && pPager->journalOff<szJ ){
41667 for(ii=0; rc==SQLITE_OK && ii<nJRec && pPager->journalOff<szJ; ii++){
41672 assert( rc!=SQLITE_OK || pPager->journalOff>=szJ );
41685 for(ii=pSavepoint->iSubRec; rc==SQLITE_OK && ii<pPager->nSubRec; ii++){
41693 if( rc==SQLITE_OK ){
41822 ** Write the file descriptor into *pFile. Return SQLITE_OK on success
41848 assert( rc!=SQLITE_OK || isOpen(pFile) );
41912 ** In all other cases, SQLITE_OK is returned.
41920 int rc = SQLITE_OK;
41944 if( rc==SQLITE_OK ){
41949 if( rc==SQLITE_OK ){
41960 if( rc==SQLITE_OK ){
42028 ** zeroed and SQLITE_OK returned. The rationale for this is that this
42037 int rc = SQLITE_OK;
42051 rc = SQLITE_OK;
42074 ** (returning SQLITE_OK immediately).
42081 ** Return SQLITE_OK on success and an error code if we cannot obtain
42177 ** If everything goes as planned, SQLITE_OK is returned. Otherwise,
42181 int rc = SQLITE_OK;
42185 if( rc==SQLITE_OK ){
42195 ** and return SQLITE_OK. Otherwise, return an SQLite error code and set
42236 return SQLITE_OK;
42330 return SQLITE_OK;
42381 ** page currently held in memory before returning SQLITE_OK. If an IO
42394 if( rc!=SQLITE_OK ) return rc;
42434 if( rc==SQLITE_OK && 0==memcmp(aMagic, aJournalMagic, 8) ){
42438 if( rc!=SQLITE_OK && rc!=SQLITE_IOERR_SHORT_READ ){
42457 if( rc!=SQLITE_OK ) return rc;
42463 if( rc!=SQLITE_OK ) return rc;
42471 if( rc!=SQLITE_OK ) return rc;
42478 if( rc!=SQLITE_OK ) return rc;
42492 return SQLITE_OK;
42523 ** If everything is successful, SQLITE_OK is returned. If an IO error
42528 int rc = SQLITE_OK; /* Return code */
42536 ** is not possible for rc to be other than SQLITE_OK if this branch
42540 assert( pPager->tempFile && rc==SQLITE_OK );
42547 assert( rc!=SQLITE_OK || isOpen(pPager->fd) );
42548 if( rc==SQLITE_OK
42556 while( rc==SQLITE_OK && pList ){
42613 ** SQLITE_OK is returned if everything goes according to plan. An
42618 int rc = SQLITE_OK;
42637 ** This function returns SQLITE_OK if everything is successful, an IO
42643 int rc = SQLITE_OK;
42659 if( rc==SQLITE_OK ){
42667 if( rc==SQLITE_OK ){
42672 if( rc==SQLITE_OK ){
42694 ** SQLITE_OK returned. If an IO error occurs while trying to make the
42696 ** made clean for some other reason, but no error occurs, then SQLITE_OK
42701 int rc = SQLITE_OK;
42721 if( NEVER(pPager->errCode) ) return SQLITE_OK;
42722 if( pPager->doNotSpill ) return SQLITE_OK;
42724 return SQLITE_OK;
42733 if( rc==SQLITE_OK ){
42773 rc==SQLITE_OK && pPg->pgno>pPager->dbSize && subjRequiresPage(pPg)
42779 if( rc==SQLITE_OK ){
42786 if( rc==SQLITE_OK ){
42819 ** successfully, SQLITE_OK is returned and *ppPager set to point to
42836 int rc = SQLITE_OK; /* Return code */
42899 if( rc==SQLITE_OK && nPathname+8>pVfs->mxPathname ){
42908 if( rc!=SQLITE_OK ){
42986 if( rc==SQLITE_OK && !readOnly ){
43029 if( rc==SQLITE_OK ){
43032 testcase( rc!=SQLITE_OK );
43038 if( rc!=SQLITE_OK ){
43107 return SQLITE_OK;
43127 ** just deleted using OsDelete, *pExists is set to 0 and SQLITE_OK
43138 ** SQLITE_OK returned. If no hot-journal file is present, *pExists is
43139 ** set to 0 and SQLITE_OK returned. If an IO error occurs while trying
43145 int rc = SQLITE_OK; /* Return code */
43161 if( rc==SQLITE_OK && exists ){
43173 if( rc==SQLITE_OK && !locked ){
43183 if( rc==SQLITE_OK ){
43186 if( pagerLockDb(pPager, RESERVED_LOCK)==SQLITE_OK ){
43202 if( rc==SQLITE_OK ){
43206 rc = SQLITE_OK;
43223 rc = SQLITE_OK;
43256 ** If everything is successful, SQLITE_OK is returned. If an IO error
43261 int rc = SQLITE_OK; /* Return code */
43279 if( rc!=SQLITE_OK ){
43290 if( rc!=SQLITE_OK ){
43315 if( rc!=SQLITE_OK ){
43337 if( rc==SQLITE_OK && bExists ){
43342 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
43343 if( rc==SQLITE_OK && fout&SQLITE_OPEN_READONLY ){
43359 assert( rc==SQLITE_OK );
43361 if( rc==SQLITE_OK ){
43369 if( rc!=SQLITE_OK ){
43426 if( rc!=SQLITE_OK && rc!=SQLITE_IOERR_SHORT_READ ){
43453 assert( pPager->pWal==0 || rc==SQLITE_OK );
43458 assert( rc==SQLITE_OK );
43462 if( pPager->eState==PAGER_OPEN && rc==SQLITE_OK ){
43467 if( rc!=SQLITE_OK ){
43494 ** successfully obtained, it is copied to *ppPage and SQLITE_OK returned.
43547 int rc = SQLITE_OK;
43573 if( pPager->errCode!=SQLITE_OK ){
43579 if( rc!=SQLITE_OK ) goto pager_acquire_err;
43589 if( rc==SQLITE_OK && pData ){
43599 assert( rc==SQLITE_OK );
43601 return SQLITE_OK;
43604 if( rc!=SQLITE_OK ){
43612 if( rc!=SQLITE_OK ){
43627 return SQLITE_OK;
43669 if( rc!=SQLITE_OK ) goto pager_acquire_err;
43674 if( rc!=SQLITE_OK ){
43681 return SQLITE_OK;
43684 assert( rc!=SQLITE_OK );
43753 ** Return SQLITE_OK if everything is successful. Otherwise, return
43758 int rc = SQLITE_OK; /* Return code */
43795 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
43802 if( rc==SQLITE_OK ){
43812 if( rc!=SQLITE_OK ){
43841 int rc = SQLITE_OK;
43856 if( rc!=SQLITE_OK ){
43875 if( rc==SQLITE_OK && exFlag ){
43880 if( rc==SQLITE_OK ){
43897 assert( rc==SQLITE_OK || pPager->eState==PAGER_READER );
43898 assert( rc!=SQLITE_OK || pPager->eState==PAGER_WRITER_LOCKED );
43916 int rc = SQLITE_OK;
43949 if( rc!=SQLITE_OK ) return rc;
43992 if( rc!=SQLITE_OK ) return rc;
43994 if( rc!=SQLITE_OK ) return rc;
43996 if( rc!=SQLITE_OK ) return rc;
44010 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
44012 if( rc!=SQLITE_OK ){
44048 ** this routine returns SQLITE_OK.
44056 ** as appropriate. Otherwise, SQLITE_OK.
44059 int rc = SQLITE_OK;
44103 for(ii=0; ii<nPage && rc==SQLITE_OK; ii++){
44109 if( rc==SQLITE_OK ){
44131 if( rc==SQLITE_OK && needSync ){
44208 int rc = SQLITE_OK;
44240 assert( pPgHdr==0 || rc==SQLITE_OK );
44245 ** above is always successful - hence the ALWAYS on rc==SQLITE_OK.
44247 if( !DIRECT_MODE && ALWAYS(rc==SQLITE_OK) ){
44251 if( rc==SQLITE_OK ){
44260 if( rc==SQLITE_OK ){
44264 if( rc==SQLITE_OK ){
44288 ** function returns SQLITE_OK. Otherwise, an IO error code is returned.
44291 int rc = SQLITE_OK;
44299 rc = SQLITE_OK;
44312 ** successful, or the connection is in WAL mode, SQLITE_OK is returned.
44317 int rc = SQLITE_OK;
44360 int rc = SQLITE_OK; /* Return code */
44376 if( pPager->eState<PAGER_WRITER_CACHEMOD ) return SQLITE_OK;
44395 assert( rc==SQLITE_OK );
44400 if( rc==SQLITE_OK ){
44447 if( rc==SQLITE_OK ){
44454 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
44461 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
44475 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
44478 if( rc!=SQLITE_OK ){
44494 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
44506 if( rc==SQLITE_OK && !pagerUseWal(pPager) ){
44526 ** moves into the error state. Otherwise, SQLITE_OK is returned.
44529 int rc = SQLITE_OK; /* Return code */
44559 return SQLITE_OK;
44594 int rc = SQLITE_OK; /* Return code */
44603 if( pPager->eState<=PAGER_READER ) return SQLITE_OK;
44609 if( rc==SQLITE_OK ) rc = rc2;
44626 assert( pPager->eState==PAGER_READER || rc!=SQLITE_OK );
44627 assert( rc==SQLITE_OK || rc==SQLITE_FULL || rc==SQLITE_CORRUPT
44730 ** returned. Otherwise, SQLITE_OK.
44733 int rc = SQLITE_OK; /* Return code */
44809 ** savepoint. If no errors occur, SQLITE_OK is returned.
44817 if( rc==SQLITE_OK && iSavepoint<pPager->nSavepoint ){
44838 assert( rc==SQLITE_OK );
44950 ** occurs. Otherwise, it returns SQLITE_OK.
44992 && SQLITE_OK!=(rc = subjournalPage(pPg))
45065 if( rc!=SQLITE_OK ){
45077 return SQLITE_OK;
45206 int rc = SQLITE_OK;
45213 assert( rc==SQLITE_OK );
45216 if( rc==SQLITE_OK ){
45219 if( rc==SQLITE_OK && state==PAGER_READER ){
45294 int rc = SQLITE_OK;
45327 if( rc!=SQLITE_OK ){
45343 int rc = SQLITE_OK;
45360 if( rc==SQLITE_OK ){
45379 ** return SQLITE_OK. If an error occurs or the VFS used by the pager does
45384 ** the WAL file is already open, set *pbOpen to 1 and return SQLITE_OK
45391 int rc = SQLITE_OK; /* Return code */
45406 if( rc==SQLITE_OK ){
45427 int rc = SQLITE_OK;
45438 if( rc==SQLITE_OK ){
45443 if( rc==SQLITE_OK && logexists ){
45451 if( rc==SQLITE_OK && pPager->pWal ){
45453 if( rc==SQLITE_OK ){
46011 ** page and SQLITE_OK is returned. If an error (an OOM or VFS error) occurs,
46015 int rc = SQLITE_OK;
46043 rc = SQLITE_OK;
46049 assert( iPage==0 || *ppPage || rc!=SQLITE_OK );
46273 if( pWal->exclusiveMode ) return SQLITE_OK;
46278 VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && rc!=SQLITE_BUSY); )
46289 if( pWal->exclusiveMode ) return SQLITE_OK;
46294 VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && rc!=SQLITE_BUSY); )
46344 assert( rc==SQLITE_OK || iHash>0 );
46346 if( rc==SQLITE_OK ){
46478 if( rc==SQLITE_OK ){
46584 if( rc!=SQLITE_OK ){
46602 if( rc!=SQLITE_OK ){
46661 if( rc!=SQLITE_OK ) break;
46665 if( rc!=SQLITE_OK ) break;
46683 if( rc==SQLITE_OK ){
46745 ** If the log file is successfully opened, SQLITE_OK is returned and
46796 if( rc==SQLITE_OK && flags&SQLITE_OPEN_READONLY ){
46800 if( rc!=SQLITE_OK ){
47012 ** return SQLITE_OK. Otherwise, return an error code. If this routine
47025 int rc = SQLITE_OK; /* Return Code */
47055 for(i=0; rc==SQLITE_OK && i<nSegment; i++){
47061 if( rc==SQLITE_OK ){
47087 if( rc!=SQLITE_OK ){
47176 if( pInfo->nBackfill>=pWal->hdr.mxFrame ) return SQLITE_OK;
47180 if( rc!=SQLITE_OK ){
47199 if( rc==SQLITE_OK ){
47212 && (rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_READ_LOCK(0), 1))==SQLITE_OK
47225 if( rc==SQLITE_OK ){
47228 if( rc==SQLITE_OK && nSize<nReq ){
47235 while( rc==SQLITE_OK && 0==walIteratorNext(pIter, &iDbpage, &iFrame) ){
47242 if( rc!=SQLITE_OK ) break;
47246 if( rc!=SQLITE_OK ) break;
47250 if( rc==SQLITE_OK ){
47255 if( rc==SQLITE_OK && sync_flags ){
47259 if( rc==SQLITE_OK ){
47271 rc = SQLITE_OK;
47279 if( rc==SQLITE_OK && eMode!=SQLITE_CHECKPOINT_PASSIVE ){
47286 if( rc==SQLITE_OK ){
47306 if( rx==SQLITE_OK && (sz > nMax ) ){
47324 int rc = SQLITE_OK;
47337 if( rc==SQLITE_OK ){
47344 if( rc==SQLITE_OK ){
47351 ** fsyned (rc==SQLITE_OK) and if we are not in persistent-wal
47356 ** completed and fsynced (rc==SQLITE_OK) and we are in persistent
47452 ** If the wal-index header is successfully read, return SQLITE_OK.
47465 if( rc!=SQLITE_OK ){
47483 if( SQLITE_OK==(rc = walLockShared(pWal, WAL_WRITE_LOCK)) ){
47487 }else if( SQLITE_OK==(rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1)) ){
47489 if( SQLITE_OK==(rc = walIndexPage(pWal, 0, &page0)) ){
47527 ** On success return SQLITE_OK. On a permanent failure (such an
47577 int rc = SQLITE_OK; /* Return code */
47628 }else if( SQLITE_OK==(rc = walLockShared(pWal, WAL_RECOVER_LOCK)) ){
47635 if( rc!=SQLITE_OK ){
47647 if( rc==SQLITE_OK ){
47666 return SQLITE_OK;
47694 if( rc==SQLITE_OK ){
47771 testcase( rc==SQLITE_OK );
47792 ** Return SQLITE_OK if successful, or an error code if an error occurs. If an
47815 return SQLITE_OK;
47852 if( rc!=SQLITE_OK ){
47886 return SQLITE_OK;
47891 ** (which is nOut bytes in size). Return SQLITE_OK if successful, or an
47978 return SQLITE_OK;
47987 ** other than SQLITE_OK, it is not invoked again and the error code is
47991 ** function returns SQLITE_OK.
47994 int rc = SQLITE_OK;
48005 ALWAYS(rc==SQLITE_OK) && iFrame<=iMax;
48024 assert( rc==SQLITE_OK );
48049 int rc = SQLITE_OK;
48082 ** SQLITE_OK is returned if no error is encountered (regardless of whether
48087 int rc = SQLITE_OK;
48097 if( rc==SQLITE_OK ){
48135 testcase( rc==SQLITE_OK );
48246 if( SQLITE_OK!=(rc = walRestartLog(pWal)) ){
48277 if( rc!=SQLITE_OK ){
48364 for(p=pList; p && rc==SQLITE_OK; p=p->pDirty){
48368 while( rc==SQLITE_OK && nExtra>0 ){
48374 if( rc==SQLITE_OK ){
48445 if( rc==SQLITE_OK ){
48449 rc = SQLITE_OK;
48454 if( rc==SQLITE_OK ){
48462 if( rc==SQLITE_OK ){
48470 if( rc==SQLITE_OK || rc==SQLITE_BUSY ){
48491 return (rc==SQLITE_OK && eMode!=eMode2 ? SQLITE_BUSY : rc);
48549 if( walLockShared(pWal, WAL_READ_LOCK(pWal->readLock))!=SQLITE_OK ){
49357 if( sqlite3_mutex_try(p->pBt->mutex)==SQLITE_OK ){
49637 return SQLITE_OK;
49653 #define querySharedCacheTableLock(a,b,c) SQLITE_OK
49654 #define setSharedCacheTableLock(a,b,c) SQLITE_OK
49784 ** SQLITE_OK if the lock may be obtained (by calling
49805 return SQLITE_OK;
49837 return SQLITE_OK;
49854 ** already been called and returned SQLITE_OK).
49856 ** SQLITE_OK is returned if the lock is added successfully. SQLITE_NOMEM
49877 assert( SQLITE_OK==querySharedCacheTableLock(p, iTable, eLock) );
49910 return SQLITE_OK;
50089 int rc = SQLITE_OK;
50097 if( rc==SQLITE_OK && pgno<=sqlite3BitvecSize(pBt->pHasContent) ){
50152 assert( rc==SQLITE_OK ); /* KeySize() cannot fail */
50164 if( rc==SQLITE_OK ){
50175 if( rc==SQLITE_OK ){
50197 if( SQLITE_OK!=rc ){
50206 return SQLITE_OK;
50269 if( rc==SQLITE_OK ){
50280 SQLITE_OK)
50303 return SQLITE_OK;
50336 ** If *pRC is initially non-zero (non-SQLITE_OK) then this routine is
50360 if( rc!=SQLITE_OK ){
50375 if( rc==SQLITE_OK ){
50390 ** An error code is returned if something goes wrong, otherwise SQLITE_OK.
50420 return SQLITE_OK;
50425 #define ptrmapGet(w,x,y,z) SQLITE_OK
50713 return SQLITE_OK;
50719 ** of the first byte of allocated space. Return either SQLITE_OK or
50790 return SQLITE_OK;
50817 return SQLITE_OK;
50906 return SQLITE_OK;
50944 return SQLITE_OK;
50950 ** Return SQLITE_OK on success. If we see that the page does
50952 ** SQLITE_CORRUPT. Note that a return of SQLITE_OK does not
51061 return SQLITE_OK;
51143 return SQLITE_OK;
51195 if( rc==SQLITE_OK ){
51197 if( rc!=SQLITE_OK ){
51292 int rc = SQLITE_OK; /* Result code from this function */
51424 if( rc==SQLITE_OK ){
51428 if( rc!=SQLITE_OK ){
51529 if( rc!=SQLITE_OK ){
51633 sqlite3BtreeRollback(p, SQLITE_OK);
51665 return SQLITE_OK;
51689 return SQLITE_OK;
51702 return SQLITE_OK;
51726 return SQLITE_OK;
51766 int rc = SQLITE_OK;
51874 int rc = SQLITE_OK;
51914 ** SQLITE_OK is returned on success. If the file is not a
51929 if( rc!=SQLITE_OK ) return rc;
51931 if( rc!=SQLITE_OK ) return rc;
51967 ** return SQLITE_OK and return without populating BtShared.pPage1.
51976 if( rc!=SQLITE_OK ){
51980 return SQLITE_OK;
52007 ** zero and return SQLITE_OK. The caller will call this function
52058 return SQLITE_OK;
52121 return SQLITE_OK;
52150 return SQLITE_OK;
52155 ** consisting of a single page and no schema objects). Return SQLITE_OK
52205 int rc = SQLITE_OK;
52254 if( SQLITE_OK!=rc ) goto trans_begun;
52260 ** lockBtree() returns something other than SQLITE_OK. lockBtree()
52261 ** may return SQLITE_OK but leave pBt->pPage1 set to 0 if after
52266 while( pBt->pPage1==0 && SQLITE_OK==(rc = lockBtree(pBt)) );
52268 if( rc==SQLITE_OK && wrflag ){
52273 if( rc==SQLITE_OK ){
52279 if( rc!=SQLITE_OK ){
52285 if( rc==SQLITE_OK ){
52318 if( rc==SQLITE_OK ){
52327 if( rc==SQLITE_OK && wrflag ){
52357 if( rc!=SQLITE_OK ){
52444 return SQLITE_OK;
52479 if( rc!=SQLITE_OK ){
52494 if( rc!=SQLITE_OK ){
52501 if( rc!=SQLITE_OK ){
52513 if( rc!=SQLITE_OK ){
52517 if( rc!=SQLITE_OK ){
52523 if( rc==SQLITE_OK ){
52535 ** SQLITE_OK. If there is no work to do (and therefore no point in
52567 if( rc!=SQLITE_OK ){
52584 if( rc!=SQLITE_OK ){
52597 if( rc!=SQLITE_OK ){
52615 if( rc!=SQLITE_OK ){
52625 if( rc!=SQLITE_OK ){
52638 return SQLITE_OK;
52670 ** SQLITE_OK is returned. Otherwise an SQLite error code.
52689 if( rc==SQLITE_OK ){
52693 if( rc==SQLITE_OK ){
52709 ** If SQLITE_OK is returned, then *pnTrunc is set to the number of pages
52715 int rc = SQLITE_OK;
52743 for(iFree=nOrig; iFree>nFin && rc==SQLITE_OK; iFree--){
52746 if( (rc==SQLITE_DONE || rc==SQLITE_OK) && nFree>0 ){
52754 if( rc!=SQLITE_OK ){
52764 # define setChildPtrmaps(x) SQLITE_OK
52794 int rc = SQLITE_OK;
52801 if( rc!=SQLITE_OK ){
52883 if( p->inTrans==TRANS_NONE ) return SQLITE_OK;
52896 if( rc!=SQLITE_OK && bCleanup==0 ){
52906 return SQLITE_OK;
52916 if( rc==SQLITE_OK ){
52972 if( tripCode==SQLITE_OK ){
52975 rc = SQLITE_OK;
52987 if( rc2!=SQLITE_OK ){
52994 if( btreeGetPage(pBt, 1, &pPage1, 0, 0)==SQLITE_OK ){
53062 int rc = SQLITE_OK;
53069 if( rc==SQLITE_OK ){
53165 return SQLITE_OK;
53262 return SQLITE_OK;
53335 ** This routine cannot fail. It always returns SQLITE_OK.
53346 return SQLITE_OK;
53357 ** Failure is not possible. This function always returns SQLITE_OK.
53366 return SQLITE_OK;
53396 int rc = SQLITE_OK;
53419 if( rc==SQLITE_OK && eType==PTRMAP_OVERFLOW2 && pgno==ovfl ){
53428 if( rc==SQLITE_OK ){
53430 assert( rc==SQLITE_OK || pPage==0 );
53431 if( rc==SQLITE_OK ){
53442 return (rc==SQLITE_DONE ? SQLITE_OK : rc);
53454 ** SQLITE_OK is returned on success, otherwise an error code.
53466 if( rc!=SQLITE_OK ){
53474 return SQLITE_OK;
53513 int rc = SQLITE_OK;
53549 if( rc==SQLITE_OK && amt>0 ){
53584 for( ; rc==SQLITE_OK && amt>0 && nextPage; iIdx++){
53653 if( rc==SQLITE_OK ){
53667 if( rc==SQLITE_OK && amt>0 ){
53681 ** Return SQLITE_OK on success or an error code if anything goes
53698 ** Return SQLITE_OK on success or an error code if anything goes
53713 if( rc==SQLITE_OK ){
53846 return SQLITE_OK;
53926 int rc = SQLITE_OK;
53936 assert( pCur->skipNext!=SQLITE_OK );
53950 return SQLITE_OK;
53953 if( rc!=SQLITE_OK ){
54005 int rc = SQLITE_OK;
54010 while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
54030 int rc = SQLITE_OK;
54035 while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
54040 if( rc==SQLITE_OK ){
54048 /* Move the cursor to the first entry in the table. Return SQLITE_OK
54058 if( rc==SQLITE_OK ){
54071 /* Move the cursor to the last entry in the table. Return SQLITE_OK
54093 return SQLITE_OK;
54097 if( rc==SQLITE_OK ){
54105 pCur->atLast = rc==SQLITE_OK ?1:0;
54160 return SQLITE_OK;
54164 return SQLITE_OK;
54178 return SQLITE_OK;
54280 rc = SQLITE_OK;
54306 rc = SQLITE_OK;
54348 if( rc!=SQLITE_OK ){
54354 return SQLITE_OK;
54359 return SQLITE_OK;
54388 return SQLITE_OK;
54397 rc = SQLITE_OK;
54403 return SQLITE_OK;
54422 if( rc!=SQLITE_OK ){
54428 return SQLITE_OK;
54433 return SQLITE_OK;
54451 return SQLITE_OK;
54463 rc = SQLITE_OK;
54478 ** SQLITE_OK is returned on success. Any other return value indicates
54613 if( rc!=SQLITE_OK ){
54631 if( rc!=SQLITE_OK ){
54635 if( rc!=SQLITE_OK ){
54711 if( rc==SQLITE_OK ){
54713 if( rc!=SQLITE_OK ){
54759 if( rc==SQLITE_OK ){
54775 if( rc!=SQLITE_OK ){
54786 if( rc==SQLITE_OK ){
54795 assert( rc!=SQLITE_OK || sqlite3PagerIswriteable((*ppPage)->pDbPage) );
54868 if( rc!=SQLITE_OK ){
54894 if( rc==SQLITE_OK ){
54913 if( pPage==0 && SQLITE_OK!=(rc = btreeGetPage(pBt, iPage, &pPage, 0, 0)) ){
54917 if( rc!=SQLITE_OK ){
54934 if( (*pRC)==SQLITE_OK ){
54953 return SQLITE_OK; /* No overflow pages. Return without doing anything */
55001 return SQLITE_OK;
55103 if( pBt->autoVacuum && rc==SQLITE_OK ){
55163 return SQLITE_OK;
55278 if( rc!=SQLITE_OK ){
55420 if( rc==SQLITE_OK ){
55542 if( (*pRC)==SQLITE_OK ){
55568 if( rc!=SQLITE_OK ){
55639 int rc = SQLITE_OK; /* The return code */
55972 if( rc!=SQLITE_OK ){
56094 if( rc!=SQLITE_OK ) goto balance_cleanup;
56275 ** page and SQLITE_OK is returned. In this case the caller is required
56293 if( rc==SQLITE_OK ){
56323 return SQLITE_OK;
56337 int rc = SQLITE_OK;
56358 if( rc==SQLITE_OK ){
56374 if( rc==SQLITE_OK ){
56440 }while( rc==SQLITE_OK );
56490 assert( pCur->skipNext!=SQLITE_OK );
56571 assert( rc!=SQLITE_OK || pPage->nCell>0 || pPage->nOverflow>0 );
56595 if( rc==SQLITE_OK && pPage->nOverflow ){
56715 if( rc==SQLITE_OK && pCur->iPage>iCellDepth ){
56722 if( rc==SQLITE_OK ){
56788 if( rc!=SQLITE_OK ){
56807 if( rc!=SQLITE_OK ){
56813 if( rc!=SQLITE_OK ){
56820 if( rc!=SQLITE_OK ){
56830 if( rc!=SQLITE_OK ){
56834 if( rc!=SQLITE_OK ){
56838 if( rc!=SQLITE_OK ){
56879 return SQLITE_OK;
56959 if( SQLITE_OK==rc ){
57036 if( rc!=SQLITE_OK ){
57047 if( rc!=SQLITE_OK ){
57052 if( rc!=SQLITE_OK ){
57059 if( rc!=SQLITE_OK ){
57120 assert( SQLITE_OK==querySharedCacheTableLock(p, MASTER_ROOT, READ_LOCK) );
57151 if( rc==SQLITE_OK ){
57170 ** SQLITE_OK is returned if the operation is successfully executed.
57180 return SQLITE_OK;
57187 while( rc==SQLITE_OK ){
57207 ** If all pages in the tree have been visited, return SQLITE_OK to the
57215 return SQLITE_OK;
57337 if( rc!=SQLITE_OK ){
57812 int rc = SQLITE_OK;
57876 ** sqlite_master table. Otherwise SQLITE_OK.
57883 assert( rc==SQLITE_OK || rc==SQLITE_LOCKED_SHAREDCACHE );
57896 int rc = SQLITE_OK;
57905 if( rc==SQLITE_OK ){
57932 if( rc!=SQLITE_OK ){
57946 ** saveAllCursors can only return SQLITE_OK.
57949 assert( rc==SQLITE_OK );
58006 if( rc==SQLITE_OK ){
58010 if( rc==SQLITE_OK ){
58012 if( rc==SQLITE_OK ){
58239 return (rc!=SQLITE_OK && rc!=SQLITE_BUSY && ALWAYS(rc!=SQLITE_LOCKED));
58265 int rc = SQLITE_OK;
58297 if( rc==SQLITE_OK && newPgsz!=nSrcPgsz ) rc = SQLITE_READONLY;
58305 for(iOff=iEnd-(i64)nSrcPgsz; rc==SQLITE_OK && iOff<iEnd; iOff+=nDestPgsz){
58309 if( SQLITE_OK==(rc = sqlite3PagerGet(pDestPager, iDest, &pDestPg))
58310 && SQLITE_OK==(rc = sqlite3PagerWrite(pDestPg))
58340 ** Return SQLITE_OK if everything is successful, or an SQLite error
58346 if( rc==SQLITE_OK && iCurrent>iSize ){
58394 rc = SQLITE_OK;
58398 if( SQLITE_OK==rc && p->bDestLocked==0
58399 && SQLITE_OK==(rc = sqlite3BtreeBeginTrans(p->pDest, 2))
58409 if( rc==SQLITE_OK && 0==sqlite3BtreeIsInReadTrans(p->pSrc) ){
58419 if( SQLITE_OK==rc && destMode==PAGER_JOURNALMODE_WAL && pgszSrc!=pgszDest ){
58434 if( rc==SQLITE_OK ){
58441 if( rc==SQLITE_OK ){
58461 if( rc==SQLITE_OK || rc==SQLITE_DONE ){
58464 if( rc==SQLITE_OK ){
58472 if( rc==SQLITE_OK ){
58530 for(iPg=nDestTruncate; rc==SQLITE_OK && iPg<=(Pgno)nDstPage; iPg++){
58534 if( rc==SQLITE_OK ){
58540 if( rc==SQLITE_OK ){
58548 rc==SQLITE_OK && iOff<iEnd;
58554 if( rc==SQLITE_OK ){
58560 if( rc==SQLITE_OK ){
58565 if( rc==SQLITE_OK ){
58574 if( SQLITE_OK==rc
58575 && SQLITE_OK==(rc = sqlite3BtreeCommitPhaseTwo(p->pDest, 0))
58591 assert( rc2==SQLITE_OK );
58616 if( p==0 ) return SQLITE_OK;
58637 sqlite3BtreeRollback(p->pDest, SQLITE_OK);
58640 rc = (p->rc==SQLITE_DONE) ? SQLITE_OK : p->rc;
58701 if( rc!=SQLITE_OK ){
58748 if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
58771 assert( b.rc!=SQLITE_OK );
58773 if( rc==SQLITE_OK ){
58816 ** SQLITE_OK is returned if the conversion is successful (or not required).
58828 return SQLITE_OK;
58835 /* MemTranslate() may return SQLITE_OK or SQLITE_NOMEM. If NOMEM is returned,
58839 assert(rc==SQLITE_OK || rc==SQLITE_NOMEM);
58840 assert(rc==SQLITE_OK || pMem->enc!=desiredEnc);
58898 return (pMem->z ? SQLITE_OK : SQLITE_NOMEM);
58907 ** Return SQLITE_OK on success or SQLITE_NOMEM if malloc fails.
58927 return SQLITE_OK;
58955 return SQLITE_OK;
58966 return SQLITE_OK; /* Nothing to do */
58974 return SQLITE_OK;
58991 int rc = SQLITE_OK;
59031 ** Return SQLITE_ERROR if the finalizer reports an error. SQLITE_OK
59035 int rc = SQLITE_OK;
59232 return SQLITE_OK;
59245 return SQLITE_OK;
59270 return SQLITE_OK;
59426 int rc = SQLITE_OK;
59493 return SQLITE_OK;
59554 return SQLITE_OK;
59697 int rc = SQLITE_OK; /* Return code */
59715 }else if( SQLITE_OK==(rc = sqlite3VdbeMemGrow(pMem, amt+2, 0)) ){
59726 if( rc!=SQLITE_OK ){
59762 if( sqlite3VdbeMemMakeWriteable(pVal)!=SQLITE_OK ){
59819 return SQLITE_OK;
59866 if( SQLITE_OK==sqlite3ValueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal) ){
59901 return SQLITE_OK;
60055 return (pNew ? SQLITE_OK : SQLITE_NOMEM);
61078 int rc = SQLITE_OK; /* Return code */
61083 assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY || p->rc==SQLITE_NOMEM );
61129 p->rc = SQLITE_OK;
61177 if( j==nSub && SQLITE_OK==sqlite3VdbeMemGrow(pSub, nByte, nSub!=0) ){
61246 p->rc = SQLITE_OK;
61364 p->rc = SQLITE_OK;
61679 int rc = SQLITE_OK;
61684 ** SQLITE_OK so p is not used.
61703 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
61713 if( rc!=SQLITE_OK ){
61737 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
61749 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
61755 if( rc==SQLITE_OK ){
61800 }while( rc==SQLITE_OK && res );
61801 if( rc==SQLITE_OK ){
61808 if( rc!=SQLITE_OK ){
61832 if( rc!=SQLITE_OK ){
61846 && SQLITE_OK!=(rc = sqlite3OsSync(pMaster, SQLITE_SYNC_NORMAL))
61864 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
61872 if( rc!=SQLITE_OK ){
61950 ** Otherwise SQLITE_OK.
61954 int rc = SQLITE_OK;
61970 int rc2 = SQLITE_OK;
61976 if( rc2==SQLITE_OK ){
61979 if( rc==SQLITE_OK ){
61987 if( rc==SQLITE_OK ){
61991 if( rc==SQLITE_OK ){
62010 ** violations, return SQLITE_ERROR. Otherwise, SQLITE_OK.
62025 return SQLITE_OK;
62068 return SQLITE_OK;
62114 if( p->rc==SQLITE_OK ){
62128 if( p->rc==SQLITE_OK || (p->errorAction==OE_Fail && !isSpecialError) ){
62130 if( rc!=SQLITE_OK ){
62146 }else if( rc!=SQLITE_OK ){
62148 sqlite3RollbackAll(db, SQLITE_OK);
62154 sqlite3RollbackAll(db, SQLITE_OK);
62158 if( p->rc==SQLITE_OK || p->errorAction==OE_Fail ){
62172 ** error code is SQLITE_OK or SQLITE_CONSTRAINT, then promote the
62178 if( p->rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT ){
62228 return (p->rc==SQLITE_BUSY ? SQLITE_BUSY : SQLITE_OK);
62234 ** in p->rc. This routine sets that result back to SQLITE_OK.
62237 p->rc = SQLITE_OK;
62270 if( sqlite3GlobalConfig.xSqllog && v->rc==SQLITE_OK && v->zSql && v->pc>=0 ){
62365 int rc = SQLITE_OK;
62487 return SQLITE_OK;
63005 ** Return SQLITE_OK if everything works, or an error code otherwise.
63027 assert( rc==SQLITE_OK ); /* pCur is always valid so KeySize cannot fail */
63069 return SQLITE_OK;
63083 ** or greater than pUnpacked. Return SQLITE_OK on success.
63102 assert( rc==SQLITE_OK ); /* pCur is always valid so KeySize cannot fail */
63117 return SQLITE_OK;
63270 rc = SQLITE_OK;
63294 rc = SQLITE_OK;
63312 int rc = SQLITE_OK;
63510 int rc = SQLITE_OK;
63517 if( db->xWalCallback && nEntry>0 && rc==SQLITE_OK ){
63623 assert( p->rc==SQLITE_OK );
63625 if( p->rc!=SQLITE_OK ){
63662 int rc = SQLITE_OK; /* Result from sqlite3Step() */
63663 int rc2 = SQLITE_OK; /* Result from sqlite3Reprepare() */
63676 && (rc2 = rc = sqlite3Reprepare(v))==SQLITE_OK ){
63681 if( rc2!=SQLITE_OK && ALWAYS(v->isPrepareV2) && ALWAYS(db->pErr) ){
64168 ** out of range, then SQLITE_RANGE is returned. Othewise SQLITE_OK.
64198 sqlite3Error(p->db, SQLITE_OK, 0);
64214 return SQLITE_OK;
64233 if( rc==SQLITE_OK ){
64237 if( rc==SQLITE_OK && encoding!=0 ){
64267 if( rc==SQLITE_OK ){
64280 if( rc==SQLITE_OK ){
64290 if( rc==SQLITE_OK ){
64350 if( rc==SQLITE_OK ){
64418 return SQLITE_OK;
64432 ** SQLITE_OK is returned.
65023 if( SQLITE_OK==sqlite3VdbeMemGrow(pMem, nByte, 0) ){
65439 int rc = SQLITE_OK; /* Value to return */
65897 assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY );
65898 p->rc = SQLITE_OK;
65919 for(pc=p->pc; rc==SQLITE_OK; pc++){
66135 ** or sqlite3_finalize(). For a normal halt, this should be SQLITE_OK (0).
66149 if( pOp->p1==SQLITE_OK && p->pFrame ){
66174 assert( p->rc!=SQLITE_OK );
66183 assert( rc==SQLITE_BUSY || rc==SQLITE_OK || rc==SQLITE_ERROR );
66187 assert( rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT );
66188 assert( rc==SQLITE_OK || db->nDeferredCons>0 );
66242 if( SQLITE_OK!=sqlite3VdbeChangeEncoding(pOut, encoding) ) goto no_mem;
66460 if( SQLITE_OK!=(rc = sqlite3VdbeCheckFk(p, 0)) ){
66483 if( NEVER(rc!=SQLITE_OK) ){
67582 assert( rc==SQLITE_OK ); /* True because of CursorMoveto() call above */
67591 assert( rc==SQLITE_OK ); /* DataSize() cannot fail */
67705 if( rc!=SQLITE_OK ){
67767 assert( rc==SQLITE_OK );
67789 if( rc!=SQLITE_OK ){
68061 if( rc!=SQLITE_OK ) goto abort_due_to_error;
68116 if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){
68137 if( rc!=SQLITE_OK ){
68174 if( rc!=SQLITE_OK ) goto abort_due_to_error;
68228 }else if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){
68241 if( p->rc==SQLITE_OK ){
68305 if( rc!=SQLITE_OK ){
68320 if( rc==SQLITE_OK ){
68589 ** sqlite3BtreeCursor() may return is SQLITE_OK. */
68590 assert( rc==SQLITE_OK );
68649 if( rc==SQLITE_OK ){
68652 if( rc==SQLITE_OK ){
68662 if( rc==SQLITE_OK ){
68850 if( rc!=SQLITE_OK ) goto abort_due_to_error;
68855 if( rc!=SQLITE_OK ) goto abort_due_to_error;
68872 if( rc!=SQLITE_OK ){
68905 if( rc!=SQLITE_OK ){
68918 if( rc!=SQLITE_OK ) goto abort_due_to_error;
68927 if( rc!=SQLITE_OK ) goto abort_due_to_error;
69051 if( rc!=SQLITE_OK ){
69286 if( rc!=SQLITE_OK ){
69294 assert( rc==SQLITE_OK ); /* Cannot fail following BtreeLast() */
69349 0, &u.bh.res))==SQLITE_OK)
69362 if( rc==SQLITE_OK && u.bh.res==0 ){
69479 if( rc==SQLITE_OK && db->xUpdateCallback && pOp->p4.z ){
69540 if( NEVER(rc!=SQLITE_OK) ) goto abort_due_to_error;
69547 if( rc==SQLITE_OK && db->xUpdateCallback && pOp->p4.z ){
69660 if( NEVER(rc!=SQLITE_OK) ) goto abort_due_to_error;
69665 assert( rc==SQLITE_OK ); /* True because of CursorMoveto() call above */
69672 assert( rc==SQLITE_OK ); /* DataSize() cannot fail */
69734 assert( rc==SQLITE_OK ); /* Always so because of CursorMoveto() above */
69961 if( rc==SQLITE_OK ){
70007 if( rc==SQLITE_OK && u.bt.res==0 ){
70043 if( rc!=SQLITE_OK ){
70170 if( rc==SQLITE_OK && u.bw.iMoved!=0 ){
70308 u.bz.initData.rc = SQLITE_OK;
70311 if( rc==SQLITE_OK ) rc = u.bz.initData.rc;
70934 rc = SQLITE_OK;
71016 if( rc==SQLITE_OK ){
71029 if( rc==SQLITE_OK ){
71082 rc = SQLITE_OK;
71207 if( SQLITE_OK==rc ){
71287 if( rc==SQLITE_OK ){
71395 if( rc==SQLITE_OK ){
71430 if( rc==SQLITE_OK ){
71496 if( rc==SQLITE_OK && pOp->p1 ){
71502 rc = SQLITE_OK;
71741 ** If successful, SQLITE_OK is returned and subsequent calls to
71788 rc = SQLITE_OK;
71792 if( rc==SQLITE_OK ){
71800 assert( rc!=SQLITE_OK || zErr==0 );
71855 int rc = SQLITE_OK;
72021 if( rc==SQLITE_OK && db->mallocFailed==0 ){
72051 rc = SQLITE_OK;
72158 if( rc!=SQLITE_OK ){
72166 assert( rc==SQLITE_OK || p->pStmt==0 );
72344 ** and return SQLITE_OK. Otherwise, if an error occurs, return an SQLite
72379 if( rc!=SQLITE_OK ) return rc;
72420 if( rc!=SQLITE_OK ) return rc;
72429 return SQLITE_OK;
72453 return SQLITE_OK;
72458 ** Advance iterator pIter to the next key in its PMA. Return SQLITE_OK if
72471 return SQLITE_OK;
72475 if( rc==SQLITE_OK ){
72496 int rc = SQLITE_OK;
72528 if( rc==SQLITE_OK ){
72537 if( rc==SQLITE_OK ){
72548 ** Otherwise, return SQLITE_OK and set *pRes to a negative, zero or positive
72634 return SQLITE_OK;
72664 return SQLITE_OK;
72704 ** set *ppFile to point to the malloc'd file-handle and return SQLITE_OK.
72751 ** Sort the linked list of records headed at pCsr->pRecord. Return SQLITE_OK
72785 return SQLITE_OK;
72812 ** Write nData bytes of data to the file-write object. Return SQLITE_OK
72842 ** Return SQLITE_OK if flushing the buffered data succeeds or is not
72865 ** SQLITE_OK if successful, or an SQLite error code if an error occurs.
72876 ** SQLITE_OK if successful, or an SQLite error code otherwise.
72888 int rc = SQLITE_OK; /* Return code */
72902 if( rc==SQLITE_OK && pSorter->pTemp1==0 ){
72904 assert( rc!=SQLITE_OK || pSorter->pTemp1 );
72909 if( rc==SQLITE_OK ){
72938 int rc = SQLITE_OK; /* Return Code */
72964 if( rc==SQLITE_OK && pSorter->mxPmaSize>0 && (
72975 assert( rc!=SQLITE_OK || (nExpect==pSorter->iWriteOff) );
72990 int rc = SQLITE_OK; /* Return code */
72999 assert( rc!=SQLITE_OK || pSorter->iReadOff<=pSorter->iWriteOff );
73000 if( rc!=SQLITE_OK || pSorter->iReadOff>=pSorter->iWriteOff ) break;
73004 for(i=pSorter->nTree-1; rc==SQLITE_OK && i>0; i--){
73038 if( rc!=SQLITE_OK ) return rc;
73055 rc==SQLITE_OK && iNew*SORTER_MAX_MERGE_COUNT<pSorter->nPMA;
73074 assert( rc!=SQLITE_OK || pSorter->aIter[ pSorter->aTree[1] ].pFile );
73075 if( rc!=SQLITE_OK || pSorter->nPMA<=SORTER_MAX_MERGE_COUNT ){
73085 if( rc==SQLITE_OK ){
73089 while( rc==SQLITE_OK && bEof==0 ){
73098 if( rc==SQLITE_OK ) rc = rc2;
73113 }while( rc==SQLITE_OK );
73134 for(i=(pSorter->nTree+iPrev)/2; rc==SQLITE_OK && i>0; i=i/2){
73145 rc = SQLITE_OK;
73186 return SQLITE_OK;
73209 return SQLITE_OK;
73264 int rc = SQLITE_OK;
73268 if( rc==SQLITE_OK ){
73274 if( rc!=SQLITE_OK ){
73296 return SQLITE_OK;
73308 int rc = SQLITE_OK;
73329 int rc = SQLITE_OK;
73334 if( rc==SQLITE_OK ){
73351 int rc = SQLITE_OK;
73370 rc = SQLITE_OK;
73379 int rc = SQLITE_OK;
73437 return SQLITE_OK;
73446 return SQLITE_OK;
73581 return SQLITE_OK;
73631 return SQLITE_OK;
73649 return SQLITE_OK;
73657 return SQLITE_OK;
73671 return SQLITE_OK;
73680 return SQLITE_OK;
74528 if( auth!=SQLITE_OK ){
75514 int rc = SQLITE_OK;
78157 v, OP_Halt, SQLITE_OK, OE_Ignore, 0, pExpr->u.zToken,0);
79854 if( SQLITE_OK!=isSystemTable(pParse, pTab->zName) ){
79857 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){ goto
80190 if( SQLITE_OK!=isSystemTable(pParse, pTab->zName) ){
81028 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
81179 return SQLITE_OK;
81352 if( rc==SQLITE_OK ){
81406 int rc = SQLITE_OK;
81410 if( rc==SQLITE_OK && !sqlite3ExprIsConstant(pExpr) ){
81502 if( rc!=SQLITE_OK ){
81516 }else if( rc==SQLITE_OK ){
81533 if( rc==SQLITE_OK && aNew->zName==0 ){
81539 if( rc==SQLITE_OK ){
81575 if( rc==SQLITE_OK ){
81690 SQLITE_OK!=(rc = resolveAttachExpr(&sName, pFilename)) ||
81691 SQLITE_OK!=(rc = resolveAttachExpr(&sName, pDbname)) ||
81692 SQLITE_OK!=(rc = resolveAttachExpr(&sName, pKey))
81707 if(rc!=SQLITE_OK ){
81990 ** should return either SQLITE_OK, SQLITE_DENY, or SQLITE_IGNORE. If
81991 ** SQLITE_OK is returned, it means that access is allowed. SQLITE_DENY
82010 return SQLITE_OK;
82049 }else if( rc!=SQLITE_IGNORE && rc!=SQLITE_OK ){
82117 ** either SQLITE_OK (zero) or SQLITE_IGNORE or SQLITE_DENY. If SQLITE_DENY
82135 return SQLITE_OK;
82139 return SQLITE_OK;
82145 }else if( rc!=SQLITE_OK && rc!=SQLITE_IGNORE ){
82487 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
82927 return SQLITE_OK;
82992 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
83032 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
84692 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
84780 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
85174 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
85691 if( rc!=SQLITE_OK ){
85940 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
86081 return SQLITE_OK;
86152 return SQLITE_OK;
86788 assert( rcauth==SQLITE_OK || rcauth==SQLITE_DENY || rcauth==SQLITE_IGNORE );
86848 if( rcauth==SQLITE_OK && pWhere==0 && !pTrigger && !IsVirtual(pTab)
88699 assert( rc==SQLITE_NOMEM || rc==SQLITE_OK );
90507 if( pParse->db->mallocFailed && rc==SQLITE_OK ) rc = SQLITE_NOMEM;
92004 sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_OK, 0);
92051 int rc = SQLITE_OK; /* Return code */
92061 sqlite3Error(db, SQLITE_OK, 0);
92062 while( rc==SQLITE_OK && zSql[0] ){
92068 assert( rc==SQLITE_OK || pStmt==0 );
92069 if( rc!=SQLITE_OK ){
92139 if( rc!=SQLITE_OK && ALWAYS(rc==sqlite3_errcode(db)) && pzErrMsg ){
93046 ** Return SQLITE_OK on success and SQLITE_ERROR if something goes wrong.
93189 return SQLITE_OK;
93230 return SQLITE_OK;
93280 int rc = SQLITE_OK;
93320 if( sqlite3_initialize()==SQLITE_OK )
93498 return SQLITE_OK;
93511 if( db->temp_store==ts ) return SQLITE_OK;
93512 if( invalidateTempStorage( pParse ) != SQLITE_OK ){
93516 return SQLITE_OK;
93731 ** connection. If it returns SQLITE_OK, then assume that the VFS
93740 if( rc==SQLITE_OK ){
94047 if( rc==SQLITE_OK && (eAuto==1 || eAuto==2) ){
94057 { OP_Halt, SQLITE_OK, OE_Abort, 0}, /* 3 */
94152 if( sqlite3_file_control(db,zDb,SQLITE_FCNTL_MMAP_SIZE,&sz)==SQLITE_OK ){
94203 if( rc!=SQLITE_OK || res==0 ){
94252 if( rc!=SQLITE_OK || res==0 ){
94310 if( res!=SQLITE_OK ){
95133 SQLITE_FCNTL_LOCKSTATE, &j)==SQLITE_OK ){
95290 if( SQLITE_OK!=rc ){
95400 initData.rc = SQLITE_OK;
95419 return SQLITE_OK;
95428 if( rc!=SQLITE_OK ){
95542 if( rc==SQLITE_OK ) rc = initData.rc;
95545 if( rc==SQLITE_OK ){
95554 if( rc==SQLITE_OK || (db->flags&SQLITE_RecoveryMode)){
95564 rc = SQLITE_OK;
95599 rc = SQLITE_OK;
95601 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
95614 if( rc==SQLITE_OK && ALWAYS(db->nDb>1)
95624 if( rc==SQLITE_OK && commit_internal ){
95636 int rc = SQLITE_OK;
95642 if( rc!=SQLITE_OK ){
95676 if( rc!=SQLITE_OK ) return;
95743 int rc = SQLITE_OK; /* Result code */
95824 if( pParse->rc==SQLITE_DONE ) pParse->rc = SQLITE_OK;
95837 if( rc==SQLITE_OK && pParse->pVdbe && pParse->explain ){
95863 if( pParse->pVdbe && (rc!=SQLITE_OK || db->mallocFailed) ){
95915 assert( rc==SQLITE_OK || *ppStmt==0 );
95922 ** If the statement is successfully recompiled, return SQLITE_OK. Otherwise,
95952 return SQLITE_OK;
95973 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
95985 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
96008 int rc = SQLITE_OK;
96053 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
96065 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
97377 ** Return SQLITE_OK on success. If a memory allocation error occurs,
97469 return SQLITE_OK;
97708 int rc = SQLITE_OK; /* Success code from a subroutine */
97801 testcase( rc!=SQLITE_OK );
97876 testcase( rc!=SQLITE_OK );
97960 testcase( rc!=SQLITE_OK );
98645 return SQLITE_OK;
99314 ** pFrom->pIndex and return SQLITE_OK.
99332 return SQLITE_OK;
100802 if( rc==SQLITE_OK && pDest->eDest==SRT_Output ){
101048 res.rc = SQLITE_OK;
101071 if( rc!=SQLITE_OK ){
101288 if( !zName || SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
101607 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
102000 if( SQLITE_OK==sqlite3ResolveExprNames(&sNC, pWhen)
102963 if( SQLITE_OK!=sqlite3_prepare(db, zSql, -1, &pStmt, 0) ){
102981 if( rc!=SQLITE_OK ) return rc;
102985 if( rc!=SQLITE_OK ){
103017 int rc = SQLITE_OK; /* Return code from service routines */
103078 if( rc!=SQLITE_OK ) goto end_of_vacuum;
103101 if( rc!=SQLITE_OK ) goto end_of_vacuum;
103108 if( rc!=SQLITE_OK ) goto end_of_vacuum;
103110 if( rc!=SQLITE_OK ) goto end_of_vacuum;
103139 if( rc!=SQLITE_OK ) goto end_of_vacuum;
103143 if( rc!=SQLITE_OK ) goto end_of_vacuum;
103147 if( rc!=SQLITE_OK ) goto end_of_vacuum;
103160 if( rc!=SQLITE_OK ) goto end_of_vacuum;
103168 if( rc!=SQLITE_OK ) goto end_of_vacuum;
103174 if( rc!=SQLITE_OK ) goto end_of_vacuum;
103224 if( NEVER(rc!=SQLITE_OK) ) goto end_of_vacuum;
103228 if( rc!=SQLITE_OK ) goto end_of_vacuum;
103230 if( rc!=SQLITE_OK ) goto end_of_vacuum;
103236 assert( rc==SQLITE_OK );
103312 int rc = SQLITE_OK;
103339 if( rc!=SQLITE_OK && xDestroy ) xDestroy(pAux);
103783 if( SQLITE_OK!=rc ){
103862 return SQLITE_OK;
103876 if( rc!=SQLITE_OK ){
103886 ** more v-table. Return SQLITE_NOMEM if a malloc fails, or SQLITE_OK otherwise.
103903 return SQLITE_OK;
103925 int rc = SQLITE_OK;
103949 ** create a valid sqlite3_vtab if it returns SQLITE_OK. */
103950 if( rc==SQLITE_OK && ALWAYS(sqlite3GetVTable(db, pTab)) ){
103952 if( rc==SQLITE_OK ){
103968 int rc = SQLITE_OK;
103988 if( SQLITE_OK==sqlite3RunParser(pParse, zCreateTable, &zErr)
104029 int rc = SQLITE_OK;
104036 assert( rc==SQLITE_OK );
104040 if( rc==SQLITE_OK ){
104082 ** SQLITE_OK if all xSync operations are successful.
104089 int rc = SQLITE_OK;
104093 for(i=0; rc==SQLITE_OK && i<db->nVTrans; i++){
104113 return SQLITE_OK;
104122 return SQLITE_OK;
104134 int rc = SQLITE_OK;
104146 return SQLITE_OK;
104156 return SQLITE_OK;
104163 if( rc==SQLITE_OK ){
104165 if( rc==SQLITE_OK ){
104183 ** If any virtual table method returns an error code other than SQLITE_OK,
104186 ** SQLITE_OK is returned.
104189 int rc = SQLITE_OK;
104195 for(i=0; rc==SQLITE_OK && i<db->nVTrans; i++){
104343 int rc = SQLITE_OK;
104365 if( rc!=SQLITE_OK ) sqlite3Error(db, rc, 0);
106602 if( rc!=SQLITE_OK ){
106833 ** Return SQLITE_OK on success.
106981 return SQLITE_OK;
106999 ** If an error occurs, return an error code. Otherwise, SQLITE_OK.
107014 return SQLITE_OK;
107067 int rc = SQLITE_OK;
107082 if( rc==SQLITE_OK
107083 && whereKeyStats(pParse, p, pRangeVal, 0, a)==SQLITE_OK
107090 if( rc==SQLITE_OK && pUpper ){
107094 if( rc==SQLITE_OK
107095 && whereKeyStats(pParse, p, pRangeVal, 1, a)==SQLITE_OK
107102 if( rc==SQLITE_OK ){
107110 return SQLITE_OK;
107134 ** Write the estimated row count into *pnRow and return SQLITE_OK.
107165 if( rc==SQLITE_OK ){
107183 ** Write the estimated row count into *pnRow and return SQLITE_OK.
107198 int rc = SQLITE_OK; /* Subfunction return code */
107204 for(i=0; rc==SQLITE_OK && i<pList->nExpr; i++){
107209 if( rc==SQLITE_OK ){
114282 pParse->rc = SQLITE_OK;
114330 if( pParse->rc!=SQLITE_OK ){
114338 if( zSql[i]==0 && nErr==0 && pParse->rc==SQLITE_OK ){
114355 if( pParse->rc!=SQLITE_OK && pParse->rc!=SQLITE_DONE && pParse->zErrMsg==0 ){
114402 if( nErr>0 && pParse->rc==SQLITE_OK ){
114904 if( rc!=SQLITE_OK ){
114914 if( sqlite3GlobalConfig.isInit ) return SQLITE_OK;
114946 if( rc==SQLITE_OK ){
114956 if( rc==SQLITE_OK ){
114961 /* If rc is not SQLITE_OK at this point, then either the malloc
114964 if( rc!=SQLITE_OK ){
114990 if( rc==SQLITE_OK ){
114994 if( rc==SQLITE_OK ){
115023 if ( rc==SQLITE_OK ){
115038 if( rc==SQLITE_OK && sqlite3GlobalConfig.isInit ){
115090 return SQLITE_OK;
115104 int rc = SQLITE_OK;
115304 ** Return SQLITE_OK on success.
115363 return SQLITE_OK;
115390 return SQLITE_OK;
115434 rc = SQLITE_OK;
115603 return SQLITE_OK;
115643 return SQLITE_OK;
115690 sqlite3RollbackAll(db, SQLITE_OK);
115756 sqlite3Error(db, SQLITE_OK, 0); /* Deallocates any cached error strings. */
115782 ** Rollback all database files. If tripCode is not SQLITE_OK, then
115840 case SQLITE_OK: zName = "SQLITE_OK"; break;
115939 /* SQLITE_OK */ "not an error",
116063 return SQLITE_OK;
116104 return SQLITE_OK;
116159 if( rc==SQLITE_OK ){
116163 if( rc!=SQLITE_OK ){
116209 return SQLITE_OK;
116254 assert( rc!=SQLITE_OK );
116308 int rc = SQLITE_OK;
116433 return SQLITE_OK;
116459 return SQLITE_OK;
116495 return SQLITE_OK;
116546 ** returned (i.e. SQLITE_IOERR). Otherwise, SQLITE_OK.
116559 int rc = SQLITE_OK; /* Return code */
116567 for(i=0; i<db->nDb && rc==SQLITE_OK; i++){
116574 rc = SQLITE_OK;
116579 return (rc==SQLITE_OK && bBusy) ? SQLITE_BUSY : rc;
116794 sqlite3Error(db, SQLITE_OK, 0);
116795 return SQLITE_OK;
116913 ** If successful, SQLITE_OK is returned. In this case *ppVfs is set to point to
116930 char **pzErrMsg /* OUT: Error message (if rc!=SQLITE_OK) */
116932 int rc = SQLITE_OK;
117123 if( rc!=SQLITE_OK ){
117274 if( rc!=SQLITE_OK ){
117284 if( rc!=SQLITE_OK ){
117312 sqlite3Error(db, SQLITE_OK, 0);
117319 if( rc==SQLITE_OK ){
117322 if( rc!=SQLITE_OK ){
117335 if( !db->mallocFailed && rc==SQLITE_OK ){
117342 if( !db->mallocFailed && rc==SQLITE_OK ){
117348 if( !db->mallocFailed && rc==SQLITE_OK ){
117354 if( !db->mallocFailed && rc==SQLITE_OK){
117388 }else if( rc!=SQLITE_OK ){
117447 if( rc==SQLITE_OK && !DbHasProperty(*ppDb, 0, DB_SchemaLoaded) ){
117509 int rc = SQLITE_OK;
117538 return SQLITE_OK;
117556 return SQLITE_OK;
117566 return SQLITE_OK;
117660 if( SQLITE_OK!=rc ){
117727 if( SQLITE_OK==rc && !pTab ){
117764 return SQLITE_OK;
117786 rc = SQLITE_OK;
118080 if( z && sqlite3Atoi64(z, &v, sqlite3Strlen30(z), SQLITE_UTF8)==SQLITE_OK ){
118271 int rc = SQLITE_OK;
118806 /* TODO(shess) Only used for SQLITE_OK and SQLITE_DONE at this time.
118852 ** This method should return either SQLITE_OK (0), or an SQLite error
118853 ** code. If SQLITE_OK is returned, then *ppTokenizer should be set
118889 ** method should either return SQLITE_OK and set the values of the
119461 # define sqlite3Fts3DeferToken(x,y,z) SQLITE_OK
119462 # define sqlite3Fts3CacheDeferredDoclists(x) SQLITE_OK
119464 # define sqlite3Fts3DeferredTokenList(x,y,z) SQLITE_OK
119770 return SQLITE_OK;
119805 int rc = SQLITE_OK; /* Return code */
119819 ** memory associated with the Fts3Table structure and return SQLITE_OK.
119822 return (rc==SQLITE_OK ? fts3DisconnectMethod(pVtab) : rc);
119836 if( *pRc==SQLITE_OK ){
119878 if( (*pRc)==SQLITE_OK ) p->bHasStat = 1;
119891 int rc = SQLITE_OK; /* Return code */
119956 if( *pRc==SQLITE_OK ){
119966 if( rc==SQLITE_OK ){
119972 rc = SQLITE_OK;
119975 assert( p->nPgsz>0 || rc!=SQLITE_OK );
120020 if( *pRc==SQLITE_OK ){
120084 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op (and
120141 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op (and
120177 ** the output value undefined. Otherwise SQLITE_OK is returned.
120191 return SQLITE_OK;
120204 ** If no error occurs, SQLITE_OK is returned and *apIndex set to point to
120246 return SQLITE_OK;
120282 int rc = SQLITE_OK; /* Return code */
120294 if( rc==SQLITE_OK ){
120356 int rc = SQLITE_OK; /* Return code */
120404 for(i=3; rc==SQLITE_OK && i<argc; i++){
120516 if( rc==SQLITE_OK && zContent ){
120528 if( rc==SQLITE_OK && zLanguageid ){
120541 if( rc!=SQLITE_OK ) goto fts3_init_out;
120552 if( rc!=SQLITE_OK ) goto fts3_init_out;
120561 if( rc!=SQLITE_OK ) goto fts3_init_out;
120630 if( rc!=SQLITE_OK ) goto fts3_init_out;
120643 int rc2 = SQLITE_OK;
120646 if( rc2==SQLITE_OK ) p->bHasStat = 1;
120665 if( rc!=SQLITE_OK ){
120786 return SQLITE_OK;
120798 ** allocation succeeds, zero it and return SQLITE_OK. Otherwise,
120806 return SQLITE_OK;
120823 return SQLITE_OK;
120835 ** Otherwise, set *ppStmt to point to pCsr->pStmt and return SQLITE_OK.
120838 int rc = SQLITE_OK;
120854 ** SQLITE_OK on success.
120857 int rc = SQLITE_OK;
120862 if( rc==SQLITE_OK ){
120866 return SQLITE_OK;
120869 if( rc==SQLITE_OK && ((Fts3Table *)pCsr->base.pVtab)->zContentTbl==0 ){
120880 if( rc!=SQLITE_OK && pContext ){
120899 ** If an OOM error occurs, SQLITE_NOMEM is returned. Otherwise, SQLITE_OK.
120909 int rc = SQLITE_OK; /* Return code */
121020 ** If an error occurs, an error code other than SQLITE_OK is returned.
121038 assert( !piLeaf2 || !piLeaf || rc!=SQLITE_OK || (*piLeaf<=*piLeaf2) );
121040 if( rc==SQLITE_OK && iHeight>1 ){
121046 if( rc==SQLITE_OK ){
121054 if( rc==SQLITE_OK ){
121057 if( rc==SQLITE_OK ){
121571 ** containing the output doclist and SQLITE_OK is returned. In this case
121654 return SQLITE_OK;
121773 ** other doclists (except the aaOutput[0] one) and return SQLITE_OK.
121800 if( rc!=SQLITE_OK ){
121816 return SQLITE_OK;
121830 ** This function returns SQLITE_OK if the merge is successful, or an
121867 if( rc!=SQLITE_OK ){
121885 return SQLITE_OK;
121906 return SQLITE_OK;
121913 ** This function returns SQLITE_OK if successful, or an SQLite error code
121927 int rc = SQLITE_OK; /* Error code */
121940 if( rc==SQLITE_OK && pSeg ){
121946 if( rc==SQLITE_OK ){
121950 while( rc==SQLITE_OK && SQLITE_ROW==(rc = sqlite3_step(pStmt)) ){
121965 if( rc!=SQLITE_OK ) goto finished;
121974 if( rc!=SQLITE_OK ) goto finished;
122020 ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
122037 ** zTerm/nTerm is a prefix. If successful, return SQLITE_OK and write
122044 ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
122080 if( rc==SQLITE_OK ){
122137 while( SQLITE_OK==rc
122143 if( rc==SQLITE_OK ){
122146 if( rc==SQLITE_OK ){
122192 ** Return SQLITE_OK if nothing goes wrong. SQLITE_OK is returned
122205 rc = SQLITE_OK;
122279 if( rc!=SQLITE_OK ){
122284 if( rc!=SQLITE_OK ) return rc;
122289 if( rc!=SQLITE_OK ) return rc;
122312 if( rc==SQLITE_OK ){
122316 if( rc!=SQLITE_OK ) return rc;
122338 return SQLITE_OK;
122357 int rc = SQLITE_OK; /* Return Code */
122380 if( rc==SQLITE_OK ){
122441 if( rc==SQLITE_OK && p->bAutoincrmerge==1 && p->nLeafAdd>(nMinMerge/16) ){
122446 assert( rc==SQLITE_OK || mxLevel==0 );
122467 return SQLITE_OK;
122483 return SQLITE_OK;
122496 return SQLITE_OK;
122524 ** output variable *ppCsr and SQLITE_OK is returned. Otherwise, an error
122545 return SQLITE_OK;
122584 }else if( SQLITE_OK==fts3CursorSeek(pContext, pCsr) ){
122604 if( SQLITE_OK==fts3CursorSeek(pContext, pCsr) ){
122637 case SQLITE_OK:
122659 if( SQLITE_OK==fts3FunctionArg(pContext, "matchinfo", apVal[0], &pCsr) ){
122761 int rc = SQLITE_OK;
122784 return SQLITE_OK;
122799 return SQLITE_OK;
122865 int rc = SQLITE_OK;
122884 if( rc!=SQLITE_OK ) return rc;
122888 if( rc!=SQLITE_OK ) return rc;
122902 if( rc==SQLITE_OK ){
122918 if( rc==SQLITE_OK ){
122927 if( SQLITE_OK==rc
122928 && SQLITE_OK==(rc = sqlite3Fts3InitHashTable(db, pHash, "fts3_tokenizer"))
122929 && SQLITE_OK==(rc = sqlite3_overload_function(db, "snippet", -1))
122930 && SQLITE_OK==(rc = sqlite3_overload_function(db, "offsets", 1))
122931 && SQLITE_OK==(rc = sqlite3_overload_function(db, "matchinfo", 1))
122932 && SQLITE_OK==(rc = sqlite3_overload_function(db, "matchinfo", 2))
122933 && SQLITE_OK==(rc = sqlite3_overload_function(db, "optimize", 1))
122938 if( rc==SQLITE_OK ){
122943 if( rc==SQLITE_OK ){
122951 assert( rc!=SQLITE_OK );
122981 if( pExpr && SQLITE_OK==*pRc ){
122991 if( rc!=SQLITE_OK ){
123072 ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
123080 int rc = SQLITE_OK;
123082 for(iToken=0; rc==SQLITE_OK && iToken<p->nToken; iToken++){
123090 if( rc==SQLITE_OK ){
123108 ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
123126 if( rc!=SQLITE_OK ) return rc;
123132 return SQLITE_OK;
123152 return SQLITE_OK;
123201 return SQLITE_OK;
123214 ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
123240 assert( rc!=SQLITE_OK || p->nToken<1 || p->aToken[0].pSegcsr==0 || p->bIncr );
123345 ** SQLITE_OK.
123356 int rc = SQLITE_OK;
123366 if( rc==SQLITE_OK && !pDL->pList ){
123417 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
123437 if( pExpr && SQLITE_OK==*pRc ){
123479 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
123491 if( *pRc==SQLITE_OK ){
123495 for(i=0; *pRc==SQLITE_OK && i<pPhrase->nToken; i++){
123528 ** write this value to *pnPage and return SQLITE_OK. Otherwise, return
123559 if( rc!=SQLITE_OK ) return rc;
123577 if( rc!=SQLITE_OK ) return rc;
123581 return SQLITE_OK;
123594 ** If no error occurs, SQLITE_OK is returned and sqlite3Fts3DeferToken()
123606 int rc = SQLITE_OK; /* Return code */
123620 return SQLITE_OK;
123632 if( nOvfl==0 || nToken<2 ) return SQLITE_OK;
123636 assert( rc!=SQLITE_OK || nDocSize>0 );
123661 for(ii=0; ii<nToken && rc==SQLITE_OK; ii++){
123698 assert( rc==SQLITE_OK || pList==0 );
123699 if( rc==SQLITE_OK ){
123729 int rc = SQLITE_OK;
123738 if( rc==SQLITE_OK && nToken>1 && pTab->bFts4 ){
123758 if( rc==SQLITE_OK ){
123760 for(ii=0; rc==SQLITE_OK && ii<nOr; ii++){
123842 ** This function is a no-op if *pRc is other than SQLITE_OK when it is called.
123887 if( *pRc==SQLITE_OK ){
123915 while( !pLeft->bEof && !pRight->bEof && *pRc==SQLITE_OK ){
123964 assert( *pRc!=SQLITE_OK || pRight->bStart );
123993 ** If *pRc is not SQLITE_OK, or if pExpr is not the root node of a NEAR
124030 if( *pRc==SQLITE_OK
124088 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
124099 if( *pRc==SQLITE_OK ){
124191 ** If *pRc is not SQLITE_OK when this function is called, it immediately
124196 ** 1. *pRc is SQLITE_OK when this function returns, and
124207 if( rc==SQLITE_OK ){
124217 if( rc==SQLITE_OK ){
124227 return (rc==SQLITE_OK && bMiss);
124235 int rc = SQLITE_OK; /* Return Code */
124261 ** If *pRc is other than SQLITE_OK when this function is called, it is
124270 if( pExpr && *pRc==SQLITE_OK ){
124343 ** SQLITE_OK is returned if the aMI[] array is successfully allocated and
124350 int rc = SQLITE_OK; /* Return code */
124382 while( pCsr->isEof==0 && rc==SQLITE_OK ){
124400 if( rc==SQLITE_OK && pCsr->isEof==0 ){
124415 ** do {...} while( pRoot->iDocid<iDocid && rc==SQLITE_OK );
124421 }while( pRoot->iDocid!=iDocid && rc==SQLITE_OK );
124438 ** If no error occurs, SQLITE_OK is returned and the values for each column
124464 int rc = SQLITE_OK;
124475 if( rc==SQLITE_OK ){
124523 return SQLITE_OK;
124540 if( bOr==0 ) return SQLITE_OK;
124546 int rc = SQLITE_OK;
124549 while( rc==SQLITE_OK && !pExpr->bEof ){
124554 assert( rc!=SQLITE_OK || pPhrase->bIncr==0 );
124555 if( rc!=SQLITE_OK ) return rc;
124585 if( pIter==0 ) return SQLITE_OK;
124601 return SQLITE_OK;
124746 if( rc!=SQLITE_OK ) return rc;
124764 return SQLITE_OK;
124787 return SQLITE_OK;
124847 return SQLITE_OK;
124863 return SQLITE_OK;
124879 return SQLITE_OK;
124895 return SQLITE_OK;
124910 if( pCsr->aStat[pCsr->iCol].nDoc>0 ) return SQLITE_OK;
124927 return SQLITE_OK;
124985 rc = SQLITE_OK;
125045 if( rc==SQLITE_OK ){
125049 if( rc==SQLITE_OK ) rc = fts3auxNextMethod(pCursor);
125086 return SQLITE_OK;
125098 return SQLITE_OK;
125102 ** Register the fts3aux module with database connection db. Return SQLITE_OK
125282 assert( rc==SQLITE_OK || pCsr==0 );
125283 if( rc==SQLITE_OK ){
125287 if( rc!=SQLITE_OK ){
125307 ** Return SQLITE_OK if successful, or SQLITE_NOMEM if a memory allocation
125325 if( rc==SQLITE_OK ){
125331 if( rc==SQLITE_OK ){
125396 ** If successful, SQLITE_OK is returned and *ppExpr set to point at the
125438 if( rc==SQLITE_OK ){
125440 for(ii=0; rc==SQLITE_OK; ii++){
125444 if( rc==SQLITE_OK ){
125495 rc = SQLITE_OK;
125521 ** Returns an SQLite error code. SQLITE_OK if everything works, SQLITE_NOMEM
125604 return SQLITE_OK;
125619 if( rc==SQLITE_OK && !*ppExpr ){
125744 ** If successful, SQLITE_OK is returned, *ppExpr is set to point to the
125760 int rc = SQLITE_OK;
125763 while( rc==SQLITE_OK ){
125767 if( rc==SQLITE_OK ){
125852 assert( rc!=SQLITE_OK || (nByte>0 && nByte<=nIn) );
125863 rc = SQLITE_OK;
125881 if( rc!=SQLITE_OK ){
125895 int rc = SQLITE_OK;
125901 if( rc==SQLITE_OK ){
125912 ** If successful, SQLITE_OK is returned and (*pp) set to point to the
125921 int rc = SQLITE_OK; /* Return code */
125930 if( rc==SQLITE_OK && (eType==FTSQUERY_AND || eType==FTSQUERY_OR) ){
125939 if( rc==SQLITE_OK ){
125962 if( rc!=SQLITE_OK ) break;
126009 if( rc==SQLITE_OK ){
126049 if( rc!=SQLITE_OK ){
126091 return SQLITE_OK;
126097 assert( rc==SQLITE_OK || *ppExpr==0 );
126100 if( rc==SQLITE_OK && sParse.nNest ){
126112 ** of the parsed expression tree and SQLITE_OK is returned. If an error
126149 if( rc==SQLITE_OK && *ppExpr ){
126151 if( rc==SQLITE_OK ){
126156 if( rc!=SQLITE_OK ){
126233 if( rc!=SQLITE_OK ){
126349 assert( rc==SQLITE_NOMEM || rc==SQLITE_OK );
126373 assert( rc==SQLITE_OK || pExpr==0 );
126381 if( rc!=SQLITE_OK && rc!=SQLITE_NOMEM ){
126408 if( rc==SQLITE_OK ){
126874 return SQLITE_OK;
126882 return SQLITE_OK;
126917 return SQLITE_OK;
126928 return SQLITE_OK;
127419 return SQLITE_OK;
127640 assert( rc!=SQLITE_OK || *ppTok );
127641 if( rc!=SQLITE_OK ){
127739 if( SQLITE_OK!=p->xCreate(argc-2, azArg, &pTokenizer) ){
127749 while( SQLITE_OK==p->xNext(pCsr, &zToken, &nToken, &iStart, &iEnd, &iPos) ){
127757 if( SQLITE_OK!=p->xClose(pCsr) ){
127761 if( SQLITE_OK!=p->xDestroy(pTokenizer) ){
127786 if( rc!=SQLITE_OK ){
127809 if( rc!=SQLITE_OK ){
127859 assert( rc==SQLITE_OK );
127868 assert( rc==SQLITE_OK );
127870 assert( rc==SQLITE_OK );
127900 int rc = SQLITE_OK;
127915 if( SQLITE_OK==rc ){
127918 if( SQLITE_OK==rc ){
127922 if( SQLITE_OK==rc ){
127925 if( SQLITE_OK==rc ){
128035 return SQLITE_OK;
128043 return SQLITE_OK;
128078 return SQLITE_OK;
128089 return SQLITE_OK;
128144 return SQLITE_OK;
128268 return SQLITE_OK;
128278 ** array of dequoted strings and SQLITE_OK is returned. The caller is
128288 int rc = SQLITE_OK; /* Return code */
128349 if( rc!=SQLITE_OK ) return rc;
128354 if( rc==SQLITE_OK ){
128364 assert( (rc==SQLITE_OK)==(pMod!=0) );
128365 if( rc==SQLITE_OK ){
128370 if( rc==SQLITE_OK ){
128377 if( rc==SQLITE_OK ){
128402 return SQLITE_OK;
128424 return SQLITE_OK;
128431 return SQLITE_OK;
128448 return SQLITE_OK;
128479 return SQLITE_OK;
128496 if( rc!=SQLITE_OK ){
128498 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
128531 if( rc==SQLITE_OK ){
128537 if( rc!=SQLITE_OK ) return rc;
128578 return SQLITE_OK;
128590 return SQLITE_OK;
128594 ** Register the fts3tok module with database connection db. Return SQLITE_OK
128716 sqlite3_log(SQLITE_OK, "%d-way merge from level %d", nMerge, (int)iAbsLevel);
128787 ** until SegmentReaderNext() returns something other than SQLITE_OK
128905 ** *pp is set to the requested statement handle and SQLITE_OK returned.
129005 int rc = SQLITE_OK;
129026 assert( rc==SQLITE_OK || pStmt==0 );
129033 for(i=0; rc==SQLITE_OK && i<nParam; i++){
129051 if( rc==SQLITE_OK ){
129056 if( rc==SQLITE_OK ) rc = FTS_CORRUPT_VTAB;
129059 rc = SQLITE_OK;
129074 if( rc==SQLITE_OK ){
129080 if( rc==SQLITE_OK ) rc = FTS_CORRUPT_VTAB;
129101 ** Returns SQLITE_OK if the statement is successfully executed, or an
129114 if( rc==SQLITE_OK ){
129147 if( rc==SQLITE_OK ){
129153 rc = SQLITE_OK;
129200 ** return SQLITE_OK. If an error occurs while preparing the statement,
129231 if( rc==SQLITE_OK ){
129240 if( rc==SQLITE_OK ){
129250 ** Append a single varint to a PendingList buffer. SQLITE_OK is returned
129293 return SQLITE_OK;
129303 ** it is set to SQLITE_OK.
129313 int rc = SQLITE_OK;
129324 if( SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, iDelta)) ){
129332 if( SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, 1))
129333 || SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, iCol))
129343 if( rc==SQLITE_OK ){
129376 int rc = SQLITE_OK;
129392 if( rc==SQLITE_OK ){
129403 ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error code.
129434 return SQLITE_OK;
129438 if( rc!=SQLITE_OK ){
129443 while( SQLITE_OK==rc
129444 && SQLITE_OK==(rc = xNext(pCsr, &zToken, &nToken, &iStart, &iEnd, &iPos))
129464 for(i=1; rc==SQLITE_OK && i<p->nIndex; i++){
129475 return (rc==SQLITE_DONE ? SQLITE_OK : rc);
129501 if( rc!=SQLITE_OK ) return rc;
129505 return SQLITE_OK;
129543 if( rc!=SQLITE_OK ){
129548 return SQLITE_OK;
129582 return SQLITE_OK;
129594 if( rc==SQLITE_OK && p->zLanguageid ){
129600 if( rc!=SQLITE_OK ) return rc;
129620 if( rc!=SQLITE_OK ) return rc;
129640 int rc = SQLITE_OK; /* Return code */
129687 if( rc==SQLITE_OK ){
129692 for(i=1; rc==SQLITE_OK && i<=p->nColumn; i++){
129697 if( rc!=SQLITE_OK ){
129729 ** If successful, *piIdx is set to the allocated index slot and SQLITE_OK
129748 if( rc==SQLITE_OK ){
129758 if( rc==SQLITE_OK ){
129789 ** an SQLite error code is returned. Otherwise, SQLITE_OK is returned. If
129827 if( rc==SQLITE_OK ){
129841 if( rc!=SQLITE_OK ){
129874 if( rc==SQLITE_OK ){
129887 int rc = SQLITE_OK;
129891 while( pReader->pBlob && rc==SQLITE_OK
129913 ** segment. If successful, SQLITE_OK is returned. If there is no next term,
129947 return SQLITE_OK;
129956 return SQLITE_OK;
129963 if( rc!=SQLITE_OK ) return rc;
129975 if( rc!=SQLITE_OK ) return rc;
129998 if( rc!=SQLITE_OK ) return rc;
130016 return SQLITE_OK;
130024 int rc = SQLITE_OK;
130037 if( rc==SQLITE_OK ){
130061 int rc = SQLITE_OK;
130104 if( rc!=SQLITE_OK ) return rc;
130128 if( rc==SQLITE_OK ){
130140 return SQLITE_OK;
130152 int rc = SQLITE_OK;
130158 for(ii=0; rc==SQLITE_OK && ii<pMsr->nSegment; ii++){
130167 if( rc!=SQLITE_OK ) break;
130236 return SQLITE_OK;
130289 int rc = SQLITE_OK; /* Return Code */
130505 if( rc==SQLITE_OK ){
130516 ** *pnMax to this value and return SQLITE_OK. Otherwise, if an error occurs,
130525 if( rc==SQLITE_OK ){
130550 if( rc==SQLITE_OK ){
130654 return SQLITE_OK;
130719 ** If successful, SQLITE_OK is returned and output variable *piLast is
130734 int rc = SQLITE_OK;
130746 for(pIter=pTree->pLeftmost; pIter && rc==SQLITE_OK; pIter=pIter->pRight){
130754 if( rc==SQLITE_OK ){
130791 ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error code.
130825 if( rc!=SQLITE_OK ) return rc;
130831 if( rc!=SQLITE_OK ) return rc;
130850 if( rc!=SQLITE_OK ) return rc;
130867 if( rc!=SQLITE_OK ) return rc;
130923 return SQLITE_OK;
130929 ** to the segment using fts3SegWriterAdd(). If successful, SQLITE_OK is
130947 if( rc==SQLITE_OK ){
130951 if( rc==SQLITE_OK ){
130984 ** document pRowid, or false otherwise, and SQLITE_OK is returned. If an
130993 rc = SQLITE_OK;
130996 if( rc==SQLITE_OK ){
131012 ** Return SQLITE_OK if successful, or an SQLite error code if not.
131031 if( rc!=SQLITE_OK ) return rc;
131051 int rc = SQLITE_OK; /* Return code */
131055 if( rc==SQLITE_OK ){
131077 ** SQLITE_OK is returned if successful, otherwise an SQLite error code.
131087 int rc = SQLITE_OK; /* Return Code */
131091 for(i=0; rc==SQLITE_OK && i<nReader; i++){
131094 if( rc!=SQLITE_OK ){
131101 if( rc==SQLITE_OK ){
131109 if( rc==SQLITE_OK ){
131116 if( rc==SQLITE_OK ){
131178 ** If successful, return SQLITE_OK. Otherwise, if an OOM error is encountered
131195 return SQLITE_OK;
131213 return SQLITE_OK;
131232 while( rc==SQLITE_OK
131240 if( rc!=SQLITE_OK ) return rc;
131245 if( rc!=SQLITE_OK ) return rc;
131263 return SQLITE_OK;
131286 if( rc!=SQLITE_OK ) return rc;
131295 return SQLITE_OK;
131326 if( rc!=SQLITE_OK ) return rc;
131340 if( rc!=SQLITE_OK ) return rc;
131347 return SQLITE_OK;
131378 return SQLITE_OK;
131386 int rc = SQLITE_OK;
131402 if( pCsr->nSegment==0 ) return SQLITE_OK;
131418 if( rc!=SQLITE_OK ) return rc;
131423 /* If all the seg-readers are at EOF, we're finished. return SQLITE_OK. */
131424 assert( rc==SQLITE_OK );
131468 if( rc==SQLITE_OK ) rc = SQLITE_ROW;
131554 }while( rc==SQLITE_OK );
131585 ** Otherwise, if successful, SQLITE_OK is returned. If an error occurs,
131610 if( rc!=SQLITE_OK || csr.nSegment==0 ) goto finished;
131635 if( rc!=SQLITE_OK ) goto finished;
131645 while( SQLITE_OK==rc ){
131651 if( rc!=SQLITE_OK ) goto finished;
131658 if( rc!=SQLITE_OK ) goto finished;
131673 int rc = SQLITE_OK;
131676 for(i=0; rc==SQLITE_OK && i<p->nIndex; i++){
131678 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
131685 if( rc==SQLITE_OK && p->bHasStat
131690 if( rc==SQLITE_OK ){
131822 if( rc!=SQLITE_OK ){
131865 if( rc==SQLITE_OK ){
131871 for(i=0; rc==SQLITE_OK && i<p->nIndex; i++){
131875 rc = SQLITE_OK;
131880 if( rc==SQLITE_OK ) rc = rc2;
131886 return (rc==SQLITE_OK && bReturnDone && bSeenDone) ? SQLITE_DONE : rc;
131903 if( rc==SQLITE_OK ){
131919 if( rc==SQLITE_OK ){
131931 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
131936 for(iCol=0; rc==SQLITE_OK && iCol<p->nColumn; iCol++){
131944 if( rc!=SQLITE_OK ){
131961 if( rc==SQLITE_OK ){
131998 if( rc==SQLITE_OK ){
132003 for(i=0; rc==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW && i<nSeg; i++){
132015 if( rc==SQLITE_OK ) rc = rc2;
132083 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
132092 if( *pRc==SQLITE_OK && nMin>pBlob->nAlloc ){
132109 ** Otherwise return SQLITE_OK. If there is no next entry on the node
132118 int rc = SQLITE_OK; /* Return code */
132132 if( rc==SQLITE_OK ){
132159 ** If successful, SQLITE_OK is returned and the NodeReader object set to
132202 int rc = SQLITE_OK;
132224 if( rc==SQLITE_OK ){
132232 if( rc==SQLITE_OK ){
132258 if( rc!=SQLITE_OK || iNextPtr==0 ) return rc;
132288 ** returned. Otherwise, SQLITE_OK.
132298 int rc = SQLITE_OK; /* Return code */
132309 if( rc!=SQLITE_OK ) return rc;
132331 return SQLITE_OK;
132338 ** Return SQLITE_OK if successful, or an SQLite error code otherwise.
132349 int rc = SQLITE_OK; /* Return code */
132382 if( rc==SQLITE_OK ){
132399 if( rc==SQLITE_OK ){
132417 ** If *pRc is not SQLITE_OK when this function is called, then no attempt
132421 ** Otherwise, if *pRc is initially SQLITE_OK and an error occurs while
132469 if( rc==SQLITE_OK ){
132482 if( pNode->block.n>0 && rc==SQLITE_OK ){
132490 if( rc==SQLITE_OK ){
132546 if( rc==SQLITE_OK ){
132583 if( rc==SQLITE_OK ){
132609 if( rc==SQLITE_OK && bAppendable ){
132614 if( rc==SQLITE_OK ){
132617 rc==SQLITE_OK && reader.aNode;
132630 if( rc==SQLITE_OK && bAppendable ){
132650 if( rc==SQLITE_OK ){
132655 for(i=nHeight; i>=0 && rc==SQLITE_OK; i--){
132660 while( reader.aNode && rc==SQLITE_OK ) rc = nodeReaderNext(&reader);
132662 if( rc==SQLITE_OK ){
132672 if( rc==SQLITE_OK ){
132684 if( rc==SQLITE_OK ) rc = rc2;
132693 ** one before returning SQLITE_OK. Or, if there are no segments at all
132708 if( rc==SQLITE_OK ){
132759 if( rc==SQLITE_OK ){
132767 if( rc!=SQLITE_OK ) return rc;
132771 if( rc==SQLITE_OK ){
132779 if( rc!=SQLITE_OK ) return rc;
132785 if( rc!=SQLITE_OK ) return rc;
132795 return SQLITE_OK;
132818 if( rc==SQLITE_OK ){
132846 if( rc==SQLITE_OK ){
132863 if( rc==SQLITE_OK ) rc = rc2;
132866 if( rc==SQLITE_OK ){
132869 if( rc==SQLITE_OK ){
132875 for(i=0; rc==SQLITE_OK && i<nIdx; i++){
132918 int rc = SQLITE_OK; /* Return code */
132923 if( rc!=SQLITE_OK ) return rc;
132928 rc==SQLITE_OK && reader.aNode;
132941 if( rc!=SQLITE_OK ) break;
132960 ** SQLITE_OK is returned if the segment is updated successfully. Or an
132970 int rc = SQLITE_OK; /* Return code */
132979 if( rc==SQLITE_OK ){
132990 if( rc==SQLITE_OK ) rc = rc2;
132993 while( rc==SQLITE_OK && iBlock ){
132999 if( rc==SQLITE_OK ){
133002 if( rc==SQLITE_OK ){
133009 if( rc==SQLITE_OK && iNewStart ){
133012 if( rc==SQLITE_OK ){
133020 if( rc==SQLITE_OK ){
133023 if( rc==SQLITE_OK ){
133056 int rc = SQLITE_OK;
133058 for(i=pCsr->nSegment-1; i>=0 && rc==SQLITE_OK; i--){
133073 if( rc==SQLITE_OK ){
133088 if( rc==SQLITE_OK && nRem!=pCsr->nSegment ){
133104 if( rc==SQLITE_OK ){
133119 ** table and return SQLITE_OK. Otherwise, if an error occurs, return an
133128 if( rc==SQLITE_OK ){
133136 if( rc==SQLITE_OK ){
133143 if( rc==SQLITE_OK ) rc = rc2;
133150 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
133155 ** If successful, leave *pRc set to SQLITE_OK and return. If an error occurs,
133165 if( *pRc==SQLITE_OK ){
133176 ** If no error occurs, return SQLITE_OK. If the hint blob in *pHint does
133192 return SQLITE_OK;
133224 while( rc==SQLITE_OK && nRem>0 ){
133250 if( rc==SQLITE_OK && hint.n ){
133281 if( rc==SQLITE_OK ){
133284 if( SQLITE_OK==rc && pCsr->nSegment==nSeg
133285 && SQLITE_OK==(rc = sqlite3Fts3SegReaderStart(p, pCsr, pFilter))
133290 if( rc==SQLITE_OK ){
133300 if( rc==SQLITE_OK && pWriter->nLeafEst ){
133304 if( rc==SQLITE_OK ) rc = sqlite3Fts3SegReaderStep(p, pCsr);
133305 if( pWriter->nWork>=nRem && rc==SQLITE_ROW ) rc = SQLITE_OK;
133309 if( rc==SQLITE_OK ){
133326 if( bDirtyHint && rc==SQLITE_OK ){
133379 rc = SQLITE_OK;
133384 if( rc==SQLITE_OK ){
133404 int rc = SQLITE_OK;
133451 ** If successful, the checksum value is returned and *pRc set to SQLITE_OK.
133466 assert( *pRc==SQLITE_OK );
133476 if( rc==SQLITE_OK ){
133480 if( rc==SQLITE_OK ){
133523 ** to true and return SQLITE_OK. Or if the contents do not match, set *pbOk
133530 int rc = SQLITE_OK; /* Return code */
133537 if( rc==SQLITE_OK ){
133540 while( rc==SQLITE_OK && sqlite3_step(pAllLangid)==SQLITE_ROW ){
133548 if( rc==SQLITE_OK ) rc = rc2;
133553 if( rc==SQLITE_OK ){
133566 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
133571 for(iCol=0; rc==SQLITE_OK && iCol<p->nColumn; iCol++){
133577 while( rc==SQLITE_OK ){
133584 if( rc==SQLITE_OK ){
133599 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
133612 ** the FTS index are correct, return SQLITE_OK. Or, if the contents of the
133647 if( rc==SQLITE_OK && bOk==0 ) rc = SQLITE_CORRUPT_VTAB;
133679 rc = SQLITE_OK;
133682 rc = SQLITE_OK;
133728 int rc = SQLITE_OK; /* Return code */
133741 for(i=0; i<p->nColumn && rc==SQLITE_OK; i++){
133746 while( rc==SQLITE_OK ){
133753 for(pDef=pCsr->pDeferred; pDef && rc==SQLITE_OK; pDef=pDef->pNext){
133765 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
133768 for(pDef=pCsr->pDeferred; pDef && rc==SQLITE_OK; pDef=pDef->pNext){
133791 return SQLITE_OK;
133802 return SQLITE_OK;
133827 return SQLITE_OK;
133842 int rc = SQLITE_OK; /* Return code */
133846 if( bFound && rc==SQLITE_OK ){
133849 if( rc==SQLITE_OK ){
133892 int rc = SQLITE_OK; /* Return Code */
133976 if( rc!=SQLITE_OK ){
133988 if( nArg>1 && rc==SQLITE_OK ){
133996 if( rc==SQLITE_OK && (!isRemove || *pRowid!=p->iPrevDocid ) ){
133999 if( rc==SQLITE_OK ){
134027 if( rc==SQLITE_OK ){
134029 if( rc==SQLITE_OK || rc==SQLITE_DONE ){
134031 if( rc2!=SQLITE_OK ) rc = rc2;
134193 if( rc==SQLITE_OK && eType!=FTSQUERY_NOT ){
134208 ** If the callback function returns anything other than SQLITE_OK,
134210 ** Otherwise, SQLITE_OK is returned after a callback has been made for
134228 int rc = SQLITE_OK;
134268 return SQLITE_OK;
134410 assert( rc==SQLITE_OK || pCsr==0 );
134421 assert( rc!=SQLITE_OK || (
134466 if( rc!=SQLITE_OK ){
134518 return SQLITE_OK;
134556 return SQLITE_OK;
134618 if( rc!=SQLITE_OK ){
134621 while( rc==SQLITE_OK && iCurrent<(nSnippet+nDesired) ){
134626 if( rc!=SQLITE_OK && rc!=SQLITE_DONE ){ return rc; }
134636 return SQLITE_OK;
134672 return SQLITE_OK;
134679 if( rc!=SQLITE_OK ){
134683 while( rc==SQLITE_OK ){
134702 if( rc!=SQLITE_OK ){
134725 if( rc==SQLITE_OK && (iPos>0 || iFragment>0) ){
134728 if( rc!=SQLITE_OK || iCurrent<iPos ) continue;
134742 if( rc==SQLITE_OK && isHighlight ) rc = fts3StringAppend(pOut, zOpen, -1);
134743 if( rc==SQLITE_OK ) rc = fts3StringAppend(pOut, &zDoc[iBegin], iFin-iBegin);
134744 if( rc==SQLITE_OK && isHighlight ) rc = fts3StringAppend(pOut, zClose, -1);
134830 int rc = SQLITE_OK;
134835 for(i=0; i<p->nCol && rc==SQLITE_OK; i++){
134861 return SQLITE_OK;
134904 if( rc!=SQLITE_OK ) return rc;
134915 return SQLITE_OK;
134945 return SQLITE_OK;
134975 ** array before returning. SQLITE_OK is returned in this case.
135009 if( rc!=SQLITE_OK ) return rc;
135045 return SQLITE_OK;
135061 ** Return SQLITE_OK if successful, or an SQLite error code if an error
135062 ** occurs. If a value other than SQLITE_OK is returned, the state the
135071 int rc = SQLITE_OK;
135076 for(i=0; rc==SQLITE_OK && zArg[i]; i++){
135101 if( rc==SQLITE_OK ){
135117 if( rc==SQLITE_OK ){
135132 if( rc==SQLITE_OK ){
135142 if( rc!=SQLITE_OK ) break;
135146 if( rc!=SQLITE_OK ) break;
135149 if( rc!=SQLITE_OK ) break;
135174 int rc = SQLITE_OK;
135246 int rc = SQLITE_OK;
135297 if( rc!=SQLITE_OK ){
135318 for(i=0; i<nSnippet && rc==SQLITE_OK; i++){
135326 if( rc!=SQLITE_OK ){
135406 if( rc!=SQLITE_OK ) goto offsets_out;
135458 if( rc!=SQLITE_OK ) goto offsets_out;
135461 while( rc==SQLITE_OK ){
135484 while( rc==SQLITE_OK && iCurrent<iMinPos ){
135487 if( rc==SQLITE_OK ){
135499 rc = SQLITE_OK;
135503 if( rc!=SQLITE_OK ) goto offsets_out;
135510 if( rc!=SQLITE_OK ){
135555 if( rc!=SQLITE_OK ){
135674 return SQLITE_OK;
135743 return SQLITE_OK;
135789 int rc = SQLITE_OK;
135796 for(i=0; rc==SQLITE_OK && i<nArg; i++){
135818 if( rc!=SQLITE_OK ){
135857 return SQLITE_OK;
135868 return SQLITE_OK;
135936 return SQLITE_OK;
136816 int rc2 = SQLITE_OK;
136830 return SQLITE_OK;
136854 if( rc==SQLITE_OK ) rc = rc2;
136873 if( pNode && rc==SQLITE_OK ){
136879 if( rc==SQLITE_OK ){
136926 ** is successful, return SQLITE_OK.
136957 int rc = SQLITE_OK;
136969 if( pNode->iNode==0 && rc==SQLITE_OK ){
136983 int rc = SQLITE_OK;
136994 if( rc==SQLITE_OK ){
137114 return SQLITE_OK;
137137 if( rc==SQLITE_OK ){
137155 rc = SQLITE_OK;
137234 ** Return SQLITE_OK if successful or an SQLite error code if an error
137241 int rc = SQLITE_OK;
137286 ** Return SQLITE_OK if successful or an SQLite error code if an error
137314 if( rc!=SQLITE_OK ){
137323 return SQLITE_OK;
137327 return SQLITE_OK;
137358 if( rc!=SQLITE_OK || isEof || iHeight==0 ){
137364 if( rc!=SQLITE_OK ){
137374 if( rc!=SQLITE_OK ){
137407 return SQLITE_OK;
137423 return SQLITE_OK;
137432 int rc = SQLITE_OK;
137453 if( rc!=SQLITE_OK || !isEof ){
137459 if( rc!=SQLITE_OK ){
137481 return SQLITE_OK;
137508 return SQLITE_OK;
137514 ** return SQLITE_OK. If there is no such record in the table, set
137515 ** *ppLeaf to 0 and return SQLITE_OK. If an error occurs, set *ppLeaf
137575 return SQLITE_OK;
137591 int rc = SQLITE_OK;
137605 assert( rc==SQLITE_OK );
137631 if( rc!=SQLITE_OK ){
137645 if( rc==SQLITE_OK ){
137649 if( rc==SQLITE_OK ){
137653 for(pCsr->iCell=0; rc==SQLITE_OK && pCsr->iCell<nCell; pCsr->iCell++){
137660 if( rc==SQLITE_OK && isEof ){
137665 assert( rc!=SQLITE_OK || !pCsr->pNode || pCsr->iCell<NCELL(pCsr->pNode) );
137708 int rc = SQLITE_OK;
137737 return SQLITE_OK;
137917 for(ii=0; rc==SQLITE_OK && ii<(pRtree->iDepth-iHeight); ii++){
138026 return SQLITE_OK;
138438 return SQLITE_OK;
138494 return SQLITE_OK;
138526 int rc = SQLITE_OK;
138575 if( rc!=SQLITE_OK ){
138584 if( SQLITE_OK!=(rc = nodeWrite(pRtree, pRight))
138585 || (0==pLeft->iNode && SQLITE_OK!=(rc = nodeWrite(pRtree, pLeft)))
138595 if( rc!=SQLITE_OK ){
138602 if( rc==SQLITE_OK ){
138606 if( rc!=SQLITE_OK ){
138620 if( rc!=SQLITE_OK ){
138628 if( rc!=SQLITE_OK ){
138636 if( rc==SQLITE_OK ){
138640 if( rc==SQLITE_OK ){
138664 int rc = SQLITE_OK;
138666 while( rc==SQLITE_OK && pChild->iNode!=1 && pChild->pParent==0 ){
138667 int rc2 = SQLITE_OK; /* sqlite3_reset() return code */
138686 if( rc==SQLITE_OK ) rc = rc2;
138687 if( rc==SQLITE_OK && !pChild->pParent ) rc = SQLITE_CORRUPT_VTAB;
138705 if( rc==SQLITE_OK ){
138711 if( rc==SQLITE_OK ){
138714 if( rc!=SQLITE_OK ){
138721 if( SQLITE_OK!=(rc = sqlite3_reset(pRtree->pDeleteNode)) ){
138728 if( SQLITE_OK!=(rc = sqlite3_reset(pRtree->pDeleteParent)) ){
138741 return SQLITE_OK;
138746 int rc = SQLITE_OK;
138759 if( rc==SQLITE_OK ){
138775 if( SQLITE_OK!=(rc = fixLeafParent(pRtree, pNode)) ){
138816 int rc = SQLITE_OK;
138868 for(ii=0; rc==SQLITE_OK && ii<(nCell-(RTREE_MINCELLS(pRtree)+1)); ii++){
138879 if( rc==SQLITE_OK ){
138882 for(; rc==SQLITE_OK && ii<nCell; ii++){
138889 if( rc==SQLITE_OK ){
138893 if( rc==SQLITE_OK ){
138913 int rc = SQLITE_OK;
138935 if( rc==SQLITE_OK ){
138948 int rc = SQLITE_OK;
138951 for(ii=0; rc==SQLITE_OK && ii<nCell; ii++){
138960 if( rc==SQLITE_OK ){
138964 if( rc==SQLITE_OK ){
139001 if( rc==SQLITE_OK ){
139006 if( rc==SQLITE_OK ){
139009 if( rc==SQLITE_OK ){
139013 if( rc==SQLITE_OK ){
139019 if( rc==SQLITE_OK ){
139033 if( rc==SQLITE_OK && pRtree->iDepth>0 && NCELL(pRoot)==1 ){
139038 if( rc==SQLITE_OK ){
139042 if( rc==SQLITE_OK ) rc = rc2;
139043 if( rc==SQLITE_OK ){
139052 if( rc==SQLITE_OK ){
139060 if( rc==SQLITE_OK ){
139109 int rc = SQLITE_OK;
139191 if( rc==SQLITE_OK && nData>1 ){
139201 if( rc==SQLITE_OK ){
139204 if( rc==SQLITE_OK ){
139209 if( rc==SQLITE_OK ){
139274 int rc = SQLITE_OK;
139311 if( rc!=SQLITE_OK ){
139326 for(i=0; i<N_STATEMENT && rc==SQLITE_OK; i++){
139343 ** is written to *piVal and SQLITE_OK returned. Otherwise, an SQLite error
139351 if( rc==SQLITE_OK ){
139364 ** to. If successful, pRtree->iNodeSize is populated and SQLITE_OK returned.
139388 if( rc==SQLITE_OK ){
139402 if( rc!=SQLITE_OK ){
139428 int rc = SQLITE_OK;
139474 if( rc==SQLITE_OK ){
139493 }else if( SQLITE_OK!=(rc = sqlite3_declare_vtab(db, zSql)) ){
139500 if( rc==SQLITE_OK ){
139592 if( rc==SQLITE_OK ){
139595 if( rc==SQLITE_OK ){
139603 if( rc==SQLITE_OK ){
140133 if( rc!=SQLITE_OK ){
140168 int rc = SQLITE_OK;
140171 for(i=0; rc==SQLITE_OK && i<(int)(sizeof(scalars)/sizeof(scalars[0])); i++){
140269 return SQLITE_OK;
140278 return SQLITE_OK;
140353 return SQLITE_OK;
140364 return SQLITE_OK;
140429 return SQLITE_OK;