Lines Matching defs:SQLITE_OK
634 ** ^Calls to sqlite3_close() and sqlite3_close_v2() return [SQLITE_OK] if
647 ** it returns [SQLITE_OK] regardless, but instead of deallocating the database
759 #define SQLITE_OK 0 /* Successful result */
885 #define SQLITE_OK_LOAD_PERMANENTLY (SQLITE_OK | (1<<8))
886 #define SQLITE_OK_SYMLINK (SQLITE_OK | (2<<8)) /* internal use only */
1339 ** file control returns [SQLITE_OK], then the parser assumes that the
1344 ** any result code other than [SQLITE_OK] or [SQLITE_NOTFOUND], that means
1424 ** If the [SQLITE_FCNTL_BEGIN_ATOMIC_WRITE] opcode returns SQLITE_OK, then
1440 ** This file control returns [SQLITE_OK] if and only if the writes were
1735 ** directory. The xAccess method returns [SQLITE_OK] on success or some
1737 ** the file given in the second argument is illegal. If SQLITE_OK
1913 ** ^The sqlite3_initialize() routine returns [SQLITE_OK] on success.
1916 ** as a mutex) it returns an [error code] other than [SQLITE_OK].
1953 ** must return [SQLITE_OK] on success and some other [error code] upon
1991 ** ^When a configuration option is set, sqlite3_config() returns [SQLITE_OK].
2011 ** ^Calls to sqlite3_db_config() return SQLITE_OK if and only if
3469 ** return [SQLITE_OK] to allow the action, [SQLITE_IGNORE] to disallow the
3473 ** any value other than [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY]
3477 ** When the callback returns [SQLITE_OK], that means the operation
3496 ** been read if [SQLITE_OK] had been returned. The [SQLITE_IGNORE]
3554 ** return either [SQLITE_OK] or one of these two constants in order
3805 ** [SQLITE_OK] is returned. Otherwise an [error code] is returned.)^ ^The
4559 ** ^On success, the sqlite3_prepare() family of routines return [SQLITE_OK];
4787 ** This routine returns SQLITE_OK if the explain mode is successfully
5003 ** ^The sqlite3_bind_* routines return [SQLITE_OK] on success or an
5603 ** SQLITE_OK. ^If the most recent evaluation of statement S failed, then
5642 ** [SQLITE_OK].
6860 ** [SQLITE_OK] to indicate success, [SQLITE_ERROR] if the type is unsupported,
7138 ** from sqlite3_autovacuum_pages() is normally SQLITE_OK, but might
7140 ** implementation will only return SQLITE_OK or SQLITE_MISUSE, but other
7253 ** ^(This routine returns [SQLITE_OK] if shared cache was enabled or disabled
7392 ** interface returns SQLITE_OK and fills in the non-NULL pointers in
7398 ** table and returns SQLITE_OK if the table exists and SQLITE_ERROR if it
7488 ** [SQLITE_OK] on success and [SQLITE_ERROR] if something goes wrong.
8043 ** ^(On success, [SQLITE_OK] is returned and the new [BLOB handle] is stored
8194 ** ^(On success, sqlite3_blob_read() returns SQLITE_OK.
8214 ** ^(On success, sqlite3_blob_write() returns SQLITE_OK.
8370 ** SQLITE_BUSY. ^The sqlite3_mutex_try() interface returns [SQLITE_OK]
8464 ** called, but only if the prior call to xMutexInit returned SQLITE_OK.
8683 ** SQLITE_OK if N is within bounds and SQLITE_ERROR if not. If either Z
8829 ** [SQLITE_MAX_LENGTH], or [SQLITE_OK] if there have been no errors.
8869 ** SQLITE_OK on success and a non-zero [error code] on failure.
8982 ** ^The sqlite3_db_status() routine returns SQLITE_OK on success and a
9522 ** are still more pages to be copied, then the function returns [SQLITE_OK].
9526 ** then an [error code] is returned. ^As well as [SQLITE_OK] and
9585 ** ^The value returned by sqlite3_backup_finish is [SQLITE_OK] if no
9707 ** returns SQLITE_OK.
9868 ** The callback function should normally return [SQLITE_OK]. ^If an error
10020 ** databases, SQLITE_OK is returned.
10023 ** mode, SQLITE_OK is returned and both *pnLog and *pnCkpt set to -1. ^If
10114 ** return SQLITE_OK. Or, if this is not possible, it may return
10415 ** rc==SQLITE_OK && pVal;
10420 ** if( rc!=SQLITE_OK ){
10426 ** routines return SQLITE_OK and set *P to point to the first or next value
10456 ** ^The sqlite3_vtab_rhs_value(P,J,V) interface returns SQLITE_OK if
10460 ** can return an result code other than SQLITE_OK or SQLITE_NOTFOUND if
10667 ** ^Otherwise, if no error occurs, [sqlite3_db_cacheflush()] returns SQLITE_OK.
10836 ** created [sqlite3_snapshot] object into *P and returns SQLITE_OK.
10885 ** database. ^The [sqlite3_snapshot_open()] interface returns SQLITE_OK
10905 ** read transaction is undefined. If SQLITE_OK is returned, then the
10987 ** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
11316 ** a pointer to the new object is written to *ppSession and SQLITE_OK is
11485 ** SQLITE_OK is returned if the call completes without error. Or, if an error
11549 ** SQLITE_OK. If an error occurs, set both *ppChangeset and *pnChangeset to
11719 ** If the operation is successful, SQLITE_OK is returned. Otherwise, an SQLite
11798 ** If successful, *pp is set to point to the iterator handle and SQLITE_OK
11913 ** If no error occurs, SQLITE_OK is returned. If an error does occur, an
11948 ** SQLITE_OK is returned and the output variables populated as described
11976 ** returns SQLITE_OK. The name of the function comes from the fact that this
12007 ** returns SQLITE_OK. If the change is an UPDATE and does not include
12009 ** SQLITE_OK returned. The name of the function comes from the fact that
12039 ** and returns SQLITE_OK.
12057 ** violations in the destination database and returns SQLITE_OK.
12083 ** to that error is returned by this function. Otherwise, SQLITE_OK is
12092 ** if( rc!=SQLITE_OK ){
12117 ** SQLITE_OK is returned. If an error occurs, both *pnOut and *ppOut are
12146 ** if( rc==SQLITE_OK ) rc = sqlite3changegroup_add(pGrp, nA, pA);
12147 ** if( rc==SQLITE_OK ) rc = sqlite3changegroup_add(pGrp, nB, pB);
12148 ** if( rc==SQLITE_OK ){
12197 ** If successful, this function returns SQLITE_OK and populates (*pp) with
12337 ** changegroup is undefined. If no error occurs, SQLITE_OK is returned.
12349 ** If the change is successfully added to the changegroup, SQLITE_OK is
12384 ** variables (*pnData) and (*ppData) are set to 0. Otherwise, SQLITE_OK
12839 ** point to the new object and return SQLITE_OK. Otherwise, if an error
12868 ** (*pnOut) to its size in bytes and SQLITE_OK returned. It is the
12936 ** before returning SQLITE_OK. If the input is completely exhausted, (*pnData)
12970 ** supplied data, it should return SQLITE_OK to indicate success. Otherwise,
13092 ** This function returns SQLITE_OK if successful, or an SQLite error code
13208 ** (not characters) of the buffer and SQLITE_OK is returned. Otherwise,
13223 ** the query within the current row. Return SQLITE_OK if successful, or
13240 ** first token of the phrase. SQLITE_OK is returned if successful, or an
13271 ** If the callback function returns any value other than SQLITE_OK, the
13273 ** If the returned value is SQLITE_DONE, xQueryPhrase returns SQLITE_OK.
13276 ** If the query runs to completion without incident, SQLITE_OK is returned.
13490 ** should be set to point to the new tokenizer handle and SQLITE_OK
13491 ** returned. If an error occurs, some value other than SQLITE_OK should
13545 ** If an xToken() callback returns any value other than SQLITE_OK, then
13548 ** input buffer is exhausted, xTokenize() should return SQLITE_OK. Finally,
13551 ** SQLITE_OK or SQLITE_DONE.
15960 # define sqlite3PagerWalWriteLock(y,z) SQLITE_OK
17360 #define sqlite3_mutex_try(X) SQLITE_OK
17365 #define sqlite3MutexInit() SQLITE_OK
20896 # define sqlite3FaultSim(X) SQLITE_OK
21170 # define sqlite3AuthCheck(a,b,c,d,e) SQLITE_OK
21420 # define sqlite3ExprCheckIN(x,y) SQLITE_OK
21464 # define sqlite3VtabSync(X,Y) SQLITE_OK
21472 # define sqlite3VtabSavepoint(X, Y, Z) SQLITE_OK
23828 #define sqlite3VdbeMemExpandBlob(x) SQLITE_OK
23829 #define ExpandBlob(P) SQLITE_OK
23975 return SQLITE_OK;
24027 int rc = SQLITE_OK; /* Return code */
24867 return SQLITE_OK;
25023 rc = p->isLocal ? SQLITE_OK : toLocaltime(p, pCtx);
25076 rc = SQLITE_OK;
26138 return flags ? id->pMethods->xSync(id, flags) : SQLITE_OK;
26241 return SQLITE_OK;
26244 return SQLITE_OK;
26267 assert( rc==SQLITE_OK || pFile->pMethods==0 );
26273 return pVfs->xDelete!=0 ? pVfs->xDelete(pVfs, zPath, dirSync) : SQLITE_OK;
26315 return SQLITE_OK;
26357 if( rc!=SQLITE_OK ){
26367 assert( *ppFile!=0 || rc!=SQLITE_OK );
26467 return SQLITE_OK;
26483 return SQLITE_OK;
26613 static int sqlite3MemInit(void *NotUsed){ return SQLITE_OK; }
26883 return SQLITE_OK;
26899 return SQLITE_OK;
27129 return SQLITE_OK;
28035 return SQLITE_OK;
28665 return SQLITE_OK;
28824 return SQLITE_OK;
28828 return SQLITE_OK;
28899 if( SQLITE_OK==pGlobalMutexMethods->xMutexTry(pCheck->mutex) ){
28962 int rc = SQLITE_OK;
29008 int rc = SQLITE_OK;
29063 ** Obtain the mutex p. If successful, return SQLITE_OK. Otherwise, if another
29067 int rc = SQLITE_OK;
29144 static int noopMutexInit(void){ return SQLITE_OK; }
29145 static int noopMutexEnd(void){ return SQLITE_OK; }
29154 return SQLITE_OK;
29207 static int debugMutexInit(void){ return SQLITE_OK; }
29208 static int debugMutexEnd(void){ return SQLITE_OK; }
29262 ** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK
29278 return SQLITE_OK;
29426 static int pthreadMutexInit(void){ return SQLITE_OK; }
29427 static int pthreadMutexEnd(void){ return SQLITE_OK; }
29568 ** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK
29636 rc = SQLITE_OK;
29641 rc = SQLITE_OK;
29654 rc = SQLITE_OK;
29661 if( rc==SQLITE_OK && p->trace ){
29959 return SQLITE_OK;
29974 return SQLITE_OK;
30090 ** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK
30150 rc = SQLITE_OK;
30295 return SQLITE_OK;
30386 if( rc!=SQLITE_OK ) memset(&mem0, 0, sizeof(mem0));
34147 return SQLITE_OK;
34158 rc = SQLITE_OK;
34160 rc = pthread_join(p->tid, ppOut) ? SQLITE_ERROR : SQLITE_OK;
34241 return SQLITE_OK;
34266 return (rc==WAIT_OBJECT_0) ? SQLITE_OK : SQLITE_ERROR;
34309 return SQLITE_OK;
34332 return SQLITE_OK;
34585 if( rc!=SQLITE_OK ){
34734 return SQLITE_OK;
34749 int rc = SQLITE_OK;
34766 if( rc==SQLITE_OK ){
34938 ** In deployment, sqlite3FaultSim() *always* return SQLITE_OK (0). The
34955 return xCallback ? xCallback(iTest) : SQLITE_OK;
35050 ** The equivalent of sqlite3Error(db, SQLITE_OK). Clear the error state
35055 db->errCode = SQLITE_OK;
35098 ** should be called with err_code set to SQLITE_OK and zFormat set
37874 return SQLITE_OK;
37906 return SQLITE_OK;
37963 return SQLITE_OK;
37992 return SQLITE_OK;
38022 return SQLITE_OK;
38036 return SQLITE_OK;
38055 return kvvfsWriteFileSize(pFile, size) ? SQLITE_IOERR : SQLITE_OK;
38085 return i ? SQLITE_IOERR : SQLITE_OK;
38088 return SQLITE_OK;
38098 return SQLITE_OK;
38108 return SQLITE_OK;
38122 return SQLITE_OK;
38135 return SQLITE_OK;
38144 return SQLITE_OK;
38158 int rc = SQLITE_OK;
38224 return SQLITE_OK;
38239 return SQLITE_OK;
38269 return SQLITE_OK;
38292 return SQLITE_OK;
38316 return SQLITE_OK;
38335 return SQLITE_OK;
38347 return SQLITE_OK;
38588 ** a normal expected return code of SQLITE_BUSY or SQLITE_OK
38590 #define IS_LOCK_ERROR(x) ((x != SQLITE_OK) && (x != SQLITE_BUSY))
38970 ** "unix" VFSes. Return SQLITE_OK upon successfully updating the
38987 rc = SQLITE_OK;
39002 rc = SQLITE_OK;
39251 rc = SQLITE_OK;
39856 return SQLITE_OK;
39914 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
39917 int rc = SQLITE_OK;
40108 int rc = SQLITE_OK;
40127 return SQLITE_OK;
40156 ** return SQLITE_OK.
40201 assert( rc==SQLITE_OK );
40215 if( unixFileLock(pFile, &lock) && rc==SQLITE_OK ){
40268 if( rc==SQLITE_OK
40278 if( rc==SQLITE_OK ){
40286 rc==SQLITE_OK ? "ok" : "failed"));
40321 int rc = SQLITE_OK;
40330 return SQLITE_OK;
40464 if( rc==SQLITE_OK ){
40528 return SQLITE_OK;
40535 int rc = SQLITE_OK;
40589 return SQLITE_OK;
40593 return SQLITE_OK;
40597 return SQLITE_OK;
40642 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
40649 int rc = SQLITE_OK;
40692 int rc = SQLITE_OK;
40706 return SQLITE_OK;
40751 return SQLITE_OK;
40759 return SQLITE_OK;
40768 rc = SQLITE_OK;
40776 return SQLITE_OK;
40826 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
40829 int rc = SQLITE_OK;
40871 rc = SQLITE_OK;
40909 int rc = SQLITE_OK;
40918 return SQLITE_OK;
40935 rc==SQLITE_OK ? "ok" : "failed"));
40962 return SQLITE_OK;
40968 return SQLITE_OK;
40974 return SQLITE_OK;
40979 return SQLITE_OK;
41013 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
41016 int rc = SQLITE_OK;
41085 int rc = SQLITE_OK;
41091 rc = SQLITE_OK;
41127 return SQLITE_OK;
41133 return SQLITE_OK;
41146 return SQLITE_OK;
41163 return SQLITE_OK;
41210 ** Return SQLITE_OK on success, SQLITE_BUSY on failure.
41248 return SQLITE_OK;
41256 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
41259 int rc = SQLITE_OK;
41270 return SQLITE_OK;
41283 if( SQLITE_OK==lrc ){
41328 int rc = SQLITE_OK;
41345 return SQLITE_OK;
41374 ** return SQLITE_OK.
41432 } else if( lrc1 != SQLITE_OK ) {
41465 int failed2 = SQLITE_OK;
41487 if( rc==SQLITE_OK ){
41498 rc==SQLITE_OK ? "ok" : "failed"));
41510 int rc = SQLITE_OK;
41523 return SQLITE_OK;
41548 if( rc==SQLITE_OK && (eFileLock==SHARED_LOCK || pInode->nShared>1) ){
41556 if( rc==SQLITE_OK && pFile->eFileLock>=PENDING_LOCK ){
41559 if( rc==SQLITE_OK && pFile->eFileLock>=RESERVED_LOCK && context->reserved ){
41565 if( rc==SQLITE_OK && (eFileLock==SHARED_LOCK || pInode->nShared>1)){
41569 if( rc==SQLITE_OK && eFileLock==NO_LOCK ){
41586 if( rc==SQLITE_OK ){
41594 if( rc==SQLITE_OK ){
41604 int rc = SQLITE_OK;
41726 ** Read data from a file into a buffer. Return SQLITE_OK if all
41757 return SQLITE_OK;
41770 return SQLITE_OK;
41858 ** Write data from a buffer into a file. Return SQLITE_OK on success
41909 return SQLITE_OK;
41938 return SQLITE_OK;
42072 ** SQLITE_OK is returned. If an error occurs, either SQLITE_NOMEM
42086 ** a no-op, replace it with a stub that returns SQLITE_OK but leaves
42089 ** If SQLITE_OK is returned, the caller is responsible for closing
42110 if( fd>=0 ) return SQLITE_OK;
42164 if( rc==SQLITE_OK ){
42169 rc = SQLITE_OK;
42222 return SQLITE_OK;
42250 return SQLITE_OK;
42327 return SQLITE_OK;
42361 return rc ? SQLITE_IOERR_BEGIN_ATOMIC : SQLITE_OK;
42365 return rc ? SQLITE_IOERR_COMMIT_ATOMIC : SQLITE_OK;
42369 return rc ? SQLITE_IOERR_ROLLBACK_ATOMIC : SQLITE_OK;
42375 return SQLITE_OK;
42379 return SQLITE_OK;
42383 return SQLITE_OK;
42394 return SQLITE_OK;
42398 return SQLITE_OK;
42402 return SQLITE_OK;
42410 return SQLITE_OK;
42414 return SQLITE_OK;
42427 return SQLITE_OK;
42433 int rc = SQLITE_OK;
42464 return SQLITE_OK;
42479 return SQLITE_OK;
42750 ** no error occurs, return SQLITE_OK and set (*piOut) to 1 if there are
42756 int rc = SQLITE_OK;
42795 int rc = SQLITE_OK; /* Result code form fcntl() */
42847 if( rc==SQLITE_OK ){
42926 ** take it now. Return SQLITE_OK if successful, or an SQLite error
42935 int rc = SQLITE_OK;
42985 if( rc==SQLITE_OK && robust_ftruncate(pShmNode->hShm, 3) ){
42993 if( rc==SQLITE_OK ){
43038 int rc = SQLITE_OK; /* Result code */
43136 if( rc!=SQLITE_OK && rc!=SQLITE_READONLY_CANTINIT ) goto shm_open_err;
43180 ** separate process), then *pp is set to NULL and SQLITE_OK returned. If
43187 ** memory and SQLITE_OK returned.
43199 int rc = SQLITE_OK;
43206 if( rc!=SQLITE_OK ) return rc;
43214 if( rc!=SQLITE_OK ) goto shmpage_out;
43244 ** false, exit early. *pp will be set to NULL and SQLITE_OK returned.
43319 if( pShmNode->isReadonly && rc==SQLITE_OK ) rc = SQLITE_READONLY;
43376 int rc = SQLITE_OK; /* Result code */
43460 if( rc!=SQLITE_OK ) goto leave_shmnode_mutexes;
43469 if( ALWAYS(rc==SQLITE_OK) ){
43493 if( rc==SQLITE_OK ){
43510 if( rc==SQLITE_OK ){
43533 if( rc==SQLITE_OK ){
43535 if( rc==SQLITE_OK ){
43598 if( p==0 ) return SQLITE_OK;
43629 return SQLITE_OK;
43734 unixLogError(SQLITE_OK, zErr, pFd->zPath);
43757 ** SQLITE_OK is returned if no error occurs (even if the mapping is not
43764 if( pFd->nFetchOut>0 ) return SQLITE_OK;
43782 return SQLITE_OK;
43790 ** If such a pointer can be obtained, store it in *pp and return SQLITE_OK.
43791 ** Or, if one cannot but no error occurs, set *pp to 0 and return SQLITE_OK.
43813 if( rc!=SQLITE_OK ) return rc;
43821 return SQLITE_OK;
43859 return SQLITE_OK;
44173 int rc = SQLITE_OK;
44223 if( rc!=SQLITE_OK ){
44266 if( rc!=SQLITE_OK ){
44300 if( (rc==SQLITE_OK) && (pNew->pInode->pSem==NULL) ){
44319 if( rc!=SQLITE_OK ){
44326 if( rc!=SQLITE_OK ){
44387 int rc = SQLITE_OK;
44500 int rc = SQLITE_OK;
44513 ** to create new files with. If no error occurs, then SQLITE_OK is returned
44539 int rc = SQLITE_OK; /* Return Code */
44563 ** the filename. In that case, just return SQLITE_OK with *pMode==0.
44624 int rc = SQLITE_OK; /* Function Return Code */
44719 if( rc!=SQLITE_OK ){
44744 if( rc!=SQLITE_OK ){
44776 if( rc==SQLITE_OK ) rc = rc2;
44865 if( rc==SQLITE_OK ){
44867 if( rc!=SQLITE_OK ){
44887 if( rc!=SQLITE_OK ){
44903 int rc = SQLITE_OK;
44922 if( rc==SQLITE_OK ){
44929 rc = SQLITE_OK;
44967 return SQLITE_OK;
45013 if( pPath->rc==SQLITE_OK ){
45097 return SQLITE_OK;
45255 ** On success, return SQLITE_OK. Return SQLITE_ERROR if the time and date
45260 int rc = SQLITE_OK;
45532 return SQLITE_OK;
45585 int rc = SQLITE_OK;
45610 if( proxyCreateLockPath(path) == SQLITE_OK ){
45649 if( rc==SQLITE_OK ){
45651 return SQLITE_OK;
45699 return SQLITE_OK;
45778 int rc = SQLITE_OK;
45833 rc = SQLITE_OK;
45857 return SQLITE_OK;
45865 int rc = SQLITE_OK;
45882 if( rc!=SQLITE_OK ){
45964 if( rc==SQLITE_OK ){
45983 if( rc==SQLITE_OK && createConch ){
46015 if( rc==SQLITE_OK && pFile->openFlags ){
46030 if( rc==SQLITE_OK && !pCtx->lockProxy ){
46033 if( rc!=SQLITE_OK && rc!=SQLITE_NOMEM && tryOldLockPath ){
46042 if( rc==SQLITE_OK ){
46053 if( rc==SQLITE_OK ){
46065 rc==SQLITE_OK?"ok":"failed"));
46076 int rc = SQLITE_OK; /* Subroutine return code */
46090 (rc==SQLITE_OK ? "ok" : "failed")));
46097 ** Make *pConchPath point to the new name. Return SQLITE_OK on success
46135 return SQLITE_OK;
46145 int rc = SQLITE_OK;
46154 return SQLITE_OK;
46198 return SQLITE_OK;
46213 int rc = SQLITE_OK;
46235 if( rc==SQLITE_OK ){
46255 rc = SQLITE_OK;
46259 if( rc==SQLITE_OK && lockPath ){
46263 if( rc==SQLITE_OK ){
46269 if( rc==SQLITE_OK ){
46287 (rc==SQLITE_OK ? "ok" : "failed")));
46311 return SQLITE_OK;
46315 int rc = SQLITE_OK;
46326 rc = SQLITE_OK;
46337 rc = SQLITE_OK;
46367 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
46372 if( rc==SQLITE_OK ){
46411 if( rc==SQLITE_OK ){
46435 if( rc==SQLITE_OK ){
46457 int rc = SQLITE_OK;
46485 return SQLITE_OK;
46633 return SQLITE_OK;
46645 return SQLITE_OK;
47813 ** "win32" VFSes. Return SQLITE_OK upon successfully updating the
47830 rc = SQLITE_OK;
47845 rc = SQLITE_OK;
47897 ** compact it. Upon success, SQLITE_OK will be returned. Upon failure, one
47903 int rc = SQLITE_OK;
47967 assert( rc!=SQLITE_OK || winMemGetHeap()!=NULL );
47968 assert( rc!=SQLITE_OK || winMemGetOwned() );
47969 assert( rc!=SQLITE_OK || sqlite3_memory_used()==0 );
48266 return SQLITE_OK;
48598 rc = SQLITE_OK;
48631 ** SQLITE_OK if successful.
48748 assert( errcode!=SQLITE_OK );
48990 return SQLITE_OK;
49272 OSTRACE(("SEEK file=%p, rc=SQLITE_OK\n", pFile->h));
49293 OSTRACE(("SEEK file=%p, rc=SQLITE_OK\n", pFile->h));
49361 return rc ? SQLITE_OK
49367 ** Read data from a file into a buffer. Return SQLITE_OK if all
49398 OSTRACE(("READ-MMAP pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n",
49400 return SQLITE_OK;
49442 OSTRACE(("READ pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n",
49444 return SQLITE_OK;
49448 ** Write data from a buffer into a file. Return SQLITE_OK on success
49476 OSTRACE(("WRITE-MMAP pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n",
49478 return SQLITE_OK;
49552 OSTRACE(("WRITE pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n",
49554 return SQLITE_OK;
49562 int rc = SQLITE_OK; /* Return code for this function */
49584 return SQLITE_OK;
49623 if( rc==SQLITE_OK && oldMmapSize>0 ){
49695 OSTRACE(("SYNC-NOP pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n",
49697 return SQLITE_OK;
49703 "rc=SQLITE_OK\n", osGetCurrentProcessId(),
49718 OSTRACE(("SYNC pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n",
49720 return SQLITE_OK;
49736 int rc = SQLITE_OK;
49895 int rc = SQLITE_OK; /* Return code from subroutines */
49911 OSTRACE(("LOCK-HELD file=%p, rc=SQLITE_OK\n", pFile->h));
49912 return SQLITE_OK;
50019 rc = SQLITE_OK;
50057 OSTRACE(("TEST-WR-LOCK file=%p, pResOut=%p, *pResOut=%d, rc=SQLITE_OK\n",
50059 return SQLITE_OK;
50076 int rc = SQLITE_OK;
50126 return SQLITE_OK;
50132 return SQLITE_OK;
50138 return SQLITE_OK;
50175 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50176 return SQLITE_OK;
50180 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50181 return SQLITE_OK;
50185 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50186 return SQLITE_OK;
50192 if( rc==SQLITE_OK ){
50203 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50204 return SQLITE_OK;
50208 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50209 return SQLITE_OK;
50213 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50214 return SQLITE_OK;
50218 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50219 return SQLITE_OK;
50233 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50234 return SQLITE_OK;
50239 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50240 return SQLITE_OK;
50248 OSTRACE(("FCNTL oldFile=%p, newFile=%p, rc=SQLITE_OK\n",
50250 return SQLITE_OK;
50256 if( rc==SQLITE_OK ){
50265 int rc = SQLITE_OK;
50469 rc = SQLITE_OK;
50536 ** take it now. Return SQLITE_OK if successful, or an SQLite error
50546 if( rc==SQLITE_OK ){
50558 if( rc==SQLITE_OK ){
50575 int rc = SQLITE_OK; /* Result code */
50634 if( rc!=SQLITE_OK ){
50642 if( rc!=SQLITE_OK && rc!=SQLITE_READONLY_CANTINIT ) goto shm_open_err;
50692 if( p==0 ) return SQLITE_OK;
50716 return SQLITE_OK;
50732 int rc = SQLITE_OK; /* Result code */
50764 rc = SQLITE_OK;
50768 if( rc==SQLITE_OK ){
50788 if( rc==SQLITE_OK ){
50792 rc = SQLITE_OK;
50797 if( rc==SQLITE_OK ){
50814 if( rc==SQLITE_OK ){
50816 if( rc==SQLITE_OK ){
50854 ** separate process), then *pp is set to NULL and SQLITE_OK returned. If
50861 ** memory and SQLITE_OK returned.
50875 int rc = SQLITE_OK;
50879 if( rc!=SQLITE_OK ) return rc;
50888 if( rc!=SQLITE_OK ) goto shmpage_out;
50905 if( rc!=SQLITE_OK ){
50913 ** zero, exit early. *pp will be set to NULL and SQLITE_OK returned.
50920 if( rc!=SQLITE_OK ){
51001 if( pShmNode->isReadonly && rc==SQLITE_OK ) rc = SQLITE_READONLY;
51045 OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, rc=SQLITE_OK\n",
51047 return SQLITE_OK;
51062 ** SQLITE_OK is returned if no error occurs (even if the mapping is not
51074 if( pFd->nFetchOut>0 ) return SQLITE_OK;
51122 return SQLITE_OK;
51140 return SQLITE_OK;
51146 OSTRACE(("MAP-FILE pid=%lu, pFile=%p, rc=SQLITE_OK\n",
51148 return SQLITE_OK;
51156 ** If such a pointer can be obtained, store it in *pp and return SQLITE_OK.
51157 ** Or, if one cannot but no error occurs, set *pp to 0 and return SQLITE_OK.
51182 if( rc!=SQLITE_OK ){
51196 OSTRACE(("FETCH pid=%lu, pFile=%p, pp=%p, *pp=%p, rc=SQLITE_OK\n",
51198 return SQLITE_OK;
51239 OSTRACE(("UNFETCH pid=%lu, pFile=%p, rc=SQLITE_OK\n",
51241 return SQLITE_OK;
51629 OSTRACE(("TEMP-FILENAME name=%s, rc=SQLITE_OK\n", zBuf));
51630 return SQLITE_OK;
51700 int rc = SQLITE_OK; /* Function Return Code */
51765 if( rc!=SQLITE_OK ){
51862 if( rc2==SQLITE_OK && isRO ) break;
51879 if( rc2==SQLITE_OK && isRO ) break;
51899 if( rc2==SQLITE_OK && isRO ) break;
51942 && (rc = winceCreateLock(zName, pFile))!=SQLITE_OK
52053 rc = SQLITE_OK; /* Deleted OK. */
52081 rc = SQLITE_OK; /* Deleted OK. */
52122 OSTRACE(("ACCESS name=%s, pResOut=%p, *pResOut=%d, rc=SQLITE_OK\n",
52124 return SQLITE_OK;
52180 OSTRACE(("ACCESS name=%s, pResOut=%p, *pResOut=%d, rc=SQLITE_OK\n",
52182 return SQLITE_OK;
52322 return SQLITE_OK;
52341 return SQLITE_OK;
52360 return SQLITE_OK;
52421 return SQLITE_OK;
52457 if( winFullPathname(pVfs, zFilename, nFull, zFull)!=SQLITE_OK ){
52616 ** On success, return SQLITE_OK. Return SQLITE_ERROR if the time and date
52654 return SQLITE_OK;
52844 return SQLITE_OK;
52859 return SQLITE_OK;
53111 return SQLITE_OK;
53133 return SQLITE_OK;
53153 return SQLITE_OK;
53176 && (rc = memdbEnlarge(p, iOfst+iAmt))!=SQLITE_OK
53186 return SQLITE_OK;
53198 int rc = SQLITE_OK;
53216 return SQLITE_OK;
53227 return SQLITE_OK;
53236 int rc = SQLITE_OK;
53237 if( eLock<=pThis->eLock ) return SQLITE_OK;
53283 if( rc==SQLITE_OK ) pThis->eLock = eLock;
53294 if( eLock>=pThis->eLock ) return SQLITE_OK;
53311 return SQLITE_OK;
53321 return SQLITE_OK;
53335 rc = SQLITE_OK;
53348 rc = SQLITE_OK;
53390 return SQLITE_OK;
53401 return SQLITE_OK;
53483 return SQLITE_OK;
53514 return SQLITE_OK;
53530 return SQLITE_OK;
53688 if( rc==SQLITE_OK ){
53764 rc = SQLITE_OK;
53975 if( p==0 ) return SQLITE_OK;
53990 return SQLITE_OK;
54006 if( p->u.aHash[h]==i ) return SQLITE_OK;
54035 return SQLITE_OK;
54594 return SQLITE_OK;
54701 if( rc!=SQLITE_OK && rc!=SQLITE_BUSY ){
54707 return *ppPage==0 ? SQLITE_NOMEM_BKPT : SQLITE_OK;
55898 return SQLITE_OK;
57440 ** * The Pager.errCode variable is set to something other than SQLITE_OK.
57943 # define pagerOpenWalIfPresent(z) SQLITE_OK
57944 # define pagerBeginReadTransaction(z) SQLITE_OK
58009 assert( pPager->errCode==SQLITE_OK );
58014 assert( pPager->errCode==SQLITE_OK );
58021 assert( pPager->errCode==SQLITE_OK );
58033 assert( pPager->errCode==SQLITE_OK );
58052 assert( pPager->errCode==SQLITE_OK );
58065 assert( pPager->errCode==SQLITE_OK );
58079 assert( pPager->errCode!=SQLITE_OK );
58203 ** that is read in *pRes. Return SQLITE_OK if everything worked, or an
58211 if( rc==SQLITE_OK ){
58224 ** Write a 32-bit integer into the given file descriptor. Return SQLITE_OK
58243 int rc = SQLITE_OK;
58250 rc = pPager->noLock ? SQLITE_OK : sqlite3OsUnlock(pPager->fd, eLock);
58271 int rc = SQLITE_OK;
58275 rc = pPager->noLock ? SQLITE_OK : sqlite3OsLock(pPager->fd, eLock);
58276 if( rc==SQLITE_OK && (pPager->eLock!=UNKNOWN_LOCK||eLock==EXCLUSIVE_LOCK) ){
58403 ** zSuper[0] is set to 0 and SQLITE_OK returned.
58417 if( SQLITE_OK!=(rc = sqlite3OsFileSize(pJrnl, &szJ))
58419 || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-16, &len))
58423 || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-12, &cksum))
58424 || SQLITE_OK!=(rc = sqlite3OsRead(pJrnl, aMagic, 8, szJ-8))
58426 || SQLITE_OK!=(rc = sqlite3OsRead(pJrnl, zSuper, len, szJ-16-len))
58438 ** definitely roll back, so just return SQLITE_OK and report a (nul)
58446 return SQLITE_OK;
58495 ** Otherwise, return SQLITE_OK.
58498 int rc = SQLITE_OK; /* Return code */
58511 if( rc==SQLITE_OK && !pPager->noSync ){
58521 if( rc==SQLITE_OK && iLimit>0 ){
58524 if( rc==SQLITE_OK && sz>iLimit ){
58548 int rc = SQLITE_OK; /* Return code */
58661 for(nWrite=0; rc==SQLITE_OK&&nWrite<JOURNAL_HDR_SZ(pPager); nWrite+=nHeader){
58681 ** is set to the value read from the journal header. SQLITE_OK is returned
58730 if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+8, pNRec))
58731 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+12, &pPager->cksumInit))
58732 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+16, pDbSize))
58742 if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+20, &iSectorSize))
58743 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+24, &iPageSize))
58778 testcase( rc!=SQLITE_OK );
58827 return SQLITE_OK;
58870 if( SQLITE_OK==(rc = sqlite3OsFileSize(pPager->jfd, &jrnlSize))
58915 ** bitvecs of all open savepoints. Return SQLITE_OK if successful
58920 int rc = SQLITE_OK; /* Result code */
58927 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
58992 if( rc!=SQLITE_OK && pPager->eState==PAGER_ERROR ){
59009 assert( pPager->errCode==SQLITE_OK || !MEMDB );
59019 pPager->errCode = SQLITE_OK;
59049 assert( rc==SQLITE_OK || !MEMDB );
59052 pPager->errCode==SQLITE_OK ||
59132 ** SQLITE_OK is returned if no error occurs. If an error occurs during
59142 int rc = SQLITE_OK; /* Error code from journal finalization operation */
59143 int rc2 = SQLITE_OK; /* Error code from db file unlock operation */
59161 return SQLITE_OK;
59177 rc = SQLITE_OK;
59180 if( rc==SQLITE_OK && pPager->fullSync ){
59228 if( rc==SQLITE_OK ){
59243 assert( rc2==SQLITE_OK );
59244 }else if( rc==SQLITE_OK && bCommit && pPager->dbFileSize>pPager->dbSize ){
59255 if( rc==SQLITE_OK && bCommit ){
59257 if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
59268 return (rc==SQLITE_OK?rc2:rc);
59312 pPager->errCode = SQLITE_OK;
59361 ** skipped and SQLITE_OK is returned.
59370 ** and played back, then SQLITE_OK is returned. If an IO error occurs
59427 if( rc!=SQLITE_OK ) return rc;
59429 if( rc!=SQLITE_OK ) return rc;
59442 return SQLITE_OK;
59455 if( pDone && (rc = sqlite3BitvecSet(pDone, pgno))!=SQLITE_OK ){
59561 if( rc!=SQLITE_OK ) return rc;
59627 ** occur, SQLITE_OK is returned.
59658 if( rc!=SQLITE_OK ) goto delsuper_out;
59666 if( rc!=SQLITE_OK ) goto delsuper_out;
59677 if( rc!=SQLITE_OK ) goto delsuper_out;
59685 if( rc!=SQLITE_OK ){
59699 if( rc!=SQLITE_OK ){
59705 if( rc!=SQLITE_OK ){
59749 ** If successful, return SQLITE_OK. If an IO error occurs while modifying
59753 int rc = SQLITE_OK;
59768 if( rc==SQLITE_OK && currentSize!=newSize ){
59779 if( rc==SQLITE_OK ){
59885 ** is then deleted and SQLITE_OK returned, just as if no corruption had
59916 if( rc!=SQLITE_OK ){
59933 if( rc==SQLITE_OK && zSuper[0] ){
59937 if( rc!=SQLITE_OK || !res ){
59954 if( rc!=SQLITE_OK ){
59956 rc = SQLITE_OK;
59995 if( rc!=SQLITE_OK ){
60013 if( rc==SQLITE_OK ){
60025 rc = SQLITE_OK;
60042 if( rc==SQLITE_OK ){
60065 if( rc==SQLITE_OK ){
60072 testcase( rc!=SQLITE_OK );
60074 if( rc==SQLITE_OK
60079 if( rc==SQLITE_OK ){
60081 testcase( rc!=SQLITE_OK );
60083 if( rc==SQLITE_OK && zSuper[0] && res ){
60090 testcase( rc!=SQLITE_OK );
60116 ** Otherwise, SQLITE_OK is returned.
60120 int rc = SQLITE_OK; /* Return code */
60140 rc = SQLITE_OK;
60207 ** return an SQLite error code. Otherwise, SQLITE_OK.
60210 int rc = SQLITE_OK;
60221 if( rc==SQLITE_OK ){
60258 while( pList && rc==SQLITE_OK ){
60319 if( rc==SQLITE_OK && pPager->pBackup ){
60358 if( rc!=SQLITE_OK || changed ){
60372 ** If no error occurs, SQLITE_OK is returned and the size of the database
60399 if( rc!=SQLITE_OK ){
60414 return SQLITE_OK;
60428 ** Return SQLITE_OK or an error code.
60437 int rc = SQLITE_OK;
60446 if( rc==SQLITE_OK ){
60506 int rc = SQLITE_OK; /* Return code */
60548 while( rc==SQLITE_OK && pPager->journalOff<iHdrOff ){
60561 while( rc==SQLITE_OK && pPager->journalOff<szJ ){
60578 for(ii=0; rc==SQLITE_OK && ii<nJRec && pPager->journalOff<szJ; ii++){
60583 assert( rc!=SQLITE_OK || pPager->journalOff>=szJ );
60596 for(ii=pSavepoint->iSubRec; rc==SQLITE_OK && ii<pPager->nSubRec; ii++){
60604 if( rc==SQLITE_OK ){
60756 ** Write the file descriptor into *pFile. Return SQLITE_OK on success
60782 assert( rc!=SQLITE_OK || isOpen(pFile) );
60844 ** In all other cases, SQLITE_OK is returned.
60852 int rc = SQLITE_OK;
60876 if( rc==SQLITE_OK ){
60887 if( rc==SQLITE_OK ){
60891 if( rc==SQLITE_OK ){
60903 if( rc==SQLITE_OK ){
60973 ** zeroed and SQLITE_OK returned. The rationale for this is that this
60982 int rc = SQLITE_OK;
60996 rc = SQLITE_OK;
61019 ** (returning SQLITE_OK immediately).
61026 ** Return SQLITE_OK on success and an error code if we cannot obtain
61129 ** If everything goes as planned, SQLITE_OK is returned. Otherwise,
61133 int rc = SQLITE_OK;
61137 if( rc==SQLITE_OK ){
61148 ** and return SQLITE_OK. Otherwise, return an SQLite error code and set
61190 return SQLITE_OK;
61221 ** under the pager. Return SQLITE_OK if the database is still where it ought
61229 if( pPager->tempFile ) return SQLITE_OK;
61230 if( pPager->dbSize==0 ) return SQLITE_OK;
61237 rc = SQLITE_OK;
61238 }else if( rc==SQLITE_OK && bHasMoved ){
61273 && SQLITE_OK==databaseIsUnmoved(pPager)
61313 return SQLITE_OK;
61364 ** page currently held in memory before returning SQLITE_OK. If an IO
61377 if( rc!=SQLITE_OK ) return rc;
61417 if( rc==SQLITE_OK && 0==memcmp(aMagic, aJournalMagic, 8) ){
61421 if( rc!=SQLITE_OK && rc!=SQLITE_IOERR_SHORT_READ ){
61440 if( rc!=SQLITE_OK ) return rc;
61446 if( rc!=SQLITE_OK ) return rc;
61454 if( rc!=SQLITE_OK ) return rc;
61461 if( rc!=SQLITE_OK ) return rc;
61475 return SQLITE_OK;
61506 ** If everything is successful, SQLITE_OK is returned. If an IO error
61511 int rc = SQLITE_OK; /* Return code */
61520 ** is not possible for rc to be other than SQLITE_OK if this branch
61524 assert( pPager->tempFile && rc==SQLITE_OK );
61531 assert( rc!=SQLITE_OK || isOpen(pPager->fd) );
61532 if( rc==SQLITE_OK
61541 while( rc==SQLITE_OK && pList ){
61597 ** SQLITE_OK is returned if everything goes according to plan. An
61602 int rc = SQLITE_OK;
61622 ** This function returns SQLITE_OK if everything is successful, an IO
61628 int rc = SQLITE_OK;
61644 if( rc==SQLITE_OK ){
61651 if( rc==SQLITE_OK ){
61656 if( rc==SQLITE_OK ){
61667 return SQLITE_OK;
61685 ** SQLITE_OK returned. If an IO error occurs while trying to make the
61687 ** made clean for some other reason, but no error occurs, then SQLITE_OK
61692 int rc = SQLITE_OK;
61713 if( NEVER(pPager->errCode) ) return SQLITE_OK;
61721 return SQLITE_OK;
61729 if( rc==SQLITE_OK ){
61737 if( rc!=SQLITE_OK ) return pager_error(pPager, rc);
61749 if( rc==SQLITE_OK ){
61756 if( rc==SQLITE_OK ){
61772 while( rc==SQLITE_OK && pList ){
61810 ** successfully, SQLITE_OK is returned and *ppPager set to point to
61827 int rc = SQLITE_OK; /* Return code */
61873 if( rc!=SQLITE_OK ){
61878 rc = SQLITE_OK;
61890 if( rc==SQLITE_OK && nPathname+8>pVfs->mxPathname ){
61899 if( rc!=SQLITE_OK ){
62041 if( rc==SQLITE_OK ){
62096 if( rc==SQLITE_OK ){
62099 testcase( rc!=SQLITE_OK );
62103 if( rc==SQLITE_OK ){
62112 if( rc!=SQLITE_OK ){
62162 return SQLITE_OK;
62198 ** just deleted using OsDelete, *pExists is set to 0 and SQLITE_OK
62209 ** SQLITE_OK returned. If no hot-journal file is present, *pExists is
62210 ** set to 0 and SQLITE_OK returned. If an IO error occurs while trying
62216 int rc = SQLITE_OK; /* Return code */
62232 if( rc==SQLITE_OK && exists ){
62244 if( rc==SQLITE_OK && !locked ){
62249 if( rc==SQLITE_OK ){
62260 if( pagerLockDb(pPager, RESERVED_LOCK)==SQLITE_OK ){
62276 if( rc==SQLITE_OK ){
62280 rc = SQLITE_OK;
62297 rc = SQLITE_OK;
62330 ** If everything is successful, SQLITE_OK is returned. If an IO error
62335 int rc = SQLITE_OK; /* Return code */
62344 assert( pPager->errCode==SQLITE_OK );
62353 if( rc!=SQLITE_OK ){
62364 if( rc!=SQLITE_OK ){
62389 if( rc!=SQLITE_OK ){
62411 if( rc==SQLITE_OK && bExists ){
62416 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
62417 if( rc==SQLITE_OK && fout&SQLITE_OPEN_READONLY ){
62433 assert( rc==SQLITE_OK );
62435 if( rc==SQLITE_OK ){
62443 if( rc!=SQLITE_OK ){
62491 if( rc!=SQLITE_OK ){
62518 assert( pPager->pWal==0 || rc==SQLITE_OK );
62523 assert( rc==SQLITE_OK );
62527 if( pPager->tempFile==0 && pPager->eState==PAGER_OPEN && rc==SQLITE_OK ){
62532 if( rc!=SQLITE_OK ){
62561 ** successfully obtained, it is copied to *ppPage and SQLITE_OK returned.
62621 int rc = SQLITE_OK;
62626 assert( pPager->errCode==SQLITE_OK );
62636 if( rc!=SQLITE_OK ) goto pager_acquire_err;
62653 return SQLITE_OK;
62701 if( rc!=SQLITE_OK ){
62707 return SQLITE_OK;
62710 assert( rc!=SQLITE_OK );
62727 int rc = SQLITE_OK;
62751 assert( pPager->errCode==SQLITE_OK );
62755 if( rc!=SQLITE_OK ){
62765 if( rc==SQLITE_OK && pData ){
62775 assert( rc==SQLITE_OK );
62777 return SQLITE_OK;
62780 if( rc!=SQLITE_OK ){
62798 assert( pPager->errCode!=SQLITE_OK );
62907 ** Return SQLITE_OK if everything is successful. Otherwise, return
62912 int rc = SQLITE_OK; /* Return code */
62950 if( rc==SQLITE_OK ){
62956 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
62963 if( rc==SQLITE_OK ){
62973 if( rc!=SQLITE_OK ){
63003 int rc = SQLITE_OK;
63018 if( rc!=SQLITE_OK ){
63037 if( rc==SQLITE_OK && exFlag ){
63042 if( rc==SQLITE_OK ){
63059 assert( rc==SQLITE_OK || pPager->eState==PAGER_READER );
63060 assert( rc!=SQLITE_OK || pPager->eState==PAGER_WRITER_LOCKED );
63097 if( rc!=SQLITE_OK ) return rc;
63099 if( rc!=SQLITE_OK ) return rc;
63101 if( rc!=SQLITE_OK ) return rc;
63115 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
63117 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
63130 int rc = SQLITE_OK;
63156 if( rc!=SQLITE_OK ) return rc;
63175 if( rc!=SQLITE_OK ){
63221 int rc = SQLITE_OK; /* Return code */
63256 for(ii=0; ii<nPage && rc==SQLITE_OK; ii++){
63262 if( rc==SQLITE_OK ){
63284 if( rc==SQLITE_OK && needSync ){
63304 ** this routine returns SQLITE_OK.
63312 ** as appropriate. Otherwise, SQLITE_OK.
63321 return SQLITE_OK;
63398 int rc = SQLITE_OK;
63430 assert( pPgHdr==0 || rc==SQLITE_OK );
63435 ** above is always successful - hence the ALWAYS on rc==SQLITE_OK.
63437 if( !DIRECT_MODE && ALWAYS(rc==SQLITE_OK) ){
63441 if( rc==SQLITE_OK ){
63450 if( rc==SQLITE_OK ){
63454 if( rc==SQLITE_OK ){
63478 ** function returns SQLITE_OK. Otherwise, an IO error code is returned.
63481 int rc = SQLITE_OK;
63484 if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
63485 if( rc==SQLITE_OK && !pPager->noSync ){
63499 ** successful, or the connection is in WAL mode, SQLITE_OK is returned.
63506 if( rc==SQLITE_OK ){
63550 int rc = SQLITE_OK; /* Return code */
63569 if( pPager->eState<PAGER_WRITER_CACHEMOD ) return SQLITE_OK;
63590 assert( rc==SQLITE_OK );
63595 if( rc==SQLITE_OK ){
63657 if( rc==SQLITE_OK ){
63666 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
63672 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
63679 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
63693 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
63699 if( rc==SQLITE_OK ){
63701 if( rc==SQLITE_OK && pPager->dbSize>pPager->dbFileSize ){
63708 if( rc==SQLITE_OK ){
63711 if( rc!=SQLITE_OK ){
63718 if( rc!=SQLITE_OK ){
63732 if( rc!=SQLITE_OK ){
63748 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
63760 if( rc==SQLITE_OK && !pagerUseWal(pPager) ){
63780 ** moves into the error state. Otherwise, SQLITE_OK is returned.
63783 int rc = SQLITE_OK; /* Return code */
63814 return SQLITE_OK;
63849 int rc = SQLITE_OK; /* Return code */
63858 if( pPager->eState<=PAGER_READER ) return SQLITE_OK;
63864 if( rc==SQLITE_OK ) rc = rc2;
63882 assert( pPager->eState==PAGER_READER || rc!=SQLITE_OK );
63883 assert( rc==SQLITE_OK || rc==SQLITE_FULL || rc==SQLITE_CORRUPT
63997 ** returned. Otherwise, SQLITE_OK.
64000 int rc = SQLITE_OK; /* Return code */
64052 return SQLITE_OK;
64085 ** savepoint. If no errors occur, SQLITE_OK is returned.
64091 if( op==SAVEPOINT_RELEASE ) rc = SQLITE_OK;
64097 if( rc==SQLITE_OK && iSavepoint<pPager->nSavepoint ){
64120 assert( rc==SQLITE_OK );
64236 ** occurs. Otherwise, it returns SQLITE_OK.
64278 && SQLITE_OK!=(rc = subjournalPageIfRequired(pPg))
64354 if( rc!=SQLITE_OK ){
64366 return SQLITE_OK;
64499 int rc = SQLITE_OK;
64506 assert( rc==SQLITE_OK );
64509 if( rc==SQLITE_OK ){
64512 if( rc==SQLITE_OK && state==PAGER_READER ){
64597 int rc = SQLITE_OK;
64646 if( rc!=SQLITE_OK ){
64662 int rc = SQLITE_OK;
64679 if( rc==SQLITE_OK ){
64698 ** return SQLITE_OK. If an error occurs or the VFS used by the pager does
64703 ** the WAL file is already open, set *pbOpen to 1 and return SQLITE_OK
64710 int rc = SQLITE_OK; /* Return code */
64725 if( rc==SQLITE_OK ){
64746 int rc = SQLITE_OK;
64757 if( rc==SQLITE_OK ){
64762 if( rc==SQLITE_OK && logexists ){
64770 if( rc==SQLITE_OK && pPager->pWal ){
64772 if( rc==SQLITE_OK ){
64788 ** Return an SQLite error code if an error occurs, or SQLITE_OK otherwise.
64791 int rc = SQLITE_OK;
64831 int rc = SQLITE_OK;
64859 ** available. If so, SQLITE_OK is returned.
64863 ** occurs (any value other than SQLITE_OK is returned), the CHECKPOINTER
65651 ** (1) rc==SQLITE_OK and *ppPage==Requested-Wal-Index-Page
65653 ** (3) rc==SQLITE_OK and *ppPage==NULL // only if iPage==0
65662 int rc = SQLITE_OK;
65689 || rc!=SQLITE_OK
65691 testcase( pWal->apWiData[iPage]==0 && rc==SQLITE_OK );
65692 if( rc==SQLITE_OK ){
65697 rc = SQLITE_OK;
65703 assert( iPage==0 || *ppPage || rc!=SQLITE_OK );
65715 return SQLITE_OK;
65984 if( pWal->exclusiveMode ) return SQLITE_OK;
65989 VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && (rc&0xFF)!=SQLITE_BUSY); )
65991 if( rc==SQLITE_OK ) pWal->lockMask |= (1 << lockIdx);
66006 if( pWal->exclusiveMode ) return SQLITE_OK;
66011 VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && (rc&0xFF)!=SQLITE_BUSY); )
66013 if( rc==SQLITE_OK ){
66078 assert( rc==SQLITE_OK || iHash>0 );
66088 }else if( NEVER(rc==SQLITE_OK) ){
66207 if( rc==SQLITE_OK ){
66314 if( rc!=SQLITE_OK ){
66333 if( rc!=SQLITE_OK ){
66394 assert( aShare!=0 || rc!=SQLITE_OK );
66406 if( rc!=SQLITE_OK ) break;
66410 if( NEVER(rc!=SQLITE_OK) ) break;
66464 if( rc==SQLITE_OK ){
66481 if( rc==SQLITE_OK ){
66540 ** If the log file is successfully opened, SQLITE_OK is returned and
66624 if( rc==SQLITE_OK && flags&SQLITE_OPEN_READONLY ){
66628 if( rc!=SQLITE_OK ){
66845 ** return SQLITE_OK. Otherwise, return an error code. If this routine
66858 int rc = SQLITE_OK; /* Return Code */
66881 for(i=walFramePage(nBackfill+1); rc==SQLITE_OK && i<nSegment; i++){
66885 if( rc==SQLITE_OK ){
66908 if( rc!=SQLITE_OK ){
66928 return (rc==SQLITE_OK);
66960 ** an SQLite error code if an error occurs, or SQLITE_OK otherwise. It is not
66966 int rc = SQLITE_OK;
66972 if( rc==SQLITE_OK ){
67106 int rc = SQLITE_OK; /* Return code */
67138 if( rc==SQLITE_OK ){
67154 assert( rc==SQLITE_OK || pIter==0 );
67158 && (rc = walBusyLock(pWal,xBusy,pBusyArg,WAL_READ_LOCK(0),1))==SQLITE_OK
67169 if( rc==SQLITE_OK ){
67174 if( rc==SQLITE_OK && nSize<nReq ){
67189 while( rc==SQLITE_OK && 0==walIteratorNext(pIter, &iDbpage, &iFrame) ){
67203 if( rc!=SQLITE_OK ) break;
67207 if( rc!=SQLITE_OK ) break;
67212 if( rc==SQLITE_OK ){
67217 if( rc==SQLITE_OK ){
67221 if( rc==SQLITE_OK ){
67233 rc = SQLITE_OK;
67242 if( rc==SQLITE_OK && eMode!=SQLITE_CHECKPOINT_PASSIVE ){
67252 if( rc==SQLITE_OK ){
67290 if( rx==SQLITE_OK && (sz > nMax ) ){
67396 int rc = SQLITE_OK;
67411 && SQLITE_OK==(rc = sqlite3OsLock(pWal->pDbFd, SQLITE_LOCK_EXCLUSIVE))
67419 if( rc==SQLITE_OK ){
67426 ** fsynced (rc==SQLITE_OK) and if we are not in persistent-wal
67431 ** completed and fsynced (rc==SQLITE_OK) and we are in persistent
67539 ** If the wal-index header is successfully read, return SQLITE_OK.
67552 if( rc!=SQLITE_OK ){
67589 if( SQLITE_OK==(rc = walLockShared(pWal, WAL_WRITE_LOCK)) ){
67596 || SQLITE_OK==(rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1))
67599 if( SQLITE_OK==(rc = walIndexPage(pWal, 0, &page0)) ){
67627 if( rc!=SQLITE_OK ){
67659 ** If this function returns SQLITE_OK, then the read transaction has
67688 if( rc!=SQLITE_OK ){
67717 assert( rc!=SQLITE_OK ); /* SQLITE_OK not possible for read-only connection */
67733 if( rc!=SQLITE_OK ){
67744 rc = (pWal->hdr.mxFrame==0 ? SQLITE_OK : WAL_RETRY);
67750 if( rc!=SQLITE_OK ){
67787 if( rc!=SQLITE_OK ) break;
67803 if( rc!=SQLITE_OK ){
67852 ** On success return SQLITE_OK. On a permanent failure (such an
67902 int rc = SQLITE_OK; /* Return code */
67961 assert( rc==SQLITE_OK );
67990 }else if( SQLITE_OK==(rc = walLockShared(pWal, WAL_RECOVER_LOCK)) ){
67997 if( rc!=SQLITE_OK ){
68019 if( rc==SQLITE_OK ){
68038 return SQLITE_OK;
68070 if( rc==SQLITE_OK ){
68162 if( rc==SQLITE_OK ){
68172 if( rc!=SQLITE_OK ) break;
68181 if( rc==SQLITE_OK ){
68185 if( rc!=SQLITE_OK || 0==memcmp(pBuf1, pBuf2, szPage) ){
68212 ** SQLITE_OK is returned if successful, or an SQLite error code if an
68221 if( rc==SQLITE_OK ){
68278 if( rc!=SQLITE_OK ){
68291 testcase( rc==SQLITE_OK );
68294 if( rc==SQLITE_OK ){
68338 if( rc!=SQLITE_OK ){
68393 ** Return SQLITE_OK if successful, or an error code if an error occurs. If an
68417 return SQLITE_OK;
68454 if( rc!=SQLITE_OK ){
68494 return SQLITE_OK;
68502 ** Return SQLITE_OK if successful, or an error code if an error occurs. If an
68523 ** (which is nOut bytes in size). Return SQLITE_OK if successful, or an
68576 return SQLITE_OK;
68609 if( rc!=SQLITE_OK ){
68627 return SQLITE_OK;
68636 ** other than SQLITE_OK, it is not invoked again and the error code is
68640 ** function returns SQLITE_OK.
68643 int rc = SQLITE_OK;
68655 ALWAYS(rc==SQLITE_OK) && iFrame<=iMax;
68700 int rc = SQLITE_OK;
68735 ** SQLITE_OK is returned if no error is encountered (regardless of whether
68740 int rc = SQLITE_OK;
68750 if( rc==SQLITE_OK ){
68776 testcase( rc==SQLITE_OK );
68851 ** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
68855 int rc = SQLITE_OK; /* Return code */
68881 for(; rc==SQLITE_OK && iRead<=iLast; iRead++){
68884 if( rc==SQLITE_OK ){
68943 if( SQLITE_OK!=(rc = walRestartLog(pWal)) ){
68974 if( rc!=SQLITE_OK ){
69014 assert( rc==SQLITE_OK || iWrite==0 );
69075 assert( rc==SQLITE_OK );
69099 for(p=pList; p && rc==SQLITE_OK; p=p->pDirty){
69105 while( rc==SQLITE_OK && nExtra>0 ){
69111 if( rc==SQLITE_OK ){
69206 testcase( rc!=SQLITE_OK && xBusy2!=0 );
69207 if( rc==SQLITE_OK ){
69221 if( rc==SQLITE_OK ){
69226 rc = SQLITE_OK;
69234 if( rc==SQLITE_OK ){
69249 if( rc==SQLITE_OK ){
69257 if( rc==SQLITE_OK || rc==SQLITE_BUSY ){
69289 return (rc==SQLITE_OK && eMode!=eMode2 ? SQLITE_BUSY : rc);
69349 if( walLockShared(pWal, WAL_READ_LOCK(pWal->readLock))!=SQLITE_OK ){
69384 int rc = SQLITE_OK;
69435 ** available. If so, SQLITE_OK is returned.
69439 ** occurs (any value other than SQLITE_OK is returned), the CHECKPOINTER
69446 if( rc==SQLITE_OK ){
70213 int rc; /* SQLITE_OK, SQLITE_NOMEM, or SQLITE_INTERRUPT */
70343 if( sqlite3_mutex_try(p->pBt->mutex)==SQLITE_OK ){
70634 return SQLITE_OK;
70650 #define querySharedCacheTableLock(a,b,c) SQLITE_OK
70651 #define setSharedCacheTableLock(a,b,c) SQLITE_OK
70869 ** SQLITE_OK if the lock may be obtained (by calling
70890 return SQLITE_OK;
70922 return SQLITE_OK;
70939 ** already been called and returned SQLITE_OK).
70941 ** SQLITE_OK is returned if the lock is added successfully. SQLITE_NOMEM
70964 assert( SQLITE_OK==querySharedCacheTableLock(p, iTable, eLock) );
70997 return SQLITE_OK;
71195 int rc = SQLITE_OK;
71203 if( rc==SQLITE_OK && pgno<=sqlite3BitvecSize(pBt->pHasContent) ){
71248 ** pCur->pKey. SQLITE_OK is returned if successful or an SQLite error
71258 int rc = SQLITE_OK;
71278 if( rc==SQLITE_OK ){
71316 if( rc==SQLITE_OK ){
71358 return SQLITE_OK;
71375 if( SQLITE_OK!=rc ){
71385 return SQLITE_OK;
71453 if( rc==SQLITE_OK ){
71468 SQLITE_OK)
71529 return SQLITE_OK;
71599 ** If *pRC is initially non-zero (non-SQLITE_OK) then this routine is
71623 if( rc!=SQLITE_OK ){
71645 if( rc==SQLITE_OK ){
71660 ** An error code is returned if something goes wrong, otherwise SQLITE_OK.
71690 return SQLITE_OK;
71695 #define ptrmapGet(w,x,y,z) SQLITE_OK
72268 return SQLITE_OK;
72347 ** of the first byte of allocated space. Return either SQLITE_OK or
72361 int rc = SQLITE_OK; /* Integer return code */
72409 return SQLITE_OK;
72440 return SQLITE_OK;
72550 return SQLITE_OK;
72621 return SQLITE_OK;
72703 return SQLITE_OK;
72739 return SQLITE_OK;
72745 ** Return SQLITE_OK on success. If we see that the page does
72747 ** SQLITE_CORRUPT. Note that a return of SQLITE_OK does not
72797 return SQLITE_OK;
72879 return SQLITE_OK;
72936 if( rc!=SQLITE_OK ){
72945 return SQLITE_OK;
72993 if( rc==SQLITE_OK ){
73076 int rc = SQLITE_OK; /* Result code from this function */
73146 rc = SQLITE_OK;
73217 if( rc==SQLITE_OK ){
73221 if( rc!=SQLITE_OK ){
73329 if( rc!=SQLITE_OK ){
73356 assert( rc!=SQLITE_OK || sqlite3BtreeConnectionCount(*ppBtree)>0 );
73436 return SQLITE_OK;
73477 sqlite3BtreeRollback(p, SQLITE_OK, 0);
73509 return SQLITE_OK;
73525 return SQLITE_OK;
73559 return SQLITE_OK;
73581 return SQLITE_OK;
73606 int rc = SQLITE_OK;
73735 int rc = SQLITE_OK;
73805 ** SQLITE_OK is returned on success. If the file is not a
73819 if( rc!=SQLITE_OK ) return rc;
73821 if( rc!=SQLITE_OK ) return rc;
73863 ** return SQLITE_OK and return without populating BtShared.pPage1.
73872 if( rc!=SQLITE_OK ){
73878 return SQLITE_OK;
73921 ** zero and return SQLITE_OK. The caller will call this function
73981 return SQLITE_OK;
74045 return SQLITE_OK;
74074 return SQLITE_OK;
74079 ** consisting of a single page and no schema objects). Return SQLITE_OK
74133 int rc = SQLITE_OK;
74191 if( SQLITE_OK!=rc ) goto trans_begun;
74204 if( rc!=SQLITE_BUSY && rc!=SQLITE_OK ) break;
74209 ** lockBtree() returns something other than SQLITE_OK. lockBtree()
74210 ** may return SQLITE_OK but leave pBt->pPage1 set to 0 if after
74215 while( pBt->pPage1==0 && SQLITE_OK==(rc = lockBtree(pBt)) );
74217 if( rc==SQLITE_OK && wrflag ){
74222 if( rc==SQLITE_OK ){
74233 if( rc!=SQLITE_OK ){
74244 if( rc==SQLITE_OK ){
74277 if( rc==SQLITE_OK ){
74285 if( rc==SQLITE_OK ){
74321 return SQLITE_OK;
74340 rc = pPage->isInit ? SQLITE_OK : btreeInitPage(pPage);
74341 if( rc!=SQLITE_OK ) return rc;
74391 rc = pPage->isInit ? SQLITE_OK : btreeInitPage(pPage);
74428 return SQLITE_OK;
74464 if( rc!=SQLITE_OK ){
74479 if( rc!=SQLITE_OK ){
74486 if( rc!=SQLITE_OK ){
74498 if( rc!=SQLITE_OK ){
74502 if( rc!=SQLITE_OK ){
74508 if( rc==SQLITE_OK ){
74520 ** SQLITE_OK. If there is no work to do (and therefore no point in
74552 if( rc!=SQLITE_OK ){
74569 if( rc!=SQLITE_OK ){
74582 if( rc!=SQLITE_OK ){
74601 if( rc!=SQLITE_OK ){
74615 if( rc!=SQLITE_OK ){
74628 return SQLITE_OK;
74660 ** SQLITE_OK is returned. Otherwise an SQLite error code.
74679 if( rc==SQLITE_OK ){
74683 if( rc==SQLITE_OK ){
74700 int rc = SQLITE_OK;
74748 return SQLITE_OK;
74758 for(iFree=nOrig; iFree>nFin && rc==SQLITE_OK; iFree--){
74761 if( (rc==SQLITE_DONE || rc==SQLITE_OK) && nFree>0 ){
74771 if( rc!=SQLITE_OK ){
74781 # define setChildPtrmaps(x) SQLITE_OK
74811 int rc = SQLITE_OK;
74818 if( rc!=SQLITE_OK ){
74901 if( p->inTrans==TRANS_NONE ) return SQLITE_OK;
74914 if( rc!=SQLITE_OK && bCleanup==0 ){
74925 return SQLITE_OK;
74935 if( rc==SQLITE_OK ){
74965 ** SQLITE_OK is returned if successful, or if an error occurs while
74970 int rc = SQLITE_OK;
74979 if( rc!=SQLITE_OK ){
75011 ** If tripCode is not SQLITE_OK then cursors will be invalidated (tripped).
75025 assert( tripCode==SQLITE_ABORT_ROLLBACK || tripCode==SQLITE_OK );
75027 if( tripCode==SQLITE_OK ){
75031 rc = SQLITE_OK;
75035 assert( rc==SQLITE_OK || (writeOnly==0 && rc2==SQLITE_OK) );
75036 if( rc2!=SQLITE_OK ) rc = rc2;
75045 if( rc2!=SQLITE_OK ){
75052 if( btreeGetPage(pBt, 1, &pPage1, 0)==SQLITE_OK ){
75116 int rc = SQLITE_OK;
75125 if( rc==SQLITE_OK ){
75128 if( rc==SQLITE_OK ){
75251 return SQLITE_OK;
75340 return SQLITE_OK;
75493 int rc = SQLITE_OK;
75516 if( rc==SQLITE_OK && eType==PTRMAP_OVERFLOW2 && pgno==ovfl ){
75525 if( rc==SQLITE_OK ){
75527 assert( rc==SQLITE_OK || pPage==0 );
75528 if( rc==SQLITE_OK ){
75539 return (rc==SQLITE_DONE ? SQLITE_OK : rc);
75551 ** SQLITE_OK is returned on success, otherwise an error code.
75563 if( rc!=SQLITE_OK ){
75571 return SQLITE_OK;
75611 int rc = SQLITE_OK;
75656 if( rc==SQLITE_OK && amt>0 ){
75706 assert( rc==SQLITE_OK && amt>0 );
75774 if( rc==SQLITE_OK ){
75791 if( rc==SQLITE_OK && amt>0 ){
75811 ** Return SQLITE_OK on success or an error code if anything goes
75940 assert( pCur->pPage!=0 || rc!=SQLITE_OK );
75941 if( rc==SQLITE_OK
76026 int rc = SQLITE_OK;
76051 assert( pCur->skipNext!=SQLITE_OK );
76058 if( rc!=SQLITE_OK ){
76112 int rc = SQLITE_OK;
76117 while( rc==SQLITE_OK && !(pPage = pCur->pPage)->leaf ){
76137 int rc = SQLITE_OK;
76151 return SQLITE_OK;
76154 /* Move the cursor to the first entry in the table. Return SQLITE_OK
76164 if( rc==SQLITE_OK ){
76171 rc = SQLITE_OK;
76193 /* Move the cursor to the last entry in the table. Return SQLITE_OK
76199 if( rc==SQLITE_OK ){
76203 if( rc==SQLITE_OK ){
76211 rc = SQLITE_OK;
76223 return SQLITE_OK;
76270 return SQLITE_OK;
76276 return SQLITE_OK;
76285 if( rc==SQLITE_OK ){
76288 return SQLITE_OK;
76306 return SQLITE_OK;
76363 return SQLITE_OK;
76375 rc = SQLITE_OK;
76526 && pIdxKey->errCode==SQLITE_OK
76529 return SQLITE_OK; /* Cursor already pointing at the correct spot */
76533 && pIdxKey->errCode==SQLITE_OK
76541 pIdxKey->errCode = SQLITE_OK;
76549 return SQLITE_OK;
76654 rc = SQLITE_OK;
76669 rc = SQLITE_OK;
76694 if( rc==SQLITE_OK
76758 ** SQLITE_OK success
76783 if( rc!=SQLITE_OK ){
76791 if( pCur->skipNext>0 ) return SQLITE_OK;
76819 return SQLITE_OK;
76823 return SQLITE_OK;
76842 return SQLITE_OK;
76852 ** SQLITE_OK success
76877 if( rc!=SQLITE_OK ){
76885 if( pCur->skipNext<0 ) return SQLITE_OK;
76915 rc = SQLITE_OK;
76933 return SQLITE_OK;
76944 ** SQLITE_OK is returned on success. Any other return value indicates
77088 if( rc!=SQLITE_OK ){
77106 if( rc!=SQLITE_OK ){
77110 if( rc!=SQLITE_OK ){
77186 if( rc==SQLITE_OK ){
77188 if( rc!=SQLITE_OK ){
77235 if( rc==SQLITE_OK ){
77251 if( rc!=SQLITE_OK ){
77263 assert( rc!=SQLITE_OK || sqlite3PagerPageRefcount((*ppPage)->pDbPage)<=1 );
77264 assert( rc!=SQLITE_OK || (*ppPage)->isInit==0 );
77344 if( rc!=SQLITE_OK ){
77375 if( rc==SQLITE_OK ){
77394 if( pPage==0 && SQLITE_OK!=(rc = btreeGetPage(pBt, iPage, &pPage, 0)) ){
77398 if( rc!=SQLITE_OK ){
77415 if( (*pRC)==SQLITE_OK ){
77488 return SQLITE_OK;
77493 ** Store the result code (SQLITE_OK or some error code) in rc.
77502 rc = SQLITE_OK; \
77575 return SQLITE_OK;
77668 if( pBt->autoVacuum && rc==SQLITE_OK ){
77700 return SQLITE_OK;
77820 if( NEVER(rc!=SQLITE_OK) ){
77850 int rc2 = SQLITE_OK;
77859 return SQLITE_OK;
77910 if( rc!=SQLITE_OK ){
77934 int rc2 = SQLITE_OK;
77943 return SQLITE_OK;
78152 return SQLITE_OK;
78411 return SQLITE_OK;
78464 if( rc==SQLITE_OK ){
78524 if( rc==SQLITE_OK ){
78600 if( (*pRC)==SQLITE_OK ){
78626 if( rc==SQLITE_OK ) rc = btreeComputeFreeSpace(pTo);
78627 if( rc!=SQLITE_OK ){
78694 int rc = SQLITE_OK; /* The return code */
78767 if( rc==SQLITE_OK ){
79108 && rc==SQLITE_OK
79125 if( rc!=SQLITE_OK ){
79314 if( rc!=SQLITE_OK ) goto balance_cleanup;
79403 testcase( rc!=SQLITE_OK );
79407 || rc!=SQLITE_OK
79432 if( ISAUTOVACUUM(pBt) && rc==SQLITE_OK && apNew[0]->isInit ){
79473 ** page and SQLITE_OK is returned. In this case the caller is required
79491 if( rc==SQLITE_OK ){
79521 return SQLITE_OK;
79545 return SQLITE_OK;
79559 int rc = SQLITE_OK;
79578 if( pPage->nOverflow && (rc = anotherValidCursor(pCur))==SQLITE_OK ){
79587 if( rc==SQLITE_OK ){
79608 if( rc==SQLITE_OK && pParent->nFree<0 ){
79611 if( rc==SQLITE_OK ){
79681 }while( rc==SQLITE_OK );
79728 return SQLITE_OK;
79780 return SQLITE_OK;
80013 rc = SQLITE_OK;
80065 assert( rc==SQLITE_OK ); /* clearCell never fails when nLocal==nPayload */
80073 return SQLITE_OK;
80085 assert( pPage->nOverflow==0 || rc==SQLITE_OK );
80086 assert( rc!=SQLITE_OK || pPage->nCell>0 || pPage->nOverflow>0 );
80109 assert( rc==SQLITE_OK );
80119 if( (flags & BTREE_SAVEPOSITION) && rc==SQLITE_OK ){
80153 ** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
80178 return SQLITE_OK;
80180 int rc = SQLITE_OK;
80218 if( rc==SQLITE_OK ){
80225 }while( rc==SQLITE_OK && nOut>0 );
80227 if( rc==SQLITE_OK && nRem>0 && ALWAYS(pPgnoOut) ){
80244 }while( nRem>0 && rc==SQLITE_OK );
80290 assert( rc!=SQLITE_OK || CORRUPT_DB || pCur->eState==CURSOR_VALID );
80406 if( rc==SQLITE_OK ){
80433 rc = SQLITE_OK;
80437 if( rc==SQLITE_OK && pCur->iPage>iCellDepth ){
80447 if( rc==SQLITE_OK ){
80465 if( rc==SQLITE_EMPTY ) rc = SQLITE_OK;
80534 if( rc!=SQLITE_OK ){
80553 if( rc!=SQLITE_OK ){
80559 if( rc!=SQLITE_OK ){
80566 if( rc!=SQLITE_OK ){
80576 if( rc!=SQLITE_OK ){
80580 if( rc!=SQLITE_OK ){
80584 if( rc!=SQLITE_OK ){
80625 return SQLITE_OK;
80714 if( SQLITE_OK==rc ){
80792 if( rc!=SQLITE_OK ){
80803 if( rc!=SQLITE_OK ){
80808 if( rc!=SQLITE_OK ){
80815 if( rc!=SQLITE_OK ){
80875 assert( SQLITE_OK==querySharedCacheTableLock(p, SCHEMA_ROOT, READ_LOCK) );
80910 if( rc==SQLITE_OK ){
80928 ** SQLITE_OK is returned if the operation is successfully executed.
80939 return SQLITE_OK;
80945 while( rc==SQLITE_OK && !AtomicLoad(&db->u1.isInterrupted) ){
80965 ** If all pages in the tree have been visited, return SQLITE_OK to the
81130 if( rc!=SQLITE_OK ){
81764 int rc = SQLITE_OK;
81822 ** sqlite_schema table. Otherwise SQLITE_OK.
81829 assert( rc==SQLITE_OK || rc==SQLITE_LOCKED_SHAREDCACHE );
81842 int rc = SQLITE_OK;
81851 if( rc==SQLITE_OK ){
81878 if( rc!=SQLITE_OK ){
81892 ** saveAllCursors can only return SQLITE_OK.
81895 assert( rc==SQLITE_OK );
81943 if( rc==SQLITE_OK ){
81947 if( rc==SQLITE_OK ){
81949 if( rc==SQLITE_OK ){
82132 ** second argument. If there is not, return SQLITE_OK. Otherwise, if there
82141 return SQLITE_OK;
82204 || checkReadTransaction(pDestDb, p->pDest)!=SQLITE_OK
82230 return (rc!=SQLITE_OK && rc!=SQLITE_BUSY && ALWAYS(rc!=SQLITE_LOCKED));
82249 int rc = SQLITE_OK;
82263 for(iOff=iEnd-(i64)nSrcPgsz; rc==SQLITE_OK && iOff<iEnd; iOff+=nDestPgsz){
82267 if( SQLITE_OK==(rc = sqlite3PagerGet(pDestPager, iDest, &pDestPg, 0))
82268 && SQLITE_OK==(rc = sqlite3PagerWrite(pDestPg))
82298 ** Return SQLITE_OK if everything is successful, or an SQLite error
82304 if( rc==SQLITE_OK && iCurrent>iSize ){
82355 rc = SQLITE_OK;
82362 if( rc==SQLITE_OK && SQLITE_TXN_NONE==sqlite3BtreeTxnState(p->pSrc) ){
82373 if( p->bDestLocked==0 && rc==SQLITE_OK && setDestPgsz(p)==SQLITE_NOMEM ){
82378 if( SQLITE_OK==rc && p->bDestLocked==0
82379 && SQLITE_OK==(rc = sqlite3BtreeBeginTrans(p->pDest, 2,
82390 if( SQLITE_OK==rc
82407 if( rc==SQLITE_OK ){
82414 if( rc==SQLITE_OK ){
82434 if( rc==SQLITE_OK || rc==SQLITE_DONE ){
82437 if( rc==SQLITE_OK ){
82445 if( rc==SQLITE_OK ){
82503 for(iPg=nDestTruncate; rc==SQLITE_OK && iPg<=(Pgno)nDstPage; iPg++){
82507 if( rc==SQLITE_OK ){
82513 if( rc==SQLITE_OK ){
82521 rc==SQLITE_OK && iOff<iEnd;
82527 if( rc==SQLITE_OK ){
82533 if( rc==SQLITE_OK ){
82538 if( rc==SQLITE_OK ){
82547 if( SQLITE_OK==rc
82548 && SQLITE_OK==(rc = sqlite3BtreeCommitPhaseTwo(p->pDest, 0))
82564 assert( rc2==SQLITE_OK );
82589 if( p==0 ) return SQLITE_OK;
82612 sqlite3BtreeRollback(p->pDest, SQLITE_OK, 0);
82615 rc = (p->rc==SQLITE_DONE) ? SQLITE_OK : p->rc;
82692 if( rc!=SQLITE_OK ){
82742 if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
82764 assert( b.rc!=SQLITE_OK );
82767 if( rc==SQLITE_OK ){
82981 ** SQLITE_OK is returned if the conversion is successful (or not required).
82995 return SQLITE_OK;
82998 return SQLITE_OK;
83005 /* MemTranslate() may return SQLITE_OK or SQLITE_NOMEM. If NOMEM is returned,
83009 assert(rc==SQLITE_OK || rc==SQLITE_NOMEM);
83010 assert(rc==SQLITE_OK || pMem->enc!=desiredEnc);
83071 return SQLITE_OK;
83084 ** Return SQLITE_OK on success or an error code (probably SQLITE_NOMEM)
83096 return SQLITE_OK;
83150 return SQLITE_OK;
83157 ** Return SQLITE_OK on success or SQLITE_NOMEM if malloc fails.
83175 return SQLITE_OK;
83195 if( (pMem->flags & MEM_Blob)==0 ) return SQLITE_OK;
83207 return SQLITE_OK;
83220 return SQLITE_OK; /* Nothing to do */
83264 return SQLITE_OK;
83272 ** Return SQLITE_ERROR if the finalizer reports an error. SQLITE_OK
83304 ** SQLITE_ERROR is returned if xValue() reports an error. SQLITE_OK
83512 return SQLITE_OK;
83526 return SQLITE_OK;
83586 return SQLITE_OK;
83597 if( pMem->flags & MEM_Null ) return SQLITE_OK;
83635 return SQLITE_OK;
83700 return SQLITE_OK;
83786 ** Return SQLITE_OK on success and SQLITE_NOMEM if a memory allocation
83800 return SQLITE_OK;
83885 int rc = SQLITE_OK;
83959 return SQLITE_OK;
84032 return SQLITE_OK;
84061 if( SQLITE_OK==(rc = sqlite3VdbeMemClearAndResize(pMem, amt+1)) ){
84063 if( rc==SQLITE_OK ){
84079 int rc = SQLITE_OK; /* Return code */
84119 if( sqlite3VdbeMemMakeWriteable(pVal)!=SQLITE_OK ){
84267 ** object containing the result before returning SQLITE_OK.
84273 ** If the conditions above are not met, this function returns SQLITE_OK
84291 int rc = SQLITE_OK; /* Return code */
84303 if( pFunc==0 ) return SQLITE_OK;
84309 return SQLITE_OK;
84320 if( apVal[i]==0 || rc!=SQLITE_OK ) goto value_from_function_out;
84340 assert( rc==SQLITE_OK );
84342 if( NEVER(rc==SQLITE_OK && sqlite3VdbeMemTooBig(pVal)) ){
84349 if( rc!=SQLITE_OK ){
84364 # define valueFromFunction(a,b,c,d,e,f) SQLITE_OK
84390 int rc = SQLITE_OK;
84407 testcase( rc!=SQLITE_OK );
84479 if( SQLITE_OK==valueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal,pCtx)
84596 int rc = SQLITE_OK;
84660 ** Unless an error is encountered, SQLITE_OK is returned. It is not an
84673 int rc = SQLITE_OK;
84704 ** SQLITE_OK. If no value can be extracted, but no other error occurs
84705 ** (e.g. OOM), return SQLITE_OK and set *ppVal to NULL. Or, if an error
84763 return SQLITE_OK;
85035 return (pNew ? SQLITE_OK : SQLITE_NOMEM_BKPT);
85629 && ((pOp->p1)!=SQLITE_OK && pOp->p2==OE_Abort))
87088 int rc = SQLITE_OK; /* Result code */
87115 p->rc = SQLITE_OK;
87150 if( p->rc!=SQLITE_OK ){
87226 int rc = SQLITE_OK; /* Return code */
87234 assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY || p->rc==SQLITE_NOMEM );
87263 if( rc==SQLITE_OK ){
87302 p->rc = SQLITE_OK;
87428 p->rc = SQLITE_OK;
87734 int rc = SQLITE_OK;
87739 ** SQLITE_OK so p is not used.
87758 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
87787 if( rc!=SQLITE_OK ){
87811 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
87823 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
87829 if( rc==SQLITE_OK ){
87874 }while( rc==SQLITE_OK && res );
87875 if( rc==SQLITE_OK ){
87882 if( rc!=SQLITE_OK ){
87903 if( rc!=SQLITE_OK ){
87916 && SQLITE_OK!=(rc = sqlite3OsSync(pSuperJrnl, SQLITE_SYNC_NORMAL))
87934 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
87942 if( rc!=SQLITE_OK ){
88023 ** Otherwise SQLITE_OK.
88027 int rc = SQLITE_OK;
88036 int rc2 = SQLITE_OK;
88042 if( rc2==SQLITE_OK ){
88045 if( rc==SQLITE_OK ){
88053 if( rc==SQLITE_OK ){
88057 if( rc==SQLITE_OK ){
88075 return SQLITE_OK;
88083 ** violations, return SQLITE_ERROR. Otherwise, SQLITE_OK.
88101 return SQLITE_OK;
88194 if( p->rc==SQLITE_OK || (p->errorAction==OE_Fail && !isSpecialError) ){
88208 if( p->rc==SQLITE_OK || (p->errorAction==OE_Fail && !isSpecialError) ){
88210 if( rc!=SQLITE_OK ){
88229 }else if( rc!=SQLITE_OK ){
88232 sqlite3RollbackAll(db, SQLITE_OK);
88243 sqlite3RollbackAll(db, SQLITE_OK);
88248 if( p->rc==SQLITE_OK || p->errorAction==OE_Fail ){
88263 ** error code is SQLITE_OK or SQLITE_CONSTRAINT, then promote the
88269 if( p->rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT ){
88319 return (p->rc==SQLITE_BUSY ? SQLITE_BUSY : SQLITE_OK);
88325 ** in p->rc. This routine sets that result back to SQLITE_OK.
88328 p->rc = SQLITE_OK;
88363 if( sqlite3GlobalConfig.xSqllog && v->rc==SQLITE_OK && v->zSql && v->pc>=0 ){
88481 int rc = SQLITE_OK;
88620 return SQLITE_OK;
88650 return SQLITE_OK;
89992 ** Return SQLITE_OK if everything works, or an error code otherwise.
90055 return SQLITE_OK;
90069 ** or greater than pUnpacked. Return SQLITE_OK on success.
90104 return SQLITE_OK;
90481 rc = SQLITE_OK;
90508 rc = SQLITE_OK;
90528 int rc = SQLITE_OK;
90562 if( ExpandBlob(p)!=SQLITE_OK ){
90734 if( sqlite3VdbeMemMakeWriteable(pNew)!=SQLITE_OK ){
91040 return SQLITE_OK;
91101 int rc = SQLITE_OK;
91111 if( nEntry>0 && db->xWalCallback && rc==SQLITE_OK ){
91213 p->rcApp = SQLITE_OK;
91227 assert( p->rc==SQLITE_OK );
91238 assert( p->rc==SQLITE_OK );
91240 if( p->rc!=SQLITE_OK ){
91273 int rc = SQLITE_OK; /* Result from sqlite3Step() */
91287 if( rc!=SQLITE_OK ){
91415 assert( rc==SQLITE_OK || sqlite3BtreeEof(pRhs->pCsr) );
91418 if( rc==SQLITE_OK ){
91424 if( rc==SQLITE_OK ){
91993 ** out of range, then SQLITE_RANGE is returned. Otherwise SQLITE_OK.
92022 p->db->errCode = SQLITE_OK;
92037 return SQLITE_OK;
92056 if( rc==SQLITE_OK ){
92060 if( rc==SQLITE_OK && encoding!=0 ){
92105 if( rc==SQLITE_OK ){
92118 if( rc==SQLITE_OK ){
92128 if( rc==SQLITE_OK ){
92143 if( rc==SQLITE_OK ){
92224 if( rc==SQLITE_OK ){
92300 return SQLITE_OK;
92314 ** SQLITE_OK is returned.
92371 rc = SQLITE_OK;
92381 rc = SQLITE_OK;
92537 int rc = SQLITE_OK;
92569 if( rc==SQLITE_OK ){
92573 if( rc!=SQLITE_OK ){
92661 int rc = SQLITE_OK;
92689 if( rc!=SQLITE_OK ) goto preupdate_new_out;
92724 if( rc!=SQLITE_OK ) goto preupdate_new_out;
93927 int rc = SQLITE_OK; /* Value to return */
93966 assert( p->rc==SQLITE_OK || (p->rc&0xff)==SQLITE_BUSY );
93967 testcase( p->rc!=SQLITE_OK );
93968 p->rc = SQLITE_OK;
94005 assert( rc==SQLITE_OK );
94336 ** or sqlite3_finalize(). For a normal halt, this should be SQLITE_OK (0).
94373 if( p->pFrame && pOp->p1==SQLITE_OK ){
94415 assert( rc==SQLITE_BUSY || rc==SQLITE_OK || rc==SQLITE_ERROR );
94419 assert( rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT );
94420 assert( rc==SQLITE_OK || db->nDeferredCons>0 || db->nDeferredImmCons>0 );
94482 assert( rc==SQLITE_OK || rc==SQLITE_TOOBIG );
94484 if( SQLITE_OK!=sqlite3VdbeChangeEncoding(pOut, encoding) ) goto no_mem;
94501 assert( rc==SQLITE_OK );
94789 if( (rc = sqlite3VdbeCheckFk(p,0))!=SQLITE_OK ){
96159 if( rc!=SQLITE_OK ) goto abort_due_to_error;
96231 assert( rc==SQLITE_OK );
96888 if( rc!=SQLITE_OK ) goto abort_due_to_error;
96944 if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){
96969 if( rc!=SQLITE_OK ) goto abort_due_to_error;
96977 if( rc!=SQLITE_OK ){
97017 if( rc!=SQLITE_OK ) goto abort_due_to_error;
97062 }else if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){
97074 if( p->rc==SQLITE_OK ){
97137 assert( rc==SQLITE_OK );
97156 if( rc!=SQLITE_OK ){
97177 if( rc==SQLITE_OK ){
97189 if( rc==SQLITE_OK
97529 assert( rc==SQLITE_OK );
97605 if( rc==SQLITE_OK ){
97607 if( rc==SQLITE_OK ){
97617 if( rc==SQLITE_OK ){
97903 if( rc!=SQLITE_OK ) goto abort_due_to_error;
97934 if( rc!=SQLITE_OK ){
97986 if( rc!=SQLITE_OK ){
98001 if( rc!=SQLITE_OK ){
98003 rc = SQLITE_OK;
98017 if( rc!=SQLITE_OK ){
98019 rc = SQLITE_OK;
98210 rc = SQLITE_OK;
98424 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
98433 if( rc!=SQLITE_OK ){
98556 assert( rc==SQLITE_OK || res==0 );
98564 assert( rc==SQLITE_OK );
98655 if( rc!=SQLITE_OK ){
98713 0, &res))==SQLITE_OK)
98878 if( rc!=SQLITE_OK ) goto abort_due_to_error;
99088 assert( rc!=SQLITE_OK || (pOut->flags & MEM_Blob) );
99520 VdbeBranchTaken(rc==SQLITE_OK,2);
99521 if( rc==SQLITE_OK ){
99530 rc = SQLITE_OK;
99717 if( rc!=SQLITE_OK ) goto abort_due_to_error;
99722 if( rc!=SQLITE_OK ){
99883 assert( rc==SQLITE_OK );
100147 initData.rc = SQLITE_OK;
100151 if( rc==SQLITE_OK ) rc = initData.rc;
100152 if( rc==SQLITE_OK && initData.nInitRow==0 ){
100953 rc = SQLITE_OK;
101036 if( rc==SQLITE_OK ){
101049 if( rc==SQLITE_OK ){
101106 rc = SQLITE_OK;
101242 assert( rc==SQLITE_OK );
101658 if( rc==SQLITE_OK && pOp->p1 ){
101664 rc = SQLITE_OK;
102251 assert( rc!=SQLITE_OK || nExtraDelete==0
102323 ** If successful, SQLITE_OK is returned and subsequent calls to
102382 rc = SQLITE_OK;
102386 if( rc==SQLITE_OK ){
102394 assert( rc!=SQLITE_OK || zErr==0 );
102415 int rc = SQLITE_OK;
102621 if( rc==SQLITE_OK && db->mallocFailed==0 ){
102652 rc = SQLITE_OK;
102783 ((Vdbe*)p->pStmt)->rc = SQLITE_OK;
102785 if( rc!=SQLITE_OK ){
102793 assert( rc==SQLITE_OK || p->pStmt==0 );
103281 ** and return SQLITE_OK. Otherwise, if an error occurs, return an SQLite
103298 return SQLITE_OK;
103322 if( rc!=SQLITE_OK ) return rc;
103365 if( rc!=SQLITE_OK ) return rc;
103374 return SQLITE_OK;
103402 return SQLITE_OK;
103407 ** new mapping and return SQLITE_OK. If the mapping is not attempted
103409 ** mmap), return SQLITE_OK and set *pp to NULL.
103415 int rc = SQLITE_OK;
103420 testcase( rc!=SQLITE_OK );
103428 ** that file) and seek it to offset iOff within the file. Return SQLITE_OK
103437 int rc = SQLITE_OK;
103451 if( rc==SQLITE_OK && pReadr->aMap==0 ){
103459 if( rc==SQLITE_OK && iBuf ){
103467 testcase( rc!=SQLITE_OK );
103475 ** Advance PmaReader pReadr to the next key in its PMA. Return SQLITE_OK if
103479 int rc = SQLITE_OK; /* Return Code */
103488 if( rc==SQLITE_OK && pIncr->bEof==0 ){
103499 testcase( rc!=SQLITE_OK );
103504 if( rc==SQLITE_OK ){
103507 if( rc==SQLITE_OK ){
103510 testcase( rc!=SQLITE_OK );
103540 if( rc==SQLITE_OK ){
103547 if( rc==SQLITE_OK ){
103727 ** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
103740 int rc = SQLITE_OK;
103915 int rc = SQLITE_OK;
103962 if( rc==SQLITE_OK ) rc = rc2;
103968 # define vdbeSorterJoinThread(pTask) SQLITE_OK
104034 (void)vdbeSorterJoinAll(pSorter, SQLITE_OK);
104103 ** set *ppFd to point to the malloc'd file-handle and return SQLITE_OK.
104118 if( rc==SQLITE_OK ){
104130 ** structure at pTask->pUnpacked. Return SQLITE_OK if successful (or
104140 return SQLITE_OK;
104200 ** SQLITE_OK if successful, or an SQLite error code (i.e. SQLITE_NOMEM) if
104210 if( rc!=SQLITE_OK ) return rc;
104245 assert( pTask->pUnpacked->errCode==SQLITE_OK
104273 ** Write nData bytes of data to the PMA. Return SQLITE_OK
104303 ** Return SQLITE_OK if flushing the buffered data succeeds or is not
104326 ** SQLITE_OK if successful, or an SQLite error code if an error occurs.
104337 ** PMA in the temp file belonging to sub-task pTask. Return SQLITE_OK if
104351 int rc = SQLITE_OK; /* Return code */
104367 assert( rc!=SQLITE_OK || pTask->file.pFd );
104373 if( rc==SQLITE_OK ){
104378 if( rc==SQLITE_OK ){
104382 if( rc==SQLITE_OK ){
104401 assert( rc!=SQLITE_OK || pList->pList==0 );
104402 assert( rc!=SQLITE_OK || pTask->file.iEof==iSz );
104411 ** Return SQLITE_OK if successful or an error code if an error occurs.
104425 if( rc==SQLITE_OK ){
104477 return (rc==SQLITE_OK ? pTask->pUnpacked->errCode : rc);
104503 int rc = SQLITE_OK;
104526 if( rc!=SQLITE_OK || pTask->pThread==0 ) break;
104529 if( rc==SQLITE_OK ){
104573 int rc = SQLITE_OK; /* Return Code */
104624 assert( rc!=SQLITE_OK || pSorter->list.pList==0 );
104681 int rc = SQLITE_OK;
104693 while( rc==SQLITE_OK ){
104712 if( rc==SQLITE_OK ) rc = rc2;
104754 ** SQLITE_OK is returned on success, or an SQLite error code otherwise.
104757 int rc = SQLITE_OK;
104763 if( rc==SQLITE_OK ){
104769 if( rc==SQLITE_OK ){
104800 int rc = SQLITE_OK;
104812 assert( *ppOut!=0 || rc!=SQLITE_OK );
104913 ** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
104920 int rc = SQLITE_OK; /* Return code */
104949 if( rc!=SQLITE_OK ) return rc;
104989 ** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
104992 int rc = SQLITE_OK;
105005 if( rc==SQLITE_OK ){
105010 if( rc==SQLITE_OK ){
105021 if( rc==SQLITE_OK ){
105030 if( rc==SQLITE_OK && pIncr->bUseThread ){
105046 if( rc==SQLITE_OK && (SQLITE_MAX_WORKER_THREADS==0 || eMode!=INCRINIT_TASK) ){
105081 int rc = SQLITE_OK; /* Return code */
105100 ** the new object and return SQLITE_OK. Or, if an error does occur, set *ppOut
105118 int rc = SQLITE_OK;
105123 for(i=0; i<nPMA && rc==SQLITE_OK; i++){
105130 if( rc!=SQLITE_OK ){
105163 ** If successful, SQLITE_OK is returned. If an error occurs, an SQLite error
105173 int rc = SQLITE_OK;
105185 for(i=1; i<nDepth && rc==SQLITE_OK; i++){
105197 if( rc==SQLITE_OK ){
105203 if( rc==SQLITE_OK ){
105217 ** If successful, SQLITE_OK is returned and *ppOut set to point to the
105227 int rc = SQLITE_OK;
105241 for(iTask=0; rc==SQLITE_OK && iTask<pSorter->nTask; iTask++){
105256 for(i=0; i<pTask->nPMA && rc==SQLITE_OK; i += SORTER_MAX_MERGE_COUNT){
105262 if( rc==SQLITE_OK ){
105268 if( rc==SQLITE_OK ){
105284 if( rc!=SQLITE_OK ){
105299 ** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
105315 if( rc==SQLITE_OK ){
105323 if( rc==SQLITE_OK ){
105328 if( rc==SQLITE_OK ){
105330 if( rc==SQLITE_OK ){
105339 for(iTask=0; rc==SQLITE_OK && iTask<pSorter->nTask; iTask++){
105359 if( rc==SQLITE_OK ){
105371 if( rc!=SQLITE_OK ){
105385 int rc = SQLITE_OK; /* Return code */
105419 if( rc==SQLITE_OK ){
105431 ** SQLITE_OK success
105449 if( rc==SQLITE_OK && pSorter->pReader->pFd==0 ) rc = SQLITE_DONE;
105457 if( rc==SQLITE_OK && res ) rc = SQLITE_DONE;
105464 rc = pSorter->list.pList ? SQLITE_OK : SQLITE_DONE;
105514 return SQLITE_OK;
105561 return SQLITE_OK;
105566 return SQLITE_OK;
105662 if( rc==SQLITE_OK ){
105679 return SQLITE_OK;
105693 return SQLITE_OK;
105721 return SQLITE_OK;
105748 if( rc!=SQLITE_OK ){
105752 return SQLITE_OK;
105884 return SQLITE_OK;
105894 return SQLITE_OK;
105910 int rc = SQLITE_OK;
105961 rc = SQLITE_OK;
106009 if( rc==SQLITE_OK ){
106015 SQLITE_PRIVATE int sqlite3VdbeBytecodeVtabInit(sqlite3 *db){ return SQLITE_OK; }
106146 return SQLITE_OK;
106171 if( rc==SQLITE_OK ){
106183 if( rc==SQLITE_OK ){
106188 if( rc!=SQLITE_OK ){
106220 if( rc==SQLITE_OK ){
106273 return SQLITE_OK;
106303 return SQLITE_OK;
106312 return SQLITE_OK;
106323 return SQLITE_OK;
106332 return SQLITE_OK;
106404 return SQLITE_OK;
106423 int rc = SQLITE_OK;
107893 if( auth!=SQLITE_OK ){
108849 if( pExpr==0 ) return SQLITE_OK;
108882 ** The return value is SQLITE_OK (0) for success or SQLITE_ERROR (1) for a
108892 if( pList==0 ) return SQLITE_OK;
108926 return SQLITE_OK;
109005 if( (rc = sqlite3ResolveExprNames(&sNC, pExpr))!=SQLITE_OK ) return rc;
109798 int rc = SQLITE_OK;
114321 v, OP_Halt, SQLITE_OK, OE_Ignore, 0, pExpr->u.zToken,0);
116309 if( SQLITE_OK!=isAlterableTable(pParse, pTab) ){
116312 if( SQLITE_OK!=sqlite3CheckObjectName(pParse,zName,"table",zName) ){
116532 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
116533 if( rc!=SQLITE_OK ){
116652 if( SQLITE_OK!=isAlterableTable(pParse, pTab) ){
116758 if( SQLITE_OK!=isAlterableTable(pParse, pTab) ) goto exit_rename_column;
116759 if( SQLITE_OK!=isRealTable(pParse, pTab, 0) ) goto exit_rename_column;
117297 if( rc==SQLITE_OK
117306 if( rc==SQLITE_OK ){
117338 int rc = SQLITE_OK;
117444 ** it was read from the schema of database zDb. Return SQLITE_OK if
117453 int rc = SQLITE_OK;
117469 if( rc==SQLITE_OK && pNew->pWhen ){
117473 for(pStep=pNew->step_list; rc==SQLITE_OK && pStep; pStep=pStep->pNext){
117478 if( rc==SQLITE_OK && pStep->zTarget ){
117500 rc = pParse->nErr ? SQLITE_ERROR : SQLITE_OK;
117509 for(i=0; i<pStep->pFrom->nSrc && rc==SQLITE_OK; i++){
117521 if( rc==SQLITE_OK && pStep->pWhere ){
117524 if( rc==SQLITE_OK ){
117528 if( pStep->pUpsert && rc==SQLITE_OK ){
117534 if( rc==SQLITE_OK ){
117538 if( rc==SQLITE_OK ){
117541 if( rc==SQLITE_OK ){
117685 if( rc!=SQLITE_OK ) goto renameColumnFunc_done;
117690 sParse.rc = SQLITE_OK;
117693 if( rc==SQLITE_OK ){
117696 if( rc!=SQLITE_OK ) goto renameColumnFunc_done;
117748 if( rc!=SQLITE_OK ) goto renameColumnFunc_done;
117774 assert( rc==SQLITE_OK );
117778 if( rc!=SQLITE_OK ){
117894 if( rc==SQLITE_OK ){
117963 if( rc==SQLITE_OK ){
117985 if( rc==SQLITE_OK ){
117988 if( rc!=SQLITE_OK ){
118065 if( rc==SQLITE_OK ){
118081 sParse.rc = SQLITE_OK;
118084 if( rc==SQLITE_OK ){
118104 if( rc==SQLITE_OK ){
118110 if( rc==SQLITE_OK ){
118115 if( rc!=SQLITE_OK ){
118183 if( rc==SQLITE_OK ){
118196 if( rc==SQLITE_OK ){
118207 if( rc!=SQLITE_OK && zWhen && !sqlite3WritableSchema(db) ){
118255 if( rc!=SQLITE_OK ) goto drop_column_done;
118283 if( rc!=SQLITE_OK ){
118313 if( SQLITE_OK!=isAlterableTable(pParse, pTab) ) goto exit_drop_column;
118314 if( SQLITE_OK!=isRealTable(pParse, pTab, 1) ) goto exit_drop_column;
119925 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
120356 if( rc==SQLITE_OK ) initAvgEq(pPrevIdx);
120365 int rc = SQLITE_OK; /* Result codes from subroutines */
120407 int rc = SQLITE_OK;
120454 if( rc==SQLITE_OK ){
120513 int rc = SQLITE_OK;
120588 if( rc==SQLITE_OK ){
120648 if( rc!=SQLITE_OK ){
120664 }else if( rc==SQLITE_OK ){
120686 if( rc==SQLITE_OK && pNew->zDbSName==0 ){
120696 if( rc==SQLITE_OK ){
120704 assert( zErrDyn==0 || rc!=SQLITE_OK );
120707 if( rc==SQLITE_OK && !REOPEN_AS_MEMDB(db) ){
120833 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ) goto attach_end;
120840 SQLITE_OK!=resolveAttachExpr(&sName, pFilename) ||
120841 SQLITE_OK!=resolveAttachExpr(&sName, pDbname) ||
120842 SQLITE_OK!=resolveAttachExpr(&sName, pKey)
120857 if(rc!=SQLITE_OK ){
121156 ** should return either SQLITE_OK, SQLITE_DENY, or SQLITE_IGNORE. If
121157 ** SQLITE_OK is returned, it means that access is allowed. SQLITE_DENY
121179 return SQLITE_OK;
121210 if( db->init.busy ) return SQLITE_OK;
121221 }else if( rc!=SQLITE_IGNORE && rc!=SQLITE_OK ){
121289 ** either SQLITE_OK (zero) or SQLITE_IGNORE or SQLITE_DENY. If SQLITE_DENY
121308 return SQLITE_OK;
121330 }else if( rc!=SQLITE_OK && rc!=SQLITE_IGNORE ){
121810 && SQLITE_OK!=sqlite3ReadSchema(pParse)
122422 return SQLITE_OK;
122442 return SQLITE_OK;
122652 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
123549 ** Resize an Index object to hold N columns total. Return SQLITE_OK
123555 if( pIdx->nColumn>=N ) return SQLITE_OK;
123573 return SQLITE_OK;
125326 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
125426 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName,"index",pTab->zName) ){
125956 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
126590 if( rc!=SQLITE_OK ){
126868 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
127136 return SQLITE_OK;
127163 return SQLITE_OK;
128010 assert( rcauth==SQLITE_OK || rcauth==SQLITE_DENY || rcauth==SQLITE_IGNORE );
128080 ** The "rcauth==SQLITE_OK" terms is the
128086 if( rcauth==SQLITE_OK
129819 if( str.accError!=SQLITE_OK ){
130876 assert( rc==SQLITE_NOMEM || rc==SQLITE_OK );
136071 && sqlite3FaultSim(411)==SQLITE_OK ){
136258 sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_OK, 0);
136306 int rc = SQLITE_OK; /* Return code */
136316 sqlite3Error(db, SQLITE_OK);
136317 while( rc==SQLITE_OK && zSql[0] ){
136323 assert( rc==SQLITE_OK || pStmt==0 );
136324 if( rc!=SQLITE_OK ){
136397 if( rc!=SQLITE_OK && pzErrMsg ){
137673 ** Return SQLITE_OK on success and SQLITE_ERROR if something goes wrong.
137804 if( rc==SQLITE_OK_LOAD_PERMANENTLY ) return SQLITE_OK;
137825 return SQLITE_OK;
137882 return SQLITE_OK;
137923 int rc = SQLITE_OK;
138000 if( sqlite3_initialize()==SQLITE_OK )
138897 return SQLITE_OK;
138910 if( db->temp_store==ts ) return SQLITE_OK;
138911 if( invalidateTempStorage( pParse ) != SQLITE_OK ){
138915 return SQLITE_OK;
139184 ** connection. If it returns SQLITE_OK, then assume that the VFS
139204 if( rc==SQLITE_OK ){
139525 if( rc==SQLITE_OK && (eAuto==1 || eAuto==2) ){
139536 { OP_Halt, SQLITE_OK, OE_Abort, 0}, /* 3 */
139678 rc = SQLITE_OK;
139680 if( rc==SQLITE_OK ){
139728 if( rc!=SQLITE_OK || res==0 ){
139775 if( rc!=SQLITE_OK || res==0 ){
139822 if( res!=SQLITE_OK ){
141368 if( zRight && sqlite3DecOrHexToI64(zRight, &N)==SQLITE_OK ){
141388 if( zRight && sqlite3DecOrHexToI64(zRight, &N)==SQLITE_OK ){
141406 && sqlite3DecOrHexToI64(zRight, &N)==SQLITE_OK
141425 && sqlite3DecOrHexToI64(zRight, &N)==SQLITE_OK /* IMP: R-40975-20399 */
141453 SQLITE_FCNTL_LOCKSTATE, &j)==SQLITE_OK ){
141550 if( rc==SQLITE_OK ){
141575 return SQLITE_OK;
141592 if( pTab->nHidden==0 ){ return SQLITE_OK; }
141607 return SQLITE_OK;
141619 return SQLITE_OK;
141630 return SQLITE_OK;
141650 return SQLITE_OK;
141656 int rc = SQLITE_OK;
141712 if( rc!=SQLITE_OK ){
141742 return SQLITE_OK;
141751 return SQLITE_OK;
141952 if( SQLITE_OK!=rc ){
142037 initData.rc = SQLITE_OK;
142055 rc = SQLITE_OK;
142065 if( rc!=SQLITE_OK ){
142188 if( rc==SQLITE_OK ) rc = initData.rc;
142191 if( rc==SQLITE_OK ){
142202 if( rc==SQLITE_OK || ((db->flags&SQLITE_NoSchemaError) && rc!=SQLITE_NOMEM)){
142214 rc = SQLITE_OK;
142272 return SQLITE_OK;
142280 int rc = SQLITE_OK;
142285 if( rc!=SQLITE_OK ){
142323 if( rc!=SQLITE_OK ) return;
142500 int rc = SQLITE_OK; /* Result code */
142610 if( sParse.rc!=SQLITE_OK && sParse.rc!=SQLITE_DONE ){
142628 rc = SQLITE_OK;
142671 assert( rc==SQLITE_OK || *ppStmt==0 );
142672 if( rc==SQLITE_OK || db->mallocFailed ) break;
142680 assert( rc==SQLITE_OK || (*ppStmt)==0 );
142688 ** If the statement is successfully recompiled, return SQLITE_OK. Otherwise,
142720 return SQLITE_OK;
142741 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
142759 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );
142781 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );
142804 int rc = SQLITE_OK;
142857 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
142869 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
142884 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
145072 ** Return SQLITE_OK on success. If a memory allocation error occurs,
145189 return SQLITE_OK;
145768 int rc = SQLITE_OK; /* Success code from a subroutine */
145803 rc = SQLITE_OK;
145861 testcase( rc!=SQLITE_OK );
145934 testcase( rc!=SQLITE_OK );
146012 testcase( rc!=SQLITE_OK );
148384 ** pFrom->pIndex and return SQLITE_OK.
148404 return SQLITE_OK;
148778 ** SQLITE_OK is returned. Otherwise, if an OOM error is encountered,
148806 return pParse->nErr ? SQLITE_ERROR : SQLITE_OK;
151650 res.rc = SQLITE_OK;
151673 if( rc!=SQLITE_OK ){
152341 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
152789 if( sqlite3ResolveExprListNames(&sNC, pNew)==SQLITE_OK
153012 && SQLITE_OK==sqlite3ResolveExprNames(&sNC, pWhen)
154731 ** Return SQLITE_OK if everything works, or an error code is something
154863 return SQLITE_OK;
155014 if( rc!=SQLITE_OK ) return rc;
155027 if( rc!=SQLITE_OK ) break;
155031 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
155125 int rc = SQLITE_OK; /* Return code from service routines */
155198 if( rc!=SQLITE_OK ) goto end_of_vacuum;
155206 if( id->pMethods!=0 && (sqlite3OsFileSize(id, &sz)!=SQLITE_OK || sz>0) ){
155229 if( rc!=SQLITE_OK ) goto end_of_vacuum;
155231 if( rc!=SQLITE_OK ) goto end_of_vacuum;
155264 if( rc!=SQLITE_OK ) goto end_of_vacuum;
155270 if( rc!=SQLITE_OK ) goto end_of_vacuum;
155286 if( rc!=SQLITE_OK ) goto end_of_vacuum;
155335 if( NEVER(rc!=SQLITE_OK) ) goto end_of_vacuum;
155341 if( rc!=SQLITE_OK ) goto end_of_vacuum;
155343 if( rc!=SQLITE_OK ) goto end_of_vacuum;
155351 assert( rc==SQLITE_OK );
155486 int rc = SQLITE_OK;
155491 if( rc!=SQLITE_OK && xDestroy ) xDestroy(pAux);
155547 return SQLITE_OK;
156007 assert( pTab->nTabRef>1 || rc!=SQLITE_OK );
156013 if( SQLITE_OK!=rc ){
156097 return SQLITE_OK;
156111 if( rc!=SQLITE_OK ){
156122 ** more v-table. Return SQLITE_NOMEM if a malloc fails, or SQLITE_OK otherwise.
156140 return SQLITE_OK;
156162 int rc = SQLITE_OK;
156186 ** create a valid sqlite3_vtab if it returns SQLITE_OK. */
156187 if( rc==SQLITE_OK && ALWAYS(sqlite3GetVTable(db, pTab)) ){
156189 if( rc==SQLITE_OK ){
156204 int rc = SQLITE_OK;
156253 if( SQLITE_OK==sqlite3RunParser(&sParse, zCreateTable) ){
156315 int rc = SQLITE_OK;
156338 if( rc==SQLITE_OK ){
156382 ** SQLITE_OK if all xSync operations are successful.
156388 int rc = SQLITE_OK;
156392 for(i=0; rc==SQLITE_OK && i<db->nVTrans; i++){
156410 return SQLITE_OK;
156419 return SQLITE_OK;
156431 int rc = SQLITE_OK;
156443 return SQLITE_OK;
156453 return SQLITE_OK;
156460 if( rc==SQLITE_OK ){
156462 if( rc==SQLITE_OK ){
156485 ** If any virtual table method returns an error code other than SQLITE_OK,
156488 ** SQLITE_OK is returned.
156491 int rc = SQLITE_OK;
156497 for(i=0; rc==SQLITE_OK && i<db->nVTrans; i++){
156722 int rc = SQLITE_OK;
156760 if( rc!=SQLITE_OK ) sqlite3Error(db, rc);
163671 if( rc!=SQLITE_OK && rc!=SQLITE_CONSTRAINT ){
163963 ** SQLITE_OK.
163977 int rc = SQLITE_OK;
163990 if( pUpper && rc==SQLITE_OK ){
163998 for(i=0; rc==SQLITE_OK && i<p->nSample; i++){
164000 if( rc==SQLITE_OK && p1 ){
164004 if( rc==SQLITE_OK && p2 ){
164084 int rc = SQLITE_OK;
164155 if( rc==SQLITE_OK && n ){
164172 if( rc==SQLITE_OK && n ){
164185 if( rc==SQLITE_OK ){
164250 ** Write the estimated row count into *pnRow and return SQLITE_OK.
164288 return SQLITE_OK;
164293 if( rc!=SQLITE_OK ) return rc;
164314 ** Write the estimated row count into *pnRow and return SQLITE_OK.
164332 int rc = SQLITE_OK; /* Subfunction return code */
164338 for(i=0; rc==SQLITE_OK && i<pList->nExpr; i++){
164345 if( rc==SQLITE_OK ){
164540 if( p->nLSlot>=n ) return SQLITE_OK;
164548 return SQLITE_OK;
164569 return SQLITE_OK;
164835 return SQLITE_OK;
164851 return SQLITE_OK;
165123 int rc = SQLITE_OK; /* Return code */
165169 for(; rc==SQLITE_OK && pTerm!=0; pTerm = whereScanNext(&scan)){
165373 if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
165374 if( rc!=SQLITE_OK ) break; /* Jump out of the pTerm loop */
165501 && (rc = whereLoopResize(db, pNew, pNew->nLTerm+1))==SQLITE_OK
165885 int rc = SQLITE_OK; /* Return code */
165950 for(pTerm=pWC->a; rc==SQLITE_OK && pTerm<pWCEnd; pTerm++){
165991 for(; rc==SQLITE_OK && pProbe;
166230 int rc = SQLITE_OK;
166275 return SQLITE_OK;
166354 return SQLITE_OK;
166461 int rc = SQLITE_OK;
166471 testcase( rc!=SQLITE_OK );
166477 if( rc==SQLITE_OK && pVal==0 ){ /* IMP: R-19933-32160 */
166545 int rc = SQLITE_OK; /* Return code */
166584 assert( rc==SQLITE_OK );
166595 if( rc==SQLITE_OK && ((mBest = (pNew->prereq & ~mPrereq))!=0 || bIn) ){
166617 while( rc==SQLITE_OK ){
166643 if( rc==SQLITE_OK && seenZero==0 ){
166653 if( rc==SQLITE_OK && seenZeroNoIN==0 ){
166680 int rc = SQLITE_OK;
166695 if( pItem->fg.jointype & JT_RIGHT ) return SQLITE_OK;
166697 for(pTerm=pWC->a; pTerm<pWCEnd && rc==SQLITE_OK; pTerm++){
166741 if( rc==SQLITE_OK ){
166771 for(i=0; rc==SQLITE_OK && i<sSum.n; i++){
166807 int rc = SQLITE_OK;
166861 if( rc==SQLITE_OK && pBuilder->pWC->hasOr ){
166869 rc = SQLITE_OK;
167338 ** Return SQLITE_OK on success or SQLITE_NOMEM of a memory allocation
167722 return SQLITE_OK;
170306 int rc = SQLITE_OK;
170462 assert( rc==SQLITE_OK || pParse->nErr!=0 );
178617 return SQLITE_OK;
179095 pParse->rc = SQLITE_OK;
179185 assert( db->mallocFailed==0 || pParse->rc!=SQLITE_OK || startedWithOom );
179186 if( pParse->rc!=SQLITE_OK ) break;
179204 if( pParse->zErrMsg || (pParse->rc!=SQLITE_OK && pParse->rc!=SQLITE_DONE) ){
179228 assert( nErr==0 || pParse->rc!=SQLITE_OK );
179983 if( rc!=SQLITE_OK ){
180000 return SQLITE_OK;
180026 if( rc==SQLITE_OK ){
180036 if( rc==SQLITE_OK ){
180041 /* If rc is not SQLITE_OK at this point, then either the malloc
180044 if( rc!=SQLITE_OK ){
180075 if( rc==SQLITE_OK ){
180080 if( rc==SQLITE_OK ){
180084 if( rc==SQLITE_OK ){
180117 if( rc==SQLITE_OK ){
180158 if( rc!=SQLITE_OK ){
180197 return SQLITE_OK;
180211 int rc = SQLITE_OK;
180546 ** Return SQLITE_OK on success.
180650 return SQLITE_OK;
180687 return SQLITE_OK;
180696 int rc = SQLITE_OK;
180704 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
180711 rc = SQLITE_OK;
180717 return ((rc==SQLITE_OK && bSeenBusy) ? SQLITE_BUSY : rc);
180737 rc = SQLITE_OK;
180790 rc = SQLITE_OK;
181020 return SQLITE_OK;
181071 return SQLITE_OK;
181148 sqlite3RollbackAll(db, SQLITE_OK);
181211 sqlite3Error(db, SQLITE_OK); /* Deallocates any cached error strings. */
181242 ** Rollback all database files. If tripCode is not SQLITE_OK, then
181303 case SQLITE_OK: zName = "SQLITE_OK"; break;
181412 /* SQLITE_OK */ "not an error",
181562 return SQLITE_OK;
181613 return SQLITE_OK;
181710 if( rc==SQLITE_OK ){
181715 if( rc!=SQLITE_OK ){
181751 return SQLITE_OK;
181777 return SQLITE_OK;
181824 assert( rc!=SQLITE_OK || (xStep==0 && xFinal==0) );
181960 if( rc ) return SQLITE_OK;
182016 return SQLITE_OK;
182180 return SQLITE_OK;
182202 return SQLITE_OK;
182231 return SQLITE_OK;
182273 return SQLITE_OK;
182343 ** returned (i.e. SQLITE_IOERR). Otherwise, SQLITE_OK.
182357 int rc = SQLITE_OK; /* Return code */
182367 for(i=0; i<db->nDb && rc==SQLITE_OK; i++){
182374 rc = SQLITE_OK;
182379 return (rc==SQLITE_OK && bBusy) ? SQLITE_BUSY : rc;
182608 sqlite3Error(db, SQLITE_OK);
182609 return SQLITE_OK;
182740 ** If successful, SQLITE_OK is returned. In this case *ppVfs is set to point to
182759 char **pzErrMsg /* OUT: Error message (if rc!=SQLITE_OK) */
182761 int rc = SQLITE_OK;
182977 if( rc!=SQLITE_OK ){
183241 if( rc!=SQLITE_OK ){
183257 if( rc!=SQLITE_OK ){
183289 sqlite3Error(db, SQLITE_OK);
183295 for(i=0; rc==SQLITE_OK && i<ArraySize(sqlite3BuiltinExtensions); i++){
183302 if( rc==SQLITE_OK ){
183305 if( rc!=SQLITE_OK ){
183346 }else if( rc!=SQLITE_OK ){
183409 if( rc==SQLITE_OK && !DbHasProperty(*ppDb, 0, DB_SchemaLoaded) ){
183469 int rc = SQLITE_OK;
183505 return SQLITE_OK;
183526 return SQLITE_OK;
183569 return SQLITE_OK;
183573 return SQLITE_OK;
183589 return SQLITE_OK;
183599 return SQLITE_OK;
183715 if( SQLITE_OK!=rc ){
183784 if( SQLITE_OK==rc && !pTab ){
183823 return SQLITE_OK;
183848 rc = SQLITE_OK;
183851 rc = SQLITE_OK;
183854 rc = SQLITE_OK;
183857 rc = SQLITE_OK;
183864 rc = SQLITE_OK;
183867 rc = SQLITE_OK;
184250 ** Return SQLITE_OK if SQLite has been initialized and SQLITE_ERROR if
184708 if( rc==SQLITE_OK ){
184748 if( rc==SQLITE_OK ){
184754 rc = SQLITE_OK;
184756 if( rc==SQLITE_OK ){
184759 if( rc==SQLITE_OK ){
184796 if( rc==SQLITE_OK ){
185021 int rc = SQLITE_OK;
185567 /* TODO(shess) Only used for SQLITE_OK and SQLITE_DONE at this time.
185614 ** This method should return either SQLITE_OK (0), or an SQLite error
185615 ** code. If SQLITE_OK is returned, then *ppTokenizer should be set
185651 ** method should either return SQLITE_OK and set the values of the
186298 # define sqlite3Fts3DeferToken(x,y,z) SQLITE_OK
186299 # define sqlite3Fts3CacheDeferredDoclists(x) SQLITE_OK
186301 # define sqlite3Fts3DeferredTokenList(x,y,z) SQLITE_OK
186702 return SQLITE_OK;
186748 int rc = SQLITE_OK; /* Return code */
186767 ** memory associated with the Fts3Table structure and return SQLITE_OK.
186770 return (rc==SQLITE_OK ? fts3DisconnectMethod(pVtab) : rc);
186784 if( *pRc==SQLITE_OK ){
186827 if( (*pRc)==SQLITE_OK ) p->bHasStat = 1;
186840 int rc = SQLITE_OK; /* Return code */
186905 if( *pRc==SQLITE_OK ){
186915 if( rc==SQLITE_OK ){
186921 rc = SQLITE_OK;
186924 assert( p->nPgsz>0 || rc!=SQLITE_OK );
186969 if( *pRc==SQLITE_OK ){
187033 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op (and
187090 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op (and
187142 ** the output value undefined. Otherwise SQLITE_OK is returned.
187159 return SQLITE_OK;
187172 ** If no error occurs, SQLITE_OK is returned and *apIndex set to point to
187220 return SQLITE_OK;
187257 int rc = SQLITE_OK; /* Return code */
187266 if( rc!=SQLITE_OK ){
187272 if( rc==SQLITE_OK ){
187334 int rc = SQLITE_OK; /* Return code */
187394 for(i=3; rc==SQLITE_OK && i<argc; i++){
187513 if( rc==SQLITE_OK && zContent ){
187525 if( rc==SQLITE_OK && zLanguageid ){
187538 if( rc!=SQLITE_OK ) goto fts3_init_out;
187549 if( rc!=SQLITE_OK ) goto fts3_init_out;
187558 if( rc!=SQLITE_OK ) goto fts3_init_out;
187645 if( rc==SQLITE_OK && (zCompress==0)!=(zUncompress==0) ){
187652 if( rc!=SQLITE_OK ) goto fts3_init_out;
187690 if( rc!=SQLITE_OK ){
187795 return SQLITE_OK;
187885 return SQLITE_OK;
187897 ** allocation succeeds, zero it and return SQLITE_OK. Otherwise,
187905 return SQLITE_OK;
187951 return SQLITE_OK;
187964 int rc = SQLITE_OK;
187981 if( rc==SQLITE_OK ) pCsr->bSeekStmt = 1;
187989 ** SQLITE_OK on success.
187992 int rc = SQLITE_OK;
187995 if( rc==SQLITE_OK ){
188002 return SQLITE_OK;
188006 if( rc==SQLITE_OK && ((Fts3Table *)pCsr->base.pVtab)->zContentTbl==0 ){
188017 if( rc!=SQLITE_OK && pContext ){
188036 ** If an OOM error occurs, SQLITE_NOMEM is returned. Otherwise, SQLITE_OK.
188046 int rc = SQLITE_OK; /* Return code */
188162 ** If an error occurs, an error code other than SQLITE_OK is returned.
188173 int rc = SQLITE_OK; /* Return code */
188180 assert_fts3_nc( !piLeaf2 || !piLeaf || rc!=SQLITE_OK || (*piLeaf<=*piLeaf2) );
188182 if( rc==SQLITE_OK && iHeight>1 ){
188188 if( rc==SQLITE_OK ){
188196 if( rc==SQLITE_OK ){
188199 if( rc==SQLITE_OK ){
188450 return SQLITE_OK;
188734 ** containing the output doclist and SQLITE_OK is returned. In this case
188746 int rc = SQLITE_OK;
188818 if( rc!=SQLITE_OK ){
188902 return SQLITE_OK;
188959 ** other doclists (except the aaOutput[0] one) and return SQLITE_OK.
188986 if( rc!=SQLITE_OK ){
189002 return SQLITE_OK;
189016 ** This function returns SQLITE_OK if the merge is successful, or an
189068 if( rc!=SQLITE_OK ){
189086 return SQLITE_OK;
189107 return SQLITE_OK;
189114 ** This function returns SQLITE_OK if successful, or an SQLite error code
189128 int rc = SQLITE_OK; /* Error code */
189141 if( rc==SQLITE_OK && pSeg ){
189147 if( rc==SQLITE_OK ){
189151 while( rc==SQLITE_OK && SQLITE_ROW==(rc = sqlite3_step(pStmt)) ){
189166 if( rc!=SQLITE_OK ) goto finished;
189175 if( rc!=SQLITE_OK ) goto finished;
189221 ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
189238 ** zTerm/nTerm is a prefix. If successful, return SQLITE_OK and write
189245 ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
189281 if( rc==SQLITE_OK ){
189338 while( SQLITE_OK==rc
189344 if( rc==SQLITE_OK ){
189347 if( rc==SQLITE_OK ){
189393 ** Return SQLITE_OK if nothing goes wrong. SQLITE_OK is returned
189408 rc = SQLITE_OK;
189456 int rc = SQLITE_OK;
189517 if( rc!=SQLITE_OK ){
189523 if( rc!=SQLITE_OK ) return rc;
189557 if( rc==SQLITE_OK ){
189561 if( rc!=SQLITE_OK ) return rc;
189588 return SQLITE_OK;
189607 int rc = SQLITE_OK; /* Return Code */
189641 if( rc==SQLITE_OK && sqlite3_data_count(pCsr->pStmt)-1>iCol ){
189697 if( rc==SQLITE_OK
189705 assert( rc==SQLITE_OK || mxLevel==0 );
189718 ** to 0 or 1). Return SQLITE_OK if successful, or an SQLite error code
189722 int rc = SQLITE_OK;
189728 p->bHasStat = (res==SQLITE_OK);
189749 if( rc==SQLITE_OK ){
189770 return SQLITE_OK;
189783 return SQLITE_OK;
189831 ** output variable *ppCsr and SQLITE_OK is returned. Otherwise, an error
189844 rc = SQLITE_OK;
189896 }else if( SQLITE_OK==fts3CursorSeek(pContext, pCsr) ){
189916 if( SQLITE_OK==fts3CursorSeek(pContext, pCsr) ){
189949 case SQLITE_OK:
189971 if( SQLITE_OK==fts3FunctionArg(pContext, "matchinfo", apVal[0], &pCsr) ){
190039 if( rc==SQLITE_OK ){
190083 int rc = SQLITE_OK;
190103 if( rc==SQLITE_OK ){
190121 return SQLITE_OK;
190137 return SQLITE_OK;
190167 int rc = SQLITE_OK;
190177 if( *pzErr ) rc = SQLITE_OK;
190178 }else if( rc==SQLITE_OK && bOk==0 ){
190257 int rc = SQLITE_OK;
190276 if( rc!=SQLITE_OK ) return rc;
190280 if( rc!=SQLITE_OK ) return rc;
190295 if( rc==SQLITE_OK ){
190311 if( rc==SQLITE_OK ){
190320 if( SQLITE_OK==rc
190321 && SQLITE_OK==(rc=sqlite3Fts3InitHashTable(db,&pHash->hash,"fts3_tokenizer"))
190322 && SQLITE_OK==(rc = sqlite3_overload_function(db, "snippet", -1))
190323 && SQLITE_OK==(rc = sqlite3_overload_function(db, "offsets", 1))
190324 && SQLITE_OK==(rc = sqlite3_overload_function(db, "matchinfo", 1))
190325 && SQLITE_OK==(rc = sqlite3_overload_function(db, "matchinfo", 2))
190326 && SQLITE_OK==(rc = sqlite3_overload_function(db, "optimize", 1))
190332 if( rc==SQLITE_OK ){
190338 if( rc==SQLITE_OK ){
190347 assert( rc!=SQLITE_OK );
190377 if( pExpr && SQLITE_OK==*pRc ){
190387 if( rc!=SQLITE_OK ){
190410 ** SQLITE_OK is returned if successful, or SQLITE_NOMEM if an error occurs.
190419 int rc = SQLITE_OK;
190474 ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
190482 int rc = SQLITE_OK;
190484 for(iToken=0; rc==SQLITE_OK && iToken<p->nToken; iToken++){
190492 if( rc==SQLITE_OK ){
190511 ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
190528 if( rc!=SQLITE_OK ) return rc;
190535 return SQLITE_OK;
190556 return SQLITE_OK;
190607 return SQLITE_OK;
190627 ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
190631 int rc = SQLITE_OK; /* Error code */
190658 for(i=0; rc==SQLITE_OK && i<p->nToken; i++){
190672 assert( rc!=SQLITE_OK || p->nToken<1 || p->aToken[0].pSegcsr==0 || p->bIncr );
190841 ** SQLITE_OK.
190850 int rc = SQLITE_OK;
190893 ** SQLITE_OK.
190900 int rc = SQLITE_OK;
190928 for(i=0; rc==SQLITE_OK && i<p->nToken && bEof==0; i++){
190935 assert( rc!=SQLITE_OK || (p->nToken>=1 && a[p->nToken-1].bIgnore==0) );
190936 assert( rc!=SQLITE_OK || bMaxSet );
190940 while( rc==SQLITE_OK && bEof==0
190990 ** SQLITE_OK.
191001 int rc = SQLITE_OK;
191021 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
191040 if( pExpr && SQLITE_OK==*pRc ){
191084 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
191096 if( *pRc==SQLITE_OK ){
191100 for(i=0; *pRc==SQLITE_OK && i<pPhrase->nToken; i++){
191133 ** write this value to *pnPage and return SQLITE_OK. Otherwise, return
191143 int rc = SQLITE_OK;
191164 if( rc!=SQLITE_OK ) return rc;
191199 ** If no error occurs, SQLITE_OK is returned and sqlite3Fts3DeferToken()
191211 int rc = SQLITE_OK; /* Return code */
191225 return SQLITE_OK;
191237 if( nOvfl==0 || nToken<2 ) return SQLITE_OK;
191241 assert( rc!=SQLITE_OK || nDocSize>0 );
191266 for(ii=0; ii<nToken && rc==SQLITE_OK; ii++){
191303 assert( rc==SQLITE_OK || pList==0 );
191304 if( rc==SQLITE_OK ){
191309 if( rc==SQLITE_OK ){
191338 int rc = SQLITE_OK;
191347 if( rc==SQLITE_OK && nToken>1 && pTab->bFts4 ){
191366 if( rc==SQLITE_OK ){
191368 for(ii=0; rc==SQLITE_OK && ii<nOr; ii++){
191452 ** This function is a no-op if *pRc is other than SQLITE_OK when it is called.
191497 if( *pRc==SQLITE_OK && pExpr->bEof==0 ){
191524 while( !pLeft->bEof && !pRight->bEof && *pRc==SQLITE_OK ){
191539 while( *pRc==SQLITE_OK && pRight->bEof==0 ){
191546 while( *pRc==SQLITE_OK && pLeft->bEof==0 ){
191591 assert( *pRc!=SQLITE_OK || pRight->bStart );
191620 ** If *pRc is not SQLITE_OK, or if pExpr is not the root node of a NEAR
191657 if( *pRc==SQLITE_OK
191711 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
191722 if( *pRc==SQLITE_OK ){
191816 ** If *pRc is not SQLITE_OK when this function is called, it immediately
191821 ** 1. *pRc is SQLITE_OK when this function returns, and
191832 if( rc==SQLITE_OK ){
191842 if( rc==SQLITE_OK ){
191852 return (rc==SQLITE_OK && bMiss);
191860 int rc = SQLITE_OK; /* Return Code */
191881 if( rc==SQLITE_OK && (
191896 ** If *pRc is other than SQLITE_OK when this function is called, it is
191905 if( pExpr && *pRc==SQLITE_OK ){
191987 return SQLITE_OK;
191998 ** SQLITE_OK is returned if the aMI[] array is successfully allocated and
192005 int rc = SQLITE_OK; /* Return code */
192029 if( rc!=SQLITE_OK ) return rc;
192032 while( pCsr->isEof==0 && rc==SQLITE_OK ){
192050 if( rc==SQLITE_OK && pCsr->isEof==0 ){
192065 ** do {...} while( pRoot->iDocid<iDocid && rc==SQLITE_OK );
192072 }while( pRoot->iDocid!=iDocid && rc==SQLITE_OK );
192088 ** If no error occurs, SQLITE_OK is returned and the values for each column
192114 int rc = SQLITE_OK;
192125 if( rc==SQLITE_OK ){
192173 return SQLITE_OK;
192179 int rc = SQLITE_OK;
192199 if( bOr==0 ) return SQLITE_OK;
192212 while( rc==SQLITE_OK && !pRun->bEof ){
192216 assert( rc!=SQLITE_OK || pPhrase->bIncr==0 );
192217 if( rc==SQLITE_OK && pRun->bEof!=bEofSave ){
192222 while( rc==SQLITE_OK && !pRun->bEof ){
192226 if( rc!=SQLITE_OK ) return rc;
192270 if( pIter==0 ) return SQLITE_OK;
192280 if( *pIter==0x00 ) return SQLITE_OK;
192289 return SQLITE_OK;
192440 if( rc!=SQLITE_OK ) return rc;
192458 return SQLITE_OK;
192481 return SQLITE_OK;
192555 return SQLITE_OK;
192571 return SQLITE_OK;
192587 return SQLITE_OK;
192603 return SQLITE_OK;
192618 if( pCsr->aStat[pCsr->iCol].nDoc>0 ) return SQLITE_OK;
192635 return SQLITE_OK;
192642 rc = SQLITE_OK;
192792 if( rc==SQLITE_OK ){
192796 if( rc==SQLITE_OK ) rc = fts3auxNextMethod(pCursor);
192846 return SQLITE_OK;
192858 return SQLITE_OK;
192862 ** Register the fts3aux module with database connection db. Return SQLITE_OK
193045 assert( rc==SQLITE_OK || pCsr==0 );
193046 if( rc==SQLITE_OK ){
193050 if( rc!=SQLITE_OK ){
193075 ** Return SQLITE_OK if successful, or SQLITE_NOMEM if a memory allocation
193100 if( rc==SQLITE_OK ){
193106 if( rc==SQLITE_OK ){
193142 rc = SQLITE_OK;
193172 ** If successful, SQLITE_OK is returned and *ppExpr set to point at the
193214 if( rc==SQLITE_OK ){
193216 for(ii=0; rc==SQLITE_OK; ii++){
193220 if( rc==SQLITE_OK ){
193271 rc = SQLITE_OK;
193291 ** Returns an SQLite error code. SQLITE_OK if everything works, SQLITE_NOMEM
193371 return SQLITE_OK;
193509 ** If successful, SQLITE_OK is returned, *ppExpr is set to point to the
193525 int rc = SQLITE_OK;
193528 while( rc==SQLITE_OK ){
193533 assert( nByte>0 || (rc!=SQLITE_OK && p==0) );
193534 if( rc==SQLITE_OK ){
193622 assert( rc!=SQLITE_OK || (nByte>0 && nByte<=nIn) );
193632 rc = SQLITE_OK;
193650 if( rc!=SQLITE_OK ){
193664 int rc = SQLITE_OK;
193670 if( rc==SQLITE_OK ){
193681 ** If successful, SQLITE_OK is returned and (*pp) set to point to the
193690 int rc = SQLITE_OK; /* Return code */
193699 if( rc==SQLITE_OK ){
193709 if( rc==SQLITE_OK ){
193732 if( rc!=SQLITE_OK ) break;
193779 if( rc==SQLITE_OK ){
193827 if( rc==SQLITE_OK ){
193831 if( rc!=SQLITE_OK ){
193844 if( rc!=SQLITE_OK ){
193886 return SQLITE_OK;
193892 assert( rc==SQLITE_OK || *ppExpr==0 );
193895 if( rc==SQLITE_OK && sParse.nNest ){
193907 ** of the parsed expression tree and SQLITE_OK is returned. If an error
193943 if( rc==SQLITE_OK && *ppExpr ){
193945 if( rc==SQLITE_OK ){
193950 if( rc!=SQLITE_OK ){
194109 if( rc!=SQLITE_OK ){
194136 assert( rc==SQLITE_OK || pExpr==0 );
194144 if( rc!=SQLITE_OK && rc!=SQLITE_NOMEM ){
194186 if( rc==SQLITE_OK ){
194656 return SQLITE_OK;
194664 return SQLITE_OK;
194699 return SQLITE_OK;
194710 return SQLITE_OK;
195217 return SQLITE_OK;
195462 assert( rc!=SQLITE_OK || *ppTok );
195463 if( rc!=SQLITE_OK ){
195565 if( SQLITE_OK!=p->xCreate(argc-2, azArg, &pTokenizer) ){
195575 while( SQLITE_OK==p->xNext(pCsr, &zToken, &nToken, &iStart, &iEnd, &iPos) ){
195583 if( SQLITE_OK!=p->xClose(pCsr) ){
195587 if( SQLITE_OK!=p->xDestroy(pTokenizer) ){
195612 if( rc!=SQLITE_OK ){
195636 if( rc!=SQLITE_OK ){
195688 assert( rc==SQLITE_OK );
195698 assert( rc==SQLITE_OK );
195700 assert( rc==SQLITE_OK );
195731 int rc = SQLITE_OK;
195746 if( SQLITE_OK==rc ){
195749 if( SQLITE_OK==rc ){
195753 if( SQLITE_OK==rc ){
195756 if( SQLITE_OK==rc ){
195868 return SQLITE_OK;
195876 return SQLITE_OK;
195911 return SQLITE_OK;
195922 return SQLITE_OK;
195977 return SQLITE_OK;
196102 return SQLITE_OK;
196112 ** array of dequoted strings and SQLITE_OK is returned. The caller is
196122 int rc = SQLITE_OK; /* Return code */
196183 if( rc!=SQLITE_OK ) return rc;
196188 if( rc==SQLITE_OK ){
196198 assert( (rc==SQLITE_OK)==(pMod!=0) );
196199 if( rc==SQLITE_OK ){
196205 if( rc==SQLITE_OK ){
196212 if( rc==SQLITE_OK ){
196237 return SQLITE_OK;
196259 return SQLITE_OK;
196266 return SQLITE_OK;
196283 return SQLITE_OK;
196314 return SQLITE_OK;
196331 if( rc!=SQLITE_OK ){
196333 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
196366 if( rc==SQLITE_OK ){
196372 if( rc!=SQLITE_OK ) return rc;
196413 return SQLITE_OK;
196425 return SQLITE_OK;
196429 ** Register the fts3tok module with database connection db. Return SQLITE_OK
196556 sqlite3_log(SQLITE_OK, "%d-way merge from level %d", nMerge, (int)iAbsLevel);
196627 ** until SegmentReaderNext() returns something other than SQLITE_OK
196750 ** *pp is set to the requested statement handle and SQLITE_OK returned.
196864 int rc = SQLITE_OK;
196887 assert( rc==SQLITE_OK || pStmt==0 );
196894 for(i=0; rc==SQLITE_OK && i<nParam; i++){
196912 if( rc==SQLITE_OK ){
196917 if( rc==SQLITE_OK ) rc = FTS_CORRUPT_VTAB;
196920 rc = SQLITE_OK;
196935 if( rc==SQLITE_OK ){
196941 if( rc==SQLITE_OK ) rc = FTS_CORRUPT_VTAB;
196962 ** Returns SQLITE_OK if the statement is successfully executed, or an
196975 if( rc==SQLITE_OK ){
196998 int rc = SQLITE_OK;
197003 if( rc==SQLITE_OK ){
197054 ** return SQLITE_OK. If an error occurs while preparing the statement,
197085 if( rc==SQLITE_OK ){
197094 if( rc==SQLITE_OK ){
197104 ** Append a single varint to a PendingList buffer. SQLITE_OK is returned
197147 return SQLITE_OK;
197157 ** it is set to SQLITE_OK.
197167 int rc = SQLITE_OK;
197178 if( SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, iDelta)) ){
197186 if( SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, 1))
197187 || SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, iCol))
197197 if( rc==SQLITE_OK ){
197230 int rc = SQLITE_OK;
197246 if( rc==SQLITE_OK ){
197257 ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error code.
197288 return SQLITE_OK;
197292 if( rc!=SQLITE_OK ){
197297 while( SQLITE_OK==rc
197298 && SQLITE_OK==(rc = xNext(pCsr, &zToken, &nToken, &iStart, &iEnd, &iPos))
197318 for(i=1; rc==SQLITE_OK && i<p->nIndex; i++){
197329 return (rc==SQLITE_DONE ? SQLITE_OK : rc);
197358 if( rc!=SQLITE_OK ) return rc;
197363 return SQLITE_OK;
197403 if( rc!=SQLITE_OK ){
197409 return SQLITE_OK;
197443 return SQLITE_OK;
197455 if( rc==SQLITE_OK && p->zLanguageid ){
197461 if( rc!=SQLITE_OK ) return rc;
197481 if( rc!=SQLITE_OK ) return rc;
197501 int rc = SQLITE_OK; /* Return code */
197548 if( rc==SQLITE_OK ){
197554 for(i=1; rc==SQLITE_OK && i<=p->nColumn; i++){
197562 if( rc!=SQLITE_OK ){
197594 ** If successful, *piIdx is set to the allocated index slot and SQLITE_OK
197613 if( rc==SQLITE_OK ){
197623 if( rc==SQLITE_OK ){
197654 ** an SQLite error code is returned. Otherwise, SQLITE_OK is returned. If
197692 if( rc==SQLITE_OK ){
197706 if( rc!=SQLITE_OK ){
197741 if( rc==SQLITE_OK ){
197754 int rc = SQLITE_OK;
197758 while( pReader->pBlob && rc==SQLITE_OK
197780 ** segment. If successful, SQLITE_OK is returned. If there is no next term,
197829 return SQLITE_OK;
197840 return SQLITE_OK;
197847 if( rc!=SQLITE_OK ) return rc;
197859 if( rc!=SQLITE_OK ) return rc;
197886 if( rc!=SQLITE_OK ) return rc;
197905 return SQLITE_OK;
197913 int rc = SQLITE_OK;
197926 if( rc==SQLITE_OK ){
197950 int rc = SQLITE_OK;
197993 if( rc!=SQLITE_OK ) return rc;
198017 if( rc==SQLITE_OK ){
198041 int rc = SQLITE_OK;
198047 for(ii=0; rc==SQLITE_OK && ii<pMsr->nSegment; ii++){
198056 if( rc!=SQLITE_OK ) break;
198130 return SQLITE_OK;
198186 int rc = SQLITE_OK; /* Return Code */
198403 if( rc==SQLITE_OK ){
198415 ** *pnMax to this value and return SQLITE_OK. Otherwise, if an error occurs,
198424 if( rc==SQLITE_OK ){
198450 if( rc==SQLITE_OK ){
198566 return SQLITE_OK;
198631 ** If successful, SQLITE_OK is returned and output variable *piLast is
198646 int rc = SQLITE_OK;
198658 for(pIter=pTree->pLeftmost; pIter && rc==SQLITE_OK; pIter=pIter->pRight){
198666 if( rc==SQLITE_OK ){
198703 ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error code.
198737 if( rc!=SQLITE_OK ) return rc;
198743 if( rc!=SQLITE_OK ) return rc;
198768 if( rc!=SQLITE_OK ) return rc;
198785 if( rc!=SQLITE_OK ) return rc;
198847 return SQLITE_OK;
198853 ** to the segment using fts3SegWriterAdd(). If successful, SQLITE_OK is
198871 if( rc==SQLITE_OK ){
198875 if( rc==SQLITE_OK ){
198908 ** document pRowid, or false otherwise, and SQLITE_OK is returned. If an
198917 rc = SQLITE_OK;
198920 if( rc==SQLITE_OK ){
198936 ** Return SQLITE_OK if successful, or an SQLite error code if not.
198955 if( rc!=SQLITE_OK ) return rc;
198970 ** iAbsLevel is indeed the largest level, or 0 otherwise, and SQLITE_OK
198984 if( rc!=SQLITE_OK ) return rc;
199006 int rc = SQLITE_OK; /* Return code */
199010 if( rc==SQLITE_OK ){
199032 ** SQLITE_OK is returned if successful, otherwise an SQLite error code.
199042 int rc = SQLITE_OK; /* Return Code */
199046 for(i=0; rc==SQLITE_OK && i<nReader; i++){
199049 if( rc!=SQLITE_OK ){
199056 if( rc==SQLITE_OK ){
199064 if( rc==SQLITE_OK ){
199071 if( rc==SQLITE_OK ){
199133 ** If successful, return SQLITE_OK. Otherwise, if an OOM error is encountered
199153 return SQLITE_OK;
199171 return SQLITE_OK;
199190 while( rc==SQLITE_OK
199198 if( rc!=SQLITE_OK ) return rc;
199203 if( rc!=SQLITE_OK ) return rc;
199221 return SQLITE_OK;
199244 if( rc!=SQLITE_OK ) return rc;
199253 return SQLITE_OK;
199284 if( rc!=SQLITE_OK ) return rc;
199298 if( rc!=SQLITE_OK ) return rc;
199305 return SQLITE_OK;
199336 return SQLITE_OK;
199349 return SQLITE_OK;
199357 int rc = SQLITE_OK;
199373 if( pCsr->nSegment==0 ) return SQLITE_OK;
199389 if( rc!=SQLITE_OK ) return rc;
199394 /* If all the seg-readers are at EOF, we're finished. return SQLITE_OK. */
199395 assert( rc==SQLITE_OK );
199440 if( rc==SQLITE_OK ) rc = SQLITE_ROW;
199524 }while( rc==SQLITE_OK );
199595 int rc = SQLITE_OK;
199600 if( rc==SQLITE_OK ){
199633 if( rc==SQLITE_OK ){
199636 if( rc==SQLITE_OK ){
199640 if( rc==SQLITE_OK ){
199658 if( rc!=SQLITE_OK ){
199664 if( rc==SQLITE_OK ){
199669 if( rc==SQLITE_OK ){
199689 ** Otherwise, if successful, SQLITE_OK is returned. If an error occurs,
199715 if( rc!=SQLITE_OK || csr.nSegment==0 ) goto finished;
199719 if( rc!=SQLITE_OK ) goto finished;
199744 if( rc!=SQLITE_OK ) goto finished;
199757 while( SQLITE_OK==rc ){
199763 if( rc!=SQLITE_OK ) goto finished;
199770 if( rc!=SQLITE_OK ) goto finished;
199774 if( rc==SQLITE_OK ){
199792 int rc = SQLITE_OK;
199795 for(i=0; rc==SQLITE_OK && i<p->nIndex; i++){
199797 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
199803 if( rc==SQLITE_OK && p->bHasStat
199808 if( rc==SQLITE_OK ){
199821 if( rc==SQLITE_OK ){
199951 if( rc!=SQLITE_OK ){
199995 if( rc==SQLITE_OK ){
199998 if( rc==SQLITE_OK ){
200005 for(i=0; rc==SQLITE_OK && i<p->nIndex; i++){
200009 rc = SQLITE_OK;
200014 if( rc==SQLITE_OK ) rc = rc2;
200019 return (rc==SQLITE_OK && bReturnDone && bSeenDone) ? SQLITE_DONE : rc;
200036 if( rc==SQLITE_OK ){
200052 if( rc==SQLITE_OK ){
200064 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
200069 for(iCol=0; rc==SQLITE_OK && iCol<p->nColumn; iCol++){
200079 if( rc!=SQLITE_OK ){
200096 if( rc==SQLITE_OK ){
200133 if( rc==SQLITE_OK ){
200138 for(i=0; rc==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW && i<nSeg; i++){
200150 if( rc==SQLITE_OK ) rc = rc2;
200220 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
200229 if( *pRc==SQLITE_OK && nMin>pBlob->nAlloc ){
200246 ** Otherwise return SQLITE_OK. If there is no next entry on the node
200255 int rc = SQLITE_OK; /* Return code */
200272 if( rc==SQLITE_OK && ALWAYS(p->term.a!=0) ){
200301 ** If successful, SQLITE_OK is returned and the NodeReader object set to
200318 return aNode ? nodeReaderNext(p) : SQLITE_OK;
200344 int rc = SQLITE_OK;
200367 if( rc==SQLITE_OK ){
200375 if( rc==SQLITE_OK ){
200403 if( rc!=SQLITE_OK || iNextPtr==0 ) return rc;
200433 ** returned. Otherwise, SQLITE_OK.
200443 int rc = SQLITE_OK; /* Return code */
200454 if( rc!=SQLITE_OK ) return rc;
200479 return SQLITE_OK;
200486 ** Return SQLITE_OK if successful, or an SQLite error code otherwise.
200497 int rc = SQLITE_OK; /* Return code */
200535 if( rc==SQLITE_OK ){
200552 if( rc==SQLITE_OK ){
200570 ** If *pRc is not SQLITE_OK when this function is called, then no attempt
200574 ** Otherwise, if *pRc is initially SQLITE_OK and an error occurs while
200622 if( rc==SQLITE_OK ){
200635 if( pNode->block.n>0 && rc==SQLITE_OK ){
200643 if( rc==SQLITE_OK ){
200704 if( rc==SQLITE_OK ){
200741 if( rc==SQLITE_OK ){
200775 if( rc==SQLITE_OK && bAppendable ){
200780 if( rc==SQLITE_OK ){
200783 rc==SQLITE_OK && reader.aNode;
200796 if( rc==SQLITE_OK && bAppendable ){
200822 if( rc==SQLITE_OK ){
200828 for(i=nHeight; i>=0 && rc==SQLITE_OK; i--){
200835 while( reader.aNode && rc==SQLITE_OK ) rc = nodeReaderNext(&reader);
200837 if( rc==SQLITE_OK ){
200852 if( rc==SQLITE_OK ){
200866 if( rc==SQLITE_OK ) rc = rc2;
200875 ** one before returning SQLITE_OK. Or, if there are no segments at all
200890 if( rc==SQLITE_OK ){
200941 if( rc==SQLITE_OK ){
200949 if( rc!=SQLITE_OK ) return rc;
200953 if( rc==SQLITE_OK ){
200961 if( rc!=SQLITE_OK ) return rc;
200967 if( rc!=SQLITE_OK ) return rc;
200977 return SQLITE_OK;
201000 if( rc==SQLITE_OK ){
201028 if( rc==SQLITE_OK ){
201045 if( rc==SQLITE_OK ) rc = rc2;
201048 if( rc==SQLITE_OK ){
201051 if( rc==SQLITE_OK ){
201057 for(i=0; rc==SQLITE_OK && i<nIdx; i++){
201100 int rc = SQLITE_OK; /* Return code */
201108 if( rc!=SQLITE_OK ) return rc;
201113 rc==SQLITE_OK && reader.aNode;
201126 if( rc!=SQLITE_OK ) break;
201145 ** SQLITE_OK is returned if the segment is updated successfully. Or an
201155 int rc = SQLITE_OK; /* Return code */
201164 if( rc==SQLITE_OK ){
201175 if( rc==SQLITE_OK ) rc = rc2;
201178 while( rc==SQLITE_OK && iBlock ){
201184 if( rc==SQLITE_OK ){
201187 if( rc==SQLITE_OK ){
201194 if( rc==SQLITE_OK && iNewStart ){
201197 if( rc==SQLITE_OK ){
201205 if( rc==SQLITE_OK ){
201208 if( rc==SQLITE_OK ){
201242 int rc = SQLITE_OK;
201244 for(i=pCsr->nSegment-1; i>=0 && rc==SQLITE_OK; i--){
201259 if( rc==SQLITE_OK ){
201274 if( rc==SQLITE_OK && nRem!=pCsr->nSegment ){
201290 if( rc==SQLITE_OK ){
201306 ** table and return SQLITE_OK. Otherwise, if an error occurs, return an
201315 if( rc==SQLITE_OK ){
201323 if( rc==SQLITE_OK ){
201330 if( rc==SQLITE_OK ) rc = rc2;
201337 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
201342 ** If successful, leave *pRc set to SQLITE_OK and return. If an error occurs,
201352 if( *pRc==SQLITE_OK ){
201363 ** If no error occurs, return SQLITE_OK. If the hint blob in *pHint does
201383 return SQLITE_OK;
201415 while( rc==SQLITE_OK && nRem>0 ){
201443 if( rc==SQLITE_OK && hint.n ){
201487 if( rc==SQLITE_OK ){
201499 if( rc==SQLITE_OK ){
201502 if( SQLITE_OK==rc && pCsr->nSegment==nSeg
201503 && SQLITE_OK==(rc = sqlite3Fts3SegReaderStart(p, pCsr, pFilter))
201507 if( rc==SQLITE_OK ){
201521 if( rc==SQLITE_OK && pWriter->nLeafEst ){
201526 if( rc==SQLITE_OK ) rc = sqlite3Fts3SegReaderStep(p, pCsr);
201527 if( pWriter->nWork>=nRem && rc==SQLITE_ROW ) rc = SQLITE_OK;
201532 if( rc==SQLITE_OK ){
201555 if( bDirtyHint && rc==SQLITE_OK ){
201611 rc = SQLITE_OK;
201616 if( rc==SQLITE_OK ){
201636 int rc = SQLITE_OK;
201686 ** If successful, the checksum value is returned and *pRc set to SQLITE_OK.
201711 if( rc==SQLITE_OK ){
201715 if( rc==SQLITE_OK ){
201762 ** to true and return SQLITE_OK. Or if the contents do not match, set *pbOk
201769 int rc = SQLITE_OK; /* Return code */
201776 if( rc==SQLITE_OK ){
201780 while( rc==SQLITE_OK && sqlite3_step(pAllLangid)==SQLITE_ROW ){
201788 if( rc==SQLITE_OK ) rc = rc2;
201792 if( rc==SQLITE_OK ){
201805 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
201810 for(iCol=0; rc==SQLITE_OK && iCol<p->nColumn; iCol++){
201816 while( rc==SQLITE_OK ){
201823 if( rc==SQLITE_OK ){
201838 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
201847 rc = SQLITE_OK;
201850 *pbOk = (rc==SQLITE_OK && cksum1==cksum2);
201857 ** the FTS index are correct, return SQLITE_OK. Or, if the contents of the
201892 if( rc==SQLITE_OK && bOk==0 ) rc = FTS_CORRUPT_VTAB;
201930 rc = SQLITE_OK;
201934 rc = SQLITE_OK;
201937 rc = SQLITE_OK;
201941 rc = SQLITE_OK;
201985 int rc = SQLITE_OK; /* Return code */
201998 for(i=0; i<p->nColumn && rc==SQLITE_OK; i++){
202004 while( rc==SQLITE_OK ){
202011 for(pDef=pCsr->pDeferred; pDef && rc==SQLITE_OK; pDef=pDef->pNext){
202023 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
202027 for(pDef=pCsr->pDeferred; pDef && rc==SQLITE_OK; pDef=pDef->pNext){
202050 return SQLITE_OK;
202061 return SQLITE_OK;
202086 return SQLITE_OK;
202101 int rc = SQLITE_OK; /* Return code */
202105 if( bFound && rc==SQLITE_OK ){
202108 if( rc==SQLITE_OK ){
202151 int rc = SQLITE_OK; /* Return Code */
202194 if( rc!=SQLITE_OK ) goto update_out;
202241 if( rc!=SQLITE_OK ){
202252 if( nArg>1 && rc==SQLITE_OK ){
202260 if( rc==SQLITE_OK ){
202263 if( rc==SQLITE_OK ){
202291 if( rc==SQLITE_OK ){
202293 if( rc==SQLITE_OK || rc==SQLITE_DONE ){
202295 if( rc2!=SQLITE_OK ) rc = rc2;
202569 if( rc==SQLITE_OK && eType!=FTSQUERY_NOT ){
202584 ** If the callback function returns anything other than SQLITE_OK,
202586 ** Otherwise, SQLITE_OK is returned after a callback has been made for
202604 int rc = SQLITE_OK;
202643 return SQLITE_OK;
202787 assert( rc==SQLITE_OK || pCsr==0 );
202801 assert( rc!=SQLITE_OK || (
202846 if( rc!=SQLITE_OK ){
202870 if( rc==SQLITE_OK ){
202940 return SQLITE_OK;
203003 if( rc!=SQLITE_OK ){
203006 while( rc==SQLITE_OK && iCurrent<(nSnippet+nDesired) ){
203011 if( rc!=SQLITE_OK && rc!=SQLITE_DONE ){ return rc; }
203021 return SQLITE_OK;
203057 return SQLITE_OK;
203064 if( rc!=SQLITE_OK ){
203068 while( rc==SQLITE_OK ){
203087 if( rc!=SQLITE_OK ){
203110 if( rc==SQLITE_OK ){
203117 if( rc!=SQLITE_OK || iCurrent<iPos ) continue;
203131 if( rc==SQLITE_OK && isHighlight ) rc = fts3StringAppend(pOut, zOpen, -1);
203132 if( rc==SQLITE_OK ) rc = fts3StringAppend(pOut, &zDoc[iBegin], iFin-iBegin);
203133 if( rc==SQLITE_OK && isHighlight ) rc = fts3StringAppend(pOut, zClose, -1);
203206 return SQLITE_OK;
203216 int rc = SQLITE_OK;
203221 if( rc==SQLITE_OK ) rc = fts3ExprLHitGather(pExpr->pRight, p);
203277 int rc = SQLITE_OK;
203282 for(i=0; i<p->nCol && rc==SQLITE_OK; i++){
203310 return SQLITE_OK;
203365 if( rc!=SQLITE_OK ) return rc;
203384 return SQLITE_OK;
203414 return SQLITE_OK;
203446 ** array before returning. SQLITE_OK is returned in this case.
203457 int rc = SQLITE_OK;
203479 if( rc!=SQLITE_OK ) goto matchinfo_lcs_out;
203536 ** Return SQLITE_OK if successful, or an SQLite error code if an error
203537 ** occurs. If a value other than SQLITE_OK is returned, the state the
203546 int rc = SQLITE_OK;
203551 for(i=0; rc==SQLITE_OK && zArg[i]; i++){
203577 if( rc==SQLITE_OK ){
203597 if( rc==SQLITE_OK ){
203617 if( rc==SQLITE_OK ){
203635 if( rc!=SQLITE_OK ) break;
203639 if( rc!=SQLITE_OK ) break;
203643 if( rc!=SQLITE_OK ) break;
203669 int rc = SQLITE_OK;
203719 if( rc==SQLITE_OK ){
203726 if( rc==SQLITE_OK ){
203735 if( rc!=SQLITE_OK ){
203757 int rc = SQLITE_OK;
203812 if( rc!=SQLITE_OK ){
203833 for(i=0; i<nSnippet && rc==SQLITE_OK; i++){
203841 if( rc!=SQLITE_OK ){
203921 if( rc!=SQLITE_OK ) goto offsets_out;
203953 if( rc!=SQLITE_OK ) goto offsets_out;
203975 if( rc!=SQLITE_OK ) goto offsets_out;
203978 while( rc==SQLITE_OK ){
204001 while( rc==SQLITE_OK && iCurrent<iMinPos ){
204004 if( rc==SQLITE_OK ){
204016 rc = SQLITE_OK;
204020 if( rc!=SQLITE_OK ) goto offsets_out;
204027 if( rc!=SQLITE_OK ){
204176 return SQLITE_OK;
204245 return SQLITE_OK;
204291 int rc = SQLITE_OK;
204298 for(i=0; rc==SQLITE_OK && i<nArg; i++){
204323 if( rc!=SQLITE_OK ){
204363 return SQLITE_OK;
204374 return SQLITE_OK;
204442 return SQLITE_OK;
205228 ** the least recently used entry. Return SQLITE_OK on success or a
205263 return SQLITE_OK;
205384 return SQLITE_OK;
209685 if( rc==SQLITE_OK ){
209699 return SQLITE_OK;
209713 return SQLITE_OK;
209719 if( rc==SQLITE_OK ){
209747 return SQLITE_OK;
209808 int rc = SQLITE_OK;
209987 return SQLITE_OK;
209994 return SQLITE_OK;
210064 return SQLITE_OK;
210080 if( idxNum==0 ) return SQLITE_OK;
210092 return SQLITE_OK;
210103 if( zRoot==0 ) return SQLITE_OK;
210121 return SQLITE_OK;
210158 return SQLITE_OK;
210296 int rc = SQLITE_OK;
210305 for(i=0; i<sizeof(aMod)/sizeof(aMod[0]) && rc==SQLITE_OK; i++){
211024 int rc = SQLITE_OK;
211037 return SQLITE_OK;
211086 if( rc==SQLITE_OK && pNode && iNode==1 ){
211098 if( pNode && rc==SQLITE_OK ){
211105 if( rc==SQLITE_OK ){
211158 ** is successful, return SQLITE_OK.
211187 int rc = SQLITE_OK;
211200 if( pNode->iNode==0 && rc==SQLITE_OK ){
211213 int rc = SQLITE_OK;
211226 if( rc==SQLITE_OK ){
211359 return SQLITE_OK;
211383 if( rc==SQLITE_OK ){
211402 rc = SQLITE_OK;
211453 return SQLITE_OK;
211692 return SQLITE_OK;
211709 return SQLITE_OK;
211937 int rc = SQLITE_OK;
212007 return SQLITE_OK;
212015 int rc = SQLITE_OK;
212034 int rc = SQLITE_OK;
212036 if( rc==SQLITE_OK && ALWAYS(p) ){
212054 int rc = SQLITE_OK;
212058 if( NEVER(p==0) ) return SQLITE_OK;
212087 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
212094 return SQLITE_OK;
212100 ** return SQLITE_OK. If there is no such record in the table, set
212101 ** *ppLeaf to 0 and return SQLITE_OK. If an error occurs, set *ppLeaf
212154 return SQLITE_OK;
212171 int rc = SQLITE_OK;
212193 rc = SQLITE_OK;
212196 if( rc==SQLITE_OK && pLeaf!=0 ){
212213 if( rc==SQLITE_OK && argc>0 ){
212234 if( rc!=SQLITE_OK ){
212272 if( rc==SQLITE_OK ){
212331 int rc = SQLITE_OK;
212376 return SQLITE_OK;
212548 for(ii=0; rc==SQLITE_OK && ii<(pRtree->iDepth-iHeight); ii++){
212630 if( NEVER(rc!=SQLITE_OK) ){
212643 return SQLITE_OK;
212834 return SQLITE_OK;
212871 int rc = SQLITE_OK;
212921 if( rc!=SQLITE_OK ){
212930 if( SQLITE_OK!=(rc = nodeWrite(pRtree, pRight))
212931 || (0==pLeft->iNode && SQLITE_OK!=(rc = nodeWrite(pRtree, pLeft)))
212941 if( rc!=SQLITE_OK ){
212948 if( ALWAYS(rc==SQLITE_OK) ){
212951 assert( rc==SQLITE_OK );
212953 if( NEVER(rc!=SQLITE_OK) ){
212967 if( rc!=SQLITE_OK ){
212975 if( rc!=SQLITE_OK ){
212983 if( rc==SQLITE_OK ){
212987 if( rc==SQLITE_OK ){
213011 int rc = SQLITE_OK;
213013 while( rc==SQLITE_OK && pChild->iNode!=1 && pChild->pParent==0 ){
213014 int rc2 = SQLITE_OK; /* sqlite3_reset() return code */
213033 if( rc==SQLITE_OK ) rc = rc2;
213034 if( rc==SQLITE_OK && !pChild->pParent ){
213055 if( rc==SQLITE_OK ){
213059 testcase( rc!=SQLITE_OK );
213062 if( rc==SQLITE_OK ){
213065 if( rc!=SQLITE_OK ){
213072 if( SQLITE_OK!=(rc = sqlite3_reset(pRtree->pDeleteNode)) ){
213079 if( SQLITE_OK!=(rc = sqlite3_reset(pRtree->pDeleteParent)) ){
213092 return SQLITE_OK;
213097 int rc = SQLITE_OK;
213110 if( rc==SQLITE_OK ){
213126 if( SQLITE_OK!=(rc = fixLeafParent(pRtree, pNode)) ){
213163 int rc = SQLITE_OK;
213176 if( ALWAYS(rc==SQLITE_OK) ){
213189 int rc = SQLITE_OK;
213192 for(ii=0; rc==SQLITE_OK && ii<nCell; ii++){
213201 if( rc==SQLITE_OK ){
213205 if( rc==SQLITE_OK ){
213242 if( rc==SQLITE_OK ){
213247 assert( pLeaf!=0 || rc!=SQLITE_OK || CORRUPT_DB );
213251 if( rc==SQLITE_OK && pLeaf ){
213254 if( rc==SQLITE_OK ){
213258 if( rc==SQLITE_OK ){
213264 if( rc==SQLITE_OK ){
213278 if( rc==SQLITE_OK && pRtree->iDepth>0 && NCELL(pRoot)==1 ){
213283 if( rc==SQLITE_OK ){
213287 if( rc==SQLITE_OK ) rc = rc2;
213288 if( rc==SQLITE_OK ){
213297 if( rc==SQLITE_OK ){
213306 if( rc==SQLITE_OK ){
213371 if( rc==SQLITE_OK ){
213387 return (rc==SQLITE_OK ? SQLITE_CONSTRAINT : rc);
213402 int rc = SQLITE_OK;
213501 if( rc==SQLITE_OK && nData>1 ){
213511 if( rc==SQLITE_OK ){
213514 if( rc==SQLITE_OK ){
213518 if( rc==SQLITE_OK ){
213522 if( rc==SQLITE_OK && pRtree->nAux ){
213546 return SQLITE_OK;
213557 return SQLITE_OK;
213606 return SQLITE_OK;
213624 if( rc!=SQLITE_OK ){
213626 return rc==SQLITE_ERROR ? SQLITE_OK : rc;
213633 if( rc==SQLITE_OK ){
213697 int rc = SQLITE_OK;
213746 if( rc!=SQLITE_OK ){
213761 for(i=0; i<N_STATEMENT && rc==SQLITE_OK; i++){
213820 ** is written to *piVal and SQLITE_OK returned. Otherwise, an SQLite error
213828 if( rc==SQLITE_OK ){
213841 ** to. If successful, pRtree->iNodeSize is populated and SQLITE_OK returned.
213865 if( rc==SQLITE_OK ){
213879 if( rc!=SQLITE_OK ){
213918 int rc = SQLITE_OK;
213994 }else if( SQLITE_OK!=(rc = sqlite3_declare_vtab(db, zSql)) ){
214025 return SQLITE_OK;
214028 if( rc==SQLITE_OK ) rc = SQLITE_ERROR;
214145 ** and RtreeCheck.rc==SQLITE_OK, set RtreeCheck.rc to the error code.
214149 if( pCheck->rc==SQLITE_OK ) pCheck->rc = rc;
214171 if( pCheck->rc==SQLITE_OK ){
214192 if( pCheck->rc==SQLITE_OK && pCheck->nErr<RTREE_CHECK_MAX_ERROR ){
214226 if( pCheck->rc==SQLITE_OK && pCheck->pGetNode==0 ){
214233 if( pCheck->rc==SQLITE_OK ){
214247 if( pCheck->rc==SQLITE_OK && pRet==0 ){
214286 if( pCheck->rc!=SQLITE_OK ) return;
214429 if( pCheck->rc==SQLITE_OK ){
214475 check.rc = SQLITE_OK;
214494 if( check.rc==SQLITE_OK ){
214527 if( rc==SQLITE_OK && *pzErr ){
214589 if( rc==SQLITE_OK ){
214824 int rc = SQLITE_OK;
214880 if( pRc ) *pRc = SQLITE_OK;
214938 if( pRc ) *pRc = SQLITE_OK;
215264 if( pRc ) *pRc = SQLITE_OK;
215337 int rc = SQLITE_OK;
215340 if( rc==SQLITE_OK ){
215846 int rc = SQLITE_OK;
215896 }else if( SQLITE_OK!=(rc = sqlite3_declare_vtab(db, zSql)) ){
215913 return SQLITE_OK;
215916 if( rc==SQLITE_OK ) rc = SQLITE_ERROR;
215972 int rc = SQLITE_OK;
215989 if( rc==SQLITE_OK && pLeaf!=0 ){
216006 if( rc==SQLITE_OK && idxNum<=3 ){
216059 if( rc==SQLITE_OK ){
216127 return SQLITE_OK;
216136 return SQLITE_OK;
216142 return SQLITE_OK;
216153 int rc = SQLITE_OK;
216157 if( p==0 ) return SQLITE_OK;
216158 if( i==0 && sqlite3_vtab_nochange(ctx) ) return SQLITE_OK;
216173 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
216179 return SQLITE_OK;
216211 int rc = SQLITE_OK;
216271 if( rc==SQLITE_OK && (nData==1 || (coordChange && oldRowidValid)) ){
216279 if( rc==SQLITE_OK && nData>1 && coordChange ){
216286 if( rc==SQLITE_OK ){
216289 if( rc==SQLITE_OK ){
216293 if( rc==SQLITE_OK ){
216300 if( rc==SQLITE_OK && nData>1 ){
216312 && rc==SQLITE_OK
216392 int rc = SQLITE_OK;
216420 for(i=0; i<sizeof(aFunc)/sizeof(aFunc[0]) && rc==SQLITE_OK; i++){
216431 for(i=0; i<sizeof(aAgg)/sizeof(aAgg[0]) && rc==SQLITE_OK; i++){
216436 if( rc==SQLITE_OK ){
216456 if( rc==SQLITE_OK ){
216459 if( rc==SQLITE_OK ){
216462 if( rc==SQLITE_OK ){
216470 if( rc==SQLITE_OK ){
216475 if( rc==SQLITE_OK ){
217150 if( rc!=SQLITE_OK ){
217184 int rc = SQLITE_OK;
217187 for(i=0; rc==SQLITE_OK && i<(int)(sizeof(scalars)/sizeof(scalars[0])); i++){
217292 return SQLITE_OK;
217301 return SQLITE_OK;
217376 return SQLITE_OK;
217387 return SQLITE_OK;
217452 return SQLITE_OK;
217916 ** sqlite3rbu_close() returns any value other than SQLITE_OK, the contents
217990 ** SQLITE_OK if no error occurs but there remains work to do to apply
217995 ** SQLITE_OK, all subsequent calls on the same RBU handle are no-ops
218008 ** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
218026 ** Otherwise, if no error occurs, this function returns SQLITE_OK if the
218132 ** moved. The callback function should return SQLITE_OK to indicate
218506 char *zErrmsg; /* Error message if rc!=SQLITE_OK */
218841 ** SQLITE_OK.
218855 if( rc!=SQLITE_OK ){
218872 if( rc!=SQLITE_OK ){
218883 ** handle and SQLITE_OK is returned.
218978 ** If no error occurs, SQLITE_OK is returned and the iterator is left
218985 if( rc==SQLITE_OK ){
218999 if( rc==SQLITE_OK ){
219011 rc = (pIter->zDataTbl && pIter->zTbl) ? SQLITE_OK : SQLITE_NOMEM;
219018 if( rc==SQLITE_OK ){
219028 rc = pIter->zIdx ? SQLITE_OK : SQLITE_NOMEM;
219035 if( rc!=SQLITE_OK ){
219095 ** If no error occurs, SQLITE_OK is returned and the iterator is left
219113 if( rc==SQLITE_OK ){
219131 ** than SQLITE_OK), then this function returns NULL without modifying the
219140 if( p->rc==SQLITE_OK ){
219165 if( p->rc==SQLITE_OK ){
219189 if( p->rc==SQLITE_OK ){
219235 if( *pRc==SQLITE_OK ){
219260 if( p->rc==SQLITE_OK && rc!=SQLITE_OK ){
219323 assert( p->rc==SQLITE_OK );
219332 if( p->rc!=SQLITE_OK || sqlite3_step(aStmt[0])!=SQLITE_ROW ){
219354 if( p->rc==SQLITE_OK ){
219369 if( p->rc==SQLITE_OK ){
219395 if( p->rc==SQLITE_OK ){
219403 while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pList) ){
219414 while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){
219441 ** Return SQLITE_OK if successful, or an SQLite error code otherwise. If
219457 if( p->rc==SQLITE_OK && pIter->eType==RBU_PK_NOTABLE ){
219475 if( p->rc==SQLITE_OK ){
219479 for(i=0; p->rc==SQLITE_OK && i<nCol; i++){
219493 if( p->rc==SQLITE_OK
219507 if( p->rc==SQLITE_OK ){
219512 while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
219635 if( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pMax) ){
219645 if( p->rc==SQLITE_OK ){
219652 if( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pMax) ){
219705 while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){
219742 if( p->rc==SQLITE_OK ){
219750 if( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSel) ){
219822 if( rc==SQLITE_OK ){
219829 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){
219883 if( rc==SQLITE_OK ) rc = rc2;
219885 if( rc!=SQLITE_OK ){
219921 if( p->rc==SQLITE_OK && pIter->abIndexed ){
220026 if( p->rc==SQLITE_OK ){
220104 if( p->rc==SQLITE_OK ){
220112 while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXList) ){
220126 while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){
220161 if( p->rc==SQLITE_OK && pIter->eType==RBU_PK_EXTERNAL ){
220176 if( p->rc==SQLITE_OK ){
220189 while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){
220235 if( p->rc==SQLITE_OK && pIter->eType!=RBU_PK_VTAB ){
220242 for(iCol=0; p->rc==SQLITE_OK && iCol<pIter->nTblCol; iCol++){
220314 int rc = SQLITE_OK;
220325 for(i=0; rc==SQLITE_OK && i<nVal; i++){
220328 if( rc==SQLITE_OK ){
220333 if( rc!=SQLITE_OK ){
220345 if( rc==SQLITE_OK ){
220350 if( rc==SQLITE_OK ){
220353 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
220426 if( rc==SQLITE_OK ) rc = rc2;
220444 if( pIter->pSelect==0 && rbuObjIterCacheTableInfo(p, pIter)==SQLITE_OK ){
220483 if( p->rc==SQLITE_OK ){
220491 if( rbuIsVacuum(p)==0 && p->rc==SQLITE_OK ){
220499 if( p->rc==SQLITE_OK ){
220542 if( p->rc==SQLITE_OK ){
220575 if( p->rc==SQLITE_OK ){
220587 if( rbuIsVacuum(p)==0 && p->rc==SQLITE_OK ){
220644 if( p->rc==SQLITE_OK ){
220667 if( p->rc==SQLITE_OK ){
220729 return SQLITE_OK;
220779 if( p->rc==SQLITE_OK ){
220824 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
220878 if( rc==SQLITE_OK ) rc = rc2;
220902 if( p->rc==SQLITE_OK && rbuIsVacuum(p) ){
220920 if( p->rc==SQLITE_OK && rbuIsVacuum(p) ){
220930 if( p->rc==SQLITE_OK ){
220937 if( p->rc==SQLITE_OK
220944 if( p->rc==SQLITE_OK ) p->rc = rc2;
220946 if( p->rc==SQLITE_OK && bOk==0 ){
220951 if( p->rc==SQLITE_OK ){
220958 if( p->rc==SQLITE_OK && rbuIsVacuum(p) ){
220978 if( p->rc==SQLITE_OK && p->dbMain==0 ){
221018 if( p->rc==SQLITE_OK ){
221024 if( p->rc==SQLITE_OK ){
221030 if( p->rc==SQLITE_OK ){
221036 if( p->rc==SQLITE_OK ){
221044 if( p->rc==SQLITE_OK ){
221097 if( p->rc==SQLITE_OK ){
221101 if( p->rc==SQLITE_OK ){
221131 if( p->rc==SQLITE_OK ){
221164 if( p->rc==SQLITE_OK ){
221171 if( p->rc==SQLITE_OK && p->nFrame>0 ){
221178 if( p->rc==SQLITE_OK ){
221232 return SQLITE_OK;
221242 return SQLITE_OK;
221255 assert( p->rc==SQLITE_OK );
221271 ** Take an EXCLUSIVE lock on the database file. Return SQLITE_OK if
221275 int rc = SQLITE_OK;
221282 if( rc==SQLITE_OK ){
221290 if( rc==SQLITE_OK && fd->pMethods ){
221292 if( rc==SQLITE_OK ){
221353 assert( p->rc==SQLITE_OK && p->zErrmsg==0 );
221377 assert( p->rc==SQLITE_OK );
221381 if( p->rc==SQLITE_OK ){
221385 if( p->rc!=SQLITE_OK
221393 if( p->rc==SQLITE_OK ){
221482 assert( p->rc==SQLITE_OK );
221542 if( p->rc==SQLITE_OK ){
221555 ** If no error occurs, SQLITE_OK is returned. Otherwise, an error code
221579 if( p->rc==SQLITE_OK ) rbuStepOneOp(p, RBU_INSERT);
221592 for(i=0; p->rc==SQLITE_OK && i<pIter->nCol; i++){
221599 if( p->rc==SQLITE_OK
221607 if( p->rc==SQLITE_OK ){
221625 if( p->rc==SQLITE_OK ){
221633 if( p->rc==SQLITE_OK ){
221644 if( p->rc==SQLITE_OK ){
221656 if( p->rc==SQLITE_OK || p->rc==SQLITE_DONE ){
221688 assert( pInsert==0 || rc==SQLITE_OK );
221690 if( rc==SQLITE_OK ){
221694 if( rc!=SQLITE_OK ) p->rc = rc;
221717 if( p->rc==SQLITE_OK ){
221722 if( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pPragma) ){
221742 if( p->rc==SQLITE_OK ){
221750 while( p->rc==SQLITE_OK && sqlite3_step(pSql)==SQLITE_ROW ){
221755 if( p->rc!=SQLITE_OK ) return;
221757 if( p->rc==SQLITE_OK ){
221763 if( p->rc==SQLITE_OK ){
221769 while( p->rc==SQLITE_OK && sqlite3_step(pSql)==SQLITE_ROW ){
221777 if( p->rc==SQLITE_OK ){
221796 if( rbuIsVacuum(p) && p->nProgress==0 && p->rc==SQLITE_OK ){
221802 while( p->rc==SQLITE_OK && pIter->zTbl ){
221817 if( p->rc==SQLITE_OK ){
221832 if( p->rc==SQLITE_OK ){
221836 if( p->rc==SQLITE_OK ){
221839 if( p->rc==SQLITE_OK ){
221848 if( p->rc==SQLITE_OK ){
221856 if( p->rc==SQLITE_OK ){
221864 if( p->rc==SQLITE_OK ){
221867 if( p->rc==SQLITE_OK ){
221872 if( p->rc==SQLITE_OK ){
221895 && p->rc==SQLITE_OK
221934 assert( p->rc==SQLITE_OK );
221937 int rc = SQLITE_OK;
221939 while( rc==SQLITE_OK && pIter->zTbl && (pIter->bCleanup
221947 if( rc==SQLITE_OK && !pIter->zTbl ){
221952 if( rc==SQLITE_OK ){
221971 assert( pVfs && p->rc==SQLITE_OK && p->zErrmsg==0 );
221987 assert( p->rc==SQLITE_OK );
221991 if( p->rc==SQLITE_OK ){
222032 if( rc!=SQLITE_OK ){
222040 if( rc==SQLITE_OK ){
222066 if( p->rc==SQLITE_OK ){
222078 if( p->rc==SQLITE_OK ){
222083 if( p->rc==SQLITE_OK ){
222090 if( p->rc==SQLITE_OK && bExists ){
222095 if( p->rc==SQLITE_OK ){
222126 if( p->rc==SQLITE_OK ){
222154 if( p->rc==SQLITE_OK ){
222156 assert( pState || p->rc!=SQLITE_OK );
222157 if( p->rc==SQLITE_OK ){
222171 assert( p->rc!=SQLITE_OK || p->eStage!=0 );
222173 if( p->rc==SQLITE_OK && p->pTargetFd->pWalFd ){
222183 if( p->rc==SQLITE_OK
222200 if( p->rc==SQLITE_OK ){
222206 if( p->rc==SQLITE_OK ){
222212 if( p->rc==SQLITE_OK && p->objiter.zTbl==0 ){
222216 if( p->rc==SQLITE_OK && pState->eStage==0 && rbuIsVacuum(p) ){
222223 if( p->rc==SQLITE_OK ){
222230 if( p->rc==SQLITE_OK ){
222232 if( frc==SQLITE_OK ){
222238 if( p->rc==SQLITE_OK ){
222351 if( p->rc==SQLITE_OK && p->eStage==RBU_STAGE_OAL ){
222356 if( p->rc==SQLITE_OK && p->eStage==RBU_STAGE_CKPT ){
222363 if( p->rc==SQLITE_OK && p->eStage==RBU_STAGE_OAL ){
222375 if( rbuIsVacuum(p) && p->rc!=SQLITE_OK && p->dbRbu ){
222377 if( p->rc==SQLITE_DONE && rc2!=SQLITE_OK ) p->rc = rc2;
222467 if( p->rc!=SQLITE_OK && p->rc!=SQLITE_DONE ){
222482 if( rc==SQLITE_DONE ) return SQLITE_OK;
222487 if( rc==SQLITE_OK ) rc = sqlite3_exec(p->dbMain, "COMMIT", 0, 0, 0);
222491 if( rc==SQLITE_OK && p->eStage==RBU_STAGE_CKPT ){
222502 if( rc==SQLITE_OK ) rc = sqlite3_exec(p->dbRbu, "COMMIT", 0, 0, 0);
222503 if( rc==SQLITE_OK ){
222507 if( rc==SQLITE_OK ) rc = sqlite3_exec(p->dbMain, "BEGIN IMMEDIATE", 0, 0,0);
222518 int rc = SQLITE_OK;
222529 rc = SQLITE_OK;
222543 rc = rename(zOld, zNew) ? SQLITE_IOERR : SQLITE_OK;
222644 return SQLITE_OK;
222793 rc = SQLITE_OK;
222805 && pRbu->rc==SQLITE_OK
222809 if( rc==SQLITE_OK ){
222827 if( rc==SQLITE_OK && iOfst==0 && (p->openFlags & SQLITE_OPEN_MAIN_DB) ){
222865 if( rc!=SQLITE_OK ) return rc;
222870 if( rc==SQLITE_OK && iOfst==0 && (p->openFlags & SQLITE_OPEN_MAIN_DB) ){
222888 if( rc!=SQLITE_OK ) return rc;
222902 return SQLITE_OK;
222919 if( rc==SQLITE_OK && *pSize==0
222934 int rc = SQLITE_OK;
222990 if( rc==SQLITE_OK ){
222998 rc = SQLITE_OK;
223011 if( rc==SQLITE_OK && op==SQLITE_FCNTL_VFSNAME ){
223044 int rc = SQLITE_OK;
223067 if( bCapture && rc==SQLITE_OK ){
223087 int rc = SQLITE_OK;
223111 if( rc==SQLITE_OK ){
223121 if( rc==SQLITE_OK ){
223147 int rc = SQLITE_OK;
223213 int rc = SQLITE_OK;
223260 if( rc==SQLITE_OK ){
223321 if( rc==SQLITE_OK && flags==SQLITE_ACCESS_EXISTS ){
223477 int rc = SQLITE_OK;
223510 if( rc!=SQLITE_OK ){
223703 int rc = SQLITE_OK;
223720 if( rc==SQLITE_OK ){
223725 assert( rc==SQLITE_OK || pTab==0 );
223726 if( rc==SQLITE_OK ){
223741 return SQLITE_OK;
223822 return SQLITE_OK;
223842 return SQLITE_OK;
223901 return SQLITE_OK;
224025 if( rc!=SQLITE_OK ){
224037 return SQLITE_OK;
224042 return SQLITE_OK;
224061 if( sqlite3OsFileControl(fd, 230440, &x)==SQLITE_OK ){
224073 ** to page object pPg. Allocate the buffer if necessary. Return SQLITE_OK
224094 if( rc==SQLITE_OK ){
224175 return z==0 ? SQLITE_NOMEM_BKPT : SQLITE_OK;
224188 return SQLITE_OK;
224218 if( rc==SQLITE_OK ){
224225 if( rc==SQLITE_OK ){
224283 int rc = SQLITE_OK; /* Result of this operation */
224298 return SQLITE_OK;
224335 if( rc==SQLITE_OK ){
224400 return SQLITE_OK;
224406 return SQLITE_OK;
224443 SQLITE_PRIVATE int sqlite3DbstatRegister(sqlite3 *db){ return SQLITE_OK; }
224521 int rc = SQLITE_OK;
224531 if( rc==SQLITE_OK ){
224536 assert( rc==SQLITE_OK || pTab==0 );
224537 if( rc==SQLITE_OK ){
224551 return SQLITE_OK;
224612 return SQLITE_OK;
224631 return SQLITE_OK;
224641 return SQLITE_OK;
224648 int rc = SQLITE_OK;
224691 if( pCsr->iDb<0 ) return SQLITE_OK;
224696 if( NEVER(pBt==0) ) return SQLITE_OK;
224723 int rc = SQLITE_OK;
224737 if( rc==SQLITE_OK ){
224757 return SQLITE_OK;
224769 int rc = SQLITE_OK;
224813 if( rc==SQLITE_OK ){
224817 && (rc = sqlite3PagerWrite(pDbPage))==SQLITE_OK
224843 return SQLITE_OK;
224881 SQLITE_PRIVATE int sqlite3DbpageRegister(sqlite3 *db){ return SQLITE_OK; }
225268 ** If no error occurs, SQLITE_OK is returned. Or, if an OOM error occurs
225340 return SQLITE_OK;
225416 ** of *piHash asn *pbNullPK are undefined. Otherwise, SQLITE_OK is returned
225447 if( rc!=SQLITE_OK ) return rc;
225482 return SQLITE_OK;
225795 assert( rc==SQLITE_OK );
225838 ** SQLITE_OK.
225841 ** that case the hash-table does not grow, but SQLITE_OK is returned anyway.
225862 return SQLITE_OK;
225883 return SQLITE_OK;
225948 if( rc==SQLITE_OK ){
225969 if( rc!=SQLITE_OK ){
225986 if( rc==SQLITE_OK ){
225995 if( rc==SQLITE_OK ){
226042 if( rc==SQLITE_OK ){
226062 ** key, sqlite3_session.rc is left set to SQLITE_OK and non-zero returned to
226072 int rc = SQLITE_OK;
226081 if( rc==SQLITE_OK ){
226118 assert( pSession->rc==SQLITE_OK );
226124 if( pSession->rc==SQLITE_OK ){
226140 if( pSession->rc==SQLITE_OK ){
226267 if( *pRc==SQLITE_OK && nReq>p->nAlloc ){
226296 return (*pRc!=SQLITE_OK);
226301 ** This function is a no-op if *pRc is other than SQLITE_OK when it is
226331 if( *pRc==SQLITE_OK ){
226363 int rc = SQLITE_OK;
226374 if( rc==SQLITE_OK ){
226392 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
226406 if( pSession->rc==SQLITE_OK ) pSession->rc = rc;
226425 if( rc==SQLITE_OK && iCol==1 && sqlite3_value_type(pVal)==SQLITE_NULL ){
226435 if( rc==SQLITE_OK && iCol==1 && sqlite3_value_type(pVal)==SQLITE_NULL ){
226550 return SQLITE_OK;
226569 int rc = SQLITE_OK;
226621 if( rc!=SQLITE_OK ) goto error_out;
226637 assert( rc==SQLITE_OK );
226646 assert( trc==SQLITE_OK );
226649 assert( trc==SQLITE_OK );
226655 if( rc!=SQLITE_OK ) goto error_out;
226711 assert( rc==SQLITE_OK );
226723 if( rc!=SQLITE_OK ){
226733 int rc = SQLITE_OK;
226749 if( rc==SQLITE_OK ){
226760 assert( rc==SQLITE_OK || pRet==0 );
226796 assert( pSession->rc==SQLITE_OK );
226849 return SQLITE_OK;
226854 return SQLITE_OK;
226959 int rc = SQLITE_OK;
226969 if( rc==SQLITE_OK ){
227013 int rc = SQLITE_OK;
227033 if( rc==SQLITE_OK ){
227067 if( rc==SQLITE_OK ){
227081 if( rc==SQLITE_OK ){
227091 if( rc==SQLITE_OK ){
227116 if( rc==SQLITE_OK ){
227123 if( rc==SQLITE_OK ){
227128 if( rc==SQLITE_OK ){
227133 if( rc==SQLITE_OK ){
227181 return SQLITE_OK;
227265 int rc = SQLITE_OK;
227317 if( rc==SQLITE_OK ){
227321 if( rc==SQLITE_OK ){
227331 ** This function is a no-op if *pRc is other than SQLITE_OK when it is
227344 ** This function is a no-op if *pRc is other than SQLITE_OK when it is
227357 ** This function is a no-op if *pRc is other than SQLITE_OK when it is
227376 ** This function is a no-op if *pRc is other than SQLITE_OK when it is
227394 ** This function is a no-op if *pRc is other than SQLITE_OK when it is
227423 ** This function is a no-op if *pRc is other than SQLITE_OK when it is
227434 if( *pRc==SQLITE_OK ){
227497 int rc = SQLITE_OK;
227597 int rc = SQLITE_OK;
227662 int rc = SQLITE_OK;
227698 if( rc==SQLITE_OK ){
227737 if( rc==SQLITE_OK ){
227752 ** Return SQLITE_OK if all PK values are successfully bound, or an SQLite
227762 int rc = SQLITE_OK;
227765 for(i=0; i<nCol && rc==SQLITE_OK; i++){
227821 ** This function is a no-op if *pRc is set to other than SQLITE_OK when it
227844 ** If no error occurs, SQLITE_OK is returned and the new changeset/patchset
227866 ** object is already in the error state (sqlite3_session.rc != SQLITE_OK),
227876 if( rc!=SQLITE_OK ) return rc;
227880 for(pTab=pSession->pTable; rc==SQLITE_OK && pTab; pTab=pTab->pNext){
227891 if( rc==SQLITE_OK && pTab->nCol!=nOldCol ){
227899 if( rc==SQLITE_OK ){
227906 for(i=0; i<pTab->nChange && rc==SQLITE_OK; i++){
227909 for(p=pTab->apChange[i]; rc==SQLITE_OK && p; p=p->pNext){
227911 if( rc!=SQLITE_OK ) continue;
227927 if( rc==SQLITE_OK ){
227934 && rc==SQLITE_OK
227953 if( rc==SQLITE_OK ){
228087 int rc = SQLITE_OK;
228164 return SQLITE_OK;
228229 ** Return an SQLite error code if an error occurs, or SQLITE_OK otherwise.
228232 int rc = SQLITE_OK;
228234 while( !pIn->bEof && (pIn->iNext+nByte)>=pIn->nData && rc==SQLITE_OK ){
228238 if( SQLITE_OK==sessionBufferGrow(&pIn->buf, nNew, &rc) ){
228282 ** buffer. SQLITE_OK is returned if successful, or SQLITE_NOMEM if an OOM
228299 return SQLITE_OK;
228334 int rc = SQLITE_OK;
228338 for(i=0; i<nCol && rc==SQLITE_OK; i++){
228342 if( rc==SQLITE_OK ){
228356 if( rc==SQLITE_OK ){
228362 if( rc==SQLITE_OK ){
228403 ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error code.
228407 int rc = SQLITE_OK;
228412 if( rc==SQLITE_OK ){
228429 while( rc==SQLITE_OK ){
228445 ** If successful, SQLITE_OK is returned and *pnByte is set to the size of
228454 int rc = SQLITE_OK;
228457 for(i=0; rc==SQLITE_OK && i<nCol; i++){
228460 if( rc==SQLITE_OK ){
228489 ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error code
228496 assert( p->rc==SQLITE_OK );
228499 if( rc==SQLITE_OK ){
228514 if( rc==SQLITE_OK ){
228556 if( p->rc!=SQLITE_OK ) return p->rc;
228571 if( p->rc!=SQLITE_OK ) return p->rc;
228616 if( p->rc!=SQLITE_OK ) return p->rc;
228627 if( p->rc!=SQLITE_OK ) return p->rc;
228633 if( p->rc!=SQLITE_OK ) return p->rc;
228734 return SQLITE_OK;
228750 return SQLITE_OK;
228764 ** not modified. Otherwise, SQLITE_OK.
228778 return SQLITE_OK;
228792 ** not modified. Otherwise, SQLITE_OK.
228806 return SQLITE_OK;
228826 ** code is returned. Otherwise, SQLITE_OK.
228840 return SQLITE_OK;
228847 ** violations in the destination database and returns SQLITE_OK.
228859 return SQLITE_OK;
228870 int rc = SQLITE_OK;
228891 int rc = SQLITE_OK; /* Return value */
228950 assert( rc==SQLITE_OK );
228979 if( rc==SQLITE_OK ){
229003 if( rc!=SQLITE_OK ){
229015 assert( rc==SQLITE_OK );
229019 if( rc!=SQLITE_OK ) goto finished_invert;
229023 assert( rc==SQLITE_OK );
229126 int rc = SQLITE_OK;
229139 if( rc==SQLITE_OK ){
229145 rc = SQLITE_OK;
229150 if( rc==SQLITE_OK ){
229230 if( rc==SQLITE_OK ){
229235 if( rc!=SQLITE_OK ){
229247 assert( (rc==SQLITE_OK)==(pUp!=0) );
229286 ** If successful, SQLITE_OK is returned and SessionApplyCtx.pDelete is left
229296 int rc = SQLITE_OK;
229333 if( rc==SQLITE_OK ){
229351 ** If successful, SQLITE_OK is returned and SessionApplyCtx.pSelect is left
229371 ** If successful, SQLITE_OK is returned and SessionApplyCtx.pInsert is left
229379 int rc = SQLITE_OK;
229397 if( rc==SQLITE_OK ){
229416 if( rc==SQLITE_OK ){
229423 if( rc==SQLITE_OK ){
229468 ** An SQLite error code is returned if an error occurs. Otherwise, SQLITE_OK.
229478 int rc = SQLITE_OK;
229486 for(i=0; rc==SQLITE_OK && i<nCol; i++){
229508 ** has occured, the statement is reset and SQLITE_OK is returned. If an
229538 for(ii=0; rc==SQLITE_OK && ii<nCol; ii++){
229548 if( rc==SQLITE_OK ){
229564 ** Return SQLITE_OK if successful, or an SQLite error code otherwise.
229571 int rc = SQLITE_OK;
229633 ** is set to non-zero before returning SQLITE_OK.
229638 ** this function returns SQLITE_OK.
229664 rc = SQLITE_OK;
229679 }else if( rc==SQLITE_OK ){
229686 return SQLITE_OK;
229694 if( rc==SQLITE_OK ){
229712 if( rc==SQLITE_OK ){
229741 ** returns SQLITE_ABORT. Otherwise, if no error occurs, SQLITE_OK is
229755 int rc = SQLITE_OK;
229778 if( rc==SQLITE_OK && sqlite3_bind_parameter_count(p->pDelete)>nCol ){
229781 if( rc!=SQLITE_OK ) return rc;
229785 if( rc==SQLITE_OK && sqlite3_changes(p->db)==0 && p->bIgnoreNoop==0 ){
229803 for(i=0; rc==SQLITE_OK && i<nCol; i++){
229809 if( rc==SQLITE_OK && pNew ){
229813 if( rc!=SQLITE_OK ) return rc;
229816 ** the result will be SQLITE_OK with 0 rows modified. */
229820 if( rc==SQLITE_OK && sqlite3_changes(p->db)==0 ){
229849 if( rc==SQLITE_OK ){
229851 if( rc!=SQLITE_OK ) return rc;
229889 if( rc==SQLITE_OK ){
229910 if( rc==SQLITE_OK ){
229915 if( rc==SQLITE_OK ){
229919 if( rc==SQLITE_OK ){
229922 if( rc==SQLITE_OK ){
229942 int rc = SQLITE_OK;
229952 if( rc==SQLITE_OK ){
229961 if( rc==SQLITE_OK ) memset(pIter2->apValue, 0, nByte);
229963 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3changeset_next(pIter2) ){
229968 if( rc==SQLITE_OK ) rc = rc2;
229973 if( rc!=SQLITE_OK ) break;
230007 int rc = SQLITE_OK; /* Return code */
230024 if( rc==SQLITE_OK ){
230027 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3changeset_next(pIter) ){
230040 if( rc!=SQLITE_OK ) break;
230080 if( rc!=SQLITE_OK ) break;
230134 if( rc==SQLITE_OK ){
230140 if( rc==SQLITE_OK ){
230144 if( rc==SQLITE_OK ){
230161 if( rc==SQLITE_OK ){
230170 if( rc==SQLITE_OK && bPatchset==0 && sApply.bRebase ){
230217 if( rc==SQLITE_OK ){
230281 if( rc==SQLITE_OK ){
230338 int rc = SQLITE_OK;
230536 int rc = SQLITE_OK;
230546 if( rc==SQLITE_OK && pTab->pDfltStmt==0 ){
230549 for(ii=nCol; rc==SQLITE_OK && ii<pTab->nCol; ii++){
230562 if( SQLITE_OK==sessionBufferGrow(pOut, 8, &rc) ){
230617 ** object and return SQLITE_OK. Otherwise, if some error occurs, return
230626 int rc = SQLITE_OK;
230691 int rc = SQLITE_OK;
230712 if( rc==SQLITE_OK ){
230718 if( rc==SQLITE_OK && nCol<pTab->nCol ){
230726 if( rc==SQLITE_OK && sessionGrowHash(0, pIter->bPatchset, pTab) ){
230730 if( rc==SQLITE_OK ){
230752 if( rc==SQLITE_OK ){
230757 if( rc==SQLITE_OK && pChange ){
230763 if( rc==SQLITE_OK ) rc = pIter->rc;
230778 int rc = SQLITE_OK;
230782 if( rc!=SQLITE_OK ) break;
230785 if( rc==SQLITE_OK ) rc = pIter->rc;
230803 ** If successful, SQLITE_OK is returned. Or, if an error occurs, an SQLite
230814 int rc = SQLITE_OK;
230822 for(pTab=pGrp->pList; rc==SQLITE_OK && pTab; pTab=pTab->pNext){
230833 if( rc==SQLITE_OK && xOutput && buf.nBuf>=sessions_strm_chunk_size ){
230841 if( rc==SQLITE_OK ){
230859 int rc = SQLITE_OK; /* Return code */
230879 int rc = SQLITE_OK;
230905 if( rc==SQLITE_OK ){
230920 || pIter->rc!=SQLITE_OK
230953 if( rc==SQLITE_OK ){
230998 if( rc==SQLITE_OK ){
231001 if( rc==SQLITE_OK ){
231004 if( rc==SQLITE_OK ){
231027 if( rc==SQLITE_OK ){
231030 if( rc==SQLITE_OK ){
231033 if( rc==SQLITE_OK ){
231062 if( *pRc==SQLITE_OK ){
231111 if( *pRc==SQLITE_OK ){
231161 ** xOutput zero or more times and SQLITE_OK returned. Or, if xOutput is NULL,
231179 int rc = SQLITE_OK;
231209 if( pTab && rc==SQLITE_OK ){
231273 if( rc==SQLITE_OK && xOutput && sOut.nBuf>sessions_strm_chunk_size ){
231280 if( rc!=SQLITE_OK ){
231285 if( rc==SQLITE_OK ){
231304 int rc = SQLITE_OK;
231327 if( rc==SQLITE_OK ){
231345 if( rc==SQLITE_OK ){
231366 if( rc==SQLITE_OK ){
231389 int rc = SQLITE_OK;
231517 ** (not characters) of the buffer and SQLITE_OK is returned. Otherwise,
231532 ** the query within the current row. Return SQLITE_OK if successful, or
231549 ** first token of the phrase. SQLITE_OK is returned if successful, or an
231580 ** If the callback function returns any value other than SQLITE_OK, the
231582 ** If the returned value is SQLITE_DONE, xQueryPhrase returns SQLITE_OK.
231585 ** If the query runs to completion without incident, SQLITE_OK is returned.
231799 ** should be set to point to the new tokenizer handle and SQLITE_OK
231800 ** returned. If an error occurs, some value other than SQLITE_OK should
231854 ** If an xToken() callback returns any value other than SQLITE_OK, then
231857 ** input buffer is exhausted, xTokenize() should return SQLITE_OK. Finally,
231860 ** SQLITE_OK or SQLITE_DONE.
232802 ** rc==SQLITE_OK && 0==sqlite3Fts5ExprEof(pExpr);
234493 ** (rc==SQLITE_OK && 0==fts5CInstIterEof(&iter);
234515 ** an SQLite error code if an error occurs, or SQLITE_OK otherwise.
234518 int rc = SQLITE_OK;
234522 while( rc==SQLITE_OK && pIter->iInst<pIter->nInst ){
234525 if( rc==SQLITE_OK ){
234562 if( rc==SQLITE_OK ){
234597 ** If *pRc is set to any value other than SQLITE_OK when this function is
234606 if( *pRc==SQLITE_OK && z ){
234625 int rc = SQLITE_OK;
234630 if( tflags & FTS5_TOKEN_COLOCATED ) return SQLITE_OK;
234634 if( iPos<p->iRangeStart || iPos>p->iRangeEnd ) return SQLITE_OK;
234671 if( rc==SQLITE_OK ){
234720 rc = SQLITE_OK;
234722 if( rc==SQLITE_OK ){
234726 if( rc==SQLITE_OK ){
234734 if( rc==SQLITE_OK ){
234739 if( rc!=SQLITE_OK ){
234761 ** necessary. Return SQLITE_OK if successful, or SQLITE_NOMEM if an
234775 return SQLITE_OK;
234791 int rc = SQLITE_OK;
234839 for(i=0; i<nInst && rc==SQLITE_OK; i++){
234841 if( rc==SQLITE_OK && ic==iCol && iOff>=iPos && iOff<iEnd ){
234881 int rc = SQLITE_OK; /* Return code */
234917 if( rc==SQLITE_OK ){
234930 if( rc!=SQLITE_OK ) break;
234934 if( rc!=SQLITE_OK ) break;
234936 if( rc!=SQLITE_OK ) break;
234938 for(ii=0; rc==SQLITE_OK && ii<nInst; ii++){
234947 if( rc!=SQLITE_OK ) continue;
234952 if( rc==SQLITE_OK && nScore>nBestScore ){
234959 if( rc==SQLITE_OK && sFinder.nFirst && nDocsize>nToken ){
234971 if( rc==SQLITE_OK && nScore>nBestScore ){
234983 if( rc==SQLITE_OK ){
234986 if( rc==SQLITE_OK && nColSize==0 ){
234990 if( rc==SQLITE_OK ){
235003 while( ctx.iter.iStart>=0 && ctx.iter.iStart<iBestStart && rc==SQLITE_OK ){
235007 if( rc==SQLITE_OK ){
235019 if( rc==SQLITE_OK ){
235055 return SQLITE_OK;
235068 int rc = SQLITE_OK; /* Return code */
235093 if( rc==SQLITE_OK ) rc = pApi->xRowCount(pFts, &nRow);
235094 assert( rc!=SQLITE_OK || nRow>0 );
235095 if( rc==SQLITE_OK ) rc = pApi->xColumnTotalSize(pFts, -1, &nToken);
235096 if( rc==SQLITE_OK ) p->avgdl = (double)nToken / (double)nRow;
235099 for(i=0; rc==SQLITE_OK && i<nPhrase; i++){
235102 if( rc==SQLITE_OK ){
235122 if( rc!=SQLITE_OK ){
235127 if( rc!=SQLITE_OK ) p = 0;
235156 if( rc==SQLITE_OK ){
235161 for(i=0; rc==SQLITE_OK && i<nInst; i++){
235164 if( rc==SQLITE_OK ){
235171 if( rc==SQLITE_OK ){
235179 if( rc==SQLITE_OK ){
235203 int rc = SQLITE_OK; /* Return code */
235206 for(i=0; rc==SQLITE_OK && i<ArraySize(aBuiltin); i++){
235322 if( *pRc==SQLITE_OK ){
235340 if( *pRc==SQLITE_OK ){
235478 return SQLITE_OK;
235483 if( *pRc==SQLITE_OK ){
235504 if( *pRc==SQLITE_OK ){
235561 int rc = SQLITE_OK;
235572 int rc = SQLITE_OK;
235853 return iVal<0 ? SQLITE_ERROR : SQLITE_OK;
235860 ** If successful, object pConfig is updated and SQLITE_OK returned. If
235872 int rc = SQLITE_OK;
236046 ** Fts5Config.pTokenizer. Return SQLITE_OK if successful, or an SQLite error
236064 ** If *pRc is other than SQLITE_OK when this function is called, it is
236080 assert( *pRc==SQLITE_OK );
236115 int rc = SQLITE_OK;
236139 int rc = SQLITE_OK;
236164 ** If successful, SQLITE_OK is returned and *ppOut is set to point to the
236178 int rc = SQLITE_OK; /* Return code */
236199 if( rc==SQLITE_OK && sqlite3_stricmp(pRet->zName, FTS5_RANK_NAME)==0 ){
236204 assert( (pRet->abUnindexed && pRet->azCol) || rc!=SQLITE_OK );
236205 for(i=3; rc==SQLITE_OK && i<nArg; i++){
236228 if( rc==SQLITE_OK ){
236251 if( rc==SQLITE_OK
236265 if( rc==SQLITE_OK && pRet->bContentlessDelete && pRet->bColumnsize==0 ){
236275 if( rc==SQLITE_OK && pRet->pTok==0 ){
236280 if( rc==SQLITE_OK && pRet->zContent==0 ){
236298 if( rc==SQLITE_OK && pRet->zContentRowid==0 ){
236303 if( rc==SQLITE_OK ){
236307 if( rc!=SQLITE_OK ){
236341 ** object passed as the only argument. Return SQLITE_OK if successful, or
236346 int rc = SQLITE_OK;
236383 ** This function returns SQLITE_OK if successful or an SQLite error code
236386 ** still returns SQLITE_OK. Or, if the tokenization was abandoned early
236397 if( pText==0 ) return SQLITE_OK;
236445 int rc = SQLITE_OK;
236464 if( rc==SQLITE_OK ){
236469 if( rc==SQLITE_OK ){
236485 if( rc!=SQLITE_OK ){
236501 int rc = SQLITE_OK;
236583 if( rc==SQLITE_OK ){
236589 rc = SQLITE_OK;
236617 int rc = SQLITE_OK;
236634 assert( rc==SQLITE_OK || p==0 );
236635 if( rc==SQLITE_OK ){
236649 if( rc==SQLITE_OK
236665 if( rc==SQLITE_OK ){
236822 if( rc==SQLITE_OK ){
236831 assert_expr_depth_ok(SQLITE_OK, pChild);
236844 if( pParse->rc==SQLITE_OK ){
236952 }while( sParse.rc==SQLITE_OK && t!=FTS5_EOF );
236959 if( iCol<pConfig->nCol && sParse.pExpr && sParse.rc==SQLITE_OK ){
236969 assert( sParse.rc!=SQLITE_OK || sParse.zErr==0 );
236970 if( sParse.rc==SQLITE_OK ){
237023 ** GLOB. If successful, SQLITE_OK is returned. Otherwise, an SQLite error
237031 int rc = SQLITE_OK;
237130 if( sParse.rc==SQLITE_OK ){
237194 int rc = SQLITE_OK;
237240 if( iMin==FTS5_LARGEST_INT64 || rc!=SQLITE_OK ) break;
237244 if( rc==SQLITE_OK ){
237263 ** SQLITE_OK is returned if an error occurs, or an SQLite error code
237276 int rc = SQLITE_OK;
237334 if( rc!=SQLITE_OK ) goto ismatch_out;
237396 ** If in/out parameter (*pRc) is set to other than SQLITE_OK when this
237424 if( rc!=SQLITE_OK ){
237536 int rc = SQLITE_OK;
237541 for(p=pTerm; rc==SQLITE_OK && p; p=p->pSynonym){
237550 if( rc!=SQLITE_OK ){
237587 for(i=0; rc==SQLITE_OK && i<pNear->nPhrase; i++){
237616 ** SQLITE_OK. It is not considered an error if some term matches zero
237631 return SQLITE_OK;
237652 assert( (rc==SQLITE_OK)==(p->pIter!=0) );
237653 if( rc!=SQLITE_OK ) return rc;
237661 return SQLITE_OK;
237668 return SQLITE_OK;
237752 ** SQLITE_OK is returned if an error occurs, or an SQLite error code
237762 int rc = SQLITE_OK;
237813 pNode->bNomatch = ((0==fts5ExprNearTest(&rc, pExpr, pNode)) && rc==SQLITE_OK);
237823 ** Return SQLITE_OK if successful, or an SQLite error code if an error
237833 int rc = SQLITE_OK;
237856 if( rc!=SQLITE_OK ) break;
237883 assert( rc==SQLITE_OK );
237913 return SQLITE_OK;
237934 if( rc==SQLITE_OK && sqlite3Fts5IterEof(pIter)==0 ){
237979 if( rc!=SQLITE_OK ){
237988 return SQLITE_OK;
238000 int rc = SQLITE_OK;
238013 if( rc!=SQLITE_OK ){
238043 return SQLITE_OK;
238053 if( rc==SQLITE_OK ){
238065 int rc = SQLITE_OK;
238070 while( rc==SQLITE_OK && p1->bEof==0 ){
238076 assert( rc!=SQLITE_OK || cmp<=0 );
238096 if( rc==SQLITE_OK ){
238099 if( rc!=SQLITE_OK ){
238106 ** If pNode currently points to a match, this function returns SQLITE_OK
238114 int rc = SQLITE_OK;
238152 ** Return an SQLite error code if an error occurs, or SQLITE_OK otherwise.
238156 int rc = SQLITE_OK;
238168 for(i=0; i<pNode->nChild && rc==SQLITE_OK; i++){
238192 if( rc==SQLITE_OK ){
238211 ** Return SQLITE_OK if successful, or an SQLite error code otherwise. It
238224 if( rc==SQLITE_OK
238232 while( pRoot->bNomatch && rc==SQLITE_OK ){
238242 ** Return SQLITE_OK if successful, or an SQLite error code otherwise. It
238251 assert( pRoot->bNomatch==0 || (rc==SQLITE_OK && pRoot->bEof==0) );
238268 int rc = SQLITE_OK;
238323 if( pParse->rc==SQLITE_OK ){
238351 assert( pParse->rc!=SQLITE_OK );
238396 int rc = SQLITE_OK;
238404 if( pCtx->rc!=SQLITE_OK ) return pCtx->rc;
238442 if( rc==SQLITE_OK ){
238447 if( pCtx->pConfig->bTokendata && rc==SQLITE_OK ){
238495 return SQLITE_OK;
238519 if( rc==SQLITE_OK ){
238563 int rc = SQLITE_OK; /* Return code */
238573 if( rc==SQLITE_OK ){
238577 if( rc==SQLITE_OK ){
238581 if( rc==SQLITE_OK ){
238585 if( rc==SQLITE_OK && ALWAYS(pOrig!=0) ){
238599 if( rc==SQLITE_OK ){
238603 for(i=0; rc==SQLITE_OK && i<pOrig->nTerm; i++){
238606 for(p=&pOrig->aTerm[i]; p && rc==SQLITE_OK; p=p->pSynonym){
238610 if( rc==SQLITE_OK ){
238622 if( rc==SQLITE_OK && ALWAYS(sCtx.pPhrase) ){
238709 assert( pParse->rc==SQLITE_OK );
238775 if( pParse->rc==SQLITE_OK ){
238790 assert( pParse->rc!=SQLITE_OK );
238799 ** SQLITE_OK when this function is called, NULL is returned.
238854 if( pParse->rc==SQLITE_OK ){
239027 if( pParse->rc==SQLITE_OK ){
239100 assert( pParse->rc!=SQLITE_OK );
239454 if( rc==SQLITE_OK ){
239457 if( rc==SQLITE_OK ){
239474 if( rc!=SQLITE_OK ){
239563 int rc = SQLITE_OK;
239566 for(i=0; rc==SQLITE_OK && i<ArraySize(aFunc); i++){
239571 int rc = SQLITE_OK;
239715 if( rc==SQLITE_OK && pExpr->pConfig->bTokendata && !pT->bPrefix ){
239727 return SQLITE_OK;
239830 int rc = SQLITE_OK;
239879 return SQLITE_OK;
239897 int rc = SQLITE_OK;
240024 int rc = SQLITE_OK;
240124 return SQLITE_OK;
240216 if( rc!=SQLITE_OK ) return rc;
240322 return SQLITE_OK;
240420 return SQLITE_OK;
240460 return SQLITE_OK;
241321 if( p->rc==SQLITE_OK ){
241322 int rc = SQLITE_OK;
241333 if( rc!=SQLITE_OK ){
241336 if( rc==SQLITE_ABORT ) rc = SQLITE_OK;
241341 if( p->pReader==0 && rc==SQLITE_OK ){
241355 if( rc==SQLITE_OK ){
241367 if( rc==SQLITE_OK ){
241370 if( rc!=SQLITE_OK ){
241384 assert( (pRet==0)==(p->rc!=SQLITE_OK) );
241414 if( p->rc==SQLITE_OK ){
241432 if( p->rc!=SQLITE_OK ) return;
241456 if( p->rc!=SQLITE_OK ) return;
241494 if( p->rc==SQLITE_OK ){
241533 return SQLITE_OK;
241539 ** This function is a no-op if (*pRc) is not SQLITE_OK when it is called. If
241544 if( *pRc==SQLITE_OK && p->nRef>1 ){
241582 ** SQLITE_OK returned.
241590 int rc = SQLITE_OK;
241631 for(iLvl=0; rc==SQLITE_OK && iLvl<nLevel; iLvl++){
241648 if( rc==SQLITE_OK ){
241677 if( nSegment!=0 && rc==SQLITE_OK ) rc = FTS5_CORRUPT;
241682 if( rc!=SQLITE_OK ){
241698 assert( (ppStruct!=0 && (*ppStruct)!=0) || (*pRc)!=SQLITE_OK );
241699 if( *pRc==SQLITE_OK ){
241729 if( *pRc==SQLITE_OK ){
241758 if( p->rc==SQLITE_OK ){
241762 if( p->rc==SQLITE_OK && (pConfig->pgsz==0 || pConfig->iCookie!=iCookie) ){
241766 if( p->rc!=SQLITE_OK ){
241778 if( p->rc==SQLITE_OK ){
241810 if( p->rc==SQLITE_OK ){
241838 if( p->rc!=SQLITE_OK ) return 0;
241889 if( p->rc==SQLITE_OK ){
241943 int rc = SQLITE_OK;
242012 if( p->rc==SQLITE_OK ){
242135 return p->rc!=SQLITE_OK || pIter->aLvl[0].bEof;
242142 for(i=pIter->nLvl-1; p->rc==SQLITE_OK && i>=0; i--){
242243 for(i=0; p->rc==SQLITE_OK && bDone==0; i++){
242263 if( p->rc==SQLITE_OK ){
242272 if( p->rc!=SQLITE_OK ){
242350 if( p->rc==SQLITE_OK ){
242386 if( p->rc==SQLITE_OK ) p->rc = FTS5_CORRUPT;
242496 if( p->rc==SQLITE_OK ){
242503 }while( p->rc==SQLITE_OK && pIter->pLeaf && pIter->pLeaf->nn==4 );
242506 if( p->rc==SQLITE_OK && pIter->pLeaf ){
242592 while( p->rc==SQLITE_OK && pIter->iLeafPgno>pIter->iTermLeafPgno ){
242644 return (p->rc==SQLITE_OK && pSeg->pLeaf && pSeg->nPos==0);
242693 assert( p->rc==SQLITE_OK );
243030 assert( p->rc==SQLITE_OK );
243201 if( p->rc==SQLITE_OK && (bGe==0 || (flags & FTS5INDEX_QUERY_SCANONETERM)) ){
243229 assert_nc( p->rc!=SQLITE_OK /* 1 */
243270 assert( p->rc==SQLITE_OK );
243303 assert( p->rc!=SQLITE_OK ||
243329 assert( p->rc==SQLITE_OK );
243475 if( p->rc==SQLITE_OK ){
243587 while( p->rc==SQLITE_OK ){
243655 if( bMove && p->rc==SQLITE_OK ) pIter->xNext(p, pIter, 0);
243660 }while( p->rc==SQLITE_OK );
243684 for(i=(pIter->nSeg+iChanged)/2; i>=iMinset && p->rc==SQLITE_OK; i=i/2){
243688 assert( p->rc==SQLITE_OK );
243848 while( p->rc==SQLITE_OK ){
243852 assert( p->rc==SQLITE_OK );
243886 if( p->rc==SQLITE_OK ){
243893 assert( p->rc==SQLITE_OK );
243905 && (p->rc==SQLITE_OK)
244140 ** This function is a no-op if *pRc is other than SQLITE_OK when it is
244150 if( *pRc==SQLITE_OK ){
244333 assert( pIter!=0 || (*pRc)!=SQLITE_OK );
244334 if( *pRc==SQLITE_OK ){
244374 if( p->rc==SQLITE_OK ) pSeg->xNext(p, pSeg, 0);
244421 if( p->rc==SQLITE_OK ){
244432 assert( p->rc!=SQLITE_OK );
244443 if( p->rc==SQLITE_OK ){
244475 if( p->rc==SQLITE_OK ){
244483 assert( (*ppOut)!=0 || p->rc!=SQLITE_OK );
244531 assert( pIter!=0 || p->rc!=SQLITE_OK );
244532 assert( p->rc!=SQLITE_OK
244588 if( p->rc==SQLITE_OK ){
244623 if( p->rc==SQLITE_OK ){
244648 p->flushRc = SQLITE_OK;
244699 if( p->rc==SQLITE_OK && nLvl>=pWriter->nDlidx ){
244751 if( p->rc==SQLITE_OK ){
244779 if( p->rc==SQLITE_OK ){
244827 for(i=0; p->rc==SQLITE_OK && bDone==0; i++){
244844 if( p->rc==SQLITE_OK && pDlidx[1].buf.n==0 ){
244935 assert( p->rc==SQLITE_OK );
244943 if( p->rc!=SQLITE_OK ) return;
244979 if( p->rc!=SQLITE_OK ) return;
245011 if( p->rc==SQLITE_OK ){
245051 assert( p->pConfig->pgsz>0 || p->rc!=SQLITE_OK );
245052 while( p->rc==SQLITE_OK
245082 if( p->rc==SQLITE_OK ){
245133 if( p->rc==SQLITE_OK ){
245154 for(i=0; i<pIter->nSeg && p->rc==SQLITE_OK; i++){
245187 if( p->rc==SQLITE_OK ){
245318 if( p->rc==SQLITE_OK && bTermWritten==0 ){
245347 assert( pIter!=0 || p->rc!=SQLITE_OK );
245433 while( nRem>0 && p->rc==SQLITE_OK ){
245462 if( p->rc==SQLITE_OK && pStruct->aLevel[iBestLvl].nMerge==0 ){
245485 if( p->rc==SQLITE_OK && p->pConfig->nAutomerge>0 && ALWAYS((*ppStruct)!=0) ){
245509 while( p->rc==SQLITE_OK && pStruct->aLevel[iLvl].nSeg>=nCrisis ){
245511 assert( p->rc!=SQLITE_OK || pStruct->nLevel>(iLvl+1) );
245521 p->rc = SQLITE_OK;
245574 if( p->rc==SQLITE_OK ){
245605 for(pgno=iPgno; p->rc==SQLITE_OK && pgno<=pSeg->pgnoLast; pgno++){
245945 if( p->rc==SQLITE_OK ){
246000 if( p->rc==SQLITE_OK
246054 if( p->rc==SQLITE_OK ){
246057 while( p->rc==SQLITE_OK && 0==sqlite3Fts5HashScanEof(pHash) ){
246067 if( p->rc!=SQLITE_OK ) break;
246083 while( p->rc==SQLITE_OK && iOff<nDoclist ){
246105 if( p->rc!=SQLITE_OK || pDoclist[iOff]==0x01 ){
246112 if( p->rc==SQLITE_OK && bTermWritten==0 ){
246115 assert( p->rc!=SQLITE_OK || writer.bFirstRowidInPage==0 );
246127 if( p->rc!=SQLITE_OK ) break;
246164 while( p->rc==SQLITE_OK ){
246189 if( p->rc==SQLITE_OK ) sqlite3Fts5HashScanNext(pHash);
246193 assert( p->rc!=SQLITE_OK || bSecureDelete || pgnoLast>0 );
246201 if( p->rc==SQLITE_OK ){
246237 if( p->rc==SQLITE_OK ){
246320 assert( p->rc==SQLITE_OK );
246322 assert( p->rc!=SQLITE_OK || p->nContentlessDelete==0 );
246324 assert( p->rc!=SQLITE_OK || pStruct!=0 );
246336 while( p->rc==SQLITE_OK && pNew->aLevel[iLvl].nSeg>0 ){
246396 if( p->rc==SQLITE_OK && 0==fts5BufferGrow(&p->rc, pBuf, nByte) ){
246688 if( p->rc==SQLITE_OK ) p->rc = FTS5_CORRUPT;
246751 assert( p->rc!=SQLITE_OK || (aBuf && pStruct) );
246753 if( p->rc==SQLITE_OK ){
246811 for(i=0; p->rc==SQLITE_OK && doclist.n; i++){
246839 if( p->rc==SQLITE_OK ){
246868 assert( p->rc==SQLITE_OK );
246895 assert( p->rc==SQLITE_OK );
246911 /* assert( p->rc==SQLITE_OK ); */
246912 return SQLITE_OK;
246937 ** If successful, set *pp to point to the new object and return SQLITE_OK.
246946 int rc = SQLITE_OK;
246950 if( rc==SQLITE_OK ){
246958 if( rc==SQLITE_OK ){
246964 if( rc==SQLITE_OK ){
246970 assert( rc!=SQLITE_OK || p->rc==SQLITE_OK );
246982 int rc = SQLITE_OK;
247062 int rc = SQLITE_OK; /* Return code */
247065 assert( p->rc==SQLITE_OK );
247073 for(i=0; i<pConfig->nPrefix && rc==SQLITE_OK; i++){
247156 if( p->rc==SQLITE_OK ){
247206 if( p->rc==SQLITE_OK ){
247374 && pIndex->rc==SQLITE_OK
247381 if( pIndex->rc==SQLITE_OK ){
247417 while( p->rc==SQLITE_OK ){
247506 if( p->rc==SQLITE_OK && pSet ){
247518 if( p->rc==SQLITE_OK ){
247609 assert( p->rc!=SQLITE_OK );
247613 if( p->rc==SQLITE_OK ){
247640 assert( pIter->pIndex->rc==SQLITE_OK );
247656 assert( pIter->pIndex->rc==SQLITE_OK );
247659 if( p->rc==SQLITE_OK ){
247746 return SQLITE_OK;
247816 if( p->rc==SQLITE_OK && pData->nn ){
247834 assert( p->rc==SQLITE_OK );
247851 ** Return SQLITE_OK if successful, or an SQLite error code if an error
247860 assert( p->rc==SQLITE_OK );
247866 if( rc==SQLITE_OK ){
247884 ** disk. If successful, SQLITE_OK is returned and (*piOrigin) set to
248114 if( p->rc==SQLITE_OK ){
248130 assert( p->rc==SQLITE_OK );
248158 assert( p->rc!=SQLITE_OK );
248175 assert( p->rc==SQLITE_OK || (nHash==0 && apHash==0) );
248196 ** rows from origin iOrigin. Return SQLITE_OK if successful, or an SQLite
248291 if( p->rc==SQLITE_OK && cksum1!=cksum2 ) p->rc = FTS5_CORRUPT;
248309 while( rc==SQLITE_OK && ALWAYS(pIter!=0) && 0==sqlite3Fts5IterEof(pIter) ){
248325 if( rc==SQLITE_OK ){
248382 if( rc==SQLITE_OK && (pPrev->n!=n || memcmp(pPrev->p, z, n)) ){
248394 if( rc==SQLITE_OK ){
248398 if( rc==SQLITE_OK && ck1!=ck2 ) rc = FTS5_CORRUPT;
248414 if( iIdx>0 && rc==SQLITE_OK ){
248418 if( rc==SQLITE_OK && ck1!=ck2 ) rc = FTS5_CORRUPT;
248420 if( iIdx>0 && rc==SQLITE_OK ){
248424 if( rc==SQLITE_OK && ck1!=ck2 ) rc = FTS5_CORRUPT;
248431 if( rc==SQLITE_OK && cksum3!=expected ){
248463 for(i=iFirst; p->rc==SQLITE_OK && i<=iLast; i++){
248481 while( ii<pLeaf->nn && p->rc==SQLITE_OK ){
248511 if( p->rc==SQLITE_OK ){
248543 while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
248663 if( p->rc==SQLITE_OK ) p->rc = rc2;
248667 if( p->rc==SQLITE_OK && iter.iLeaf!=pSeg->pgnoLast ){
248680 ** checksum does not match. Return SQLITE_OK if all checks pass without
248702 assert( p->rc!=SQLITE_OK );
248759 if( p->rc==SQLITE_OK && bUseCksum && cksum!=cksum2 ) p->rc = FTS5_CORRUPT;
248873 if( rc!=SQLITE_OK ){
248971 ** If *pRc is other than SQLITE_OK when this function is called, it is a
249009 if( *pRc==SQLITE_OK ){
249038 int rc = SQLITE_OK; /* Return code */
249123 while( iOff<szLeaf && rc==SQLITE_OK ){
249203 while( iPgidxOff<n && rc==SQLITE_OK ){
249249 if( rc==SQLITE_OK ){
249321 int rc = SQLITE_OK;
249328 if( rc==SQLITE_OK ){
249354 rc = SQLITE_OK;
249369 return SQLITE_OK;
249376 int rc = SQLITE_OK;
249382 return SQLITE_OK;
249392 return SQLITE_OK;
249414 return SQLITE_OK;
249432 return SQLITE_OK;
249483 return SQLITE_OK;
249498 int rc = SQLITE_OK;
249510 if( rc==SQLITE_OK ){
249527 ** If successful, SQLITE_OK is returned. If an error occurs, some other
249536 if( rc==SQLITE_OK ){
249543 if( rc==SQLITE_OK ){
249549 if( rc==SQLITE_OK ){
249581 return SQLITE_OK;
249926 return SQLITE_OK;
249935 if( rc==SQLITE_OK ){
249963 int rc = SQLITE_OK; /* Return code */
249969 if( rc==SQLITE_OK ){
249971 assert( (rc==SQLITE_OK && *pzErr==0) || pConfig==0 );
249973 if( rc==SQLITE_OK ){
249979 if( rc==SQLITE_OK ){
249984 if( rc==SQLITE_OK ){
249991 if( rc==SQLITE_OK ){
249996 if( rc==SQLITE_OK ){
250004 if( rc==SQLITE_OK && pConfig->eContent==FTS5_CONTENT_NORMAL ){
250007 if( rc==SQLITE_OK ){
250011 if( rc!=SQLITE_OK ){
250199 return SQLITE_OK;
250285 return SQLITE_OK;
250291 if( pCsr->base.pVtab==(sqlite3_vtab*)pTab ) return SQLITE_OK;
250307 if( rc==SQLITE_OK ){
250403 return SQLITE_OK;
250412 rc = SQLITE_OK;
250420 rc = SQLITE_OK;
250469 ** Return SQLITE_OK if successful or if no reseek was required, or an
250473 int rc = SQLITE_OK;
250481 if( rc==SQLITE_OK && iRowid!=sqlite3Fts5ExprRowid(pCsr->pExpr) ){
250500 ** Return SQLITE_OK if nothing goes wrong. SQLITE_OK is returned
250533 rc = SQLITE_OK;
250550 if( rc!=SQLITE_OK ){
250556 rc = SQLITE_OK;
250585 if( rc!=SQLITE_OK ){
250632 if( rc==SQLITE_OK ){
250639 if( rc!=SQLITE_OK ){
250670 int rc = SQLITE_OK; /* Return code */
250715 int rc = SQLITE_OK;
250727 assert( rc==SQLITE_OK || pCsr->pRankArgStmt==0 );
250728 if( rc==SQLITE_OK ){
250734 if( rc==SQLITE_OK ){
250743 assert( rc!=SQLITE_OK );
250749 if( rc==SQLITE_OK ){
250768 int rc = SQLITE_OK;
250779 if( rc==SQLITE_OK ){
250831 int rc = SQLITE_OK; /* Error code */
250891 if( rc==SQLITE_OK ){
250895 if( rc!=SQLITE_OK ) goto filter_out;
250912 if( rc==SQLITE_OK ){
250916 if( rc!=SQLITE_OK ) goto filter_out;
250949 if( rc!=SQLITE_OK ) goto filter_out;
250973 assert( rc==SQLITE_OK );
250975 if( rc==SQLITE_OK ){
250996 if( rc==SQLITE_OK ){
251065 return SQLITE_OK;
251070 ** Return SQLITE_OK if no error occurs, or an SQLite error code otherwise.
251076 int rc = SQLITE_OK;
251085 assert( rc!=SQLITE_OK || pTab->p.base.zErrMsg==0 );
251089 if( rc==SQLITE_OK && CsrFlagTest(pCsr, FTS5CSR_REQUIRE_CONTENT) ){
251098 rc = SQLITE_OK;
251102 if( rc==SQLITE_OK ){
251130 ** statement. This function returns SQLITE_OK if successful, or an SQLite
251143 int rc = SQLITE_OK;
251184 if( rc==SQLITE_OK ){
251187 if( rc==SQLITE_OK ){
251190 if( rc==SQLITE_OK ){
251199 if( rc==SQLITE_OK && bLoadConfig ){
251211 int rc = SQLITE_OK;
251227 if( rc==SQLITE_OK ){
251230 if( rc==SQLITE_OK ){
251259 int rc = SQLITE_OK; /* Return code */
251273 if( rc!=SQLITE_OK ) return rc;
251369 if( rc==SQLITE_OK ){
251375 if( rc==SQLITE_OK ){
251378 if( rc==SQLITE_OK ){
251391 if( rc==SQLITE_OK
251399 if( rc==SQLITE_OK ){
251427 return SQLITE_OK;
251438 return SQLITE_OK;
251510 int rc = SQLITE_OK;
251522 if( rc==SQLITE_OK ){
251537 int rc = SQLITE_OK;
251548 for(i=0; i<pConfig->nCol && rc==SQLITE_OK; i++){
251551 if( rc==SQLITE_OK ){
251566 if( rc==SQLITE_OK ){
251586 ** correctly for the current view. Return SQLITE_OK if successful, or an
251590 int rc = SQLITE_OK;
251607 for(i=0; i<nIter && rc==SQLITE_OK; i++){
251611 if( rc==SQLITE_OK ){
251616 if( rc==SQLITE_OK ){
251665 int rc = SQLITE_OK;
251667 || SQLITE_OK==(rc = fts5CacheInstArray(pCsr)) ){
251681 int rc = SQLITE_OK;
251683 || SQLITE_OK==(rc = fts5CacheInstArray(pCsr))
251714 return SQLITE_OK;
251721 int rc = SQLITE_OK;
251736 for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
251742 if( rc==SQLITE_OK ){
251789 int rc = SQLITE_OK;
251802 return SQLITE_OK;
251856 if( rc==SQLITE_OK ){
251902 int rc = SQLITE_OK;
251916 if( rc==SQLITE_OK ){
251925 if( rc==SQLITE_OK ){
251965 int rc = SQLITE_OK;
251967 || SQLITE_OK==(rc = fts5CacheInstArray(pCsr))
252029 if( rc==SQLITE_OK ){
252037 if( rc==SQLITE_OK ){
252039 rc==SQLITE_OK && CsrFlagTest(pNew, FTS5CSR_EOF)==0;
252043 if( rc!=SQLITE_OK ){
252044 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
252133 int rc = SQLITE_OK;
252160 for(i=0; rc==SQLITE_OK && i<(nPhrase-1); i++){
252168 for(i=0; rc==SQLITE_OK && i<nPhrase; i++){
252196 int rc = SQLITE_OK;
252221 if( pCsr->pRank || SQLITE_OK==(rc = fts5FindRankFunction(pCsr)) ){
252228 if( rc==SQLITE_OK ){
252294 int rc = SQLITE_OK;
252298 if( rc==SQLITE_OK ){
252311 int rc = SQLITE_OK;
252315 if( rc==SQLITE_OK ){
252329 int rc = SQLITE_OK;
252351 if( rc==SQLITE_OK ){
252392 int rc = SQLITE_OK;
252443 int rc = SQLITE_OK;
252466 int rc = SQLITE_OK;
252478 if( rc!=SQLITE_OK ){
252489 if( rc!=SQLITE_OK ){
252578 if( *pzErr==0 && rc!=SQLITE_OK ){
252582 rc = (*pzErr) ? SQLITE_OK : SQLITE_NOMEM;
252640 if( rc==SQLITE_OK ) rc = sqlite3Fts5IndexInit(db);
252641 if( rc==SQLITE_OK ) rc = sqlite3Fts5ExprInit(pGlobal, db);
252642 if( rc==SQLITE_OK ) rc = sqlite3Fts5AuxInit(&pGlobal->api);
252643 if( rc==SQLITE_OK ) rc = sqlite3Fts5TokenizerInit(&pGlobal->api);
252644 if( rc==SQLITE_OK ) rc = sqlite3Fts5VocabInit(pGlobal, db);
252645 if( rc==SQLITE_OK ){
252650 if( rc==SQLITE_OK ){
252663 if( rc==SQLITE_OK ){
252763 ** Return SQLITE_OK if successful, or an SQLite error code if an error
252772 int rc = SQLITE_OK;
252870 if( rc!=SQLITE_OK && pzErrMsg ){
252907 ** Drop all shadow tables. Return SQLITE_OK if successful or an SQLite error
252919 if( rc==SQLITE_OK && pConfig->bColumnsize ){
252925 if( rc==SQLITE_OK && pConfig->eContent==FTS5_CONTENT_NORMAL ){
252940 if( *pRc==SQLITE_OK ){
252966 ** SQLITE_OK if successful, or an SQLite error code otherwise.
253000 ** If successful, set *pp to point to the new object and return SQLITE_OK.
253010 int rc = SQLITE_OK;
253044 if( rc==SQLITE_OK && pConfig->bColumnsize ){
253051 if( rc==SQLITE_OK ){
253056 if( rc==SQLITE_OK ){
253072 int rc = SQLITE_OK;
253126 int rc = SQLITE_OK; /* Return code */
253133 if( rc!=SQLITE_OK ) return rc;
253142 for(iCol=1; rc==SQLITE_OK && iCol<=pConfig->nCol; iCol++){
253167 if( rc==SQLITE_OK && p->nTotalRow<1 ){
253174 if( rc==SQLITE_OK ) rc = rc2;
253181 ** iDel. If successful, SQLITE_OK is returned. Or, if an error occurs,
253187 int rc = SQLITE_OK;
253195 if( rc==SQLITE_OK ){
253203 if( rc==SQLITE_OK && iOrigin!=0 ){
253223 int rc = SQLITE_OK;
253227 if( rc==SQLITE_OK ){
253234 if( rc==SQLITE_OK ){
253252 ** Return SQLITE_OK if successful, or an SQLite error code if an error
253256 int rc = SQLITE_OK;
253268 ** Return SQLITE_OK if successful, or an SQLite error code if an error
253275 int rc = SQLITE_OK;
253282 if( rc==SQLITE_OK ){
253302 if( rc==SQLITE_OK ){
253306 if( rc==SQLITE_OK ){
253315 if( rc==SQLITE_OK && pConfig->bColumnsize ){
253317 if( rc==SQLITE_OK ){
253326 if( rc==SQLITE_OK ){
253329 if( rc==SQLITE_OK ){
253355 if( rc==SQLITE_OK && pConfig->bColumnsize ){
253364 if( rc==SQLITE_OK ){
253367 if( rc==SQLITE_OK ){
253383 if( rc==SQLITE_OK ){
253387 if( rc==SQLITE_OK ){
253391 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pScan) ){
253396 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
253413 if( rc==SQLITE_OK ){
253419 if( rc==SQLITE_OK ) rc = rc2;
253422 if( rc==SQLITE_OK ){
253454 if( rc==SQLITE_OK ){
253460 if( rc==SQLITE_OK ){
253476 int rc = SQLITE_OK;
253489 for(i=1; rc==SQLITE_OK && i<=pConfig->nCol+1; i++){
253492 if( rc==SQLITE_OK ){
253511 int rc = SQLITE_OK; /* Return code */
253519 if( rc==SQLITE_OK ){
253522 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
253540 if( rc==SQLITE_OK ){
253561 if( rc==SQLITE_OK ){
253602 int rc = SQLITE_OK;
253632 if( rc==SQLITE_OK && bPresent==0 ){
253638 for(ii=0; rc==SQLITE_OK && ii<pCtx->pConfig->nPrefix; ii++){
253656 ** table. Return SQLITE_OK if they do, or SQLITE_CORRUPT if not. Return
253662 int rc = SQLITE_OK; /* Return code */
253683 if( rc==SQLITE_OK ){
253692 if( rc==SQLITE_OK && pConfig->eDetail==FTS5_DETAIL_NONE ){
253695 for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
253702 if( rc==SQLITE_OK ){
253712 if( rc==SQLITE_OK && pConfig->bColumnsize && ctx.szCol!=aColSize[i] ){
253724 if( rc!=SQLITE_OK ) break;
253727 if( rc==SQLITE_OK ) rc = rc2;
253731 if( rc==SQLITE_OK ){
253734 for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
253741 if( rc==SQLITE_OK && pConfig->eContent==FTS5_CONTENT_NORMAL ){
253744 if( rc==SQLITE_OK && nRow!=p->nTotalRow ) rc = FTS5_CORRUPT;
253746 if( rc==SQLITE_OK && pConfig->bColumnsize ){
253749 if( rc==SQLITE_OK && nRow!=p->nTotalRow ) rc = FTS5_CORRUPT;
253756 if( rc==SQLITE_OK ){
253780 if( rc==SQLITE_OK ){
253827 ** An SQLite error code is returned if an error occurs, or SQLITE_OK
253839 assert( rc==SQLITE_OK );
253849 if( bCorrupt && rc==SQLITE_OK ){
253853 assert( rc!=SQLITE_OK );
253861 if( rc==SQLITE_OK ){
253879 if( rc==SQLITE_OK ){
253895 int rc = SQLITE_OK;
253899 if( rc==SQLITE_OK ){
253903 if( rc==SQLITE_OK ){
253923 if( rc==SQLITE_OK ){
253934 if( rc==SQLITE_OK && pVal ){
253937 if( rc==SQLITE_OK ){
254012 int rc = SQLITE_OK;
254025 for(i=0; rc==SQLITE_OK && i<nArg-1; i+=2){
254036 if( rc==SQLITE_OK && i<nArg ) rc = SQLITE_ERROR;
254037 if( rc!=SQLITE_OK ){
254069 int rc = SQLITE_OK;
254080 while( is<nText && rc==SQLITE_OK ){
254114 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
254204 int rc = SQLITE_OK;
254295 return SQLITE_OK;
254306 int rc = SQLITE_OK; /* Return code */
254328 for(i=0; rc==SQLITE_OK && i<nArg-1; i+=2){
254333 if( rc==SQLITE_OK ){
254337 for(i=0; rc==SQLITE_OK && i<nArg-1; i+=2){
254362 if( i<nArg && rc==SQLITE_OK ) rc = SQLITE_ERROR;
254367 if( rc!=SQLITE_OK ){
254396 int rc = SQLITE_OK;
254411 while( rc==SQLITE_OK ){
254488 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
254529 int rc = SQLITE_OK;
254545 if( rc==SQLITE_OK ){
254551 if( rc!=SQLITE_OK ){
255236 int rc = SQLITE_OK;
255245 for(i=0; rc==SQLITE_OK && i<nArg-1; i+=2){
255263 if( i<nArg && rc==SQLITE_OK ) rc = SQLITE_ERROR;
255269 if( rc!=SQLITE_OK ){
255289 int rc = SQLITE_OK;
255305 if( iCode==0 ) return SQLITE_OK;
255333 if( iCode==0 || rc!=SQLITE_OK ) break;
255390 int rc = SQLITE_OK; /* Return code */
255393 for(i=0; rc==SQLITE_OK && i<ArraySize(aBuiltin); i++){
256629 ** value and return SQLITE_OK. Otherwise, set *pzErr to an error message
256633 int rc = SQLITE_OK;
256635 if( rc==SQLITE_OK ){
256664 return SQLITE_OK;
256673 return SQLITE_OK;
256712 int rc = SQLITE_OK; /* Return code */
256730 if( rc==SQLITE_OK ){
256848 return SQLITE_OK;
256861 int rc = SQLITE_OK;
256879 assert( rc==SQLITE_OK || pStmt==0 );
256880 if( rc==SQLITE_ERROR ) rc = SQLITE_OK;
256889 if( rc==SQLITE_OK ){
256893 if( rc==SQLITE_OK ){
256904 if( rc==SQLITE_OK ){
256944 return SQLITE_OK;
256948 int rc = SQLITE_OK;
256971 int rc = SQLITE_OK;
256985 if( rc==SQLITE_OK ){
257008 if( rc!=SQLITE_OK ) return rc;
257035 return SQLITE_OK;
257045 while( rc==SQLITE_OK ){
257099 if( rc==SQLITE_OK ){
257104 if( rc==SQLITE_OK ){
257117 if( rc==SQLITE_OK && pCsr->bEof==0 && pTab->eType==FTS5_VOCAB_COL ){
257139 int rc = SQLITE_OK;
257179 if( rc==SQLITE_OK ){
257182 if( rc==SQLITE_OK ){
257186 if( rc==SQLITE_OK && eType==FTS5_VOCAB_INSTANCE ){
257189 if( rc==SQLITE_OK && !pCsr->bEof
257272 return SQLITE_OK;
257286 return SQLITE_OK;
257434 if( rc==SQLITE_OK ){
257449 return SQLITE_OK;
257462 return SQLITE_OK;
257481 return SQLITE_OK;
257493 return SQLITE_OK;
257512 return SQLITE_OK;
257522 return SQLITE_OK;
257596 return SQLITE_OK;
257612 return SQLITE_OK;
257650 int rc = SQLITE_OK;
257666 int rc = SQLITE_OK;