Lines Matching defs:SQLITE_OK
645 ** ^Calls to sqlite3_close() and sqlite3_close_v2() return [SQLITE_OK] if
658 ** it returns [SQLITE_OK] regardless, but instead of deallocating the database
770 #define SQLITE_OK 0 /* Successful result */
901 #define SQLITE_OK_LOAD_PERMANENTLY (SQLITE_OK | (1<<8))
902 #define SQLITE_OK_SYMLINK (SQLITE_OK | (2<<8)) /* internal only */
1364 ** file control returns [SQLITE_OK], then the parser assumes that the
1369 ** any result code other than [SQLITE_OK] or [SQLITE_NOTFOUND], that means
1454 ** If the [SQLITE_FCNTL_BEGIN_ATOMIC_WRITE] opcode returns SQLITE_OK, then
1470 ** This file control returns [SQLITE_OK] if and only if the writes were
1789 ** directory. The xAccess method returns [SQLITE_OK] on success or some
1791 ** the file given in the second argument is illegal. If SQLITE_OK
1967 ** ^The sqlite3_initialize() routine returns [SQLITE_OK] on success.
1970 ** as a mutex) it returns an [error code] other than [SQLITE_OK].
2007 ** must return [SQLITE_OK] on success and some other [error code] upon
2046 ** ^When a configuration option is set, sqlite3_config() returns [SQLITE_OK].
2066 ** ^Calls to sqlite3_db_config() return SQLITE_OK if and only if
3709 ** return [SQLITE_OK] to allow the action, [SQLITE_IGNORE] to disallow the
3713 ** any value other than [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY]
3717 ** When the callback returns [SQLITE_OK], that means the operation
3736 ** been read if [SQLITE_OK] had been returned. The [SQLITE_IGNORE]
3794 ** return either [SQLITE_OK] or one of these two constants in order
4045 ** [SQLITE_OK] is returned. Otherwise an [error code] is returned.)^ ^The
4584 ** This function returns SQLITE_OK if the error code and error message are
4866 ** ^On success, the sqlite3_prepare() family of routines return [SQLITE_OK];
5094 ** This routine returns SQLITE_OK if the explain mode is successfully
5317 ** ^The sqlite3_bind_* routines return [SQLITE_OK] on success or an
5917 ** SQLITE_OK. ^If the most recent evaluation of statement S failed, then
5956 ** [SQLITE_OK].
7237 ** [SQLITE_OK] to indicate success, [SQLITE_ERROR] if the type is unsupported,
7515 ** from sqlite3_autovacuum_pages() is normally SQLITE_OK, but might
7517 ** implementation will only return SQLITE_OK or SQLITE_MISUSE, but other
7632 ** ^(This routine returns [SQLITE_OK] if shared cache was enabled or disabled
7771 ** interface returns SQLITE_OK and fills in the non-NULL pointers in
7777 ** table and returns SQLITE_OK if the table exists and SQLITE_ERROR if it
7867 ** [SQLITE_OK] on success and [SQLITE_ERROR] if something goes wrong.
8426 ** ^(On success, [SQLITE_OK] is returned and the new [BLOB handle] is stored
8577 ** ^(On success, sqlite3_blob_read() returns SQLITE_OK.
8597 ** ^(On success, sqlite3_blob_write() returns SQLITE_OK.
8746 ** SQLITE_BUSY. ^The sqlite3_mutex_try() interface returns [SQLITE_OK]
8840 ** called, but only if the prior call to xMutexInit returned SQLITE_OK.
9061 ** SQLITE_OK if N is within bounds and SQLITE_ERROR if not. If either Z
9217 ** [SQLITE_MAX_LENGTH], or [SQLITE_OK] if there have been no errors.
9257 ** SQLITE_OK on success and a non-zero [error code] on failure.
9370 ** ^The sqlite3_db_status() routine returns SQLITE_OK on success and a
9938 ** are still more pages to be copied, then the function returns [SQLITE_OK].
9942 ** then an [error code] is returned. ^As well as [SQLITE_OK] and
10001 ** ^The value returned by sqlite3_backup_finish is [SQLITE_OK] if no
10133 ** returns SQLITE_OK.
10294 ** ^The callback function should normally return [SQLITE_OK]. ^If an error
10465 ** databases, SQLITE_OK is returned.
10468 ** mode, SQLITE_OK is returned and both *pnLog and *pnCkpt set to -1. ^If
10560 ** return SQLITE_OK. Or, if this is not possible, it may return
10862 ** rc==SQLITE_OK && pVal;
10873 ** routines return SQLITE_OK and set *P to point to the first or next value
10903 ** ^The sqlite3_vtab_rhs_value(P,J,V) interface returns SQLITE_OK if
10907 ** can return a result code other than SQLITE_OK or SQLITE_NOTFOUND if
11115 ** ^Otherwise, if no error occurs, [sqlite3_db_cacheflush()] returns SQLITE_OK.
11284 ** created [sqlite3_snapshot] object into *P and returns SQLITE_OK.
11341 ** database. ^The [sqlite3_snapshot_open()] interface returns SQLITE_OK
11361 ** read transaction is undefined. If SQLITE_OK is returned, then the
11443 ** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
11843 ** a pointer to the new object is written to *ppSession and SQLITE_OK is
12012 ** SQLITE_OK is returned if the call completes without error. Or, if an error
12076 ** SQLITE_OK. If an error occurs, set both *ppChangeset and *pnChangeset to
12248 ** If the operation is successful, SQLITE_OK is returned. Otherwise, an SQLite
12327 ** If successful, *pp is set to point to the iterator handle and SQLITE_OK
12442 ** If no error occurs, SQLITE_OK is returned. If an error does occur, an
12477 ** SQLITE_OK is returned and the output variables populated as described
12505 ** returns SQLITE_OK. The name of the function comes from the fact that this
12536 ** returns SQLITE_OK. If the change is an UPDATE and does not include
12538 ** SQLITE_OK returned. The name of the function comes from the fact that
12568 ** and returns SQLITE_OK.
12586 ** violations in the destination database and returns SQLITE_OK.
12612 ** to that error is returned by this function. Otherwise, SQLITE_OK is
12621 ** if( rc!=SQLITE_OK ){
12646 ** SQLITE_OK is returned. If an error occurs, both *pnOut and *ppOut are
12675 ** if( rc==SQLITE_OK ) rc = sqlite3changegroup_add(pGrp, nA, pA);
12676 ** if( rc==SQLITE_OK ) rc = sqlite3changegroup_add(pGrp, nB, pB);
12677 ** if( rc==SQLITE_OK ){
12713 ** If successful, this function returns SQLITE_OK and populates (*pp) with
12853 ** changegroup is undefined. If no error occurs, SQLITE_OK is returned.
12865 ** If the change is successfully added to the changegroup, SQLITE_OK is
12900 ** variables (*pnData) and (*ppData) are set to 0. Otherwise, SQLITE_OK
13384 ** point to the new object and return SQLITE_OK. Otherwise, if an error
13413 ** (*pnOut) to its size in bytes and SQLITE_OK returned. It is the
13481 ** before returning SQLITE_OK. If the input is completely exhausted, (*pnData)
13515 ** supplied data, it should return SQLITE_OK to indicate success. Otherwise,
13654 ** This function returns SQLITE_OK if successful, or an SQLite error code
13739 ** If successful, SQLITE_OK is returned. Otherwise, if an error occurs, an
13781 ** If this call is successful, SQLITE_OK is returned. Otherwise, if an
13842 ** discarded. In this case this function is always successful and SQLITE_OK
13877 ** If the call is successful, SQLITE_OK is returned. Otherwise, if an error
13996 ** (not characters) of the buffer and SQLITE_OK is returned. Otherwise,
14011 ** the query within the current row. Return SQLITE_OK if successful, or
14028 ** first token of the phrase. SQLITE_OK is returned if successful, or an
14059 ** If the callback function returns any value other than SQLITE_OK, the
14061 ** If the returned value is SQLITE_DONE, xQueryPhrase returns SQLITE_OK.
14064 ** If the query runs to completion without incident, SQLITE_OK is returned.
14240 ** If successful, SQLITE_OK is returned. Or, if an error occurs, an
14329 ** should be set to point to the new tokenizer handle and SQLITE_OK
14330 ** returned. If an error occurs, some value other than SQLITE_OK should
14391 ** If an xToken() callback returns any value other than SQLITE_OK, then
14394 ** input buffer is exhausted, xTokenize() should return SQLITE_OK. Finally,
14397 ** SQLITE_OK or SQLITE_DONE.
17013 # define sqlite3PagerWalWriteLock(y,z) SQLITE_OK
18443 #define sqlite3_mutex_try(X) SQLITE_OK
18448 #define sqlite3MutexInit() SQLITE_OK
22034 # define sqlite3FaultSim(X) SQLITE_OK
22318 # define sqlite3AuthCheck(a,b,c,d,e) SQLITE_OK
22572 # define sqlite3ExprCheckIN(x,y) SQLITE_OK
22616 # define sqlite3VtabSync(X,Y) SQLITE_OK
22624 # define sqlite3VtabSavepoint(X, Y, Z) SQLITE_OK
25019 #define sqlite3VdbeMemExpandBlob(x) SQLITE_OK
25020 #define ExpandBlob(P) SQLITE_OK
25166 return SQLITE_OK;
25219 int rc = SQLITE_OK; /* Return code */
26113 return SQLITE_OK;
26269 rc = p->isLocal ? SQLITE_OK : toLocaltime(p, pCtx);
26322 rc = SQLITE_OK;
27390 return flags ? id->pMethods->xSync(id, flags) : SQLITE_OK;
27493 return SQLITE_OK;
27496 return SQLITE_OK;
27519 assert( rc==SQLITE_OK || pFile->pMethods==0 );
27525 return pVfs->xDelete!=0 ? pVfs->xDelete(pVfs, zPath, dirSync) : SQLITE_OK;
27567 return SQLITE_OK;
27609 if( rc!=SQLITE_OK ){
27619 assert( *ppFile!=0 || rc!=SQLITE_OK );
27719 return SQLITE_OK;
27735 return SQLITE_OK;
27865 static int sqlite3MemInit(void *NotUsed){ return SQLITE_OK; }
28135 return SQLITE_OK;
28151 return SQLITE_OK;
28381 return SQLITE_OK;
29287 return SQLITE_OK;
29917 return SQLITE_OK;
30157 if( SQLITE_OK==pGlobalMutexMethods->xMutexTry(pCheck->mutex) ){
30223 int rc = SQLITE_OK;
30269 int rc = SQLITE_OK;
30324 ** Obtain the mutex p. If successful, return SQLITE_OK. Otherwise, if another
30328 int rc = SQLITE_OK;
30418 static int noopMutexInit(void){ return SQLITE_OK; }
30419 static int noopMutexEnd(void){ return SQLITE_OK; }
30428 return SQLITE_OK;
30481 static int debugMutexInit(void){ return SQLITE_OK; }
30482 static int debugMutexEnd(void){ return SQLITE_OK; }
30536 ** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK
30552 return SQLITE_OK;
30700 static int pthreadMutexInit(void){ return SQLITE_OK; }
30701 static int pthreadMutexEnd(void){ return SQLITE_OK; }
30842 ** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK
30910 rc = SQLITE_OK;
30915 rc = SQLITE_OK;
30928 rc = SQLITE_OK;
30935 if( rc==SQLITE_OK && p->trace ){
31223 return SQLITE_OK;
31238 return SQLITE_OK;
31350 ** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK
31410 rc = SQLITE_OK;
31555 return SQLITE_OK;
31646 if( rc!=SQLITE_OK ) memset(&mem0, 0, sizeof(mem0));
35568 return SQLITE_OK;
35579 rc = SQLITE_OK;
35581 rc = pthread_join(p->tid, ppOut) ? SQLITE_ERROR : SQLITE_OK;
35662 return SQLITE_OK;
35688 return (rc==WAIT_OBJECT_0) ? SQLITE_OK : SQLITE_ERROR;
35731 return SQLITE_OK;
35754 return SQLITE_OK;
36036 if( rc!=SQLITE_OK ){
36185 return SQLITE_OK;
36200 int rc = SQLITE_OK;
36217 if( rc==SQLITE_OK ){
36391 ** In deployment, sqlite3FaultSim() *always* return SQLITE_OK (0). The
36408 return xCallback ? xCallback(iTest) : SQLITE_OK;
36503 ** The equivalent of sqlite3Error(db, SQLITE_OK). Clear the error state
36508 db->errCode = SQLITE_OK;
36551 ** should be called with err_code set to SQLITE_OK and zFormat set
39649 return SQLITE_OK;
39687 return SQLITE_OK;
39744 return SQLITE_OK;
39773 return SQLITE_OK;
39818 return SQLITE_OK;
39837 return kvvfsWriteFileSize(pFile, size) ? SQLITE_IOERR : SQLITE_OK;
39867 return i ? SQLITE_IOERR : SQLITE_OK;
39870 return SQLITE_OK;
39880 return SQLITE_OK;
39890 return SQLITE_OK;
39904 return SQLITE_OK;
39917 return SQLITE_OK;
39926 return SQLITE_OK;
39940 int rc = SQLITE_OK;
40005 return SQLITE_OK;
40075 return SQLITE_OK;
40098 return SQLITE_OK;
40122 return SQLITE_OK;
40141 return SQLITE_OK;
40153 return SQLITE_OK;
40394 ** a normal expected return code of SQLITE_BUSY or SQLITE_OK
40396 #define IS_LOCK_ERROR(x) ((x != SQLITE_OK) && (x != SQLITE_BUSY))
40799 ** Return SQLITE_OK on success and SQLITE_ERROR_UNABLE if the /proc
40870 return SQLITE_OK;
40891 ** "unix" VFSes. Return SQLITE_OK upon successfully updating the
40908 rc = SQLITE_OK;
40923 rc = SQLITE_OK;
41171 rc = SQLITE_OK;
41781 return SQLITE_OK;
41839 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
41842 int rc = SQLITE_OK;
42071 int rc = SQLITE_OK;
42090 return SQLITE_OK;
42119 ** return SQLITE_OK.
42164 assert( rc==SQLITE_OK );
42178 if( unixFileLock(pFile, &lock) && rc==SQLITE_OK ){
42239 if( rc==SQLITE_OK
42249 if( rc==SQLITE_OK ){
42257 rc==SQLITE_OK ? "ok" : "failed"));
42292 int rc = SQLITE_OK;
42301 return SQLITE_OK;
42435 if( rc==SQLITE_OK ){
42499 return SQLITE_OK;
42506 int rc = SQLITE_OK;
42560 return SQLITE_OK;
42564 return SQLITE_OK;
42568 return SQLITE_OK;
42626 return SQLITE_OK;
42659 int rc = SQLITE_OK;
42673 return SQLITE_OK;
42718 return SQLITE_OK;
42726 return SQLITE_OK;
42735 rc = SQLITE_OK;
42743 return SQLITE_OK;
42793 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
42822 return SQLITE_OK;
42855 int rc = SQLITE_OK;
42864 return SQLITE_OK;
42881 rc==SQLITE_OK ? "ok" : "failed"));
42908 return SQLITE_OK;
42914 return SQLITE_OK;
42920 return SQLITE_OK;
42925 return SQLITE_OK;
42959 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
42962 int rc = SQLITE_OK;
43031 int rc = SQLITE_OK;
43037 rc = SQLITE_OK;
43073 return SQLITE_OK;
43079 return SQLITE_OK;
43092 return SQLITE_OK;
43109 return SQLITE_OK;
43156 ** Return SQLITE_OK on success, SQLITE_BUSY on failure.
43194 return SQLITE_OK;
43202 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
43205 int rc = SQLITE_OK;
43216 return SQLITE_OK;
43229 if( SQLITE_OK==lrc ){
43274 int rc = SQLITE_OK;
43291 return SQLITE_OK;
43320 ** return SQLITE_OK.
43378 } else if( lrc1 != SQLITE_OK ) {
43411 int failed2 = SQLITE_OK;
43433 if( rc==SQLITE_OK ){
43444 rc==SQLITE_OK ? "ok" : "failed"));
43456 int rc = SQLITE_OK;
43469 return SQLITE_OK;
43494 if( rc==SQLITE_OK && (eFileLock==SHARED_LOCK || pInode->nShared>1) ){
43502 if( rc==SQLITE_OK && pFile->eFileLock>=PENDING_LOCK ){
43505 if( rc==SQLITE_OK && pFile->eFileLock>=RESERVED_LOCK && context->reserved ){
43511 if( rc==SQLITE_OK && (eFileLock==SHARED_LOCK || pInode->nShared>1)){
43515 if( rc==SQLITE_OK && eFileLock==NO_LOCK ){
43532 if( rc==SQLITE_OK ){
43540 if( rc==SQLITE_OK ){
43550 int rc = SQLITE_OK;
43672 ** Read data from a file into a buffer. Return SQLITE_OK if all
43703 return SQLITE_OK;
43716 return SQLITE_OK;
43804 ** Write data from a buffer into a file. Return SQLITE_OK on success
43855 return SQLITE_OK;
43884 return SQLITE_OK;
44018 ** SQLITE_OK is returned. If an error occurs, either SQLITE_NOMEM
44032 ** a no-op, replace it with a stub that returns SQLITE_OK but leaves
44035 ** If SQLITE_OK is returned, the caller is responsible for closing
44056 if( fd>=0 ) return SQLITE_OK;
44110 if( rc==SQLITE_OK ){
44115 rc = SQLITE_OK;
44168 return SQLITE_OK;
44196 return SQLITE_OK;
44273 return SQLITE_OK;
44311 return rc ? SQLITE_IOERR_BEGIN_ATOMIC : SQLITE_OK;
44315 return rc ? SQLITE_IOERR_COMMIT_ATOMIC : SQLITE_OK;
44319 return rc ? SQLITE_IOERR_ROLLBACK_ATOMIC : SQLITE_OK;
44326 return SQLITE_OK;
44330 return SQLITE_OK;
44334 return SQLITE_OK;
44338 return SQLITE_OK;
44349 return SQLITE_OK;
44353 return SQLITE_OK;
44357 return SQLITE_OK;
44365 return SQLITE_OK;
44369 return SQLITE_OK;
44383 return SQLITE_OK;
44388 return SQLITE_OK;
44394 int rc = SQLITE_OK;
44425 return SQLITE_OK;
44440 return SQLITE_OK;
44456 if( unixPosixAdvisoryLocks(pFile->h, aLck)==SQLITE_OK ){
44487 if( unixPosixAdvisoryLocks(pUFd->fd, aLck)==SQLITE_OK ){
44500 return SQLITE_OK;
44782 if( unixPosixAdvisoryLocks(pNode->hShm, aLck)==SQLITE_OK ){
44792 ** no error occurs, return SQLITE_OK and set (*piOut) to 1 if there are
44798 int rc = SQLITE_OK;
44875 int rc = SQLITE_OK; /* Result code form fcntl() */
44928 if( rc==SQLITE_OK ){
45007 ** take it now. Return SQLITE_OK if successful, or an SQLite error
45016 int rc = SQLITE_OK;
45066 if( rc==SQLITE_OK && robust_ftruncate(pShmNode->hShm, 3) ){
45074 if( rc==SQLITE_OK ){
45119 int rc = SQLITE_OK; /* Result code */
45217 if( rc!=SQLITE_OK && rc!=SQLITE_READONLY_CANTINIT ) goto shm_open_err;
45261 ** separate process), then *pp is set to NULL and SQLITE_OK returned. If
45268 ** memory and SQLITE_OK returned.
45280 int rc = SQLITE_OK;
45287 if( rc!=SQLITE_OK ) return rc;
45295 if( rc!=SQLITE_OK ) goto shmpage_out;
45325 ** false, exit early. *pp will be set to NULL and SQLITE_OK returned.
45400 if( pShmNode->isReadonly && rc==SQLITE_OK ) rc = SQLITE_READONLY;
45457 int rc = SQLITE_OK; /* Result code */
45540 if( rc!=SQLITE_OK ) goto leave_shmnode_mutexes;
45549 if( ALWAYS(rc==SQLITE_OK) ){
45573 if( rc==SQLITE_OK ){
45590 if( rc==SQLITE_OK ){
45613 if( rc==SQLITE_OK ){
45615 if( rc==SQLITE_OK ){
45678 if( p==0 ) return SQLITE_OK;
45709 return SQLITE_OK;
45814 unixLogError(SQLITE_OK, zErr, pFd->zPath);
45837 ** SQLITE_OK is returned if no error occurs (even if the mapping is not
45844 if( pFd->nFetchOut>0 ) return SQLITE_OK;
45862 return SQLITE_OK;
45870 ** If such a pointer can be obtained, store it in *pp and return SQLITE_OK.
45871 ** Or, if one cannot but no error occurs, set *pp to 0 and return SQLITE_OK.
45893 if( rc!=SQLITE_OK ) return rc;
45901 return SQLITE_OK;
45939 return SQLITE_OK;
46253 SQLITE_OK;
46303 if( rc!=SQLITE_OK ){
46346 if( rc!=SQLITE_OK ){
46380 if( (rc==SQLITE_OK) && (pNew->pInode->pSem==NULL) ){
46399 if( rc!=SQLITE_OK ){
46413 if( rc!=SQLITE_OK ){
46477 int rc = SQLITE_OK;
46590 int rc = SQLITE_OK;
46603 ** to create new files with. If no error occurs, then SQLITE_OK is returned
46629 int rc = SQLITE_OK; /* Return Code */
46653 ** the filename. In that case, just return SQLITE_OK with *pMode==0.
46714 int rc = SQLITE_OK; /* Function Return Code */
46815 if( rc!=SQLITE_OK ){
46840 if( rc!=SQLITE_OK ){
46872 if( rc==SQLITE_OK ) rc = rc2;
46961 if( rc==SQLITE_OK ){
46963 if( rc!=SQLITE_OK ){
46986 if( rc!=SQLITE_OK ){
47002 int rc = SQLITE_OK;
47021 if( rc==SQLITE_OK ){
47028 rc = SQLITE_OK;
47066 return SQLITE_OK;
47112 if( pPath->rc==SQLITE_OK ){
47196 return SQLITE_OK;
47354 ** On success, return SQLITE_OK. Return SQLITE_ERROR if the time and date
47359 int rc = SQLITE_OK;
47631 return SQLITE_OK;
47684 int rc = SQLITE_OK;
47709 if( proxyCreateLockPath(path) == SQLITE_OK ){
47748 if( rc==SQLITE_OK ){
47750 return SQLITE_OK;
47798 return SQLITE_OK;
47877 int rc = SQLITE_OK;
47932 rc = SQLITE_OK;
47956 return SQLITE_OK;
47964 int rc = SQLITE_OK;
47981 if( rc!=SQLITE_OK ){
48063 if( rc==SQLITE_OK ){
48082 if( rc==SQLITE_OK && createConch ){
48114 if( rc==SQLITE_OK && pFile->openFlags ){
48129 if( rc==SQLITE_OK && !pCtx->lockProxy ){
48132 if( rc!=SQLITE_OK && rc!=SQLITE_NOMEM && tryOldLockPath ){
48141 if( rc==SQLITE_OK ){
48152 if( rc==SQLITE_OK ){
48164 rc==SQLITE_OK?"ok":"failed"));
48175 int rc = SQLITE_OK; /* Subroutine return code */
48189 (rc==SQLITE_OK ? "ok" : "failed")));
48196 ** Make *pConchPath point to the new name. Return SQLITE_OK on success
48234 return SQLITE_OK;
48244 int rc = SQLITE_OK;
48253 return SQLITE_OK;
48297 return SQLITE_OK;
48312 int rc = SQLITE_OK;
48334 if( rc==SQLITE_OK ){
48354 rc = SQLITE_OK;
48358 if( rc==SQLITE_OK && lockPath ){
48362 if( rc==SQLITE_OK ){
48368 if( rc==SQLITE_OK ){
48386 (rc==SQLITE_OK ? "ok" : "failed")));
48410 return SQLITE_OK;
48414 int rc = SQLITE_OK;
48425 rc = SQLITE_OK;
48436 rc = SQLITE_OK;
48466 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
48471 if( rc==SQLITE_OK ){
48510 if( rc==SQLITE_OK ){
48534 if( rc==SQLITE_OK ){
48556 int rc = SQLITE_OK;
48584 return SQLITE_OK;
48735 return SQLITE_OK;
48750 return SQLITE_OK;
49903 ** "win32" VFSes. Return SQLITE_OK upon successfully updating the
49920 rc = SQLITE_OK;
49935 rc = SQLITE_OK;
49987 ** compact it. Upon success, SQLITE_OK will be returned. Upon failure, one
49993 int rc = SQLITE_OK;
50057 assert( rc!=SQLITE_OK || winMemGetHeap()!=NULL );
50058 assert( rc!=SQLITE_OK || winMemGetOwned() );
50059 assert( rc!=SQLITE_OK || sqlite3_memory_used()==0 );
50337 return SQLITE_OK;
50676 rc = SQLITE_OK;
50709 ** SQLITE_OK if successful.
50813 assert( errcode!=SQLITE_OK );
51055 return SQLITE_OK;
51268 ** This function returns SQLITE_OK if the lock is obtained successfully. If
51280 int rc = SQLITE_OK;
51339 if( rc==SQLITE_OK && !ret ){
51385 return (ret ? SQLITE_OK : SQLITE_IOERR_UNLOCK);
51404 ** If successful, return SQLITE_OK. Or, if an error occurs, return an SQLite
51408 int rc = SQLITE_OK; /* Return value */
51444 if( rc!=SQLITE_OK ){
51515 return rc ? SQLITE_OK
51521 ** Read data from a file into a buffer. Return SQLITE_OK if all
51552 OSTRACE(("READ-MMAP pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n",
51554 return SQLITE_OK;
51596 OSTRACE(("READ pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n",
51598 return SQLITE_OK;
51602 ** Write data from a buffer into a file. Return SQLITE_OK on success
51630 OSTRACE(("WRITE-MMAP pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n",
51632 return SQLITE_OK;
51706 OSTRACE(("WRITE pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n",
51708 return SQLITE_OK;
51716 int rc = SQLITE_OK; /* Return code */
51718 if( rc==SQLITE_OK ){
51731 int rc = SQLITE_OK;
51759 int rc = SQLITE_OK; /* Return code for this function */
51781 return SQLITE_OK;
51820 if( rc==SQLITE_OK && oldMmapSize>0 ){
51892 OSTRACE(("SYNC-NOP pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n",
51894 return SQLITE_OK;
51900 "rc=SQLITE_OK\n", osGetCurrentProcessId(),
51915 OSTRACE(("SYNC pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n",
51917 return SQLITE_OK;
51933 int rc = SQLITE_OK;
52078 int rc = SQLITE_OK; /* Return code from subroutines */
52094 OSTRACE(("LOCK-HELD file=%p, rc=SQLITE_OK\n", pFile->h));
52095 return SQLITE_OK;
52218 rc = SQLITE_OK;
52256 OSTRACE(("TEST-WR-LOCK file=%p, pResOut=%p, *pResOut=%d, rc=SQLITE_OK\n",
52258 return SQLITE_OK;
52275 int rc = SQLITE_OK;
52325 return SQLITE_OK;
52331 return SQLITE_OK;
52337 return SQLITE_OK;
52374 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
52375 return SQLITE_OK;
52379 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
52380 return SQLITE_OK;
52384 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
52385 return SQLITE_OK;
52391 if( rc==SQLITE_OK ){
52402 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
52403 return SQLITE_OK;
52407 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
52408 return SQLITE_OK;
52412 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
52413 return SQLITE_OK;
52417 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
52418 return SQLITE_OK;
52432 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
52433 return SQLITE_OK;
52438 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
52439 return SQLITE_OK;
52447 OSTRACE(("FCNTL oldFile=%p, newFile=%p, rc=SQLITE_OK\n",
52449 return SQLITE_OK;
52455 return SQLITE_OK;
52460 if( rc==SQLITE_OK ){
52469 int rc = SQLITE_OK;
52506 return SQLITE_OK;
52511 return SQLITE_OK;
52533 return SQLITE_OK;
52837 ** Return SQLITE_OK if successful, or an SQLite error code otherwise.
52841 int rc = SQLITE_OK;
52845 if( rc==SQLITE_OK ){
52858 rc = SQLITE_OK;
52861 if( rc==SQLITE_OK ){
52864 if( rc==SQLITE_OK ){
52884 int rc = SQLITE_OK;
52963 if( p==0 ) return SQLITE_OK;
52983 return SQLITE_OK;
53014 int rc = SQLITE_OK; /* Result code */
53055 if( rc==SQLITE_OK ){
53064 if( rc==SQLITE_OK ){
53078 if( rc==SQLITE_OK ){
53092 assert( rc!=SQLITE_OK || pShmNode->isUnlocked==0 || pShmNode->nRegion==0 );
53099 if( rc==SQLITE_OK && pShmNode->bUseSharedLockHandle==0 ){
53102 if( rc!=SQLITE_OK ){
53134 int rc = SQLITE_OK; /* Result code */
53220 if( rc==SQLITE_OK ){
53253 if( rc==SQLITE_OK ){
53298 ** separate process), then *pp is set to NULL and SQLITE_OK returned. If
53305 ** memory and SQLITE_OK returned.
53319 int rc = SQLITE_OK;
53323 if( rc!=SQLITE_OK ) return rc;
53334 if( rc!=SQLITE_OK ) goto shmpage_out;
53351 if( rc!=SQLITE_OK ){
53358 ** zero, exit early. *pp will be set to NULL and SQLITE_OK returned.
53364 if( rc!=SQLITE_OK ){
53431 if( pShmNode->isReadonly && rc==SQLITE_OK ){
53477 OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, rc=SQLITE_OK\n",
53479 return SQLITE_OK;
53494 ** SQLITE_OK is returned if no error occurs (even if the mapping is not
53506 if( pFd->nFetchOut>0 ) return SQLITE_OK;
53552 return SQLITE_OK;
53566 return SQLITE_OK;
53572 OSTRACE(("MAP-FILE pid=%lu, pFile=%p, rc=SQLITE_OK\n",
53574 return SQLITE_OK;
53582 ** If such a pointer can be obtained, store it in *pp and return SQLITE_OK.
53583 ** Or, if one cannot but no error occurs, set *pp to 0 and return SQLITE_OK.
53608 if( rc!=SQLITE_OK ){
53622 OSTRACE(("FETCH pid=%lu, pFile=%p, pp=%p, *pp=%p, rc=SQLITE_OK\n",
53624 return SQLITE_OK;
53665 OSTRACE(("UNFETCH pid=%lu, pFile=%p, rc=SQLITE_OK\n",
53667 return SQLITE_OK;
53988 OSTRACE(("TEMP-FILENAME name=%s, rc=SQLITE_OK\n", zBuf));
53989 return SQLITE_OK;
54066 int rc = SQLITE_OK; /* Function Return Code */
54124 if( rc!=SQLITE_OK ){
54213 if( rc2==SQLITE_OK && isRO ) break;
54232 if( rc2==SQLITE_OK && isRO ) break;
54275 && (rc = winceCreateLock(zName, pFile))!=SQLITE_OK
54368 rc = SQLITE_OK; /* Deleted OK. */
54396 rc = SQLITE_OK; /* Deleted OK. */
54443 OSTRACE(("ACCESS name=%s, pResOut=%p, *pResOut=%d, rc=SQLITE_OK\n",
54445 return SQLITE_OK;
54505 OSTRACE(("ACCESS name=%s, pResOut=%p, *pResOut=%d, rc=SQLITE_OK\n",
54507 return SQLITE_OK;
54629 return SQLITE_OK;
54664 int rc = SQLITE_OK;
54694 if( rc==SQLITE_OK ){
54718 assert( rc!=SQLITE_OK || zIn!=zFull || zIn[0]=='/' );
54719 if( rc==SQLITE_OK && zIn!=zFull ){
54724 }while( rc==SQLITE_OK );
54749 return SQLITE_OK;
54769 return SQLITE_OK;
54849 return SQLITE_OK;
55016 ** On success, return SQLITE_OK. Return SQLITE_ERROR if the time and date
55054 return SQLITE_OK;
55245 return SQLITE_OK;
55252 return SQLITE_OK;
55504 return SQLITE_OK;
55526 return SQLITE_OK;
55546 return SQLITE_OK;
55569 && (rc = memdbEnlarge(p, iOfst+iAmt))!=SQLITE_OK
55579 return SQLITE_OK;
55591 int rc = SQLITE_OK;
55609 return SQLITE_OK;
55620 return SQLITE_OK;
55629 int rc = SQLITE_OK;
55630 if( eLock<=pThis->eLock ) return SQLITE_OK;
55676 if( rc==SQLITE_OK ) pThis->eLock = eLock;
55687 if( eLock>=pThis->eLock ) return SQLITE_OK;
55704 return SQLITE_OK;
55714 return SQLITE_OK;
55728 rc = SQLITE_OK;
55741 rc = SQLITE_OK;
55783 return SQLITE_OK;
55794 return SQLITE_OK;
55876 return SQLITE_OK;
55907 return SQLITE_OK;
55923 return SQLITE_OK;
56081 if( rc==SQLITE_OK ){
56157 rc = SQLITE_OK;
56369 if( p==0 ) return SQLITE_OK;
56384 return SQLITE_OK;
56400 if( p->u.aHash[h]==i ) return SQLITE_OK;
56431 return SQLITE_OK;
57071 return SQLITE_OK;
57178 if( rc!=SQLITE_OK && rc!=SQLITE_BUSY ){
57184 return *ppPage==0 ? SQLITE_NOMEM_BKPT : SQLITE_OK;
58374 return SQLITE_OK;
59916 ** * The Pager.errCode variable is set to something other than SQLITE_OK.
60418 # define pagerOpenWalIfPresent(z) SQLITE_OK
60419 # define pagerBeginReadTransaction(z) SQLITE_OK
60484 assert( pPager->errCode==SQLITE_OK );
60489 assert( pPager->errCode==SQLITE_OK );
60496 assert( pPager->errCode==SQLITE_OK );
60508 assert( pPager->errCode==SQLITE_OK );
60527 assert( pPager->errCode==SQLITE_OK );
60540 assert( pPager->errCode==SQLITE_OK );
60554 assert( pPager->errCode!=SQLITE_OK );
60678 ** that is read in *pRes. Return SQLITE_OK if everything worked, or an
60686 if( rc==SQLITE_OK ){
60699 ** Write a 32-bit integer into the given file descriptor. Return SQLITE_OK
60718 int rc = SQLITE_OK;
60725 rc = pPager->noLock ? SQLITE_OK : sqlite3OsUnlock(pPager->fd, eLock);
60746 int rc = SQLITE_OK;
60750 rc = pPager->noLock ? SQLITE_OK : sqlite3OsLock(pPager->fd, eLock);
60751 if( rc==SQLITE_OK && (pPager->eLock!=UNKNOWN_LOCK||eLock==EXCLUSIVE_LOCK) ){
60878 ** zSuper[0] is set to 0 and SQLITE_OK returned.
60892 if( SQLITE_OK!=(rc = sqlite3OsFileSize(pJrnl, &szJ))
60894 || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-16, &len))
60898 || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-12, &cksum))
60899 || SQLITE_OK!=(rc = sqlite3OsRead(pJrnl, aMagic, 8, szJ-8))
60901 || SQLITE_OK!=(rc = sqlite3OsRead(pJrnl, zSuper, len, szJ-16-len))
60913 ** definitely roll back, so just return SQLITE_OK and report a (nul)
60921 return SQLITE_OK;
60970 ** Otherwise, return SQLITE_OK.
60973 int rc = SQLITE_OK; /* Return code */
60986 if( rc==SQLITE_OK && !pPager->noSync ){
60996 if( rc==SQLITE_OK && iLimit>0 ){
60999 if( rc==SQLITE_OK && sz>iLimit ){
61023 int rc = SQLITE_OK; /* Return code */
61136 for(nWrite=0; rc==SQLITE_OK&&nWrite<JOURNAL_HDR_SZ(pPager); nWrite+=nHeader){
61156 ** is set to the value read from the journal header. SQLITE_OK is returned
61205 if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+8, pNRec))
61206 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+12, &pPager->cksumInit))
61207 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+16, pDbSize))
61217 if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+20, &iSectorSize))
61218 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+24, &iPageSize))
61253 testcase( rc!=SQLITE_OK );
61302 return SQLITE_OK;
61345 if( SQLITE_OK==(rc = sqlite3OsFileSize(pPager->jfd, &jrnlSize))
61390 ** bitvecs of all open savepoints. Return SQLITE_OK if successful
61395 int rc = SQLITE_OK; /* Result code */
61402 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
61476 if( rc!=SQLITE_OK && pPager->eState==PAGER_ERROR ){
61493 assert( pPager->errCode==SQLITE_OK || !MEMDB );
61503 pPager->errCode = SQLITE_OK;
61533 assert( rc==SQLITE_OK || !MEMDB );
61536 pPager->errCode==SQLITE_OK ||
61616 ** SQLITE_OK is returned if no error occurs. If an error occurs during
61626 int rc = SQLITE_OK; /* Error code from journal finalization operation */
61627 int rc2 = SQLITE_OK; /* Error code from db file unlock operation */
61645 return SQLITE_OK;
61661 rc = SQLITE_OK;
61664 if( rc==SQLITE_OK && pPager->fullSync ){
61712 if( rc==SQLITE_OK ){
61727 assert( rc2==SQLITE_OK );
61728 }else if( rc==SQLITE_OK && bCommit && pPager->dbFileSize>pPager->dbSize ){
61739 if( rc==SQLITE_OK && bCommit ){
61741 if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
61752 return (rc==SQLITE_OK?rc2:rc);
61796 pPager->errCode = SQLITE_OK;
61845 ** skipped and SQLITE_OK is returned.
61854 ** and played back, then SQLITE_OK is returned. If an IO error occurs
61911 if( rc!=SQLITE_OK ) return rc;
61913 if( rc!=SQLITE_OK ) return rc;
61926 return SQLITE_OK;
61939 if( pDone && (rc = sqlite3BitvecSet(pDone, pgno))!=SQLITE_OK ){
62045 if( rc!=SQLITE_OK ) return rc;
62111 ** occur, SQLITE_OK is returned.
62142 if( rc!=SQLITE_OK ) goto delsuper_out;
62150 if( rc!=SQLITE_OK ) goto delsuper_out;
62164 if( rc!=SQLITE_OK ) goto delsuper_out;
62172 if( rc!=SQLITE_OK ){
62186 if( rc!=SQLITE_OK ){
62192 if( rc!=SQLITE_OK ){
62236 ** If successful, return SQLITE_OK. If an IO error occurs while modifying
62240 int rc = SQLITE_OK;
62255 if( rc==SQLITE_OK && currentSize!=newSize ){
62266 if( rc==SQLITE_OK ){
62372 ** is then deleted and SQLITE_OK returned, just as if no corruption had
62403 if( rc!=SQLITE_OK ){
62420 if( rc==SQLITE_OK && zSuper[0] ){
62424 if( rc!=SQLITE_OK || !res ){
62441 if( rc!=SQLITE_OK ){
62443 rc = SQLITE_OK;
62482 if( rc!=SQLITE_OK ){
62500 if( rc==SQLITE_OK ){
62512 rc = SQLITE_OK;
62529 if( rc==SQLITE_OK ){
62552 if( rc==SQLITE_OK ){
62559 testcase( rc!=SQLITE_OK );
62561 if( rc==SQLITE_OK
62566 if( rc==SQLITE_OK ){
62568 testcase( rc!=SQLITE_OK );
62570 if( rc==SQLITE_OK && zSuper[0] && res ){
62577 testcase( rc!=SQLITE_OK );
62603 ** Otherwise, SQLITE_OK is returned.
62607 int rc = SQLITE_OK; /* Return code */
62627 rc = SQLITE_OK;
62694 ** return an SQLite error code. Otherwise, SQLITE_OK.
62697 int rc = SQLITE_OK;
62708 if( rc==SQLITE_OK ){
62745 while( pList && rc==SQLITE_OK ){
62806 if( rc==SQLITE_OK && pPager->pBackup ){
62845 if( rc!=SQLITE_OK || changed ){
62859 ** If no error occurs, SQLITE_OK is returned and the size of the database
62886 if( rc!=SQLITE_OK ){
62901 return SQLITE_OK;
62915 ** Return SQLITE_OK or an error code.
62924 int rc = SQLITE_OK;
62933 if( rc==SQLITE_OK ){
62993 int rc = SQLITE_OK; /* Return code */
63035 while( rc==SQLITE_OK && pPager->journalOff<iHdrOff ){
63048 while( rc==SQLITE_OK && pPager->journalOff<szJ ){
63065 for(ii=0; rc==SQLITE_OK && ii<nJRec && pPager->journalOff<szJ; ii++){
63070 assert( rc!=SQLITE_OK || pPager->journalOff>=szJ );
63083 for(ii=pSavepoint->iSubRec; rc==SQLITE_OK && ii<pPager->nSubRec; ii++){
63091 if( rc==SQLITE_OK ){
63256 ** Write the file descriptor into *pFile. Return SQLITE_OK on success
63282 assert( rc!=SQLITE_OK || isOpen(pFile) );
63344 ** In all other cases, SQLITE_OK is returned.
63352 int rc = SQLITE_OK;
63376 if( rc==SQLITE_OK ){
63387 if( rc==SQLITE_OK ){
63391 if( rc==SQLITE_OK ){
63403 if( rc==SQLITE_OK ){
63473 ** zeroed and SQLITE_OK returned. The rationale for this is that this
63482 int rc = SQLITE_OK;
63496 rc = SQLITE_OK;
63519 ** (returning SQLITE_OK immediately).
63526 ** Return SQLITE_OK on success and an error code if we cannot obtain
63629 ** If everything goes as planned, SQLITE_OK is returned. Otherwise,
63633 int rc = SQLITE_OK;
63637 if( rc==SQLITE_OK ){
63648 ** and return SQLITE_OK. Otherwise, return an SQLite error code and set
63691 return SQLITE_OK;
63722 ** under the pager. Return SQLITE_OK if the database is still where it ought
63730 if( pPager->tempFile ) return SQLITE_OK;
63731 if( pPager->dbSize==0 ) return SQLITE_OK;
63738 rc = SQLITE_OK;
63739 }else if( rc==SQLITE_OK && bHasMoved ){
63774 && SQLITE_OK==databaseIsUnmoved(pPager)
63816 return SQLITE_OK;
63867 ** page currently held in memory before returning SQLITE_OK. If an IO
63880 if( rc!=SQLITE_OK ) return rc;
63920 if( rc==SQLITE_OK && 0==memcmp(aMagic, aJournalMagic, 8) ){
63924 if( rc!=SQLITE_OK && rc!=SQLITE_IOERR_SHORT_READ ){
63943 if( rc!=SQLITE_OK ) return rc;
63949 if( rc!=SQLITE_OK ) return rc;
63957 if( rc!=SQLITE_OK ) return rc;
63964 if( rc!=SQLITE_OK ) return rc;
63978 return SQLITE_OK;
64009 ** If everything is successful, SQLITE_OK is returned. If an IO error
64014 int rc = SQLITE_OK; /* Return code */
64023 ** is not possible for rc to be other than SQLITE_OK if this branch
64027 assert( pPager->tempFile && rc==SQLITE_OK );
64034 assert( rc!=SQLITE_OK || isOpen(pPager->fd) );
64035 if( rc==SQLITE_OK
64044 while( rc==SQLITE_OK && pList ){
64100 ** SQLITE_OK is returned if everything goes according to plan. An
64105 int rc = SQLITE_OK;
64125 ** This function returns SQLITE_OK if everything is successful, an IO
64131 int rc = SQLITE_OK;
64147 if( rc==SQLITE_OK ){
64154 if( rc==SQLITE_OK ){
64159 if( rc==SQLITE_OK ){
64170 return SQLITE_OK;
64188 ** SQLITE_OK returned. If an IO error occurs while trying to make the
64190 ** made clean for some other reason, but no error occurs, then SQLITE_OK
64195 int rc = SQLITE_OK;
64216 if( NEVER(pPager->errCode) ) return SQLITE_OK;
64224 return SQLITE_OK;
64232 if( rc==SQLITE_OK ){
64240 if( rc!=SQLITE_OK ) return pager_error(pPager, rc);
64252 if( rc==SQLITE_OK ){
64259 if( rc==SQLITE_OK ){
64275 while( rc==SQLITE_OK && pList ){
64313 ** successfully, SQLITE_OK is returned and *ppPager set to point to
64330 int rc = SQLITE_OK; /* Return code */
64377 if( rc!=SQLITE_OK ){
64382 rc = SQLITE_OK;
64394 if( rc==SQLITE_OK && nPathname+8>pVfs->mxPathname ){
64403 if( rc!=SQLITE_OK ){
64545 if( rc==SQLITE_OK ){
64600 if( rc==SQLITE_OK ){
64603 testcase( rc!=SQLITE_OK );
64607 if( rc==SQLITE_OK ){
64616 if( rc!=SQLITE_OK ){
64666 return SQLITE_OK;
64702 ** just deleted using OsDelete, *pExists is set to 0 and SQLITE_OK
64713 ** SQLITE_OK returned. If no hot-journal file is present, *pExists is
64714 ** set to 0 and SQLITE_OK returned. If an IO error occurs while trying
64720 int rc = SQLITE_OK; /* Return code */
64736 if( rc==SQLITE_OK && exists ){
64748 if( rc==SQLITE_OK && !locked ){
64753 if( rc==SQLITE_OK ){
64764 if( pagerLockDb(pPager, RESERVED_LOCK)==SQLITE_OK ){
64780 if( rc==SQLITE_OK ){
64784 rc = SQLITE_OK;
64801 rc = SQLITE_OK;
64834 ** If everything is successful, SQLITE_OK is returned. If an IO error
64839 int rc = SQLITE_OK; /* Return code */
64848 assert( pPager->errCode==SQLITE_OK );
64857 if( rc!=SQLITE_OK ){
64868 if( rc!=SQLITE_OK ){
64893 if( rc!=SQLITE_OK ){
64915 if( rc==SQLITE_OK && bExists ){
64920 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
64921 if( rc==SQLITE_OK && fout&SQLITE_OPEN_READONLY ){
64937 assert( rc==SQLITE_OK );
64939 if( rc==SQLITE_OK ){
64947 if( rc!=SQLITE_OK ){
64995 if( rc!=SQLITE_OK ){
65022 assert( pPager->pWal==0 || rc==SQLITE_OK );
65027 assert( rc==SQLITE_OK );
65031 if( pPager->tempFile==0 && pPager->eState==PAGER_OPEN && rc==SQLITE_OK ){
65036 if( rc!=SQLITE_OK ){
65065 ** successfully obtained, it is copied to *ppPage and SQLITE_OK returned.
65125 int rc = SQLITE_OK;
65130 assert( pPager->errCode==SQLITE_OK );
65140 if( rc!=SQLITE_OK ) goto pager_acquire_err;
65157 return SQLITE_OK;
65205 if( rc!=SQLITE_OK ){
65211 return SQLITE_OK;
65214 assert( rc!=SQLITE_OK );
65231 int rc = SQLITE_OK;
65255 assert( pPager->errCode==SQLITE_OK );
65259 if( rc!=SQLITE_OK ){
65269 if( rc==SQLITE_OK && pData ){
65279 assert( rc==SQLITE_OK );
65281 return SQLITE_OK;
65284 if( rc!=SQLITE_OK ){
65302 assert( pPager->errCode!=SQLITE_OK );
65411 ** Return SQLITE_OK if everything is successful. Otherwise, return
65416 int rc = SQLITE_OK; /* Return code */
65454 if( rc==SQLITE_OK ){
65460 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
65467 if( rc==SQLITE_OK ){
65477 if( rc!=SQLITE_OK ){
65507 int rc = SQLITE_OK;
65522 if( rc!=SQLITE_OK ){
65541 if( rc==SQLITE_OK && exFlag ){
65546 if( rc==SQLITE_OK ){
65563 assert( rc==SQLITE_OK || pPager->eState==PAGER_READER );
65564 assert( rc!=SQLITE_OK || pPager->eState==PAGER_WRITER_LOCKED );
65601 if( rc!=SQLITE_OK ) return rc;
65603 if( rc!=SQLITE_OK ) return rc;
65605 if( rc!=SQLITE_OK ) return rc;
65619 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
65621 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
65634 int rc = SQLITE_OK;
65660 if( rc!=SQLITE_OK ) return rc;
65679 if( rc!=SQLITE_OK ){
65725 int rc = SQLITE_OK; /* Return code */
65760 for(ii=0; ii<nPage && rc==SQLITE_OK; ii++){
65766 if( rc==SQLITE_OK ){
65788 if( rc==SQLITE_OK && needSync ){
65808 ** this routine returns SQLITE_OK.
65816 ** as appropriate. Otherwise, SQLITE_OK.
65825 return SQLITE_OK;
65902 int rc = SQLITE_OK;
65934 assert( pPgHdr==0 || rc==SQLITE_OK );
65939 ** above is always successful - hence the ALWAYS on rc==SQLITE_OK.
65941 if( !DIRECT_MODE && ALWAYS(rc==SQLITE_OK) ){
65945 if( rc==SQLITE_OK ){
65954 if( rc==SQLITE_OK ){
65958 if( rc==SQLITE_OK ){
65982 ** function returns SQLITE_OK. Otherwise, an IO error code is returned.
65985 int rc = SQLITE_OK;
65988 if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
65989 if( rc==SQLITE_OK && !pPager->noSync ){
66003 ** successful, or the connection is in WAL mode, SQLITE_OK is returned.
66010 if( rc==SQLITE_OK ){
66054 int rc = SQLITE_OK; /* Return code */
66073 if( pPager->eState<PAGER_WRITER_CACHEMOD ) return SQLITE_OK;
66094 assert( rc==SQLITE_OK );
66099 if( rc==SQLITE_OK ){
66161 if( rc==SQLITE_OK ){
66170 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
66176 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
66183 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
66197 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
66203 if( rc==SQLITE_OK ){
66205 if( rc==SQLITE_OK && pPager->dbSize>pPager->dbFileSize ){
66212 if( rc==SQLITE_OK ){
66215 if( rc!=SQLITE_OK ){
66222 if( rc!=SQLITE_OK ){
66236 if( rc!=SQLITE_OK ){
66252 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
66264 if( rc==SQLITE_OK && !pagerUseWal(pPager) ){
66284 ** moves into the error state. Otherwise, SQLITE_OK is returned.
66287 int rc = SQLITE_OK; /* Return code */
66318 return SQLITE_OK;
66353 int rc = SQLITE_OK; /* Return code */
66362 if( pPager->eState<=PAGER_READER ) return SQLITE_OK;
66368 if( rc==SQLITE_OK ) rc = rc2;
66386 assert( pPager->eState==PAGER_READER || rc!=SQLITE_OK );
66387 assert( rc==SQLITE_OK || rc==SQLITE_FULL || rc==SQLITE_CORRUPT
66501 ** returned. Otherwise, SQLITE_OK.
66504 int rc = SQLITE_OK; /* Return code */
66556 return SQLITE_OK;
66589 ** savepoint. If no errors occur, SQLITE_OK is returned.
66595 if( op==SAVEPOINT_RELEASE ) rc = SQLITE_OK;
66601 if( rc==SQLITE_OK && iSavepoint<pPager->nSavepoint ){
66624 assert( rc==SQLITE_OK );
66740 ** occurs. Otherwise, it returns SQLITE_OK.
66782 && SQLITE_OK!=(rc = subjournalPageIfRequired(pPg))
66858 if( rc!=SQLITE_OK ){
66870 return SQLITE_OK;
67003 int rc = SQLITE_OK;
67010 assert( rc==SQLITE_OK );
67013 if( rc==SQLITE_OK ){
67016 if( rc==SQLITE_OK && state==PAGER_READER ){
67101 int rc = SQLITE_OK;
67150 if( rc!=SQLITE_OK ){
67166 int rc = SQLITE_OK;
67183 if( rc==SQLITE_OK ){
67189 if( rc==SQLITE_OK ){
67207 ** return SQLITE_OK. If an error occurs or the VFS used by the pager does
67212 ** the WAL file is already open, set *pbOpen to 1 and return SQLITE_OK
67219 int rc = SQLITE_OK; /* Return code */
67234 if( rc==SQLITE_OK ){
67255 int rc = SQLITE_OK;
67266 if( rc==SQLITE_OK ){
67271 if( rc==SQLITE_OK && logexists ){
67279 if( rc==SQLITE_OK && pPager->pWal ){
67281 if( rc==SQLITE_OK ){
67297 ** Return an SQLite error code if an error occurs, or SQLITE_OK otherwise.
67300 int rc = SQLITE_OK;
67341 int rc = SQLITE_OK;
67369 ** available. If so, SQLITE_OK is returned.
67373 ** occurs (any value other than SQLITE_OK is returned), the CHECKPOINTER
68171 ** (1) rc==SQLITE_OK and *ppPage==Requested-Wal-Index-Page
68173 ** (3) rc==SQLITE_OK and *ppPage==NULL // only if iPage==0
68182 int rc = SQLITE_OK;
68209 || rc!=SQLITE_OK
68211 testcase( pWal->apWiData[iPage]==0 && rc==SQLITE_OK );
68212 if( rc==SQLITE_OK ){
68217 rc = SQLITE_OK;
68223 assert( iPage==0 || *ppPage || rc!=SQLITE_OK );
68235 return SQLITE_OK;
68502 if( pWal->exclusiveMode ) return SQLITE_OK;
68507 VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && (rc&0xFF)!=SQLITE_BUSY); )
68509 if( rc==SQLITE_OK ) pWal->lockMask |= (1 << lockIdx);
68524 if( pWal->exclusiveMode ) return SQLITE_OK;
68529 VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && (rc&0xFF)!=SQLITE_BUSY); )
68531 if( rc==SQLITE_OK ){
68596 assert( rc==SQLITE_OK || iHash>0 );
68606 }else if( NEVER(rc==SQLITE_OK) ){
68725 if( rc==SQLITE_OK ){
68832 if( rc!=SQLITE_OK ){
68851 if( rc!=SQLITE_OK ){
68912 assert( aShare!=0 || rc!=SQLITE_OK );
68924 if( rc!=SQLITE_OK ) break;
68928 if( NEVER(rc!=SQLITE_OK) ) break;
68982 if( rc==SQLITE_OK ){
68999 if( rc==SQLITE_OK ){
69058 ** If the log file is successfully opened, SQLITE_OK is returned and
69142 if( rc==SQLITE_OK && flags&SQLITE_OPEN_READONLY ){
69146 if( rc!=SQLITE_OK ){
69363 ** return SQLITE_OK. Otherwise, return an error code. If this routine
69376 int rc = SQLITE_OK; /* Return Code */
69398 for(i=walFramePage(nBackfill+1); rc==SQLITE_OK && i<nSegment; i++){
69402 if( rc==SQLITE_OK ){
69425 if( rc!=SQLITE_OK ){
69445 return (rc==SQLITE_OK);
69477 ** an SQLite error code if an error occurs, or SQLITE_OK otherwise. It is not
69483 int rc = SQLITE_OK;
69489 if( rc==SQLITE_OK ){
69623 int rc = SQLITE_OK; /* Return code */
69655 if( rc==SQLITE_OK ){
69671 assert( rc==SQLITE_OK || pIter==0 );
69675 && (rc = walBusyLock(pWal,xBusy,pBusyArg,WAL_READ_LOCK(0),1))==SQLITE_OK
69697 if( rc==SQLITE_OK ){
69702 if( rc==SQLITE_OK && nSize<nReq ){
69719 while( rc==SQLITE_OK && 0==walIteratorNext(pIter, &iDbpage, &iFrame) ){
69733 if( rc!=SQLITE_OK ) break;
69737 if( rc!=SQLITE_OK ) break;
69742 if( rc==SQLITE_OK ){
69747 if( rc==SQLITE_OK ){
69751 if( rc==SQLITE_OK ){
69764 rc = SQLITE_OK;
69773 if( rc==SQLITE_OK && eMode!=SQLITE_CHECKPOINT_PASSIVE ){
69783 if( rc==SQLITE_OK ){
69821 if( rx==SQLITE_OK && (sz > nMax ) ){
69929 int rc = SQLITE_OK;
69944 && SQLITE_OK==(rc = sqlite3OsLock(pWal->pDbFd, SQLITE_LOCK_EXCLUSIVE))
69952 if( rc==SQLITE_OK ){
69959 ** fsynced (rc==SQLITE_OK) and if we are not in persistent-wal
69964 ** completed and fsynced (rc==SQLITE_OK) and we are in persistent
70072 ** If the wal-index header is successfully read, return SQLITE_OK.
70085 if( rc!=SQLITE_OK ){
70122 if( SQLITE_OK==(rc = walLockShared(pWal, WAL_WRITE_LOCK)) ){
70129 || SQLITE_OK==(rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1))
70137 if( SQLITE_OK==(rc = walIndexPage(pWal, 0, &page0)) ){
70165 if( rc!=SQLITE_OK ){
70197 ** If this function returns SQLITE_OK, then the read transaction has
70226 if( rc!=SQLITE_OK ){
70255 assert( rc!=SQLITE_OK ); /* SQLITE_OK not possible for read-only connection */
70271 if( rc!=SQLITE_OK ){
70282 rc = (pWal->hdr.mxFrame==0 ? SQLITE_OK : WAL_RETRY);
70288 if( rc!=SQLITE_OK ){
70325 if( rc!=SQLITE_OK ) break;
70341 if( rc!=SQLITE_OK ){
70390 ** On success return SQLITE_OK. On a permanent failure (such an
70437 int rc = SQLITE_OK; /* Return code */
70495 assert( rc==SQLITE_OK );
70524 }else if( SQLITE_OK==(rc = walLockShared(pWal, WAL_RECOVER_LOCK)) ){
70532 if( rc!=SQLITE_OK ){
70559 if( rc==SQLITE_OK ){
70578 return SQLITE_OK;
70610 if( rc==SQLITE_OK ){
70703 if( rc==SQLITE_OK ){
70713 if( rc!=SQLITE_OK ) break;
70722 if( rc==SQLITE_OK ){
70726 if( rc!=SQLITE_OK || 0==memcmp(pBuf1, pBuf2, szPage) ){
70753 ** SQLITE_OK is returned if successful, or an SQLite error code if an
70762 if( rc==SQLITE_OK ){
70819 if( rc!=SQLITE_OK ){
70832 testcase( rc==SQLITE_OK );
70835 if( rc==SQLITE_OK ){
70879 if( rc!=SQLITE_OK ){
70937 ** Return SQLITE_OK if successful, or an error code if an error occurs. If an
70961 return SQLITE_OK;
70998 if( rc!=SQLITE_OK ){
71041 return SQLITE_OK;
71049 ** Return SQLITE_OK if successful, or an error code if an error occurs. If an
71070 ** (which is nOut bytes in size). Return SQLITE_OK if successful, or an
71123 return SQLITE_OK;
71156 if( rc!=SQLITE_OK ){
71174 return SQLITE_OK;
71183 ** other than SQLITE_OK, it is not invoked again and the error code is
71187 ** function returns SQLITE_OK.
71190 int rc = SQLITE_OK;
71202 ALWAYS(rc==SQLITE_OK) && iFrame<=iMax;
71248 int rc = SQLITE_OK;
71286 ** SQLITE_OK is returned if no error is encountered (regardless of whether
71291 int rc = SQLITE_OK;
71301 if( rc==SQLITE_OK ){
71327 testcase( rc==SQLITE_OK );
71402 ** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
71406 int rc = SQLITE_OK; /* Return code */
71432 for(; rc==SQLITE_OK && iRead<=iLast; iRead++){
71435 if( rc==SQLITE_OK ){
71494 if( SQLITE_OK!=(rc = walRestartLog(pWal)) ){
71525 if( rc!=SQLITE_OK ){
71565 assert( rc==SQLITE_OK || iWrite==0 );
71626 assert( rc==SQLITE_OK );
71650 for(p=pList; p && rc==SQLITE_OK; p=p->pDirty){
71656 while( rc==SQLITE_OK && nExtra>0 ){
71662 if( rc==SQLITE_OK ){
71759 testcase( rc!=SQLITE_OK && xBusy2!=0 );
71760 if( rc==SQLITE_OK ){
71774 if( rc==SQLITE_OK ){
71779 rc = SQLITE_OK;
71784 rc = SQLITE_OK;
71790 if( rc==SQLITE_OK ){
71805 if( rc==SQLITE_OK ){
71814 if( rc==SQLITE_OK || rc==SQLITE_BUSY ){
71846 return (rc==SQLITE_OK && eMode!=eMode2 ? SQLITE_BUSY : rc);
71906 if( walLockShared(pWal, WAL_READ_LOCK(pWal->readLock))!=SQLITE_OK ){
71941 int rc = SQLITE_OK;
72005 ** available. If so, SQLITE_OK is returned.
72009 ** occurs (any value other than SQLITE_OK is returned), the CHECKPOINTER
72016 if( rc==SQLITE_OK ){
72789 int rc; /* SQLITE_OK, SQLITE_NOMEM, or SQLITE_INTERRUPT */
72919 if( sqlite3_mutex_try(p->pBt->mutex)==SQLITE_OK ){
73210 return SQLITE_OK;
73226 #define querySharedCacheTableLock(a,b,c) SQLITE_OK
73227 #define setSharedCacheTableLock(a,b,c) SQLITE_OK
73445 ** SQLITE_OK if the lock may be obtained (by calling
73466 return SQLITE_OK;
73498 return SQLITE_OK;
73515 ** already been called and returned SQLITE_OK).
73517 ** SQLITE_OK is returned if the lock is added successfully. SQLITE_NOMEM
73540 assert( SQLITE_OK==querySharedCacheTableLock(p, iTable, eLock) );
73573 return SQLITE_OK;
73771 int rc = SQLITE_OK;
73779 if( rc==SQLITE_OK && pgno<=sqlite3BitvecSize(pBt->pHasContent) ){
73824 ** pCur->pKey. SQLITE_OK is returned if successful or an SQLite error
73834 int rc = SQLITE_OK;
73854 if( rc==SQLITE_OK ){
73892 if( rc==SQLITE_OK ){
73934 return SQLITE_OK;
73951 if( SQLITE_OK!=rc ){
73961 return SQLITE_OK;
74029 if( rc==SQLITE_OK ){
74044 SQLITE_OK)
74105 return SQLITE_OK;
74175 ** If *pRC is initially non-zero (non-SQLITE_OK) then this routine is
74199 if( rc!=SQLITE_OK ){
74221 if( rc==SQLITE_OK ){
74236 ** An error code is returned if something goes wrong, otherwise SQLITE_OK.
74266 return SQLITE_OK;
74271 #define ptrmapGet(w,x,y,z) SQLITE_OK
74849 return SQLITE_OK;
74928 ** of the first byte of allocated space. Return either SQLITE_OK or
74942 int rc = SQLITE_OK; /* Integer return code */
74990 return SQLITE_OK;
75021 return SQLITE_OK;
75132 return SQLITE_OK;
75203 return SQLITE_OK;
75285 return SQLITE_OK;
75321 return SQLITE_OK;
75327 ** Return SQLITE_OK on success. If we see that the page does
75329 ** SQLITE_CORRUPT. Note that a return of SQLITE_OK does not
75379 return SQLITE_OK;
75461 return SQLITE_OK;
75518 if( rc!=SQLITE_OK ){
75527 return SQLITE_OK;
75575 if( rc==SQLITE_OK ){
75658 int rc = SQLITE_OK; /* Result code from this function */
75728 rc = SQLITE_OK;
75799 if( rc==SQLITE_OK ){
75803 if( rc!=SQLITE_OK ){
75911 if( rc!=SQLITE_OK ){
75938 assert( rc!=SQLITE_OK || sqlite3BtreeConnectionCount(*ppBtree)>0 );
76019 return SQLITE_OK;
76060 sqlite3BtreeRollback(p, SQLITE_OK, 0);
76092 return SQLITE_OK;
76108 return SQLITE_OK;
76142 return SQLITE_OK;
76164 return SQLITE_OK;
76189 int rc = SQLITE_OK;
76198 return SQLITE_OK;
76322 int rc = SQLITE_OK;
76392 ** SQLITE_OK is returned on success. If the file is not a
76406 if( rc!=SQLITE_OK ) return rc;
76408 if( rc!=SQLITE_OK ) return rc;
76450 ** return SQLITE_OK and return without populating BtShared.pPage1.
76459 if( rc!=SQLITE_OK ){
76465 return SQLITE_OK;
76508 ** zero and return SQLITE_OK. The caller will call this function
76568 return SQLITE_OK;
76632 return SQLITE_OK;
76661 return SQLITE_OK;
76666 ** consisting of a single page and no schema objects). Return SQLITE_OK
76720 int rc = SQLITE_OK;
76778 if( SQLITE_OK!=rc ) goto trans_begun;
76791 if( rc!=SQLITE_BUSY && rc!=SQLITE_OK ) break;
76820 ** lockBtree() returns something other than SQLITE_OK. lockBtree()
76821 ** may return SQLITE_OK but leave pBt->pPage1 set to 0 if after
76826 while( pBt->pPage1==0 && SQLITE_OK==(rc = lockBtree(pBt)) );
76828 if( rc==SQLITE_OK && wrflag ){
76833 if( rc==SQLITE_OK ){
76844 if( rc!=SQLITE_OK ){
76862 if( rc==SQLITE_OK ){
76895 if( rc==SQLITE_OK ){
76903 if( rc==SQLITE_OK ){
76939 return SQLITE_OK;
76958 rc = pPage->isInit ? SQLITE_OK : btreeInitPage(pPage);
76959 if( rc!=SQLITE_OK ) return rc;
77009 rc = pPage->isInit ? SQLITE_OK : btreeInitPage(pPage);
77046 return SQLITE_OK;
77082 if( rc!=SQLITE_OK ){
77097 if( rc!=SQLITE_OK ){
77104 if( rc!=SQLITE_OK ){
77116 if( rc!=SQLITE_OK ){
77120 if( rc!=SQLITE_OK ){
77126 if( rc==SQLITE_OK ){
77138 ** SQLITE_OK. If there is no work to do (and therefore no point in
77170 if( rc!=SQLITE_OK ){
77187 if( rc!=SQLITE_OK ){
77200 if( rc!=SQLITE_OK ){
77219 if( rc!=SQLITE_OK ){
77233 if( rc!=SQLITE_OK ){
77246 return SQLITE_OK;
77278 ** SQLITE_OK is returned. Otherwise an SQLite error code.
77297 if( rc==SQLITE_OK ){
77301 if( rc==SQLITE_OK ){
77318 int rc = SQLITE_OK;
77366 return SQLITE_OK;
77376 for(iFree=nOrig; iFree>nFin && rc==SQLITE_OK; iFree--){
77379 if( (rc==SQLITE_DONE || rc==SQLITE_OK) && nFree>0 ){
77389 if( rc!=SQLITE_OK ){
77399 # define setChildPtrmaps(x) SQLITE_OK
77429 int rc = SQLITE_OK;
77436 if( rc!=SQLITE_OK ){
77519 if( p->inTrans==TRANS_NONE ) return SQLITE_OK;
77532 if( rc!=SQLITE_OK && bCleanup==0 ){
77543 return SQLITE_OK;
77553 if( rc==SQLITE_OK ){
77583 ** SQLITE_OK is returned if successful, or if an error occurs while
77588 int rc = SQLITE_OK;
77597 if( rc!=SQLITE_OK ){
77629 ** If tripCode is not SQLITE_OK then cursors will be invalidated (tripped).
77643 assert( tripCode==SQLITE_ABORT_ROLLBACK || tripCode==SQLITE_OK );
77645 if( tripCode==SQLITE_OK ){
77649 rc = SQLITE_OK;
77653 assert( rc==SQLITE_OK || (writeOnly==0 && rc2==SQLITE_OK) );
77654 if( rc2!=SQLITE_OK ) rc = rc2;
77663 if( rc2!=SQLITE_OK ){
77670 if( btreeGetPage(pBt, 1, &pPage1, 0)==SQLITE_OK ){
77734 int rc = SQLITE_OK;
77743 if( rc==SQLITE_OK ){
77746 if( rc==SQLITE_OK ){
77869 return SQLITE_OK;
77977 return SQLITE_OK;
78130 int rc = SQLITE_OK;
78153 if( rc==SQLITE_OK && eType==PTRMAP_OVERFLOW2 && pgno==ovfl ){
78162 if( rc==SQLITE_OK ){
78164 assert( rc==SQLITE_OK || pPage==0 );
78165 if( rc==SQLITE_OK ){
78176 return (rc==SQLITE_DONE ? SQLITE_OK : rc);
78188 ** SQLITE_OK is returned on success, otherwise an error code.
78200 if( rc!=SQLITE_OK ){
78208 return SQLITE_OK;
78248 int rc = SQLITE_OK;
78293 if( rc==SQLITE_OK && amt>0 ){
78343 assert( rc==SQLITE_OK && amt>0 );
78411 if( rc==SQLITE_OK ){
78428 if( rc==SQLITE_OK && amt>0 ){
78448 ** Return SQLITE_OK on success or an error code if anything goes
78577 assert( pCur->pPage!=0 || rc!=SQLITE_OK );
78578 if( rc==SQLITE_OK
78663 int rc = SQLITE_OK;
78688 assert( pCur->skipNext!=SQLITE_OK );
78695 if( rc!=SQLITE_OK ){
78749 int rc = SQLITE_OK;
78754 while( rc==SQLITE_OK && !(pPage = pCur->pPage)->leaf ){
78774 int rc = SQLITE_OK;
78788 return SQLITE_OK;
78791 /* Move the cursor to the first entry in the table. Return SQLITE_OK
78801 if( rc==SQLITE_OK ){
78808 rc = SQLITE_OK;
78815 ** Return SQLITE_OK on success or some error code (ex: SQLITE_NOMEM) if
78825 return SQLITE_OK;
78830 rc = SQLITE_OK;
78854 /* Move the cursor to the last entry in the table. Return SQLITE_OK
78860 if( rc==SQLITE_OK ){
78864 if( rc==SQLITE_OK ){
78872 rc = SQLITE_OK;
78884 return SQLITE_OK;
78931 return SQLITE_OK;
78937 return SQLITE_OK;
78946 if( rc==SQLITE_OK ){
78949 return SQLITE_OK;
78967 return SQLITE_OK;
79024 return SQLITE_OK;
79036 rc = SQLITE_OK;
79186 && pIdxKey->errCode==SQLITE_OK
79189 return SQLITE_OK; /* Cursor already pointing at the correct spot */
79193 && pIdxKey->errCode==SQLITE_OK
79201 pIdxKey->errCode = SQLITE_OK;
79209 return SQLITE_OK;
79314 rc = SQLITE_OK;
79329 rc = SQLITE_OK;
79354 if( rc==SQLITE_OK
79418 ** SQLITE_OK success
79443 if( rc!=SQLITE_OK ){
79451 if( pCur->skipNext>0 ) return SQLITE_OK;
79479 return SQLITE_OK;
79483 return SQLITE_OK;
79502 return SQLITE_OK;
79512 ** SQLITE_OK success
79537 if( rc!=SQLITE_OK ){
79545 if( pCur->skipNext<0 ) return SQLITE_OK;
79575 rc = SQLITE_OK;
79593 return SQLITE_OK;
79604 ** SQLITE_OK is returned on success. Any other return value indicates
79748 if( rc!=SQLITE_OK ){
79766 if( rc!=SQLITE_OK ){
79770 if( rc!=SQLITE_OK ){
79846 if( rc==SQLITE_OK ){
79848 if( rc!=SQLITE_OK ){
79895 if( rc==SQLITE_OK ){
79911 if( rc!=SQLITE_OK ){
79923 assert( rc!=SQLITE_OK || sqlite3PagerPageRefcount((*ppPage)->pDbPage)<=1 );
79924 assert( rc!=SQLITE_OK || (*ppPage)->isInit==0 );
80004 if( rc!=SQLITE_OK ){
80035 if( rc==SQLITE_OK ){
80054 if( pPage==0 && SQLITE_OK!=(rc = btreeGetPage(pBt, iPage, &pPage, 0)) ){
80058 if( rc!=SQLITE_OK ){
80075 if( (*pRC)==SQLITE_OK ){
80148 return SQLITE_OK;
80153 ** Store the result code (SQLITE_OK or some error code) in rc.
80162 rc = SQLITE_OK; \
80235 return SQLITE_OK;
80328 if( pBt->autoVacuum && rc==SQLITE_OK ){
80360 return SQLITE_OK;
80480 if( NEVER(rc!=SQLITE_OK) ){
80510 int rc2 = SQLITE_OK;
80519 return SQLITE_OK;
80570 if( rc!=SQLITE_OK ){
80594 int rc2 = SQLITE_OK;
80603 return SQLITE_OK;
80814 return SQLITE_OK;
81078 return SQLITE_OK;
81131 if( rc==SQLITE_OK ){
81192 if( rc==SQLITE_OK ){
81268 if( (*pRC)==SQLITE_OK ){
81294 if( rc==SQLITE_OK ) rc = btreeComputeFreeSpace(pTo);
81295 if( rc!=SQLITE_OK ){
81362 int rc = SQLITE_OK; /* The return code */
81437 if( rc==SQLITE_OK ){
81778 && rc==SQLITE_OK
81795 if( rc!=SQLITE_OK ){
81990 if( rc!=SQLITE_OK ) goto balance_cleanup;
82079 testcase( rc!=SQLITE_OK );
82083 || rc!=SQLITE_OK
82108 if( ISAUTOVACUUM(pBt) && rc==SQLITE_OK && apNew[0]->isInit ){
82149 ** page and SQLITE_OK is returned. In this case the caller is required
82167 if( rc==SQLITE_OK ){
82197 return SQLITE_OK;
82221 return SQLITE_OK;
82235 int rc = SQLITE_OK;
82254 if( pPage->nOverflow && (rc = anotherValidCursor(pCur))==SQLITE_OK ){
82263 if( rc==SQLITE_OK ){
82284 if( rc==SQLITE_OK && pParent->nFree<0 ){
82287 if( rc==SQLITE_OK ){
82357 }while( rc==SQLITE_OK );
82404 return SQLITE_OK;
82456 return SQLITE_OK;
82689 rc = SQLITE_OK;
82741 assert( rc==SQLITE_OK ); /* clearCell never fails when nLocal==nPayload */
82749 return SQLITE_OK;
82761 assert( pPage->nOverflow==0 || rc==SQLITE_OK );
82762 assert( rc!=SQLITE_OK || pPage->nCell>0 || pPage->nOverflow>0 );
82785 assert( rc==SQLITE_OK );
82795 if( (flags & BTREE_SAVEPOSITION) && rc==SQLITE_OK ){
82829 ** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
82854 return SQLITE_OK;
82856 int rc = SQLITE_OK;
82894 if( rc==SQLITE_OK ){
82901 }while( rc==SQLITE_OK && nOut>0 );
82903 if( rc==SQLITE_OK && nRem>0 && ALWAYS(pPgnoOut) ){
82920 }while( nRem>0 && rc==SQLITE_OK );
82966 assert( rc!=SQLITE_OK || CORRUPT_DB || pCur->eState==CURSOR_VALID );
83082 if( rc==SQLITE_OK ){
83109 rc = SQLITE_OK;
83113 if( rc==SQLITE_OK && pCur->iPage>iCellDepth ){
83123 if( rc==SQLITE_OK ){
83141 if( rc==SQLITE_EMPTY ) rc = SQLITE_OK;
83210 if( rc!=SQLITE_OK ){
83229 if( rc!=SQLITE_OK ){
83235 if( rc!=SQLITE_OK ){
83242 if( rc!=SQLITE_OK ){
83252 if( rc!=SQLITE_OK ){
83256 if( rc!=SQLITE_OK ){
83260 if( rc!=SQLITE_OK ){
83301 return SQLITE_OK;
83390 if( SQLITE_OK==rc ){
83468 if( rc!=SQLITE_OK ){
83479 if( rc!=SQLITE_OK ){
83484 if( rc!=SQLITE_OK ){
83491 if( rc!=SQLITE_OK ){
83551 assert( SQLITE_OK==querySharedCacheTableLock(p, SCHEMA_ROOT, READ_LOCK) );
83586 if( rc==SQLITE_OK ){
83604 ** SQLITE_OK is returned if the operation is successfully executed.
83615 return SQLITE_OK;
83621 while( rc==SQLITE_OK && !AtomicLoad(&db->u1.isInterrupted) ){
83641 ** If all pages in the tree have been visited, return SQLITE_OK to the
83806 if( rc!=SQLITE_OK ){
84440 int rc = SQLITE_OK;
84499 ** sqlite_schema table. Otherwise SQLITE_OK.
84507 assert( rc==SQLITE_OK || rc==SQLITE_LOCKED_SHAREDCACHE );
84520 int rc = SQLITE_OK;
84529 if( rc==SQLITE_OK ){
84556 if( rc!=SQLITE_OK ){
84570 ** saveAllCursors can only return SQLITE_OK.
84573 assert( rc==SQLITE_OK );
84621 if( rc==SQLITE_OK ){
84625 if( rc==SQLITE_OK ){
84627 if( rc==SQLITE_OK ){
84810 ** second argument. If there is not, return SQLITE_OK. Otherwise, if there
84819 return SQLITE_OK;
84882 || checkReadTransaction(pDestDb, p->pDest)!=SQLITE_OK
84908 return (rc!=SQLITE_OK && rc!=SQLITE_BUSY && ALWAYS(rc!=SQLITE_LOCKED));
84927 int rc = SQLITE_OK;
84941 for(iOff=iEnd-(i64)nSrcPgsz; rc==SQLITE_OK && iOff<iEnd; iOff+=nDestPgsz){
84945 if( SQLITE_OK==(rc = sqlite3PagerGet(pDestPager, iDest, &pDestPg, 0))
84946 && SQLITE_OK==(rc = sqlite3PagerWrite(pDestPg))
84976 ** Return SQLITE_OK if everything is successful, or an SQLite error
84982 if( rc==SQLITE_OK && iCurrent>iSize ){
85033 rc = SQLITE_OK;
85040 if( rc==SQLITE_OK && SQLITE_TXN_NONE==sqlite3BtreeTxnState(p->pSrc) ){
85051 if( p->bDestLocked==0 && rc==SQLITE_OK && setDestPgsz(p)==SQLITE_NOMEM ){
85056 if( SQLITE_OK==rc && p->bDestLocked==0
85057 && SQLITE_OK==(rc = sqlite3BtreeBeginTrans(p->pDest, 2,
85068 if( SQLITE_OK==rc
85085 if( rc==SQLITE_OK ){
85092 if( rc==SQLITE_OK ){
85112 if( rc==SQLITE_OK || rc==SQLITE_DONE ){
85115 if( rc==SQLITE_OK ){
85123 if( rc==SQLITE_OK ){
85181 for(iPg=nDestTruncate; rc==SQLITE_OK && iPg<=(Pgno)nDstPage; iPg++){
85185 if( rc==SQLITE_OK ){
85191 if( rc==SQLITE_OK ){
85199 rc==SQLITE_OK && iOff<iEnd;
85205 if( rc==SQLITE_OK ){
85211 if( rc==SQLITE_OK ){
85216 if( rc==SQLITE_OK ){
85225 if( SQLITE_OK==rc
85226 && SQLITE_OK==(rc = sqlite3BtreeCommitPhaseTwo(p->pDest, 0))
85242 assert( rc2==SQLITE_OK );
85267 if( p==0 ) return SQLITE_OK;
85290 sqlite3BtreeRollback(p->pDest, SQLITE_OK, 0);
85293 rc = (p->rc==SQLITE_DONE) ? SQLITE_OK : p->rc;
85370 if( rc!=SQLITE_OK ){
85420 if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
85442 assert( b.rc!=SQLITE_OK );
85445 if( rc==SQLITE_OK ){
85668 ** SQLITE_OK is returned if the conversion is successful (or not required).
85682 return SQLITE_OK;
85685 return SQLITE_OK;
85692 /* MemTranslate() may return SQLITE_OK or SQLITE_NOMEM. If NOMEM is returned,
85696 assert(rc==SQLITE_OK || rc==SQLITE_NOMEM);
85697 assert(rc==SQLITE_OK || pMem->enc!=desiredEnc);
85758 return SQLITE_OK;
85771 ** Return SQLITE_OK on success or an error code (probably SQLITE_NOMEM)
85783 return SQLITE_OK;
85841 return SQLITE_OK;
85848 ** Return SQLITE_OK on success or SQLITE_NOMEM if malloc fails.
85866 return SQLITE_OK;
85886 if( (pMem->flags & MEM_Blob)==0 ) return SQLITE_OK;
85898 return SQLITE_OK;
85911 return SQLITE_OK; /* Nothing to do */
85955 return SQLITE_OK;
85963 ** Return SQLITE_ERROR if the finalizer reports an error. SQLITE_OK
85995 ** SQLITE_ERROR is returned if xValue() reports an error. SQLITE_OK
86141 int rc = SQLITE_OK;
86302 return SQLITE_OK;
86316 return SQLITE_OK;
86376 return SQLITE_OK;
86387 if( pMem->flags & MEM_Null ) return SQLITE_OK;
86425 return SQLITE_OK;
86490 return SQLITE_OK;
86576 ** Return SQLITE_OK on success and SQLITE_NOMEM if a memory allocation
86590 return SQLITE_OK;
86678 int rc = SQLITE_OK;
86752 return SQLITE_OK;
86826 return SQLITE_OK;
86851 return SQLITE_OK;
86904 return SQLITE_OK;
86938 if( SQLITE_OK==(rc = sqlite3VdbeMemClearAndResize(pMem, amt+1)) ){
86940 if( rc==SQLITE_OK ){
86956 int rc = SQLITE_OK; /* Return code */
86996 if( sqlite3VdbeMemMakeWriteable(pVal)!=SQLITE_OK ){
87144 ** object containing the result before returning SQLITE_OK.
87150 ** If the conditions above are not met, this function returns SQLITE_OK
87168 int rc = SQLITE_OK; /* Return code */
87180 if( pFunc==0 ) return SQLITE_OK;
87186 return SQLITE_OK;
87198 if( apVal[i]==0 || rc!=SQLITE_OK ) goto value_from_function_out;
87218 assert( rc==SQLITE_OK );
87220 if( NEVER(rc==SQLITE_OK && sqlite3VdbeMemTooBig(pVal)) ){
87227 if( rc!=SQLITE_OK ){
87242 # define valueFromFunction(a,b,c,d,e,f) SQLITE_OK
87268 int rc = SQLITE_OK;
87285 testcase( rc!=SQLITE_OK );
87357 if( SQLITE_OK==valueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal,pCtx)
87474 int rc = SQLITE_OK;
87538 ** Unless an error is encountered, SQLITE_OK is returned. It is not an
87551 int rc = SQLITE_OK;
87582 ** SQLITE_OK. If no value can be extracted, but no other error occurs
87583 ** (e.g. OOM), return SQLITE_OK and set *ppVal to NULL. Or, if an error
87646 return SQLITE_OK;
87918 return (pNew ? SQLITE_OK : SQLITE_NOMEM_BKPT);
88510 && ((pOp->p1)!=SQLITE_OK && pOp->p2==OE_Abort))
89994 int rc = SQLITE_OK; /* Result code */
90021 p->rc = SQLITE_OK;
90056 if( p->rc!=SQLITE_OK ){
90132 int rc = SQLITE_OK; /* Return code */
90140 assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY || p->rc==SQLITE_NOMEM );
90169 if( rc==SQLITE_OK ){
90208 p->rc = SQLITE_OK;
90334 p->rc = SQLITE_OK;
90644 int rc = SQLITE_OK;
90649 ** SQLITE_OK so p is not used.
90668 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
90697 if( rc!=SQLITE_OK ){
90722 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
90735 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
90743 if( rc==SQLITE_OK ){
90788 }while( rc==SQLITE_OK && res );
90789 if( rc==SQLITE_OK ){
90796 if( rc!=SQLITE_OK ){
90817 if( rc!=SQLITE_OK ){
90830 && SQLITE_OK!=(rc = sqlite3OsSync(pSuperJrnl, SQLITE_SYNC_NORMAL))
90848 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
90856 if( rc!=SQLITE_OK ){
90937 ** Otherwise SQLITE_OK.
90941 int rc = SQLITE_OK;
90950 int rc2 = SQLITE_OK;
90956 if( rc2==SQLITE_OK ){
90959 if( rc==SQLITE_OK ){
90967 if( rc==SQLITE_OK ){
90971 if( rc==SQLITE_OK ){
90989 return SQLITE_OK;
90997 ** return an error code. Otherwise, SQLITE_OK.
91012 if( p->nFkConstraint==0 ) return SQLITE_OK;
91017 if( (db->nDeferredCons+db->nDeferredImmCons)==0 ) return SQLITE_OK;
91111 if( p->rc==SQLITE_OK || (p->errorAction==OE_Fail && !isSpecialError) ){
91125 if( p->rc==SQLITE_OK || (p->errorAction==OE_Fail && !isSpecialError) ){
91127 if( rc!=SQLITE_OK ){
91146 }else if( rc!=SQLITE_OK ){
91149 sqlite3RollbackAll(db, SQLITE_OK);
91160 sqlite3RollbackAll(db, SQLITE_OK);
91165 if( p->rc==SQLITE_OK || p->errorAction==OE_Fail ){
91180 ** error code is SQLITE_OK or SQLITE_CONSTRAINT, then promote the
91186 if( p->rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT ){
91236 return (p->rc==SQLITE_BUSY ? SQLITE_BUSY : SQLITE_OK);
91242 ** in p->rc. This routine sets that result back to SQLITE_OK.
91245 p->rc = SQLITE_OK;
91280 if( sqlite3GlobalConfig.xSqllog && v->rc==SQLITE_OK && v->zSql && v->pc>=0 ){
91398 int rc = SQLITE_OK;
91537 return SQLITE_OK;
91567 return SQLITE_OK;
92906 ** Return SQLITE_OK if everything works, or an error code otherwise.
92969 return SQLITE_OK;
92983 ** or greater than pUnpacked. Return SQLITE_OK on success.
93018 return SQLITE_OK;
93174 int rc = SQLITE_OK;
93194 if( rc==SQLITE_OK ){
93207 for(ii=0; ii<nCol && rc==SQLITE_OK; ii++){
93272 int rc = SQLITE_OK;
93314 for(ii=0; rc==SQLITE_OK && (ii<nStep || nStep<0); ii++){
93316 if( res==0 || rc!=SQLITE_OK ) break;
93320 rc = SQLITE_OK;
93323 if( nStep<0 || rc!=SQLITE_OK || res==0 || bIntegrity ) break;
93632 rc = SQLITE_OK;
93659 rc = SQLITE_OK;
93679 int rc = SQLITE_OK;
93713 if( ExpandBlob(p)!=SQLITE_OK ){
93885 if( sqlite3VdbeMemMakeWriteable(pNew)!=SQLITE_OK ){
94207 return SQLITE_OK;
94268 int rc = SQLITE_OK;
94278 if( nEntry>0 && db->xWalCallback && rc==SQLITE_OK ){
94382 p->rcApp = SQLITE_OK;
94396 assert( p->rc==SQLITE_OK );
94407 assert( p->rc==SQLITE_OK );
94409 if( p->rc!=SQLITE_OK ){
94442 int rc = SQLITE_OK; /* Result from sqlite3Step() */
94456 if( rc!=SQLITE_OK ){
94584 assert( rc==SQLITE_OK || sqlite3BtreeEof(pRhs->pCsr) );
94587 if( rc==SQLITE_OK ){
94593 if( rc==SQLITE_OK ){
95163 ** out of range, then SQLITE_RANGE is returned. Otherwise SQLITE_OK.
95171 ** (tag-20240917-01) If vdbeUnbind(p,(u32)(i-1)) returns SQLITE_OK,
95203 p->db->errCode = SQLITE_OK;
95218 return SQLITE_OK;
95237 if( rc==SQLITE_OK ){
95258 if( rc==SQLITE_OK && encoding!=0 ){
95303 if( rc==SQLITE_OK ){
95317 if( rc==SQLITE_OK ){
95328 if( rc==SQLITE_OK ){
95344 if( rc==SQLITE_OK ){
95426 if( rc==SQLITE_OK ){
95503 return SQLITE_OK;
95517 ** SQLITE_OK is returned.
95574 rc = SQLITE_OK;
95584 rc = SQLITE_OK;
95740 int rc = SQLITE_OK;
95783 if( rc==SQLITE_OK ){
95787 if( rc!=SQLITE_OK ){
95813 if( rc==SQLITE_OK && pVal==0 ){
95899 int rc = SQLITE_OK;
95933 if( rc!=SQLITE_OK ) goto preupdate_new_out;
95969 if( rc!=SQLITE_OK ) goto preupdate_new_out;
97302 int rc = SQLITE_OK; /* Value to return */
97341 assert( p->rc==SQLITE_OK || (p->rc&0xff)==SQLITE_BUSY );
97342 testcase( p->rc!=SQLITE_OK );
97343 p->rc = SQLITE_OK;
97380 assert( rc==SQLITE_OK );
97711 ** or sqlite3_finalize(). For a normal halt, this should be SQLITE_OK (0).
97755 if( p->pFrame && pOp->p1==SQLITE_OK ){
97801 assert( rc==SQLITE_BUSY || rc==SQLITE_OK || rc==SQLITE_ERROR );
97805 assert( rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT );
97806 assert( rc==SQLITE_OK || db->nDeferredCons>0 || db->nDeferredImmCons>0 );
97868 assert( rc==SQLITE_OK || rc==SQLITE_TOOBIG );
97870 if( SQLITE_OK!=sqlite3VdbeChangeEncoding(pOut, encoding) ) goto no_mem;
97887 assert( rc==SQLITE_OK );
98177 if( (rc = sqlite3VdbeCheckFkImmediate(p))!=SQLITE_OK ){
99558 if( rc!=SQLITE_OK ) goto abort_due_to_error;
99630 assert( rc==SQLITE_OK );
100309 if( rc!=SQLITE_OK ) goto abort_due_to_error;
100365 if( (rc = sqlite3VdbeCheckFkDeferred(p))!=SQLITE_OK ){
100390 if( rc!=SQLITE_OK ) goto abort_due_to_error;
100398 if( rc!=SQLITE_OK ){
100438 if( rc!=SQLITE_OK ) goto abort_due_to_error;
100483 }else if( (rc = sqlite3VdbeCheckFkDeferred(p))!=SQLITE_OK ){
100495 if( p->rc==SQLITE_OK ){
100558 assert( rc==SQLITE_OK );
100577 if( rc!=SQLITE_OK ){
100598 if( rc==SQLITE_OK ){
100610 if( rc==SQLITE_OK
100950 assert( rc==SQLITE_OK );
101026 if( rc==SQLITE_OK ){
101028 if( rc==SQLITE_OK ){
101038 if( rc==SQLITE_OK ){
101329 if( rc!=SQLITE_OK ) goto abort_due_to_error;
101360 if( rc!=SQLITE_OK ){
101412 if( rc!=SQLITE_OK ){
101427 if( rc!=SQLITE_OK ){
101429 rc = SQLITE_OK;
101443 if( rc!=SQLITE_OK ){
101445 rc = SQLITE_OK;
101636 rc = SQLITE_OK;
101851 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
101860 if( rc!=SQLITE_OK ){
101983 assert( rc==SQLITE_OK || res==0 );
101991 assert( rc==SQLITE_OK );
102082 if( rc!=SQLITE_OK ){
102140 0, &res))==SQLITE_OK)
102305 if( rc!=SQLITE_OK ) goto abort_due_to_error;
102515 assert( rc!=SQLITE_OK || (pOut->flags & MEM_Blob) );
102973 VdbeBranchTaken(rc==SQLITE_OK,2);
102974 if( rc==SQLITE_OK ){
102983 rc = SQLITE_OK;
103106 if( rc!=SQLITE_OK ) goto abort_due_to_error;
103176 if( rc!=SQLITE_OK ) goto abort_due_to_error;
103181 if( rc!=SQLITE_OK ){
103342 assert( rc==SQLITE_OK );
103606 initData.rc = SQLITE_OK;
103610 if( rc==SQLITE_OK ) rc = initData.rc;
103611 if( rc==SQLITE_OK && initData.nInitRow==0 ){
103792 rc = SQLITE_OK;
104478 rc = SQLITE_OK;
104561 if( rc==SQLITE_OK ){
104574 if( rc==SQLITE_OK ){
104631 rc = SQLITE_OK;
104767 assert( rc==SQLITE_OK );
105192 if( rc==SQLITE_OK && pOp->p1 ){
105198 rc = SQLITE_OK;
105799 assert( rc!=SQLITE_OK || nExtraDelete==0
105871 ** If successful, SQLITE_OK is returned and subsequent calls to
105930 rc = SQLITE_OK;
105934 if( rc==SQLITE_OK ){
105942 assert( rc!=SQLITE_OK || zErr==0 );
105963 int rc = SQLITE_OK;
106173 if( rc==SQLITE_OK && db->mallocFailed==0 ){
106204 rc = SQLITE_OK;
106219 int rc = SQLITE_OK;
106278 if( rc==SQLITE_OK ){
106350 ((Vdbe*)p->pStmt)->rc = SQLITE_OK;
106352 if( rc!=SQLITE_OK ){
106360 assert( rc==SQLITE_OK || p->pStmt==0 );
106853 ** and return SQLITE_OK. Otherwise, if an error occurs, return an SQLite
106870 return SQLITE_OK;
106894 if( rc!=SQLITE_OK ) return rc;
106937 if( rc!=SQLITE_OK ) return rc;
106947 return SQLITE_OK;
106975 return SQLITE_OK;
106980 ** new mapping and return SQLITE_OK. If the mapping is not attempted
106982 ** mmap), return SQLITE_OK and set *pp to NULL.
106988 int rc = SQLITE_OK;
106993 testcase( rc!=SQLITE_OK );
107001 ** that file) and seek it to offset iOff within the file. Return SQLITE_OK
107010 int rc = SQLITE_OK;
107024 if( rc==SQLITE_OK && pReadr->aMap==0 ){
107032 if( rc==SQLITE_OK && iBuf ){
107040 testcase( rc!=SQLITE_OK );
107048 ** Advance PmaReader pReadr to the next key in its PMA. Return SQLITE_OK if
107052 int rc = SQLITE_OK; /* Return Code */
107061 if( rc==SQLITE_OK && pIncr->bEof==0 ){
107072 testcase( rc!=SQLITE_OK );
107077 if( rc==SQLITE_OK ){
107080 if( rc==SQLITE_OK ){
107083 testcase( rc!=SQLITE_OK );
107113 if( rc==SQLITE_OK ){
107120 if( rc==SQLITE_OK ){
107302 ** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
107315 int rc = SQLITE_OK;
107498 int rc = SQLITE_OK;
107545 if( rc==SQLITE_OK ) rc = rc2;
107551 # define vdbeSorterJoinThread(pTask) SQLITE_OK
107617 (void)vdbeSorterJoinAll(pSorter, SQLITE_OK);
107692 ** set *ppFd to point to the malloc'd file-handle and return SQLITE_OK.
107707 if( rc==SQLITE_OK ){
107719 ** structure at pTask->pUnpacked. Return SQLITE_OK if successful (or
107729 return SQLITE_OK;
107789 ** SQLITE_OK if successful, or an SQLite error code (i.e. SQLITE_NOMEM) if
107799 if( rc!=SQLITE_OK ) return rc;
107838 assert( pTask->pUnpacked->errCode==SQLITE_OK
107866 ** Write nData bytes of data to the PMA. Return SQLITE_OK
107897 ** Return SQLITE_OK if flushing the buffered data succeeds or is not
107923 ** SQLITE_OK if successful, or an SQLite error code if an error occurs.
107934 ** PMA in the temp file belonging to sub-task pTask. Return SQLITE_OK if
107948 int rc = SQLITE_OK; /* Return code */
107964 assert( rc!=SQLITE_OK || pTask->file.pFd );
107970 if( rc==SQLITE_OK ){
107975 if( rc==SQLITE_OK ){
107979 if( rc==SQLITE_OK ){
107998 assert( rc!=SQLITE_OK || pList->pList==0 );
107999 assert( rc!=SQLITE_OK || pTask->file.iEof==iSz );
108008 ** Return SQLITE_OK if successful or an error code if an error occurs.
108022 if( rc==SQLITE_OK ){
108074 return (rc==SQLITE_OK ? pTask->pUnpacked->errCode : rc);
108100 int rc = SQLITE_OK;
108123 if( rc!=SQLITE_OK || pTask->pThread==0 ) break;
108126 if( rc==SQLITE_OK ){
108170 int rc = SQLITE_OK; /* Return Code */
108221 assert( rc!=SQLITE_OK || pSorter->list.pList==0 );
108278 int rc = SQLITE_OK;
108290 while( rc==SQLITE_OK ){
108309 if( rc==SQLITE_OK ) rc = rc2;
108351 ** SQLITE_OK is returned on success, or an SQLite error code otherwise.
108354 int rc = SQLITE_OK;
108360 if( rc==SQLITE_OK ){
108366 if( rc==SQLITE_OK ){
108397 int rc = SQLITE_OK;
108409 assert( *ppOut!=0 || rc!=SQLITE_OK );
108510 ** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
108517 int rc = SQLITE_OK; /* Return code */
108546 if( rc!=SQLITE_OK ) return rc;
108586 ** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
108589 int rc = SQLITE_OK;
108602 if( rc==SQLITE_OK ){
108607 if( rc==SQLITE_OK ){
108618 if( rc==SQLITE_OK ){
108627 if( rc==SQLITE_OK && pIncr->bUseThread ){
108643 if( rc==SQLITE_OK && (SQLITE_MAX_WORKER_THREADS==0 || eMode!=INCRINIT_TASK) ){
108678 int rc = SQLITE_OK; /* Return code */
108697 ** the new object and return SQLITE_OK. Or, if an error does occur, set *ppOut
108715 int rc = SQLITE_OK;
108720 for(i=0; i<nPMA && rc==SQLITE_OK; i++){
108727 if( rc!=SQLITE_OK ){
108760 ** If successful, SQLITE_OK is returned. If an error occurs, an SQLite error
108770 int rc = SQLITE_OK;
108782 for(i=1; i<nDepth && rc==SQLITE_OK; i++){
108794 if( rc==SQLITE_OK ){
108800 if( rc==SQLITE_OK ){
108814 ** If successful, SQLITE_OK is returned and *ppOut set to point to the
108824 int rc = SQLITE_OK;
108838 for(iTask=0; rc==SQLITE_OK && iTask<pSorter->nTask; iTask++){
108853 for(i=0; i<pTask->nPMA && rc==SQLITE_OK; i += SORTER_MAX_MERGE_COUNT){
108859 if( rc==SQLITE_OK ){
108865 if( rc==SQLITE_OK ){
108881 if( rc!=SQLITE_OK ){
108896 ** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
108912 if( rc==SQLITE_OK ){
108920 if( rc==SQLITE_OK ){
108925 if( rc==SQLITE_OK ){
108927 if( rc==SQLITE_OK ){
108936 for(iTask=0; rc==SQLITE_OK && iTask<pSorter->nTask; iTask++){
108956 if( rc==SQLITE_OK ){
108968 if( rc!=SQLITE_OK ){
108982 int rc = SQLITE_OK; /* Return code */
109016 if( rc==SQLITE_OK ){
109028 ** SQLITE_OK success
109046 if( rc==SQLITE_OK && pSorter->pReader->pFd==0 ) rc = SQLITE_DONE;
109054 if( rc==SQLITE_OK && res ) rc = SQLITE_DONE;
109061 rc = pSorter->list.pList ? SQLITE_OK : SQLITE_DONE;
109111 return SQLITE_OK;
109158 return SQLITE_OK;
109163 return SQLITE_OK;
109259 if( rc==SQLITE_OK ){
109276 return SQLITE_OK;
109290 return SQLITE_OK;
109318 return SQLITE_OK;
109345 if( rc!=SQLITE_OK ){
109349 return SQLITE_OK;
109481 return SQLITE_OK;
109491 return SQLITE_OK;
109507 int rc = SQLITE_OK;
109558 rc = SQLITE_OK;
109606 if( rc==SQLITE_OK ){
109612 SQLITE_PRIVATE int sqlite3VdbeBytecodeVtabInit(sqlite3 *db){ return SQLITE_OK; }
109743 return SQLITE_OK;
109768 if( rc==SQLITE_OK ){
109780 if( rc==SQLITE_OK ){
109785 if( rc!=SQLITE_OK ){
109817 if( rc==SQLITE_OK ){
109870 return SQLITE_OK;
109900 return SQLITE_OK;
109909 return SQLITE_OK;
109920 return SQLITE_OK;
109929 return SQLITE_OK;
110001 return SQLITE_OK;
110020 int rc = SQLITE_OK;
111489 if( auth!=SQLITE_OK ){
112478 if( pExpr==0 ) return SQLITE_OK;
112511 ** The return value is SQLITE_OK (0) for success or SQLITE_ERROR (1) for a
112521 if( pList==0 ) return SQLITE_OK;
112555 return SQLITE_OK;
112639 if( (rc = sqlite3ResolveExprNames(&sNC, pExpr))!=SQLITE_OK ) return rc;
113438 int rc = SQLITE_OK;
118388 sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_OK, OE_Ignore);
120517 if( SQLITE_OK!=isAlterableTable(pParse, pTab) ){
120520 if( SQLITE_OK!=sqlite3CheckObjectName(pParse,zName,"table",zName) ){
120740 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
120741 if( rc!=SQLITE_OK ){
120860 if( SQLITE_OK!=isAlterableTable(pParse, pTab) ){
120969 if( SQLITE_OK!=isAlterableTable(pParse, pTab) ) goto exit_rename_column;
120970 if( SQLITE_OK!=isRealTable(pParse, pTab, 0) ) goto exit_rename_column;
121536 if( rc==SQLITE_OK
121545 if( rc==SQLITE_OK ){
121577 int rc = SQLITE_OK;
121687 ** it was read from the schema of database zDb. Return SQLITE_OK if
121696 int rc = SQLITE_OK;
121712 if( rc==SQLITE_OK && pNew->pWhen ){
121716 for(pStep=pNew->step_list; rc==SQLITE_OK && pStep; pStep=pStep->pNext){
121721 if( rc==SQLITE_OK && pStep->pSrc ){
121743 rc = pParse->nErr ? SQLITE_ERROR : SQLITE_OK;
121752 for(i=0; i<pStep->pSrc->nSrc && rc==SQLITE_OK; i++){
121765 if( rc==SQLITE_OK && pStep->pWhere ){
121768 if( rc==SQLITE_OK ){
121772 if( pStep->pUpsert && rc==SQLITE_OK ){
121778 if( rc==SQLITE_OK ){
121782 if( rc==SQLITE_OK ){
121785 if( rc==SQLITE_OK ){
121933 if( rc!=SQLITE_OK ) goto renameColumnFunc_done;
121938 sParse.rc = SQLITE_OK;
121941 if( rc==SQLITE_OK ){
121944 if( rc!=SQLITE_OK ) goto renameColumnFunc_done;
121996 if( rc!=SQLITE_OK ) goto renameColumnFunc_done;
122021 assert( rc==SQLITE_OK );
122025 if( rc!=SQLITE_OK ){
122141 if( rc==SQLITE_OK ){
122210 if( rc==SQLITE_OK ){
122229 if( rc==SQLITE_OK ){
122232 if( rc!=SQLITE_OK ){
122309 if( rc==SQLITE_OK ){
122325 sParse.rc = SQLITE_OK;
122328 if( rc==SQLITE_OK ){
122348 if( rc==SQLITE_OK ){
122354 if( rc==SQLITE_OK ){
122359 if( rc!=SQLITE_OK ){
122427 if( rc==SQLITE_OK ){
122440 if( rc==SQLITE_OK ){
122451 if( rc!=SQLITE_OK && zWhen && !sqlite3WritableSchema(db) ){
122550 if( rc!=SQLITE_OK ) goto drop_column_done;
122587 if( rc!=SQLITE_OK ){
122617 if( SQLITE_OK!=isAlterableTable(pParse, pTab) ) goto exit_drop_column;
122618 if( SQLITE_OK!=isRealTable(pParse, pTab, 1) ) goto exit_drop_column;
122803 ** non-zero if they differ. Normally return SQLITE_OK, except if there
122818 return SQLITE_OK;
122829 return SQLITE_OK;
122835 ** that offset into *piOff and return SQLITE_OK. Or, if not found,
122855 return SQLITE_OK;
123048 ** SQLITE_OK. Otherwise, set *piCol to -1 and return an SQLite error
123063 rc = SQLITE_OK;
123068 if( rc==SQLITE_OK ){
123108 if( SQLITE_OK!=isRealTable(pParse, pTab, 2)
123109 || SQLITE_OK!=isAlterableTable(pParse, pTab)
124879 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
125304 if( rc==SQLITE_OK ) initAvgEq(pPrevIdx);
125313 int rc = SQLITE_OK; /* Result codes from subroutines */
125355 int rc = SQLITE_OK;
125402 if( rc==SQLITE_OK ){
125461 int rc = SQLITE_OK;
125536 if( rc==SQLITE_OK ){
125596 if( rc!=SQLITE_OK ){
125618 }else if( rc==SQLITE_OK ){
125640 if( rc==SQLITE_OK && pNew->zDbSName==0 ){
125650 if( rc==SQLITE_OK ){
125665 assert( zErrDyn==0 || rc!=SQLITE_OK );
125785 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ) goto attach_end;
125792 SQLITE_OK!=resolveAttachExpr(&sName, pFilename) ||
125793 SQLITE_OK!=resolveAttachExpr(&sName, pDbname) ||
125794 SQLITE_OK!=resolveAttachExpr(&sName, pKey)
125809 if(rc!=SQLITE_OK ){
126109 ** should return either SQLITE_OK, SQLITE_DENY, or SQLITE_IGNORE. If
126110 ** SQLITE_OK is returned, it means that access is allowed. SQLITE_DENY
126132 return SQLITE_OK;
126163 if( db->init.busy ) return SQLITE_OK;
126170 }else if( rc!=SQLITE_IGNORE && rc!=SQLITE_OK ){
126238 ** either SQLITE_OK (zero) or SQLITE_IGNORE or SQLITE_DENY. If SQLITE_DENY
126257 return SQLITE_OK;
126275 }else if( rc!=SQLITE_OK && rc!=SQLITE_IGNORE ){
126732 && SQLITE_OK!=sqlite3ReadSchema(pParse)
127355 return SQLITE_OK;
127375 return SQLITE_OK;
127591 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
128499 ** Resize an Index object to hold N columns total. Return SQLITE_OK
128506 if( pIdx->nColumn>=N ) return SQLITE_OK;
128528 return SQLITE_OK;
130291 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
130388 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName,"index",pTab->zName) ){
130920 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
131648 if( rc!=SQLITE_OK ){
131891 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
132188 return SQLITE_OK;
132215 return SQLITE_OK;
133071 assert( rcauth==SQLITE_OK || rcauth==SQLITE_DENY || rcauth==SQLITE_IGNORE );
133141 ** The "rcauth==SQLITE_OK" terms is the
133147 if( rcauth==SQLITE_OK
134977 if( str.accError!=SQLITE_OK ){
136043 assert( rc==SQLITE_NOMEM || rc==SQLITE_OK );
141858 && sqlite3FaultSim(411)==SQLITE_OK ){
142045 sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_OK, 0);
142093 int rc = SQLITE_OK; /* Return code */
142103 sqlite3Error(db, SQLITE_OK);
142104 while( rc==SQLITE_OK && zSql[0] ){
142110 assert( rc==SQLITE_OK || pStmt==0 );
142111 if( rc!=SQLITE_OK ){
142184 if( rc!=SQLITE_OK && pzErrMsg ){
143495 ** Return SQLITE_OK on success and SQLITE_ERROR if something goes wrong.
143635 if( rc==SQLITE_OK_LOAD_PERMANENTLY ) return SQLITE_OK;
143656 return SQLITE_OK;
143713 return SQLITE_OK;
143754 int rc = SQLITE_OK;
143831 if( sqlite3_initialize()==SQLITE_OK )
144728 return SQLITE_OK;
144741 if( db->temp_store==ts ) return SQLITE_OK;
144742 if( invalidateTempStorage( pParse ) != SQLITE_OK ){
144746 return SQLITE_OK;
145031 ** connection. If it returns SQLITE_OK, then assume that the VFS
145051 if( rc==SQLITE_OK ){
145372 if( rc==SQLITE_OK && (eAuto==1 || eAuto==2) ){
145383 { OP_Halt, SQLITE_OK, OE_Abort, 0}, /* 3 */
145525 rc = SQLITE_OK;
145527 if( rc==SQLITE_OK ){
145575 if( rc!=SQLITE_OK || res==0 ){
145622 if( rc!=SQLITE_OK || res==0 ){
145669 if( res!=SQLITE_OK ){
147228 if( zRight && sqlite3DecOrHexToI64(zRight, &N)==SQLITE_OK ){
147248 if( zRight && sqlite3DecOrHexToI64(zRight, &N)==SQLITE_OK ){
147266 && sqlite3DecOrHexToI64(zRight, &N)==SQLITE_OK
147285 && sqlite3DecOrHexToI64(zRight, &N)==SQLITE_OK /* IMP: R-40975-20399 */
147313 SQLITE_FCNTL_LOCKSTATE, &j)==SQLITE_OK ){
147410 if( rc==SQLITE_OK ){
147435 return SQLITE_OK;
147452 if( pTab->nHidden==0 ){ return SQLITE_OK; }
147467 return SQLITE_OK;
147479 return SQLITE_OK;
147490 return SQLITE_OK;
147510 return SQLITE_OK;
147516 int rc = SQLITE_OK;
147572 if( rc!=SQLITE_OK ){
147602 return SQLITE_OK;
147611 return SQLITE_OK;
147813 if( SQLITE_OK!=rc ){
147898 initData.rc = SQLITE_OK;
147916 rc = SQLITE_OK;
147926 if( rc!=SQLITE_OK ){
148042 if( rc==SQLITE_OK ) rc = initData.rc;
148045 if( rc==SQLITE_OK ){
148056 if( rc==SQLITE_OK || ((db->flags&SQLITE_NoSchemaError) && rc!=SQLITE_NOMEM)){
148068 rc = SQLITE_OK;
148126 return SQLITE_OK;
148134 int rc = SQLITE_OK;
148139 if( rc!=SQLITE_OK ){
148177 if( rc!=SQLITE_OK ) return;
148354 int rc = SQLITE_OK; /* Result code */
148464 if( sParse.rc!=SQLITE_OK && sParse.rc!=SQLITE_DONE ){
148482 rc = SQLITE_OK;
148525 assert( rc==SQLITE_OK || *ppStmt==0 );
148526 if( rc==SQLITE_OK || db->mallocFailed ) break;
148536 assert( rc==SQLITE_OK || (*ppStmt)==0 );
148544 ** If the statement is successfully recompiled, return SQLITE_OK. Otherwise,
148576 return SQLITE_OK;
148597 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
148615 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );
148637 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );
148660 int rc = SQLITE_OK;
148725 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
148737 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
148752 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
150974 ** Return SQLITE_OK on success. If a memory allocation error occurs,
151091 return SQLITE_OK;
151690 int rc = SQLITE_OK; /* Success code from a subroutine */
151725 rc = SQLITE_OK;
151791 testcase( rc!=SQLITE_OK );
154228 ** pFrom->pIndex and return SQLITE_OK.
154248 return SQLITE_OK;
154632 ** SQLITE_OK is returned. Otherwise, if an OOM error is encountered,
154663 return pParse->nErr ? SQLITE_ERROR : SQLITE_OK;
157865 res.rc = SQLITE_OK;
157888 if( rc!=SQLITE_OK ){
158593 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
159005 if( sqlite3ResolveExprListNames(&sNC, pNew)==SQLITE_OK
159230 && SQLITE_OK==sqlite3ResolveExprNames(&sNC, pWhen)
160943 ** Return SQLITE_OK if everything works, or an error code is something
161075 return SQLITE_OK;
161226 if( rc!=SQLITE_OK ) return rc;
161239 if( rc!=SQLITE_OK ) break;
161243 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
161337 int rc = SQLITE_OK; /* Return code from service routines */
161416 if( rc!=SQLITE_OK ) goto end_of_vacuum;
161426 if( id->pMethods!=0 && (sqlite3OsFileSize(id, &sz)!=SQLITE_OK || sz>0) ){
161457 if( rc!=SQLITE_OK ) goto end_of_vacuum;
161459 if( rc!=SQLITE_OK ) goto end_of_vacuum;
161492 if( rc!=SQLITE_OK ) goto end_of_vacuum;
161498 if( rc!=SQLITE_OK ) goto end_of_vacuum;
161514 if( rc!=SQLITE_OK ) goto end_of_vacuum;
161563 if( NEVER(rc!=SQLITE_OK) ) goto end_of_vacuum;
161569 if( rc!=SQLITE_OK ) goto end_of_vacuum;
161571 if( rc!=SQLITE_OK ) goto end_of_vacuum;
161579 assert( rc==SQLITE_OK );
161714 int rc = SQLITE_OK;
161719 if( rc!=SQLITE_OK && xDestroy ) xDestroy(pAux);
161775 return SQLITE_OK;
162236 assert( pTab->nTabRef>1 || rc!=SQLITE_OK );
162242 if( SQLITE_OK!=rc ){
162326 return SQLITE_OK;
162340 if( rc!=SQLITE_OK ){
162351 ** more v-table. Return SQLITE_NOMEM if a malloc fails, or SQLITE_OK otherwise.
162369 return SQLITE_OK;
162391 int rc = SQLITE_OK;
162415 ** create a valid sqlite3_vtab if it returns SQLITE_OK. */
162416 if( rc==SQLITE_OK && ALWAYS(sqlite3GetVTable(db, pTab)) ){
162418 if( rc==SQLITE_OK ){
162433 int rc = SQLITE_OK;
162484 if( SQLITE_OK==sqlite3RunParser(&sParse, zCreateTable) ){
162547 int rc = SQLITE_OK;
162570 if( rc==SQLITE_OK ){
162614 ** SQLITE_OK if all xSync operations are successful.
162620 int rc = SQLITE_OK;
162624 for(i=0; rc==SQLITE_OK && i<db->nVTrans; i++){
162642 return SQLITE_OK;
162651 return SQLITE_OK;
162663 int rc = SQLITE_OK;
162675 return SQLITE_OK;
162685 return SQLITE_OK;
162692 if( rc==SQLITE_OK ){
162694 if( rc==SQLITE_OK ){
162717 ** If any virtual table method returns an error code other than SQLITE_OK,
162720 ** SQLITE_OK is returned.
162723 int rc = SQLITE_OK;
162729 for(i=0; rc==SQLITE_OK && i<db->nVTrans; i++){
162957 int rc = SQLITE_OK;
162995 if( rc!=SQLITE_OK ) sqlite3Error(db, rc);
170256 if( rc!=SQLITE_OK && rc!=SQLITE_CONSTRAINT ){
170548 ** SQLITE_OK.
170562 int rc = SQLITE_OK;
170575 if( pUpper && rc==SQLITE_OK ){
170583 for(i=0; rc==SQLITE_OK && i<p->nSample; i++){
170585 if( rc==SQLITE_OK && p1 ){
170589 if( rc==SQLITE_OK && p2 ){
170669 int rc = SQLITE_OK;
170740 if( rc==SQLITE_OK && n ){
170757 if( rc==SQLITE_OK && n ){
170770 if( rc==SQLITE_OK ){
170835 ** Write the estimated row count into *pnRow and return SQLITE_OK.
170873 return SQLITE_OK;
170878 if( rc!=SQLITE_OK ) return rc;
170899 ** Write the estimated row count into *pnRow and return SQLITE_OK.
170917 int rc = SQLITE_OK; /* Subfunction return code */
170923 for(i=0; rc==SQLITE_OK && i<pList->nExpr; i++){
170930 if( rc==SQLITE_OK ){
171141 if( p->nLSlot>=n ) return SQLITE_OK;
171149 return SQLITE_OK;
171170 return SQLITE_OK;
171436 return SQLITE_OK;
171452 return SQLITE_OK;
171810 int rc = SQLITE_OK; /* Return code */
171853 for(; rc==SQLITE_OK && pTerm!=0; pTerm = whereScanNext(&scan)){
172071 if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
172072 if( rc!=SQLITE_OK ) break; /* Jump out of the pTerm loop */
172201 && (rc = whereLoopResize(db, pNew, pNew->nLTerm+1))==SQLITE_OK
172585 int rc = SQLITE_OK; /* Return code */
172649 for(pTerm=pWC->a; rc==SQLITE_OK && pTerm<pWCEnd; pTerm++){
172690 for(; rc==SQLITE_OK && pProbe;
172943 int rc = SQLITE_OK;
172988 return SQLITE_OK;
173062 return SQLITE_OK;
173170 int rc = SQLITE_OK;
173182 testcase( rc!=SQLITE_OK );
173188 if( rc==SQLITE_OK && pVal==0 ){ /* IMP: R-19933-32160 */
173256 int rc = SQLITE_OK; /* Return code */
173295 assert( rc==SQLITE_OK );
173306 if( rc==SQLITE_OK && ((mBest = (pNew->prereq & ~mPrereq))!=0 || bIn) ){
173328 while( rc==SQLITE_OK ){
173353 if( rc==SQLITE_OK && seenZero==0 ){
173363 if( rc==SQLITE_OK && seenZeroNoIN==0 ){
173389 int rc = SQLITE_OK;
173404 if( pItem->fg.jointype & JT_RIGHT ) return SQLITE_OK;
173406 for(pTerm=pWC->a; pTerm<pWCEnd && rc==SQLITE_OK; pTerm++){
173450 if( rc==SQLITE_OK ){
173480 for(i=0; rc==SQLITE_OK && i<sSum.n; i++){
173516 int rc = SQLITE_OK;
173589 if( rc==SQLITE_OK && pBuilder->pWC->hasOr ){
173597 rc = SQLITE_OK;
174401 ** Return SQLITE_OK on success or SQLITE_NOMEM of a memory allocation
174826 return SQLITE_OK;
177432 int rc = SQLITE_OK;
177585 assert( rc==SQLITE_OK || pParse->nErr!=0 );
183689 || sqlite3ReadSchema(pParse)==SQLITE_OK
185953 return SQLITE_OK;
186432 pParse->rc = SQLITE_OK;
186529 assert( db->mallocFailed==0 || pParse->rc!=SQLITE_OK || startedWithOom );
186530 if( pParse->rc!=SQLITE_OK ) break;
186548 if( pParse->zErrMsg || (pParse->rc!=SQLITE_OK && pParse->rc!=SQLITE_DONE) ){
186574 assert( nErr==0 || pParse->rc!=SQLITE_OK );
187301 if( rc!=SQLITE_OK ){
187318 return SQLITE_OK;
187344 if( rc==SQLITE_OK ){
187354 if( rc==SQLITE_OK ){
187359 /* If rc is not SQLITE_OK at this point, then either the malloc
187362 if( rc!=SQLITE_OK ){
187393 if( rc==SQLITE_OK ){
187398 if( rc==SQLITE_OK ){
187402 if( rc==SQLITE_OK ){
187412 if( rc==SQLITE_OK ){
187443 if( rc==SQLITE_OK ){
187477 if( rc!=SQLITE_OK ){
187516 return SQLITE_OK;
187530 int rc = SQLITE_OK;
187865 ** Return SQLITE_OK on success.
187979 return SQLITE_OK;
188016 return SQLITE_OK;
188025 int rc = SQLITE_OK;
188033 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
188040 rc = SQLITE_OK;
188046 return ((rc==SQLITE_OK && bSeenBusy) ? SQLITE_BUSY : rc);
188066 rc = SQLITE_OK;
188081 rc = SQLITE_OK;
188130 rc = SQLITE_OK;
188360 return SQLITE_OK;
188411 return SQLITE_OK;
188488 sqlite3RollbackAll(db, SQLITE_OK);
188552 sqlite3Error(db, SQLITE_OK); /* Deallocates any cached error strings. */
188579 ** Rollback all database files. If tripCode is not SQLITE_OK, then
188640 case SQLITE_OK: zName = "SQLITE_OK"; break;
188752 /* SQLITE_OK */ "not an error",
188905 return SQLITE_OK;
188959 return SQLITE_OK;
188993 return SQLITE_OK;
189091 if( rc==SQLITE_OK ){
189096 if( rc!=SQLITE_OK ){
189132 return SQLITE_OK;
189158 return SQLITE_OK;
189205 assert( rc!=SQLITE_OK || (xStep==0 && xFinal==0) );
189341 if( rc ) return SQLITE_OK;
189397 return SQLITE_OK;
189561 return SQLITE_OK;
189583 return SQLITE_OK;
189612 return SQLITE_OK;
189662 return SQLITE_OK;
189733 ** returned (i.e. SQLITE_IOERR). Otherwise, SQLITE_OK.
189747 int rc = SQLITE_OK; /* Return code */
189757 for(i=0; i<db->nDb && rc==SQLITE_OK; i++){
189764 rc = SQLITE_OK;
189769 return (rc==SQLITE_OK && bBusy) ? SQLITE_BUSY : rc;
189844 int rc = SQLITE_OK;
190021 sqlite3Error(db, SQLITE_OK);
190022 return SQLITE_OK;
190158 ** If successful, SQLITE_OK is returned. In this case *ppVfs is set to point to
190177 char **pzErrMsg /* OUT: Error message (if rc!=SQLITE_OK) */
190179 int rc = SQLITE_OK;
190395 if( rc!=SQLITE_OK ){
190664 if( rc!=SQLITE_OK ){
190680 if( rc!=SQLITE_OK ){
190712 sqlite3Error(db, SQLITE_OK);
190718 for(i=0; rc==SQLITE_OK && i<ArraySize(sqlite3BuiltinExtensions); i++){
190725 if( rc==SQLITE_OK ){
190728 if( rc!=SQLITE_OK ){
190769 }else if( rc!=SQLITE_OK ){
190832 if( rc==SQLITE_OK && !DbHasProperty(*ppDb, 0, DB_SchemaLoaded) ){
190892 int rc = SQLITE_OK;
190928 return SQLITE_OK;
190949 return SQLITE_OK;
190998 return SQLITE_OK;
191002 return SQLITE_OK;
191018 return SQLITE_OK;
191028 return SQLITE_OK;
191144 if( SQLITE_OK!=rc ){
191210 if( SQLITE_OK==rc && !pTab ){
191249 return SQLITE_OK;
191274 rc = SQLITE_OK;
191277 rc = SQLITE_OK;
191280 rc = SQLITE_OK;
191283 rc = SQLITE_OK;
191290 rc = SQLITE_OK;
191293 rc = SQLITE_OK;
191687 ** Return SQLITE_OK if SQLite has been initialized and SQLITE_ERROR if
192145 if( rc==SQLITE_OK ){
192185 if( rc==SQLITE_OK ){
192191 rc = SQLITE_OK;
192193 if( rc==SQLITE_OK ){
192196 if( rc==SQLITE_OK ){
192233 if( rc==SQLITE_OK ){
192458 int rc = SQLITE_OK;
193014 /* TODO(shess) Only used for SQLITE_OK and SQLITE_DONE at this time.
193061 ** This method should return either SQLITE_OK (0), or an SQLite error
193062 ** code. If SQLITE_OK is returned, then *ppTokenizer should be set
193098 ** method should either return SQLITE_OK and set the values of the
193764 # define sqlite3Fts3DeferToken(x,y,z) SQLITE_OK
193765 # define sqlite3Fts3CacheDeferredDoclists(x) SQLITE_OK
193767 # define sqlite3Fts3DeferredTokenList(x,y,z) SQLITE_OK
194172 return SQLITE_OK;
194218 int rc = SQLITE_OK; /* Return code */
194237 ** memory associated with the Fts3Table structure and return SQLITE_OK.
194240 return (rc==SQLITE_OK ? fts3DisconnectMethod(pVtab) : rc);
194254 if( *pRc==SQLITE_OK ){
194297 if( (*pRc)==SQLITE_OK ) p->bHasStat = 1;
194310 int rc = SQLITE_OK; /* Return code */
194375 if( *pRc==SQLITE_OK ){
194385 if( rc==SQLITE_OK ){
194391 rc = SQLITE_OK;
194394 assert( p->nPgsz>0 || rc!=SQLITE_OK );
194439 if( *pRc==SQLITE_OK ){
194503 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op (and
194560 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op (and
194612 ** the output value undefined. Otherwise SQLITE_OK is returned.
194629 return SQLITE_OK;
194642 ** If no error occurs, SQLITE_OK is returned and *apIndex set to point to
194690 return SQLITE_OK;
194727 int rc = SQLITE_OK; /* Return code */
194736 if( rc!=SQLITE_OK ){
194742 if( rc==SQLITE_OK ){
194804 int rc = SQLITE_OK; /* Return code */
194864 for(i=3; rc==SQLITE_OK && i<argc; i++){
194983 if( rc==SQLITE_OK && zContent ){
194995 if( rc==SQLITE_OK && zLanguageid ){
195008 if( rc!=SQLITE_OK ) goto fts3_init_out;
195019 if( rc!=SQLITE_OK ) goto fts3_init_out;
195028 if( rc!=SQLITE_OK ) goto fts3_init_out;
195115 if( rc==SQLITE_OK && (zCompress==0)!=(zUncompress==0) ){
195122 if( rc!=SQLITE_OK ) goto fts3_init_out;
195160 if( rc!=SQLITE_OK ){
195265 return SQLITE_OK;
195355 return SQLITE_OK;
195367 ** allocation succeeds, zero it and return SQLITE_OK. Otherwise,
195375 return SQLITE_OK;
195421 return SQLITE_OK;
195434 int rc = SQLITE_OK;
195449 if( rc==SQLITE_OK ) pCsr->bSeekStmt = 1;
195457 ** SQLITE_OK on success.
195460 int rc = SQLITE_OK;
195463 if( rc==SQLITE_OK ){
195470 return SQLITE_OK;
195474 if( rc==SQLITE_OK && ((Fts3Table *)pCsr->base.pVtab)->zContentTbl==0 ){
195485 if( rc!=SQLITE_OK && pContext ){
195504 ** If an OOM error occurs, SQLITE_NOMEM is returned. Otherwise, SQLITE_OK.
195514 int rc = SQLITE_OK; /* Return code */
195630 ** If an error occurs, an error code other than SQLITE_OK is returned.
195641 int rc = SQLITE_OK; /* Return code */
195648 assert_fts3_nc( !piLeaf2 || !piLeaf || rc!=SQLITE_OK || (*piLeaf<=*piLeaf2) );
195650 if( rc==SQLITE_OK && iHeight>1 ){
195656 if( rc==SQLITE_OK ){
195664 if( rc==SQLITE_OK ){
195667 if( rc==SQLITE_OK ){
195918 return SQLITE_OK;
196207 ** containing the output doclist and SQLITE_OK is returned. In this case
196219 int rc = SQLITE_OK;
196291 if( rc!=SQLITE_OK ){
196375 return SQLITE_OK;
196432 ** other doclists (except the aaOutput[0] one) and return SQLITE_OK.
196459 if( rc!=SQLITE_OK ){
196475 return SQLITE_OK;
196489 ** This function returns SQLITE_OK if the merge is successful, or an
196541 if( rc!=SQLITE_OK ){
196559 return SQLITE_OK;
196580 return SQLITE_OK;
196587 ** This function returns SQLITE_OK if successful, or an SQLite error code
196601 int rc = SQLITE_OK; /* Error code */
196614 if( rc==SQLITE_OK && pSeg ){
196620 if( rc==SQLITE_OK ){
196624 while( rc==SQLITE_OK && SQLITE_ROW==(rc = sqlite3_step(pStmt)) ){
196639 if( rc!=SQLITE_OK ) goto finished;
196648 if( rc!=SQLITE_OK ) goto finished;
196694 ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
196711 ** zTerm/nTerm is a prefix. If successful, return SQLITE_OK and write
196718 ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
196754 if( rc==SQLITE_OK ){
196811 while( SQLITE_OK==rc
196817 if( rc==SQLITE_OK ){
196820 if( rc==SQLITE_OK ){
196866 ** Return SQLITE_OK if nothing goes wrong. SQLITE_OK is returned
196881 rc = SQLITE_OK;
196929 int rc = SQLITE_OK;
196990 if( rc!=SQLITE_OK ){
196996 if( rc!=SQLITE_OK ) return rc;
197028 if( rc==SQLITE_OK ){
197032 if( rc!=SQLITE_OK ) return rc;
197059 return SQLITE_OK;
197078 int rc = SQLITE_OK; /* Return Code */
197112 if( rc==SQLITE_OK && sqlite3_data_count(pCsr->pStmt)-1>iCol ){
197168 if( rc==SQLITE_OK
197176 assert( rc==SQLITE_OK || mxLevel==0 );
197189 ** to 0 or 1). Return SQLITE_OK if successful, or an SQLite error code
197193 int rc = SQLITE_OK;
197199 p->bHasStat = (res==SQLITE_OK);
197220 if( rc==SQLITE_OK ){
197241 return SQLITE_OK;
197254 return SQLITE_OK;
197302 ** output variable *ppCsr and SQLITE_OK is returned. Otherwise, an error
197315 rc = SQLITE_OK;
197367 }else if( SQLITE_OK==fts3CursorSeek(pContext, pCsr) ){
197387 if( SQLITE_OK==fts3CursorSeek(pContext, pCsr) ){
197420 case SQLITE_OK:
197442 if( SQLITE_OK==fts3FunctionArg(pContext, "matchinfo", apVal[0], &pCsr) ){
197510 if( rc==SQLITE_OK ){
197554 int rc = SQLITE_OK;
197574 if( rc==SQLITE_OK ){
197592 return SQLITE_OK;
197608 return SQLITE_OK;
197638 int rc = SQLITE_OK;
197643 assert( pVtab->zErrMsg==0 || rc!=SQLITE_OK );
197649 if( *pzErr ) rc = SQLITE_OK;
197650 }else if( rc==SQLITE_OK && bOk==0 ){
197729 int rc = SQLITE_OK;
197748 if( rc!=SQLITE_OK ) return rc;
197752 if( rc!=SQLITE_OK ) return rc;
197767 if( rc==SQLITE_OK ){
197783 if( rc==SQLITE_OK ){
197792 if( SQLITE_OK==rc
197793 && SQLITE_OK==(rc=sqlite3Fts3InitHashTable(db,&pHash->hash,"fts3_tokenizer"))
197794 && SQLITE_OK==(rc = sqlite3_overload_function(db, "snippet", -1))
197795 && SQLITE_OK==(rc = sqlite3_overload_function(db, "offsets", 1))
197796 && SQLITE_OK==(rc = sqlite3_overload_function(db, "matchinfo", 1))
197797 && SQLITE_OK==(rc = sqlite3_overload_function(db, "matchinfo", 2))
197798 && SQLITE_OK==(rc = sqlite3_overload_function(db, "optimize", 1))
197804 if( rc==SQLITE_OK ){
197810 if( rc==SQLITE_OK ){
197819 assert( rc!=SQLITE_OK );
197849 if( pExpr && SQLITE_OK==*pRc ){
197859 if( rc!=SQLITE_OK ){
197882 ** SQLITE_OK is returned if successful, or SQLITE_NOMEM if an error occurs.
197891 int rc = SQLITE_OK;
197946 ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
197954 int rc = SQLITE_OK;
197956 for(iToken=0; rc==SQLITE_OK && iToken<p->nToken; iToken++){
197964 if( rc==SQLITE_OK ){
197983 ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
198000 if( rc!=SQLITE_OK ) return rc;
198007 return SQLITE_OK;
198028 return SQLITE_OK;
198079 return SQLITE_OK;
198099 ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
198103 int rc = SQLITE_OK; /* Error code */
198130 for(i=0; rc==SQLITE_OK && i<p->nToken; i++){
198144 assert( rc!=SQLITE_OK || p->nToken<1 || p->aToken[0].pSegcsr==0 || p->bIncr );
198313 ** SQLITE_OK.
198322 int rc = SQLITE_OK;
198365 ** SQLITE_OK.
198372 int rc = SQLITE_OK;
198400 for(i=0; rc==SQLITE_OK && i<p->nToken && bEof==0; i++){
198407 assert( rc!=SQLITE_OK || (p->nToken>=1 && a[p->nToken-1].bIgnore==0) );
198408 assert( rc!=SQLITE_OK || bMaxSet );
198412 while( rc==SQLITE_OK && bEof==0
198462 ** SQLITE_OK.
198473 int rc = SQLITE_OK;
198493 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
198512 if( pExpr && SQLITE_OK==*pRc ){
198556 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
198568 if( *pRc==SQLITE_OK ){
198572 for(i=0; *pRc==SQLITE_OK && i<pPhrase->nToken; i++){
198605 ** write this value to *pnPage and return SQLITE_OK. Otherwise, return
198615 int rc = SQLITE_OK;
198636 if( rc!=SQLITE_OK ) return rc;
198671 ** If no error occurs, SQLITE_OK is returned and sqlite3Fts3DeferToken()
198683 int rc = SQLITE_OK; /* Return code */
198697 return SQLITE_OK;
198709 if( nOvfl==0 || nToken<2 ) return SQLITE_OK;
198713 assert( rc!=SQLITE_OK || nDocSize>0 );
198738 for(ii=0; ii<nToken && rc==SQLITE_OK; ii++){
198775 assert( rc==SQLITE_OK || pList==0 );
198776 if( rc==SQLITE_OK ){
198781 if( rc==SQLITE_OK ){
198810 int rc = SQLITE_OK;
198819 if( rc==SQLITE_OK && nToken>1 && pTab->bFts4 ){
198838 if( rc==SQLITE_OK ){
198840 for(ii=0; rc==SQLITE_OK && ii<nOr; ii++){
198924 ** This function is a no-op if *pRc is other than SQLITE_OK when it is called.
198969 if( *pRc==SQLITE_OK && pExpr->bEof==0 ){
198996 while( !pLeft->bEof && !pRight->bEof && *pRc==SQLITE_OK ){
199011 while( *pRc==SQLITE_OK && pRight->bEof==0 ){
199018 while( *pRc==SQLITE_OK && pLeft->bEof==0 ){
199063 assert( *pRc!=SQLITE_OK || pRight->bStart );
199092 ** If *pRc is not SQLITE_OK, or if pExpr is not the root node of a NEAR
199129 if( *pRc==SQLITE_OK
199183 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
199194 if( *pRc==SQLITE_OK ){
199288 ** If *pRc is not SQLITE_OK when this function is called, it immediately
199293 ** 1. *pRc is SQLITE_OK when this function returns, and
199304 if( rc==SQLITE_OK ){
199314 if( rc==SQLITE_OK ){
199324 return (rc==SQLITE_OK && bMiss);
199332 int rc = SQLITE_OK; /* Return Code */
199353 if( rc==SQLITE_OK && (
199368 ** If *pRc is other than SQLITE_OK when this function is called, it is
199377 if( pExpr && *pRc==SQLITE_OK ){
199409 ** so that it is a regular phrase query, not an MSR. SQLITE_OK is returned
199413 int rc = SQLITE_OK;
199417 while( rc==SQLITE_OK && pExpr->iDocid!=iDocid ){
199477 return SQLITE_OK;
199488 ** SQLITE_OK is returned if the aMI[] array is successfully allocated and
199495 int rc = SQLITE_OK; /* Return code */
199519 if( rc!=SQLITE_OK ) return rc;
199522 while( pCsr->isEof==0 && rc==SQLITE_OK ){
199540 if( rc==SQLITE_OK && pCsr->isEof==0 ){
199555 ** do {...} while( pRoot->iDocid<iDocid && rc==SQLITE_OK );
199562 }while( pRoot->iDocid!=iDocid && rc==SQLITE_OK );
199578 ** If no error occurs, SQLITE_OK is returned and the values for each column
199604 int rc = SQLITE_OK;
199615 if( rc==SQLITE_OK ){
199663 return SQLITE_OK;
199669 int rc = SQLITE_OK;
199689 if( bOr==0 ) return SQLITE_OK;
199702 while( rc==SQLITE_OK && !pRun->bEof ){
199706 assert( rc!=SQLITE_OK || pPhrase->bIncr==0 );
199707 if( rc==SQLITE_OK && pRun->bEof!=bEofSave ){
199712 while( rc==SQLITE_OK && !pRun->bEof ){
199716 if( rc!=SQLITE_OK ) return rc;
199760 if( pIter==0 ) return SQLITE_OK;
199770 if( *pIter==0x00 ) return SQLITE_OK;
199779 return SQLITE_OK;
199930 if( rc!=SQLITE_OK ) return rc;
199948 return SQLITE_OK;
199971 return SQLITE_OK;
200045 return SQLITE_OK;
200061 return SQLITE_OK;
200077 return SQLITE_OK;
200093 return SQLITE_OK;
200108 if( pCsr->aStat[pCsr->iCol].nDoc>0 ) return SQLITE_OK;
200125 return SQLITE_OK;
200132 rc = SQLITE_OK;
200282 if( rc==SQLITE_OK ){
200286 if( rc==SQLITE_OK ) rc = fts3auxNextMethod(pCursor);
200336 return SQLITE_OK;
200348 return SQLITE_OK;
200352 ** Register the fts3aux module with database connection db. Return SQLITE_OK
200535 assert( rc==SQLITE_OK || pCsr==0 );
200536 if( rc==SQLITE_OK ){
200540 if( rc!=SQLITE_OK ){
200582 ** Return SQLITE_OK if successful, or SQLITE_NOMEM if a memory allocation
200600 if( rc==SQLITE_OK ){
200606 if( rc==SQLITE_OK ){
200657 rc = SQLITE_OK;
200687 ** If successful, SQLITE_OK is returned and *ppExpr set to point at the
200729 if( rc==SQLITE_OK ){
200731 for(ii=0; rc==SQLITE_OK; ii++){
200735 if( rc==SQLITE_OK ){
200785 rc = SQLITE_OK;
200793 if( rc!=SQLITE_OK ){
200805 ** Returns an SQLite error code. SQLITE_OK if everything works, SQLITE_NOMEM
200885 return SQLITE_OK;
201023 ** If successful, SQLITE_OK
201039 int rc = SQLITE_OK;
201042 while( rc==SQLITE_OK ){
201047 assert( nByte>0 || (rc!=SQLITE_OK && p==0) );
201048 if( rc==SQLITE_OK ){
201136 assert( rc!=SQLITE_OK || (nByte>0 && nByte<=nIn) );
201146 rc = SQLITE_OK;
201164 if( rc!=SQLITE_OK ){
201178 int rc = SQLITE_OK;
201184 if( rc==SQLITE_OK ){
201195 ** If successful, SQLITE_OK is returned and (*pp) set to point to the
201204 int rc = SQLITE_OK; /* Return code */
201213 if( rc==SQLITE_OK ){
201223 if( rc==SQLITE_OK ){
201246 if( rc!=SQLITE_OK ) break;
201293 if( rc==SQLITE_OK ){
201341 if( rc==SQLITE_OK ){
201345 if( rc!=SQLITE_OK ){
201358 if( rc!=SQLITE_OK ){
201400 return SQLITE_OK;
201406 assert( rc==SQLITE_OK || *ppExpr==0 );
201409 if( rc==SQLITE_OK && sParse.nNest ){
201421 ** of the parsed expression tree and SQLITE_OK is returned. If an error
201457 if( rc==SQLITE_OK && *ppExpr ){
201459 if( rc==SQLITE_OK ){
201464 if( rc!=SQLITE_OK ){
201623 if( rc!=SQLITE_OK ){
201650 assert( rc==SQLITE_OK || pExpr==0 );
201658 if( rc!=SQLITE_OK && rc!=SQLITE_NOMEM ){
201699 if( rc==SQLITE_OK ){
202169 return SQLITE_OK;
202177 return SQLITE_OK;
202212 return SQLITE_OK;
202223 return SQLITE_OK;
202730 return SQLITE_OK;
202975 assert( rc!=SQLITE_OK || *ppTok );
202976 if( rc!=SQLITE_OK ){
203074 if( SQLITE_OK!=p->xCreate(argc-2, azArg, &pTokenizer) ){
203084 while( SQLITE_OK==p->xNext(pCsr, &zToken, &nToken, &iStart, &iEnd, &iPos) ){
203092 if( SQLITE_OK!=p->xClose(pCsr) ){
203096 if( SQLITE_OK!=p->xDestroy(pTokenizer) ){
203121 if( rc!=SQLITE_OK ){
203145 if( rc!=SQLITE_OK ){
203197 assert( rc==SQLITE_OK );
203207 assert( rc==SQLITE_OK );
203209 assert( rc==SQLITE_OK );
203240 int rc = SQLITE_OK;
203255 if( SQLITE_OK==rc ){
203258 if( SQLITE_OK==rc ){
203262 if( SQLITE_OK==rc ){
203265 if( SQLITE_OK==rc ){
203377 return SQLITE_OK;
203385 return SQLITE_OK;
203420 return SQLITE_OK;
203431 return SQLITE_OK;
203486 return SQLITE_OK;
203611 return SQLITE_OK;
203621 ** array of dequoted strings and SQLITE_OK is returned. The caller is
203631 int rc = SQLITE_OK; /* Return code */
203692 if( rc!=SQLITE_OK ) return rc;
203697 if( rc==SQLITE_OK ){
203707 assert( (rc==SQLITE_OK)==(pMod!=0) );
203708 if( rc==SQLITE_OK ){
203714 if( rc==SQLITE_OK ){
203721 if( rc==SQLITE_OK ){
203746 return SQLITE_OK;
203768 return SQLITE_OK;
203775 return SQLITE_OK;
203792 return SQLITE_OK;
203823 return SQLITE_OK;
203840 if( rc!=SQLITE_OK ){
203842 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
203875 if( rc==SQLITE_OK ){
203881 if( rc!=SQLITE_OK ) return rc;
203922 return SQLITE_OK;
203934 return SQLITE_OK;
203938 ** Register the fts3tok module with database connection db. Return SQLITE_OK
204065 sqlite3_log(SQLITE_OK, "%d-way merge from level %d", nMerge, (int)iAbsLevel);
204136 ** until SegmentReaderNext() returns something other than SQLITE_OK
204277 ** *pp is set to the requested statement handle and SQLITE_OK returned.
204391 int rc = SQLITE_OK;
204414 assert( rc==SQLITE_OK || pStmt==0 );
204421 for(i=0; rc==SQLITE_OK && i<nParam; i++){
204439 if( rc==SQLITE_OK ){
204444 if( rc==SQLITE_OK ) rc = FTS_CORRUPT_VTAB;
204447 rc = SQLITE_OK;
204462 if( rc==SQLITE_OK ){
204468 if( rc==SQLITE_OK ) rc = FTS_CORRUPT_VTAB;
204489 ** Returns SQLITE_OK if the statement is successfully executed, or an
204502 if( rc==SQLITE_OK ){
204525 int rc = SQLITE_OK;
204530 if( rc==SQLITE_OK ){
204581 ** return SQLITE_OK. If an error occurs while preparing the statement,
204612 if( rc==SQLITE_OK ){
204621 if( rc==SQLITE_OK ){
204631 ** Append a single varint to a PendingList buffer. SQLITE_OK is returned
204674 return SQLITE_OK;
204684 ** it is set to SQLITE_OK.
204694 int rc = SQLITE_OK;
204705 if( SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, iDelta)) ){
204713 if( SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, 1))
204714 || SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, iCol))
204724 if( rc==SQLITE_OK ){
204757 int rc = SQLITE_OK;
204775 if( rc==SQLITE_OK ){
204788 ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error code.
204819 return SQLITE_OK;
204823 if( rc!=SQLITE_OK ){
204828 while( SQLITE_OK==rc
204829 && SQLITE_OK==(rc = xNext(pCsr, &zToken, &nToken, &iStart, &iEnd, &iPos))
204849 for(i=1; rc==SQLITE_OK && i<p->nIndex; i++){
204860 return (rc==SQLITE_DONE ? SQLITE_OK : rc);
204889 if( rc!=SQLITE_OK ) return rc;
204894 return SQLITE_OK;
204934 if( rc!=SQLITE_OK ){
204940 return SQLITE_OK;
204974 return SQLITE_OK;
204986 if( rc==SQLITE_OK && p->zLanguageid ){
204992 if( rc!=SQLITE_OK ) return rc;
205012 if( rc!=SQLITE_OK ) return rc;
205032 int rc = SQLITE_OK; /* Return code */
205079 if( rc==SQLITE_OK ){
205085 for(i=1; rc==SQLITE_OK && i<=p->nColumn; i++){
205093 if( rc!=SQLITE_OK ){
205125 ** If successful, *piIdx is set to the allocated index slot and SQLITE_OK
205144 if( rc==SQLITE_OK ){
205154 if( rc==SQLITE_OK ){
205185 ** an SQLite error code is returned. Otherwise, SQLITE_OK is returned. If
205223 if( rc==SQLITE_OK ){
205237 if( rc!=SQLITE_OK ){
205272 if( rc==SQLITE_OK ){
205285 int rc = SQLITE_OK;
205289 while( pReader->pBlob && rc==SQLITE_OK
205311 ** segment. If successful, SQLITE_OK is returned. If there is no next term,
205360 return SQLITE_OK;
205371 return SQLITE_OK;
205378 if( rc!=SQLITE_OK ) return rc;
205390 if( rc!=SQLITE_OK ) return rc;
205417 if( rc!=SQLITE_OK ) return rc;
205436 return SQLITE_OK;
205444 int rc = SQLITE_OK;
205457 if( rc==SQLITE_OK ){
205481 int rc = SQLITE_OK;
205524 if( rc!=SQLITE_OK ) return rc;
205548 if( rc==SQLITE_OK ){
205572 int rc = SQLITE_OK;
205578 for(ii=0; rc==SQLITE_OK && ii<pMsr->nSegment; ii++){
205587 if( rc!=SQLITE_OK ) break;
205661 return SQLITE_OK;
205717 int rc = SQLITE_OK; /* Return Code */
205934 if( rc==SQLITE_OK ){
205946 ** *pnMax to this value and return SQLITE_OK. Otherwise, if an error occurs,
205955 if( rc==SQLITE_OK ){
205981 if( rc==SQLITE_OK ){
206097 return SQLITE_OK;
206162 ** If successful, SQLITE_OK is returned and output variable *piLast is
206177 int rc = SQLITE_OK;
206189 for(pIter=pTree->pLeftmost; pIter && rc==SQLITE_OK; pIter=pIter->pRight){
206197 if( rc==SQLITE_OK ){
206234 ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error code.
206268 if( rc!=SQLITE_OK ) return rc;
206274 if( rc!=SQLITE_OK ) return rc;
206299 if( rc!=SQLITE_OK ) return rc;
206316 if( rc!=SQLITE_OK ) return rc;
206378 return SQLITE_OK;
206384 ** to the segment using fts3SegWriterAdd(). If successful, SQLITE_OK is
206402 if( rc==SQLITE_OK ){
206406 if( rc==SQLITE_OK ){
206439 ** document pRowid, or false otherwise, and SQLITE_OK is returned. If an
206448 rc = SQLITE_OK;
206451 if( rc==SQLITE_OK ){
206467 ** Return SQLITE_OK if successful, or an SQLite error code if not.
206486 if( rc!=SQLITE_OK ) return rc;
206501 ** iAbsLevel is indeed the largest level, or 0 otherwise, and SQLITE_OK
206515 if( rc!=SQLITE_OK ) return rc;
206537 int rc = SQLITE_OK; /* Return code */
206541 if( rc==SQLITE_OK ){
206563 ** SQLITE_OK is returned if successful, otherwise an SQLite error code.
206573 int rc = SQLITE_OK; /* Return Code */
206577 for(i=0; rc==SQLITE_OK && i<nReader; i++){
206580 if( rc!=SQLITE_OK ){
206587 if( rc==SQLITE_OK ){
206595 if( rc==SQLITE_OK ){
206602 if( rc==SQLITE_OK ){
206664 ** If successful, return SQLITE_OK. Otherwise, if an OOM error is encountered
206684 return SQLITE_OK;
206702 return SQLITE_OK;
206721 while( rc==SQLITE_OK
206729 if( rc!=SQLITE_OK ) return rc;
206734 if( rc!=SQLITE_OK ) return rc;
206752 return SQLITE_OK;
206775 if( rc!=SQLITE_OK ) return rc;
206784 return SQLITE_OK;
206815 if( rc!=SQLITE_OK ) return rc;
206829 if( rc!=SQLITE_OK ) return rc;
206836 return SQLITE_OK;
206867 return SQLITE_OK;
206880 return SQLITE_OK;
206888 int rc = SQLITE_OK;
206904 if( pCsr->nSegment==0 ) return SQLITE_OK;
206920 if( rc!=SQLITE_OK ) return rc;
206925 /* If all the seg-readers are at EOF, we're finished. return SQLITE_OK. */
206926 assert( rc==SQLITE_OK );
206971 if( rc==SQLITE_OK ) rc = SQLITE_ROW;
207055 }while( rc==SQLITE_OK );
207126 int rc = SQLITE_OK;
207131 if( rc==SQLITE_OK ){
207164 if( rc==SQLITE_OK ){
207167 if( rc==SQLITE_OK ){
207171 if( rc==SQLITE_OK ){
207189 if( rc!=SQLITE_OK ){
207195 if( rc==SQLITE_OK ){
207200 if( rc==SQLITE_OK ){
207220 ** Otherwise, if successful, SQLITE_OK is returned. If an error occurs,
207246 if( rc!=SQLITE_OK || csr.nSegment==0 ) goto finished;
207250 if( rc!=SQLITE_OK ) goto finished;
207275 if( rc!=SQLITE_OK ) goto finished;
207288 while( SQLITE_OK==rc ){
207294 if( rc!=SQLITE_OK ) goto finished;
207301 if( rc!=SQLITE_OK ) goto finished;
207305 if( rc==SQLITE_OK ){
207323 int rc = SQLITE_OK;
207326 for(i=0; rc==SQLITE_OK && i<p->nIndex; i++){
207328 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
207334 if( rc==SQLITE_OK && p->bHasStat
207339 if( rc==SQLITE_OK ){
207352 if( rc==SQLITE_OK ){
207482 if( rc!=SQLITE_OK ){
207526 if( rc==SQLITE_OK ){
207529 if( rc==SQLITE_OK ){
207536 for(i=0; rc==SQLITE_OK && i<p->nIndex; i++){
207540 rc = SQLITE_OK;
207545 if( rc==SQLITE_OK ) rc = rc2;
207550 return (rc==SQLITE_OK && bReturnDone && bSeenDone) ? SQLITE_DONE : rc;
207567 if( rc==SQLITE_OK ){
207583 if( rc==SQLITE_OK ){
207595 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
207600 for(iCol=0; rc==SQLITE_OK && iCol<p->nColumn; iCol++){
207610 if( rc!=SQLITE_OK ){
207627 if( rc==SQLITE_OK ){
207664 if( rc==SQLITE_OK ){
207669 for(i=0; rc==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW && i<nSeg; i++){
207681 if( rc==SQLITE_OK ) rc = rc2;
207751 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
207760 if( *pRc==SQLITE_OK && nMin>pBlob->nAlloc ){
207777 ** Otherwise return SQLITE_OK. If there is no next entry on the node
207786 int rc = SQLITE_OK; /* Return code */
207803 if( rc==SQLITE_OK && ALWAYS(p->term.a!=0) ){
207832 ** If successful, SQLITE_OK is returned and the NodeReader object set to
207849 return aNode ? nodeReaderNext(p) : SQLITE_OK;
207875 int rc = SQLITE_OK;
207898 if( rc==SQLITE_OK ){
207906 if( rc==SQLITE_OK ){
207934 if( rc!=SQLITE_OK || iNextPtr==0 ) return rc;
207964 ** returned. Otherwise, SQLITE_OK.
207974 int rc = SQLITE_OK; /* Return code */
207985 if( rc!=SQLITE_OK ) return rc;
208010 return SQLITE_OK;
208017 ** Return SQLITE_OK if successful, or an SQLite error code otherwise.
208028 int rc = SQLITE_OK; /* Return code */
208066 if( rc==SQLITE_OK ){
208083 if( rc==SQLITE_OK ){
208101 ** If *pRc is not SQLITE_OK when this function is called, then no attempt
208105 ** Otherwise, if *pRc is initially SQLITE_OK and an error occurs while
208153 if( rc==SQLITE_OK ){
208166 if( pNode->block.n>0 && rc==SQLITE_OK ){
208174 if( rc==SQLITE_OK ){
208235 if( rc==SQLITE_OK ){
208272 if( rc==SQLITE_OK ){
208306 if( rc==SQLITE_OK && bAppendable ){
208311 if( rc==SQLITE_OK ){
208314 rc==SQLITE_OK && reader.aNode;
208327 if( rc==SQLITE_OK && bAppendable ){
208353 if( rc==SQLITE_OK ){
208359 for(i=nHeight; i>=0 && rc==SQLITE_OK; i--){
208366 while( reader.aNode && rc==SQLITE_OK ) rc = nodeReaderNext(&reader);
208368 if( rc==SQLITE_OK ){
208383 if( rc==SQLITE_OK ){
208397 if( rc==SQLITE_OK ) rc = rc2;
208406 ** one before returning SQLITE_OK. Or, if there are no segments at all
208421 if( rc==SQLITE_OK ){
208472 if( rc==SQLITE_OK ){
208480 if( rc!=SQLITE_OK ) return rc;
208484 if( rc==SQLITE_OK ){
208492 if( rc!=SQLITE_OK ) return rc;
208498 if( rc!=SQLITE_OK ) return rc;
208508 return SQLITE_OK;
208531 if( rc==SQLITE_OK ){
208559 if( rc==SQLITE_OK ){
208576 if( rc==SQLITE_OK ) rc = rc2;
208579 if( rc==SQLITE_OK ){
208582 if( rc==SQLITE_OK ){
208588 for(i=0; rc==SQLITE_OK && i<nIdx; i++){
208631 int rc = SQLITE_OK; /* Return code */
208639 if( rc!=SQLITE_OK ) return rc;
208644 rc==SQLITE_OK && reader.aNode;
208657 if( rc!=SQLITE_OK ) break;
208676 ** SQLITE_OK is returned if the segment is updated successfully. Or an
208686 int rc = SQLITE_OK; /* Return code */
208695 if( rc==SQLITE_OK ){
208706 if( rc==SQLITE_OK ) rc = rc2;
208709 while( rc==SQLITE_OK && iBlock ){
208715 if( rc==SQLITE_OK ){
208718 if( rc==SQLITE_OK ){
208725 if( rc==SQLITE_OK && iNewStart ){
208728 if( rc==SQLITE_OK ){
208736 if( rc==SQLITE_OK ){
208739 if( rc==SQLITE_OK ){
208773 int rc = SQLITE_OK;
208775 for(i=pCsr->nSegment-1; i>=0 && rc==SQLITE_OK; i--){
208790 if( rc==SQLITE_OK ){
208805 if( rc==SQLITE_OK && nRem!=pCsr->nSegment ){
208821 if( rc==SQLITE_OK ){
208837 ** table and return SQLITE_OK. Otherwise, if an error occurs, return an
208846 if( rc==SQLITE_OK ){
208854 if( rc==SQLITE_OK ){
208861 if( rc==SQLITE_OK ) rc = rc2;
208868 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
208873 ** If successful, leave *pRc set to SQLITE_OK and return. If an error occurs,
208883 if( *pRc==SQLITE_OK ){
208894 ** If no error occurs, return SQLITE_OK. If the hint blob in *pHint does
208914 return SQLITE_OK;
208946 while( rc==SQLITE_OK && nRem>0 ){
208974 if( rc==SQLITE_OK && hint.n ){
209018 if( rc==SQLITE_OK ){
209030 if( rc==SQLITE_OK ){
209033 if( SQLITE_OK==rc && pCsr->nSegment==nSeg
209034 && SQLITE_OK==(rc = sqlite3Fts3SegReaderStart(p, pCsr, pFilter))
209038 if( rc==SQLITE_OK ){
209052 if( rc==SQLITE_OK && pWriter->nLeafEst ){
209057 if( rc==SQLITE_OK ) rc = sqlite3Fts3SegReaderStep(p, pCsr);
209058 if( pWriter->nWork>=nRem && rc==SQLITE_ROW ) rc = SQLITE_OK;
209063 if( rc==SQLITE_OK ){
209086 if( bDirtyHint && rc==SQLITE_OK ){
209142 rc = SQLITE_OK;
209147 if( rc==SQLITE_OK ){
209167 int rc = SQLITE_OK;
209217 ** If successful, the checksum value is returned and *pRc set to SQLITE_OK.
209242 if( rc==SQLITE_OK ){
209246 if( rc==SQLITE_OK ){
209293 ** to true and return SQLITE_OK. Or if the contents do not match, set *pbOk
209300 int rc = SQLITE_OK; /* Return code */
209307 if( rc==SQLITE_OK ){
209311 while( rc==SQLITE_OK && sqlite3_step(pAllLangid)==SQLITE_ROW ){
209319 if( rc==SQLITE_OK ) rc = rc2;
209323 if( rc==SQLITE_OK ){
209336 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
209341 for(iCol=0; rc==SQLITE_OK && iCol<p->nColumn; iCol++){
209347 while( rc==SQLITE_OK ){
209354 if( rc==SQLITE_OK ){
209369 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
209378 rc = SQLITE_OK;
209381 *pbOk = (rc==SQLITE_OK && cksum1==cksum2);
209388 ** the FTS index are correct, return SQLITE_OK. Or, if the contents of the
209423 if( rc==SQLITE_OK && bOk==0 ) rc = FTS_CORRUPT_VTAB;
209461 rc = SQLITE_OK;
209465 rc = SQLITE_OK;
209468 rc = SQLITE_OK;
209472 rc = SQLITE_OK;
209516 int rc = SQLITE_OK; /* Return code */
209529 for(i=0; i<p->nColumn && rc==SQLITE_OK; i++){
209535 while( rc==SQLITE_OK ){
209542 for(pDef=pCsr->pDeferred; pDef && rc==SQLITE_OK; pDef=pDef->pNext){
209554 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
209558 for(pDef=pCsr->pDeferred; pDef && rc==SQLITE_OK; pDef=pDef->pNext){
209581 return SQLITE_OK;
209592 return SQLITE_OK;
209617 return SQLITE_OK;
209632 int rc = SQLITE_OK; /* Return code */
209636 if( bFound && rc==SQLITE_OK ){
209639 SQLITE_OK ){
209682 int rc = SQLITE_OK; /* Return Code */
209725 if( rc!=SQLITE_OK ) goto update_out;
209772 if( rc!=SQLITE_OK ){
209783 if( nArg>1 && rc==SQLITE_OK ){
209791 if( rc==SQLITE_OK ){
209794 if( rc==SQLITE_OK ){
209822 if( rc==SQLITE_OK ){
209824 if( rc==SQLITE_OK || rc==SQLITE_DONE ){
209826 if( rc2!=SQLITE_OK ) rc = rc2;
210100 if( rc==SQLITE_OK && eType!=FTSQUERY_NOT ){
210115 ** If the callback function returns anything other than SQLITE_OK,
210117 ** Otherwise, SQLITE_OK is returned after a callback has been made for
210135 int rc = SQLITE_OK;
210174 return SQLITE_OK;
210319 assert( rc==SQLITE_OK || pCsr==0 );
210333 assert( rc!=SQLITE_OK || (
210378 if( rc!=SQLITE_OK ){
210402 if( rc==SQLITE_OK ){
210472 return SQLITE_OK;
210535 if( rc!=SQLITE_OK ){
210538 while( rc==SQLITE_OK && iCurrent<(nSnippet+nDesired) ){
210543 if( rc!=SQLITE_OK && rc!=SQLITE_DONE ){ return rc; }
210553 return SQLITE_OK;
210589 return SQLITE_OK;
210596 if( rc!=SQLITE_OK ){
210600 while( rc==SQLITE_OK ){
210619 if( rc!=SQLITE_OK ){
210642 if( rc==SQLITE_OK ){
210649 if( rc!=SQLITE_OK || iCurrent<iPos ) continue;
210663 if( rc==SQLITE_OK && isHighlight ) rc = fts3StringAppend(pOut, zOpen, -1);
210664 if( rc==SQLITE_OK ) rc = fts3StringAppend(pOut, &zDoc[iBegin], iFin-iBegin);
210665 if( rc==SQLITE_OK && isHighlight ) rc = fts3StringAppend(pOut, zClose, -1);
210738 return SQLITE_OK;
210748 int rc = SQLITE_OK;
210753 if( rc==SQLITE_OK ) rc = fts3ExprLHitGather(pExpr->pRight, p);
210809 int rc = SQLITE_OK;
210814 for(i=0; i<p->nCol && rc==SQLITE_OK; i++){
210842 return SQLITE_OK;
210897 if( rc!=SQLITE_OK ) return rc;
210916 return SQLITE_OK;
210946 return SQLITE_OK;
210978 ** array before returning. SQLITE_OK is returned in this case.
210989 int rc = SQLITE_OK;
211011 if( rc!=SQLITE_OK ) goto matchinfo_lcs_out;
211068 ** Return SQLITE_OK if successful, or an SQLite error code if an error
211069 ** occurs. If a value other than SQLITE_OK is returned, the state the
211078 int rc = SQLITE_OK;
211083 for(i=0; rc==SQLITE_OK && zArg[i]; i++){
211109 if( rc==SQLITE_OK ){
211129 if( rc==SQLITE_OK ){
211149 if( rc==SQLITE_OK ){
211167 if( rc!=SQLITE_OK ) break;
211171 if( rc!=SQLITE_OK ) break;
211175 if( rc!=SQLITE_OK ) break;
211201 int rc = SQLITE_OK;
211251 if( rc==SQLITE_OK ){
211258 if( rc==SQLITE_OK ){
211267 if( rc!=SQLITE_OK ){
211289 int rc = SQLITE_OK;
211344 if( rc!=SQLITE_OK ){
211365 for(i=0; i<nSnippet && rc==SQLITE_OK; i++){
211373 if( rc!=SQLITE_OK ){
211430 ** restart it as a regular, non-incremental query. Return SQLITE_OK
211435 int rc = SQLITE_OK;
211469 if( rc!=SQLITE_OK ) goto offsets_out;
211484 if( rc!=SQLITE_OK ) goto offsets_out;
211507 if( rc!=SQLITE_OK ) goto offsets_out;
211529 if( rc!=SQLITE_OK ) goto offsets_out;
211532 while( rc==SQLITE_OK ){
211555 while( rc==SQLITE_OK && iCurrent<iMinPos ){
211558 if( rc==SQLITE_OK ){
211570 rc = SQLITE_OK;
211574 if( rc!=SQLITE_OK ) goto offsets_out;
211581 if( rc!=SQLITE_OK ){
211730 return SQLITE_OK;
211799 return SQLITE_OK;
211845 int rc = SQLITE_OK;
211852 for(i=0; rc==SQLITE_OK && i<nArg; i++){
211877 if( rc!=SQLITE_OK ){
211917 return SQLITE_OK;
211928 return SQLITE_OK;
211996 return SQLITE_OK;
212840 ** the least recently used entry. Return SQLITE_OK on success or a
212875 return SQLITE_OK;
213005 return SQLITE_OK;
217496 if( rc==SQLITE_OK ){
217512 return SQLITE_OK;
217528 return SQLITE_OK;
217552 return SQLITE_OK;
217613 int rc = SQLITE_OK;
217792 return SQLITE_OK;
217799 return SQLITE_OK;
217869 return SQLITE_OK;
217885 if( idxNum==0 ) return SQLITE_OK;
217896 return SQLITE_OK;
217907 if( zRoot==0 ) return SQLITE_OK;
217925 return SQLITE_OK;
217962 return SQLITE_OK;
218814 int rc = SQLITE_OK;
218827 return SQLITE_OK;
218876 if( rc==SQLITE_OK && pNode && iNode==1 ){
218888 if( pNode && rc==SQLITE_OK ){
218895 if( rc==SQLITE_OK ){
218948 ** is successful, return SQLITE_OK.
218977 int rc = SQLITE_OK;
218990 if( pNode->iNode==0 && rc==SQLITE_OK ){
219003 int rc = SQLITE_OK;
219016 if( rc==SQLITE_OK ){
219159 return SQLITE_OK;
219183 if( rc==SQLITE_OK ){
219202 rc = SQLITE_OK;
219259 return SQLITE_OK;
219498 return SQLITE_OK;
219515 return SQLITE_OK;
219743 int rc = SQLITE_OK;
219813 return SQLITE_OK;
219821 int rc = SQLITE_OK;
219840 int rc = SQLITE_OK;
219842 if( rc==SQLITE_OK && ALWAYS(p) ){
219860 int rc = SQLITE_OK;
219864 if( NEVER(p==0) ) return SQLITE_OK;
219893 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
219900 return SQLITE_OK;
219906 ** return SQLITE_OK. If there is no such record in the table, set
219907 ** *ppLeaf to 0 and return SQLITE_OK. If an error occurs, set *ppLeaf
219960 return SQLITE_OK;
219977 int rc = SQLITE_OK;
219999 rc = SQLITE_OK;
220002 if( rc==SQLITE_OK && pLeaf!=0 ){
220019 if( rc==SQLITE_OK && argc>0 ){
220040 if( rc!=SQLITE_OK ){
220078 if( rc==SQLITE_OK ){
220137 int rc = SQLITE_OK;
220182 return SQLITE_OK;
220354 for(ii=0; rc==SQLITE_OK && ii<(pRtree->iDepth-iHeight); ii++){
220436 if( NEVER(rc!=SQLITE_OK) ){
220449 return SQLITE_OK;
220640 return SQLITE_OK;
220677 int rc = SQLITE_OK;
220727 if( rc!=SQLITE_OK ){
220736 if( SQLITE_OK!=(rc = nodeWrite(pRtree, pRight))
220737 || (0==pLeft->iNode && SQLITE_OK!=(rc = nodeWrite(pRtree, pLeft)))
220747 if( rc!=SQLITE_OK ){
220754 if( ALWAYS(rc==SQLITE_OK) ){
220757 assert( rc==SQLITE_OK );
220759 if( NEVER(rc!=SQLITE_OK) ){
220773 if( rc!=SQLITE_OK ){
220781 if( rc!=SQLITE_OK ){
220808 int rc = SQLITE_OK;
220810 while( rc==SQLITE_OK && pChild->iNode!=1 && pChild->pParent==0 ){
220811 int rc2 = SQLITE_OK; /* sqlite3_reset() return code */
220830 if( rc==SQLITE_OK ) rc = rc2;
220831 if( rc==SQLITE_OK && !pChild->pParent ){
220852 if( rc==SQLITE_OK ){
220856 testcase( rc!=SQLITE_OK );
220859 if( rc==SQLITE_OK ){
220862 if( rc!=SQLITE_OK ){
220869 if( SQLITE_OK!=(rc = sqlite3_reset(pRtree->pDeleteNode)) ){
220876 if( SQLITE_OK!=(rc = sqlite3_reset(pRtree->pDeleteParent)) ){
220889 return SQLITE_OK;
220894 int rc = SQLITE_OK;
220907 if( rc==SQLITE_OK ){
220923 if( SQLITE_OK!=(rc = fixLeafParent(pRtree, pNode)) ){
220960 int rc = SQLITE_OK;
220973 if( rc==SQLITE_OK ){
220986 int rc = SQLITE_OK;
220989 for(ii=0; rc==SQLITE_OK && ii<nCell; ii++){
220998 if( rc==SQLITE_OK ){
221002 if( rc==SQLITE_OK ){
221039 if( rc==SQLITE_OK ){
221044 assert( pLeaf!=0 || rc!=SQLITE_OK || CORRUPT_DB );
221048 if( rc==SQLITE_OK && pLeaf ){
221051 if( rc==SQLITE_OK ){
221055 if( rc==SQLITE_OK ){
221061 if( rc==SQLITE_OK ){
221075 if( rc==SQLITE_OK && pRtree->iDepth>0 && NCELL(pRoot)==1 ){
221080 if( rc==SQLITE_OK ){
221084 if( rc==SQLITE_OK ) rc = rc2;
221085 if( rc==SQLITE_OK ){
221094 if( rc==SQLITE_OK ){
221103 if( rc==SQLITE_OK ){
221168 if( rc==SQLITE_OK ){
221184 return (rc==SQLITE_OK ? SQLITE_CONSTRAINT : rc);
221199 int rc = SQLITE_OK;
221298 if( rc==SQLITE_OK && nData>1 ){
221308 if( rc==SQLITE_OK ){
221311 if( rc==SQLITE_OK ){
221315 if( rc==SQLITE_OK ){
221319 if( rc==SQLITE_OK && pRtree->nAux ){
221343 return SQLITE_OK;
221354 return SQLITE_OK;
221403 return SQLITE_OK;
221421 if( rc!=SQLITE_OK ){
221423 return rc==SQLITE_ERROR ? SQLITE_OK : rc;
221430 if( rc==SQLITE_OK ){
221494 int rc = SQLITE_OK;
221543 if( rc!=SQLITE_OK ){
221558 for(i=0; i<N_STATEMENT && rc==SQLITE_OK; i++){
221617 ** is written to *piVal and SQLITE_OK returned. Otherwise, an SQLite error
221625 if( rc==SQLITE_OK ){
221638 ** to. If successful, pRtree->iNodeSize is populated and SQLITE_OK returned.
221662 if( rc==SQLITE_OK ){
221676 if( rc!=SQLITE_OK ){
221715 int rc = SQLITE_OK;
221791 }else if( SQLITE_OK!=(rc = sqlite3_declare_vtab(db, zSql)) ){
221822 return SQLITE_OK;
221825 if( rc==SQLITE_OK ) rc = SQLITE_ERROR;
221942 ** and RtreeCheck.rc==SQLITE_OK, set RtreeCheck.rc to the error code.
221946 if( pCheck->rc==SQLITE_OK ) pCheck->rc = rc;
221968 if( pCheck->rc==SQLITE_OK ){
221989 if( pCheck->rc==SQLITE_OK && pCheck->nErr<RTREE_CHECK_MAX_ERROR ){
222023 if( pCheck->rc==SQLITE_OK && pCheck->pGetNode==0 ){
222030 if( pCheck->rc==SQLITE_OK ){
222044 if( pCheck->rc==SQLITE_OK && pRet==0 ){
222083 if( pCheck->rc!=SQLITE_OK ) return;
222226 if( pCheck->rc==SQLITE_OK ){
222272 check.rc = SQLITE_OK;
222291 if( check.rc==SQLITE_OK ){
222324 if( rc==SQLITE_OK && *pzErr ){
222386 if( rc==SQLITE_OK ){
222621 int rc = SQLITE_OK;
222677 if( pRc ) *pRc = SQLITE_OK;
222735 if( pRc ) *pRc = SQLITE_OK;
223061 if( pRc ) *pRc = SQLITE_OK;
223134 int rc = SQLITE_OK;
223137 if( rc==SQLITE_OK ){
223643 int rc = SQLITE_OK;
223693 }else if( SQLITE_OK!=(rc = sqlite3_declare_vtab(db, zSql)) ){
223710 return SQLITE_OK;
223713 if( rc==SQLITE_OK ) rc = SQLITE_ERROR;
223769 int rc = SQLITE_OK;
223786 if( rc==SQLITE_OK && pLeaf!=0 ){
223803 if( rc==SQLITE_OK && idxNum<=3 ){
223856 if( rc==SQLITE_OK ){
223924 return SQLITE_OK;
223933 return SQLITE_OK;
223939 return SQLITE_OK;
223950 int rc = SQLITE_OK;
223954 if( p==0 ) return SQLITE_OK;
223955 if( i==0 && sqlite3_vtab_nochange(ctx) ) return SQLITE_OK;
223970 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
223976 return SQLITE_OK;
224008 int rc = SQLITE_OK;
224068 if( rc==SQLITE_OK && (nData==1 || (coordChange && oldRowidValid)) ){
224076 if( rc==SQLITE_OK && nData>1 && coordChange ){
224083 if( rc==SQLITE_OK ){
224086 if( rc==SQLITE_OK ){
224090 if( rc==SQLITE_OK ){
224097 if( rc==SQLITE_OK && nData>1 ){
224109 && rc==SQLITE_OK
224189 int rc = SQLITE_OK;
224217 for(i=0; i<sizeof(aFunc)/sizeof(aFunc[0]) && rc==SQLITE_OK; i++){
224228 for(i=0; i<sizeof(aAgg)/sizeof(aAgg[0]) && rc==SQLITE_OK; i++){
224233 if( rc==SQLITE_OK ){
224253 if( rc==SQLITE_OK ){
224256 if( rc==SQLITE_OK ){
224259 if( rc==SQLITE_OK ){
224267 if( rc==SQLITE_OK ){
224272 if( rc==SQLITE_OK ){
224946 if( rc!=SQLITE_OK ){
224980 int rc = SQLITE_OK;
224983 for(i=0; rc==SQLITE_OK && i<(int)(sizeof(scalars)/sizeof(scalars[0])); i++){
225088 return SQLITE_OK;
225097 return SQLITE_OK;
225172 return SQLITE_OK;
225183 return SQLITE_OK;
225248 return SQLITE_OK;
225712 ** sqlite3rbu_close() returns any value other than SQLITE_OK, the contents
225786 ** SQLITE_OK if no error occurs but there remains work to do to apply
225791 ** SQLITE_OK, all subsequent calls on the same RBU handle are no-ops
225804 ** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
225822 ** Otherwise, if no error occurs, this function returns SQLITE_OK if the
225928 ** moved. The callback function should return SQLITE_OK to indicate
226323 char *zErrmsg; /* Error message if rc!=SQLITE_OK */
226659 ** SQLITE_OK.
226673 if( rc!=SQLITE_OK ){
226690 if( rc!=SQLITE_OK ){
226701 ** handle and SQLITE_OK is returned.
226796 ** If no error occurs, SQLITE_OK is returned and the iterator is left
226803 if( rc==SQLITE_OK ){
226817 if( rc==SQLITE_OK ){
226829 rc = (pIter->zDataTbl && pIter->zTbl) ? SQLITE_OK : SQLITE_NOMEM;
226836 if( rc==SQLITE_OK ){
226846 rc = pIter->zIdx ? SQLITE_OK : SQLITE_NOMEM;
226853 if( rc!=SQLITE_OK ){
226913 ** If no error occurs, SQLITE_OK is returned and the iterator is left
226931 if( rc==SQLITE_OK ){
226949 ** than SQLITE_OK), then this function returns NULL without modifying the
226958 if( p->rc==SQLITE_OK ){
226983 if( p->rc==SQLITE_OK ){
227007 if( p->rc==SQLITE_OK ){
227053 if( *pRc==SQLITE_OK ){
227078 if( p->rc==SQLITE_OK && rc!=SQLITE_OK ){
227141 assert( p->rc==SQLITE_OK );
227150 if( p->rc!=SQLITE_OK || sqlite3_step(aStmt[0])!=SQLITE_ROW ){
227172 if( p->rc==SQLITE_OK ){
227187 if( p->rc==SQLITE_OK ){
227213 if( p->rc==SQLITE_OK ){
227221 while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pList) ){
227232 while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){
227259 ** Return SQLITE_OK if successful, or an SQLite error code otherwise. If
227275 if( p->rc==SQLITE_OK && pIter->eType==RBU_PK_NOTABLE ){
227293 if( p->rc==SQLITE_OK ){
227297 for(i=0; p->rc==SQLITE_OK && i<nCol; i++){
227311 if( p->rc==SQLITE_OK
227325 if( p->rc==SQLITE_OK ){
227330 while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
227453 if( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pMax) ){
227463 if( p->rc==SQLITE_OK ){
227470 if( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pMax) ){
227523 while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){
227560 if( p->rc==SQLITE_OK ){
227568 if( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSel) ){
227640 if( rc==SQLITE_OK ){
227647 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){
227701 if( rc==SQLITE_OK ) rc = rc2;
227703 if( rc!=SQLITE_OK ){
227739 if( p->rc==SQLITE_OK && pIter->abIndexed ){
227844 if( p->rc==SQLITE_OK ){
227922 if( p->rc==SQLITE_OK ){
227930 while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXList) ){
227944 while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){
227979 if( p->rc==SQLITE_OK && pIter->eType==RBU_PK_EXTERNAL ){
227994 if( p->rc==SQLITE_OK ){
228007 while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){
228053 if( p->rc==SQLITE_OK && pIter->eType!=RBU_PK_VTAB ){
228060 for(iCol=0; p->rc==SQLITE_OK && iCol<pIter->nTblCol; iCol++){
228132 int rc = SQLITE_OK;
228143 for(i=0; rc==SQLITE_OK && i<nVal; i++){
228146 if( rc==SQLITE_OK ){
228151 if( rc!=SQLITE_OK ){
228163 if( rc==SQLITE_OK ){
228168 if( rc==SQLITE_OK ){
228171 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
228244 if( rc==SQLITE_OK ) rc = rc2;
228262 if( pIter->pSelect==0 && rbuObjIterCacheTableInfo(p, pIter)==SQLITE_OK ){
228301 if( p->rc==SQLITE_OK ){
228309 if( rbuIsVacuum(p)==0 && p->rc==SQLITE_OK ){
228317 if( p->rc==SQLITE_OK ){
228360 SQLITE_OK ){
228393 if( p->rc==SQLITE_OK ){
228405 if( rbuIsVacuum(p)==0 && p->rc==SQLITE_OK ){
228462 if( p->rc==SQLITE_OK ){
228485 if( p->rc==SQLITE_OK ){
228547 return SQLITE_OK;
228597 if( p->rc==SQLITE_OK ){
228642 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
228696 if( rc==SQLITE_OK ) rc = rc2;
228720 if( p->rc==SQLITE_OK && rbuIsVacuum(p) ){
228738 if( p->rc==SQLITE_OK && rbuIsVacuum(p) ){
228748 if( p->rc==SQLITE_OK ){
228755 if( p->rc==SQLITE_OK
228762 if( p->rc==SQLITE_OK ) p->rc = rc2;
228764 if( p->rc==SQLITE_OK && bOk==0 ){
228769 if( p->rc==SQLITE_OK ){
228776 if( p->rc==SQLITE_OK && rbuIsVacuum(p) ){
228796 if( p->rc==SQLITE_OK && p->dbMain==0 ){
228836 if( p->rc==SQLITE_OK ){
228842 if( p->rc==SQLITE_OK ){
228848 if( p->rc==SQLITE_OK ){
228854 if( p->rc==SQLITE_OK ){
228862 if( p->rc==SQLITE_OK ){
228917 if( p->rc==SQLITE_OK ){
228921 if( p->rc==SQLITE_OK ){
228951 if( p->rc==SQLITE_OK ){
228984 if( p->rc==SQLITE_OK ){
228991 if( p->rc==SQLITE_OK && p->nFrame>0 ){
228998 if( p->rc==SQLITE_OK ){
229052 return SQLITE_OK;
229062 return SQLITE_OK;
229075 assert( p->rc==SQLITE_OK );
229091 ** Take an EXCLUSIVE lock on the database file. Return SQLITE_OK if
229095 int rc = SQLITE_OK;
229102 if( rc==SQLITE_OK ){
229110 if( rc==SQLITE_OK && fd->pMethods ){
229112 if( rc==SQLITE_OK ){
229173 assert( p->rc==SQLITE_OK && p->zErrmsg==0 );
229197 assert( p->rc==SQLITE_OK );
229201 if( p->rc==SQLITE_OK ){
229205 if( p->rc!=SQLITE_OK
229213 if( p->rc==SQLITE_OK ){
229302 assert( p->rc==SQLITE_OK );
229362 if( p->rc==SQLITE_OK ){
229375 ** If no error occurs, SQLITE_OK is returned. Otherwise, an error code
229399 if( p->rc==SQLITE_OK ) rbuStepOneOp(p, RBU_INSERT);
229412 for(i=0; p->rc==SQLITE_OK && i<pIter->nCol; i++){
229419 if( p->rc==SQLITE_OK
229427 if( p->rc==SQLITE_OK ){
229445 if( p->rc==SQLITE_OK ){
229453 if( p->rc==SQLITE_OK ){
229464 if( p->rc==SQLITE_OK ){
229476 if( p->rc==SQLITE_OK || p->rc==SQLITE_DONE ){
229508 assert( pInsert==0 || rc==SQLITE_OK );
229510 if( rc==SQLITE_OK ){
229514 if( rc!=SQLITE_OK ) p->rc = rc;
229537 if( p->rc==SQLITE_OK ){
229542 if( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pPragma) ){
229562 if( p->rc==SQLITE_OK ){
229570 while( p->rc==SQLITE_OK && sqlite3_step(pSql)==SQLITE_ROW ){
229575 if( p->rc!=SQLITE_OK ) return;
229577 if( p->rc==SQLITE_OK ){
229583 if( p->rc==SQLITE_OK ){
229589 while( p->rc==SQLITE_OK && sqlite3_step(pSql)==SQLITE_ROW ){
229597 if( p->rc==SQLITE_OK ){
229616 if( rbuIsVacuum(p) && p->nProgress==0 && p->rc==SQLITE_OK ){
229622 while( p->rc==SQLITE_OK && pIter->zTbl ){
229637 if( p->rc==SQLITE_OK ){
229652 if( p->rc==SQLITE_OK ){
229656 if( p->rc==SQLITE_OK ){
229659 if( p->rc==SQLITE_OK ){
229668 if( p->rc==SQLITE_OK ){
229676 if( p->rc==SQLITE_OK ){
229684 if( p->rc==SQLITE_OK ){
229687 if( p->rc==SQLITE_OK ){
229692 if( p->rc==SQLITE_OK ){
229715 && p->rc==SQLITE_OK
229754 assert( p->rc==SQLITE_OK );
229757 int rc = SQLITE_OK;
229759 while( rc==SQLITE_OK && pIter->zTbl && (pIter->bCleanup
229767 if( rc==SQLITE_OK && !pIter->zTbl ){
229772 if( rc==SQLITE_OK ){
229791 assert( pVfs && p->rc==SQLITE_OK && p->zErrmsg==0 );
229807 assert( p->rc==SQLITE_OK );
229811 if( p->rc==SQLITE_OK ){
229853 if( rc!=SQLITE_OK ){
229861 if( rc==SQLITE_OK ){
229887 if( p->rc==SQLITE_OK ){
229899 if( p->rc==SQLITE_OK ){
229904 if( p->rc==SQLITE_OK ){
229911 if( p->rc==SQLITE_OK && bExists ){
229916 if( p->rc==SQLITE_OK ){
229947 if( p->rc==SQLITE_OK ){
229975 if( p->rc==SQLITE_OK ){
229977 assert( pState || p->rc!=SQLITE_OK );
229978 if( p->rc==SQLITE_OK ){
229992 assert( p->rc!=SQLITE_OK || p->eStage!=0 );
229994 if( p->rc==SQLITE_OK && p->pTargetFd->pWalFd ){
230004 if( p->rc==SQLITE_OK
230021 if( p->rc==SQLITE_OK ){
230027 if( p->rc==SQLITE_OK ){
230033 if( p->rc==SQLITE_OK && p->objiter.zTbl==0 ){
230037 if( p->rc==SQLITE_OK && pState->eStage==0 && rbuIsVacuum(p) ){
230044 if( p->rc==SQLITE_OK ){
230051 if( p->rc==SQLITE_OK ){
230053 if( frc==SQLITE_OK ){
230059 if( p->rc==SQLITE_OK ){
230172 if( p->rc==SQLITE_OK && p->eStage==RBU_STAGE_OAL ){
230177 if( p->rc==SQLITE_OK && p->eStage==RBU_STAGE_CKPT ){
230184 if( p->rc==SQLITE_OK && p->eStage==RBU_STAGE_OAL ){
230196 if( rbuIsVacuum(p) && p->rc!=SQLITE_OK && p->dbRbu ){
230198 if( p->rc==SQLITE_DONE && rc2!=SQLITE_OK ) p->rc = rc2;
230288 if( p->rc!=SQLITE_OK && p->rc!=SQLITE_DONE ){
230303 if( rc==SQLITE_DONE ) return SQLITE_OK;
230308 if( rc==SQLITE_OK ) rc = sqlite3_exec(p->dbMain, "COMMIT", 0, 0, 0);
230312 if( rc==SQLITE_OK && p->eStage==RBU_STAGE_CKPT ){
230323 if( rc==SQLITE_OK ) rc = sqlite3_exec(p->dbRbu, "COMMIT", 0, 0, 0);
230324 if( rc==SQLITE_OK ){
230328 if( rc==SQLITE_OK ) rc = sqlite3_exec(p->dbMain, "BEGIN IMMEDIATE", 0, 0,0);
230339 int rc = SQLITE_OK;
230351 rc = SQLITE_OK;
230365 rc = rename(zOld, zNew) ? SQLITE_IOERR : SQLITE_OK;
230466 return SQLITE_OK;
230615 rc = SQLITE_OK;
230627 && pRbu->rc==SQLITE_OK
230631 if( rc==SQLITE_OK ){
230649 if( rc==SQLITE_OK && iOfst==0 && (p->openFlags & SQLITE_OPEN_MAIN_DB) ){
230687 if( rc!=SQLITE_OK ) return rc;
230692 if( rc==SQLITE_OK && iOfst==0 && (p->openFlags & SQLITE_OPEN_MAIN_DB) ){
230710 if( rc!=SQLITE_OK ) return rc;
230724 return SQLITE_OK;
230741 if( rc==SQLITE_OK && *pSize==0
230756 int rc = SQLITE_OK;
230812 if( rc==SQLITE_OK ){
230820 rc = SQLITE_OK;
230833 if( rc==SQLITE_OK && op==SQLITE_FCNTL_VFSNAME ){
230866 int rc = SQLITE_OK;
230889 if( bCapture && rc==SQLITE_OK ){
230909 int rc = SQLITE_OK;
230933 if( rc==SQLITE_OK ){
230943 if( rc==SQLITE_OK ){
230969 int rc = SQLITE_OK;
231035 int rc = SQLITE_OK;
231082 if( rc==SQLITE_OK ){
231143 if( rc==SQLITE_OK && flags==SQLITE_ACCESS_EXISTS ){
231302 int rc = SQLITE_OK;
231335 if( rc!=SQLITE_OK ){
231528 int rc = SQLITE_OK;
231545 if( rc==SQLITE_OK ){
231550 assert( rc==SQLITE_OK || pTab==0 );
231551 if( rc==SQLITE_OK ){
231566 return SQLITE_OK;
231648 return SQLITE_OK;
231668 return SQLITE_OK;
231727 return SQLITE_OK;
231851 if( rc!=SQLITE_OK ){
231863 return SQLITE_OK;
231868 return SQLITE_OK;
231887 if( sqlite3OsFileControl(fd, 230440, &x)==SQLITE_OK ){
231899 ** to page object pPg. Allocate the buffer if necessary. Return SQLITE_OK
231920 if( rc==SQLITE_OK ){
232001 return z==0 ? SQLITE_NOMEM_BKPT : SQLITE_OK;
232014 return SQLITE_OK;
232044 if( rc==SQLITE_OK ){
232051 if( rc==SQLITE_OK ){
232109 int rc = SQLITE_OK; /* Result of this operation */
232124 return SQLITE_OK;
232161 if( rc==SQLITE_OK ){
232226 return SQLITE_OK;
232232 return SQLITE_OK;
232269 SQLITE_PRIVATE int sqlite3DbstatRegister(sqlite3 *db){ return SQLITE_OK; }
232354 int rc = SQLITE_OK;
232364 if( rc==SQLITE_OK ){
232369 assert( rc==SQLITE_OK || pTab==0 );
232370 if( rc==SQLITE_OK ){
232384 return SQLITE_OK;
232445 return SQLITE_OK;
232464 return SQLITE_OK;
232474 return SQLITE_OK;
232481 int rc = SQLITE_OK;
232525 if( pCsr->iDb<0 ) return SQLITE_OK;
232530 if( NEVER(pBt==0) ) return SQLITE_OK;
232557 int rc = SQLITE_OK;
232571 SQLITE_OK ){
232591 return SQLITE_OK;
232599 ** Return SQLITE_OK if successful, or an SQLite error code otherwise.
232603 int rc = SQLITE_OK;
232605 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
232621 int rc = SQLITE_OK;
232680 if( dbpageBeginTrans(pTab)!=SQLITE_OK ){
232687 if( rc==SQLITE_OK ){
232689 if( (rc = sqlite3PagerWrite(pDbPage))==SQLITE_OK && pData ){
232695 if( rc!=SQLITE_OK ){
232711 return SQLITE_OK;
232728 return SQLITE_OK;
232737 return SQLITE_OK;
232774 SQLITE_PRIVATE int sqlite3DbpageRegister(sqlite3 *db){ return SQLITE_OK; }
232908 if( rc==SQLITE_OK ){
232921 return SQLITE_OK;
232933 return SQLITE_OK;
232941 return SQLITE_OK;
232951 return SQLITE_OK;
232966 case CARRAY_COLUMN_POINTER: return SQLITE_OK;
232970 return SQLITE_OK;
232977 return SQLITE_OK;
232982 return SQLITE_OK;
232987 return SQLITE_OK;
232992 return SQLITE_OK;
232999 return SQLITE_OK;
233005 return SQLITE_OK;
233015 return SQLITE_OK;
233072 return SQLITE_OK;
233152 return SQLITE_OK;
233224 int rc = SQLITE_OK;
233756 ** If no error occurs, SQLITE_OK is returned. Or, if an OOM error occurs
233825 return SQLITE_OK;
233901 ** of *piHash asn *pbNullPK are undefined. Otherwise, SQLITE_OK is returned
233932 if( rc!=SQLITE_OK ) return rc;
233967 return SQLITE_OK;
234281 assert( rc==SQLITE_OK );
234324 ** SQLITE_OK.
234327 ** that case the hash-table does not grow, but SQLITE_OK is returned anyway.
234348 return SQLITE_OK;
234369 return SQLITE_OK;
234439 if( rc==SQLITE_OK ){
234460 if( rc!=SQLITE_OK ){
234479 if( rc==SQLITE_OK ){
234488 if( rc==SQLITE_OK ){
234540 if( rc==SQLITE_OK ){
234561 ** key, sqlite3_session.rc is left set to SQLITE_OK and non-zero returned to
234571 int rc = SQLITE_OK;
234583 if( rc==SQLITE_OK ){
234622 assert( pSession->rc==SQLITE_OK );
234628 if( pSession->rc==SQLITE_OK ){
234644 if( pSession->rc==SQLITE_OK ){
234771 if( *pRc==SQLITE_OK && nReq>p->nAlloc ){
234800 return (*pRc!=SQLITE_OK);
234805 ** This function is a no-op if *pRc is other than SQLITE_OK when it is
234835 if( *pRc==SQLITE_OK ){
234867 int rc = SQLITE_OK;
234878 if( rc==SQLITE_OK ){
234896 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
234910 if( pSession->rc==SQLITE_OK ) pSession->rc = rc;
234929 if( rc==SQLITE_OK && iCol==1 && sqlite3_value_type(pVal)==SQLITE_NULL ){
234939 if( rc==SQLITE_OK && iCol==1 && sqlite3_value_type(pVal)==SQLITE_NULL ){
235055 return SQLITE_OK;
235074 int rc = SQLITE_OK;
235126 if( rc!=SQLITE_OK ) goto error_out;
235142 assert( rc==SQLITE_OK );
235156 assert( trc==SQLITE_OK );
235159 if( rc==SQLITE_OK ){
235164 if( rc!=SQLITE_OK ) goto error_out;
235221 assert( rc==SQLITE_OK );
235233 if( rc!=SQLITE_OK ){
235243 int rc = SQLITE_OK;
235259 if( rc==SQLITE_OK ){
235270 assert( rc==SQLITE_OK || pRet==0 );
235306 assert( pSession->rc==SQLITE_OK );
235359 return SQLITE_OK;
235364 return SQLITE_OK;
235469 int rc = SQLITE_OK;
235479 if( rc==SQLITE_OK ){
235523 int rc = SQLITE_OK;
235543 if( rc==SQLITE_OK ){
235577 if( rc==SQLITE_OK ){
235593 if( rc==SQLITE_OK ){
235610 rc = SQLITE_OK;
235617 if( rc==SQLITE_OK && nCol==0 ){
235623 if( rc==SQLITE_OK ){
235655 if( rc==SQLITE_OK ){
235662 if( rc==SQLITE_OK ){
235667 if( rc==SQLITE_OK ){
235672 if( rc==SQLITE_OK ){
235720 return SQLITE_OK;
235804 int rc = SQLITE_OK;
235856 if( rc==SQLITE_OK ){
235860 if( rc==SQLITE_OK ){
235870 ** This function is a no-op if *pRc is other than SQLITE_OK when it is
235883 ** This function is a no-op if *pRc is other than SQLITE_OK when it is
235896 ** This function is a no-op if *pRc is other than SQLITE_OK when it is
235915 ** This function is a no-op if *pRc is other than SQLITE_OK when it is
235933 ** This function is a no-op if *pRc is other than SQLITE_OK when it is
235964 ** This function is a no-op if *pRc is other than SQLITE_OK when it is
235975 if( *pRc==SQLITE_OK ){
236037 int rc = SQLITE_OK;
236137 int rc = SQLITE_OK;
236186 if( pzErrmsg && rc!=SQLITE_OK ){
236216 int rc = SQLITE_OK;
236258 if( rc==SQLITE_OK ){
236297 if( rc==SQLITE_OK ){
236313 ** Return SQLITE_OK if all PK values are successfully bound, or an SQLite
236323 int rc = SQLITE_OK;
236326 for(i=0; i<nCol && rc==SQLITE_OK; i++){
236382 ** This function is a no-op if *pRc is set to other than SQLITE_OK when it
236405 ** If no error occurs, SQLITE_OK is returned and the new changeset/patchset
236427 ** object is already in the error state (sqlite3_session.rc != SQLITE_OK),
236439 if( rc!=SQLITE_OK ){
236444 for(pTab=pSession->pTable; rc==SQLITE_OK && pTab; pTab=pTab->pNext){
236455 if( rc==SQLITE_OK && pTab->nCol!=nOldCol ){
236463 if( rc==SQLITE_OK ){
236470 for(i=0; i<pTab->nChange && rc==SQLITE_OK; i++){
236473 for(p=pTab->apChange[i]; rc==SQLITE_OK && p; p=p->pNext){
236475 if( rc!=SQLITE_OK ) continue;
236491 if( rc==SQLITE_OK ){
236498 && rc==SQLITE_OK
236517 if( rc==SQLITE_OK ){
236651 int rc = SQLITE_OK;
236728 return SQLITE_OK;
236794 ** Return an SQLite error code if an error occurs, or SQLITE_OK otherwise.
236797 int rc = SQLITE_OK;
236799 while( !pIn->bEof && (pIn->iNext+nByte)>=pIn->nData && rc==SQLITE_OK ){
236803 if( SQLITE_OK==sessionBufferGrow(&pIn->buf, nNew, &rc) ){
236847 ** buffer. SQLITE_OK is returned if successful, or SQLITE_NOMEM if an OOM
236864 return SQLITE_OK;
236899 int rc = SQLITE_OK;
236903 for(i=0; i<nCol && rc==SQLITE_OK; i++){
236907 if( rc==SQLITE_OK ){
236921 if( rc==SQLITE_OK ){
236928 if( rc==SQLITE_OK ){
236969 ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error code.
236973 int rc = SQLITE_OK;
236978 if( rc==SQLITE_OK ){
236996 while( rc==SQLITE_OK ){
237006 if( rc==SQLITE_OK && (pIn->iNext + nRead)>=pIn->nData ){
237019 ** If successful, SQLITE_OK is returned and *pnByte is set to the size of
237028 int rc = SQLITE_OK;
237031 for(i=0; rc==SQLITE_OK && i<nCol; i++){
237034 if( rc==SQLITE_OK ){
237067 ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error code
237074 assert( p->rc==SQLITE_OK );
237077 if( rc==SQLITE_OK ){
237092 if( rc==SQLITE_OK ){
237134 if( p->rc!=SQLITE_OK ) return p->rc;
237149 if( p->rc!=SQLITE_OK ) return p->rc;
237196 if( p->rc!=SQLITE_OK ) return p->rc;
237207 SQLITE_OK ) return p->rc;
237213 if( p->rc!=SQLITE_OK ) return p->rc;
237314 return SQLITE_OK;
237330 return SQLITE_OK;
237344 ** not modified. Otherwise, SQLITE_OK.
237358 return SQLITE_OK;
237372 ** not modified. Otherwise, SQLITE_OK.
237386 return SQLITE_OK;
237406 ** code is returned. Otherwise, SQLITE_OK.
237420 return SQLITE_OK;
237427 ** violations in the destination database and returns SQLITE_OK.
237439 return SQLITE_OK;
237450 int rc = SQLITE_OK;
237471 int rc = SQLITE_OK; /* Return value */
237530 assert( rc==SQLITE_OK );
237559 if( rc==SQLITE_OK ){
237583 if( rc!=SQLITE_OK ){
237595 assert( rc==SQLITE_OK );
237599 if( rc!=SQLITE_OK ) goto finished_invert;
237603 assert( rc==SQLITE_OK );
237707 int rc = SQLITE_OK;
237720 if( rc==SQLITE_OK ){
237726 rc = SQLITE_OK;
237731 if( rc==SQLITE_OK ){
237811 if( rc==SQLITE_OK ){
237816 if( rc!=SQLITE_OK ){
237828 assert( (rc==SQLITE_OK)==(pUp!=0) );
237867 ** If successful, SQLITE_OK is returned and SessionApplyCtx.pDelete is left
237877 int rc = SQLITE_OK;
237914 if( rc==SQLITE_OK ){
237932 ** If successful, SQLITE_OK is returned and SessionApplyCtx.pSelect is left
237952 ** If successful, SQLITE_OK is returned and SessionApplyCtx.pInsert is left
237960 int rc = SQLITE_OK;
237978 if( rc==SQLITE_OK ){
237993 if( rc==SQLITE_OK ){
238000 if( rc==SQLITE_OK ){
238045 ** An SQLite error code is returned if an error occurs. Otherwise, SQLITE_OK.
238055 int rc = SQLITE_OK;
238063 for(i=0; rc==SQLITE_OK && i<nCol; i++){
238085 ** has occured, the statement is reset and SQLITE_OK is returned. If an
238115 for(ii=0; rc==SQLITE_OK && ii<nCol; ii++){
238125 if( rc==SQLITE_OK ){
238141 ** Return SQLITE_OK if successful, or an SQLite error code otherwise.
238148 int rc = SQLITE_OK;
238210 ** is set to non-zero before returning SQLITE_OK.
238215 ** this function returns SQLITE_OK.
238241 rc = SQLITE_OK;
238254 }else if( rc==SQLITE_OK ){
238261 return SQLITE_OK;
238271 if( rc==SQLITE_OK ){
238289 if( rc==SQLITE_OK ){
238318 ** returns SQLITE_ABORT. Otherwise, if no error occurs, SQLITE_OK is
238332 int rc = SQLITE_OK;
238355 if( rc==SQLITE_OK && sqlite3_bind_parameter_count(p->pDelete)>nCol ){
238358 if( rc!=SQLITE_OK ) return rc;
238362 if( rc==SQLITE_OK && sqlite3_changes(p->db)==0 ){
238380 for(i=0; rc==SQLITE_OK && i<nCol; i++){
238386 if( rc==SQLITE_OK && pNew ){
238390 if( rc!=SQLITE_OK ) return rc;
238393 ** the result will be SQLITE_OK with 0 rows modified. */
238397 if( rc==SQLITE_OK && sqlite3_changes(p->db)==0 ){
238426 if( rc==SQLITE_OK ){
238428 if( rc!=SQLITE_OK ) return rc;
238466 if( rc==SQLITE_OK ){
238487 if( rc==SQLITE_OK ){
238492 if( rc==SQLITE_OK ){
238496 if( rc==SQLITE_OK ){
238499 if( rc==SQLITE_OK ){
238519 int rc = SQLITE_OK;
238529 if( rc==SQLITE_OK ){
238538 if( rc==SQLITE_OK ) memset(pIter2->apValue, 0, nByte);
238540 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3changeset_next(pIter2) ){
238545 if( rc==SQLITE_OK ) rc = rc2;
238550 if( rc!=SQLITE_OK ) break;
238588 int rc = SQLITE_OK; /* Return code */
238611 if( rc==SQLITE_OK ){
238614 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3changeset_next(pIter) ){
238627 if( rc!=SQLITE_OK ) break;
238668 if( rc!=SQLITE_OK ) break;
238725 if( rc==SQLITE_OK ){
238731 if( rc==SQLITE_OK ){
238735 if( rc==SQLITE_OK ){
238752 if( rc==SQLITE_OK ) rc = rc2;
238756 if( rc==SQLITE_OK ){
238759 if( rc!=SQLITE_OK ){
238766 if( rc==SQLITE_OK && bPatchset==0 && sApply.bRebase ){
238786 assert( rc!=SQLITE_OK || sApply.zErr==0 );
238867 if( rc==SQLITE_OK ){
239081 int rc = SQLITE_OK;
239279 int rc = SQLITE_OK;
239289 if( rc==SQLITE_OK && pTab->pDfltStmt==0 ){
239291 if( rc==SQLITE_OK && SQLITE_ROW!=sqlite3_step(pTab->pDfltStmt) ){
239295 for(ii=nCol; rc==SQLITE_OK && ii<pTab->nCol; ii++){
239301 if( SQLITE_OK==sessionBufferGrow(pOut, 8, &rc) ){
239363 ** object and return SQLITE_OK. Otherwise, if some error occurs, return
239372 int rc = SQLITE_OK;
239389 return SQLITE_OK;
239449 int rc = SQLITE_OK;
239465 if( rc==SQLITE_OK && sessionGrowHash(0, pGrp->bPatch, pTab) ){
239469 if( rc==SQLITE_OK ){
239491 if( rc==SQLITE_OK ){
239496 if( rc==SQLITE_OK && pChange ){
239520 int rc = SQLITE_OK;
239532 if( rc==SQLITE_OK ){
239537 if( rc==SQLITE_OK ){
239543 if( rc==SQLITE_OK ) rc = pIter->rc;
239558 int rc = SQLITE_OK;
239563 if( rc!=SQLITE_OK ) break;
239566 if( rc==SQLITE_OK ) rc = pIter->rc;
239584 ** If successful, SQLITE_OK is returned. Or, if an error occurs, an SQLite
239595 int rc = SQLITE_OK;
239603 for(pTab=pGrp->pList; rc==SQLITE_OK && pTab; pTab=pTab->pNext){
239614 if( rc==SQLITE_OK && xOutput && buf.nBuf>=sessions_strm_chunk_size ){
239622 if( rc==SQLITE_OK ){
239640 int rc = SQLITE_OK; /* Return code */
239660 int rc = SQLITE_OK;
239687 int rc = SQLITE_OK;
239713 if( rc==SQLITE_OK ){
239727 int rc = SQLITE_OK;
239730 || pIter->rc!=SQLITE_OK
239766 if( rc==SQLITE_OK ){
239817 if( rc==SQLITE_OK ){
239820 if( rc==SQLITE_OK ){
239823 if( rc==SQLITE_OK ){
239846 if( rc==SQLITE_OK ){
239849 if( rc==SQLITE_OK ){
239852 if( rc==SQLITE_OK ){
239881 if( *pRc==SQLITE_OK ){
239930 if( *pRc==SQLITE_OK ){
239980 ** xOutput zero or more times and SQLITE_OK returned. Or, if xOutput is NULL,
239998 int rc = SQLITE_OK;
240028 if( pTab && rc==SQLITE_OK ){
240092 if( rc==SQLITE_OK && xOutput && sOut.nBuf>sessions_strm_chunk_size ){
240099 if( rc!=SQLITE_OK ){
240104 if( rc==SQLITE_OK ){
240123 int rc = SQLITE_OK;
240146 if( rc==SQLITE_OK ){
240164 if( rc==SQLITE_OK ){
240185 if( rc==SQLITE_OK ){
240208 int rc = SQLITE_OK;
240236 SQLITE_OK;
240245 if( rc==SQLITE_OK ){
240298 int rc = SQLITE_OK;
240330 int rc = SQLITE_OK;
240333 if( SQLITE_OK!=(rc = checkChangeParams(pGrp, bNew, iCol, 9, &pBuf)) ){
240339 return SQLITE_OK;
240350 int rc = SQLITE_OK;
240353 if( SQLITE_OK!=(rc = checkChangeParams(pGrp, bNew, iCol, 1, &pBuf)) ){
240358 return SQLITE_OK;
240370 int rc = SQLITE_OK;
240373 if( SQLITE_OK!=(rc = checkChangeParams(pGrp, bNew, iCol, 9, &pBuf)) ){
240379 return SQLITE_OK;
240394 int rc = SQLITE_OK;
240397 if( SQLITE_OK!=(rc = checkChangeParams(pGrp, bNew, iCol, nByte, &pBuf)) ){
240406 return SQLITE_OK;
240420 int rc = SQLITE_OK;
240423 if( SQLITE_OK!=(rc = checkChangeParams(pGrp, bNew, iCol, nByte, &pBuf)) ){
240432 return SQLITE_OK;
240443 int rc = SQLITE_OK;
240524 if( rc==SQLITE_OK ){
240684 ** (not characters) of the buffer and SQLITE_OK is returned. Otherwise,
240699 ** the query within the current row. Return SQLITE_OK if successful, or
240716 ** first token of the phrase. SQLITE_OK is returned if successful, or an
240747 ** If the callback function returns any value other than SQLITE_OK, the
240749 ** If the returned value is SQLITE_DONE, xQueryPhrase returns SQLITE_OK.
240752 ** If the query runs to completion without incident, SQLITE_OK is returned.
240928 ** If successful, SQLITE_OK is returned. Or, if an error occurs, an
241017 ** should be set to point to the new tokenizer handle and SQLITE_OK
241018 ** returned. If an error occurs, some value other than SQLITE_OK should
241079 ** If an xToken() callback returns any value other than SQLITE_OK, then
241082 ** input buffer is exhausted, xTokenize() should return SQLITE_OK. Finally,
241085 ** SQLITE_OK or SQLITE_DONE.
242159 ** rc==SQLITE_OK && 0==sqlite3Fts5ExprEof(pExpr);
243870 ** (rc==SQLITE_OK && 0==fts5CInstIterEof(&iter);
243892 ** an SQLite error code if an error occurs, or SQLITE_OK otherwise.
243895 int rc = SQLITE_OK;
243899 while( rc==SQLITE_OK && pIter->iInst<pIter->nInst ){
243902 if( rc==SQLITE_OK ){
243939 if( rc==SQLITE_OK ){
243974 ** If *pRc is set to any value other than SQLITE_OK when this function is
243983 if( *pRc==SQLITE_OK && z ){
244002 int rc = SQLITE_OK;
244007 if( tflags & FTS5_TOKEN_COLOCATED ) return SQLITE_OK;
244011 if( iPos<p->iRangeStart || iPos>p->iRangeEnd ) return SQLITE_OK;
244048 if( rc==SQLITE_OK ){
244098 rc = SQLITE_OK;
244102 if( rc==SQLITE_OK ){
244106 if( rc==SQLITE_OK ){
244109 if( rc==SQLITE_OK ){
244119 if( rc==SQLITE_OK ){
244124 if( rc!=SQLITE_OK ){
244146 ** necessary. Return SQLITE_OK if successful, or SQLITE_NOMEM if an
244160 return SQLITE_OK;
244176 int rc = SQLITE_OK;
244224 for(i=0; i<nInst && rc==SQLITE_OK; i++){
244226 if( rc==SQLITE_OK && ic==iCol && iOff>=iPos && iOff<iEnd ){
244266 int rc = SQLITE_OK; /* Return code */
244302 if( rc==SQLITE_OK ){
244317 if( rc!=SQLITE_OK ) break;
244319 if( rc!=SQLITE_OK ) break;
244323 if( rc!=SQLITE_OK ) break;
244325 if( rc!=SQLITE_OK ) break;
244327 for(ii=0; rc==SQLITE_OK && ii<nInst; ii++){
244336 if( rc!=SQLITE_OK ) continue;
244341 if( rc==SQLITE_OK && nScore>nBestScore ){
244348 if( rc==SQLITE_OK && sFinder.nFirst && nDocsize>nToken ){
244360 if( rc==SQLITE_OK && nScore>nBestScore ){
244372 if( rc==SQLITE_OK ){
244375 if( rc==SQLITE_OK && nColSize==0 ){
244382 if( rc==SQLITE_OK ){
244395 while( ctx.iter.iStart>=0 && ctx.iter.iStart<iBestStart && rc==SQLITE_OK ){
244399 if( rc==SQLITE_OK ){
244402 if( rc==SQLITE_OK ){
244416 if( rc==SQLITE_OK ){
244452 return SQLITE_OK;
244465 int rc = SQLITE_OK; /* Return code */
244490 if( rc==SQLITE_OK ) rc = pApi->xRowCount(pFts, &nRow);
244491 assert( rc!=SQLITE_OK || nRow>0 );
244492 if( rc==SQLITE_OK ) rc = pApi->xColumnTotalSize(pFts, -1, &nToken);
244493 if( rc==SQLITE_OK ) p->avgdl = (double)nToken / (double)nRow;
244496 for(i=0; rc==SQLITE_OK && i<nPhrase; i++){
244499 if( rc==SQLITE_OK ){
244519 if( rc!=SQLITE_OK ){
244524 if( rc!=SQLITE_OK ) p = 0;
244553 if( rc==SQLITE_OK ){
244558 for(i=0; rc==SQLITE_OK && i<nInst; i++){
244561 if( rc==SQLITE_OK ){
244568 if( rc==SQLITE_OK ){
244576 if( rc==SQLITE_OK ){
244601 int rc = SQLITE_OK;
244628 if( rc!=SQLITE_OK ){
244648 int rc = SQLITE_OK; /* Return code */
244651 for(i=0; rc==SQLITE_OK && i<ArraySize(aBuiltin); i++){
244767 SQLITE_OK ){
244785 if( *pRc==SQLITE_OK ){
244923 return SQLITE_OK;
244928 if( *pRc==SQLITE_OK ){
244949 if( *pRc==SQLITE_OK ){
245006 int rc = SQLITE_OK;
245017 int rc = SQLITE_OK;
245298 return iVal<0 ? SQLITE_ERROR : SQLITE_OK;
245305 ** If successful, object pConfig is updated and SQLITE_OK returned. If
245316 int rc = SQLITE_OK;
245516 ** If *pRc is other than SQLITE_OK when this function is called, it is
245532 assert( *pRc==SQLITE_OK );
245568 int rc = SQLITE_OK;
245593 int rc = SQLITE_OK;
245633 ** If successful, SQLITE_OK is returned and *ppOut is set to point to the
245647 int rc = SQLITE_OK; /* Return code */
245670 if( rc==SQLITE_OK && sqlite3_stricmp(pRet->zName, FTS5_RANK_NAME)==0 ){
245675 assert( (pRet->abUnindexed && pRet->azCol) || rc!=SQLITE_OK );
245676 for(i=3; rc==SQLITE_OK && i<nArg; i++){
245699 if( rc==SQLITE_OK ){
245722 if( rc==SQLITE_OK
245736 if( rc==SQLITE_OK && pRet->bContentlessDelete && pRet->bColumnsize==0 ){
245746 if( rc==SQLITE_OK
245757 if( rc==SQLITE_OK && pRet->zContent==0 ){
245778 if( rc==SQLITE_OK && pRet->zContentRowid==0 ){
245783 if( rc==SQLITE_OK ){
245787 if( rc!=SQLITE_OK ){
245826 ** object passed as the only argument. Return SQLITE_OK if successful, or
245831 int rc = SQLITE_OK;
245868 ** This function returns SQLITE_OK if successful or an SQLite error code
245871 ** still returns SQLITE_OK. Or, if the tokenization was abandoned early
245882 int rc = SQLITE_OK;
245887 if( rc==SQLITE_OK ){
245944 int rc = SQLITE_OK;
245963 if( rc==SQLITE_OK ){
245968 if( rc==SQLITE_OK ){
245984 if( rc!=SQLITE_OK ){
246000 int rc = SQLITE_OK;
246082 if( rc==SQLITE_OK ){
246088 rc = SQLITE_OK;
246129 int rc = SQLITE_OK;
246146 assert( rc==SQLITE_OK || p==0 );
246147 if( rc==SQLITE_OK ){
246161 if( rc==SQLITE_OK
246174 if( rc==SQLITE_OK ){
246367 if( rc==SQLITE_OK ){
246376 assert_expr_depth_ok(SQLITE_OK, pChild);
246389 if( pParse->rc==SQLITE_OK ){
246497 }while( sParse.rc==SQLITE_OK && t!=FTS5_EOF );
246500 assert( sParse.pExpr || sParse.rc!=SQLITE_OK );
246505 if( sParse.rc==SQLITE_OK && iCol<pConfig->nCol ){
246515 assert( sParse.rc!=SQLITE_OK || sParse.zErr==0 );
246516 if( sParse.rc==SQLITE_OK ){
246561 ** GLOB. If successful, SQLITE_OK is returned. Otherwise, an SQLite error
246569 int rc = SQLITE_OK;
246668 if( sParse.rc==SQLITE_OK ){
246732 int rc = SQLITE_OK;
246778 if( iMin==FTS5_LARGEST_INT64 || rc!=SQLITE_OK ) break;
246782 if( rc==SQLITE_OK ){
246801 ** SQLITE_OK is returned if an error occurs, or an SQLite error code
246814 int rc = SQLITE_OK;
246872 if( rc!=SQLITE_OK ) goto ismatch_out;
246934 ** If in/out parameter (*pRc) is set to other than SQLITE_OK when this
246962 if( rc!=SQLITE_OK ){
247074 int rc = SQLITE_OK;
247079 SQLITE_OK && p; p=p->pSynonym){
247088 if( rc!=SQLITE_OK ){
247125 for(i=0; rc==SQLITE_OK && i<pNear->nPhrase; i++){
247154 ** SQLITE_OK. It is not considered an error if some term matches zero
247169 return SQLITE_OK;
247190 assert( (rc==SQLITE_OK)==(p->pIter!=0) );
247191 if( rc!=SQLITE_OK ) return rc;
247199 return SQLITE_OK;
247206 return SQLITE_OK;
247290 ** SQLITE_OK is returned if an error occurs, or an SQLite error code
247300 int rc = SQLITE_OK;
247351 pNode->bNomatch = ((0==fts5ExprNearTest(&rc, pExpr, pNode)) && rc==SQLITE_OK);
247361 ** Return SQLITE_OK if successful, or an SQLite error code if an error
247371 int rc = SQLITE_OK;
247394 if( rc!=SQLITE_OK ) break;
247421 assert( rc==SQLITE_OK );
247451 return SQLITE_OK;
247472 if( rc==SQLITE_OK && sqlite3Fts5IterEof(pIter)==0 ){
247517 if( rc!=SQLITE_OK ){
247526 return SQLITE_OK;
247538 int rc = SQLITE_OK;
247551 if( rc!=SQLITE_OK ){
247581 return SQLITE_OK;
247591 if( rc==SQLITE_OK ){
247603 int rc = SQLITE_OK;
247608 while( rc==SQLITE_OK && p1->bEof==0 ){
247614 assert( rc!=SQLITE_OK || cmp<=0 );
247634 if( rc==SQLITE_OK ){
247637 if( rc!=SQLITE_OK ){
247644 ** If pNode currently points to a match, this function returns SQLITE_OK
247652 int rc = SQLITE_OK;
247690 ** Return an SQLite error code if an error occurs, or SQLITE_OK otherwise.
247694 int rc = SQLITE_OK;
247706 for(i=0; i<pNode->nChild && rc==SQLITE_OK; i++){
247730 if( rc==SQLITE_OK ){
247749 ** Return SQLITE_OK if successful, or an SQLite error code otherwise. It
247768 if( rc==SQLITE_OK
247776 while( pRoot->bNomatch && rc==SQLITE_OK ){
247789 ** Return SQLITE_OK if successful, or an SQLite error code otherwise. It
247798 assert( pRoot->bNomatch==0 || (rc==SQLITE_OK && pRoot->bEof==0) );
247815 int rc = SQLITE_OK;
247870 if( pParse->rc==SQLITE_OK ){
247895 assert( pParse->rc!=SQLITE_OK );
247940 int rc = SQLITE_OK;
247948 if( pCtx->rc!=SQLITE_OK ) return pCtx->rc;
247986 if( rc==SQLITE_OK ){
247991 if( pCtx->pConfig->bTokendata && rc==SQLITE_OK ){
248039 return SQLITE_OK;
248063 if( rc==SQLITE_OK ){
248108 int rc = SQLITE_OK; /* Return code */
248118 if( rc==SQLITE_OK ){
248122 if( rc==SQLITE_OK ){
248125 if( rc==SQLITE_OK ){
248129 if( rc==SQLITE_OK && ALWAYS(pOrig!=0) ){
248143 if( rc==SQLITE_OK ){
248147 for(i=0; rc==SQLITE_OK && i<pOrig->nTerm; i++){
248150 for(p=&pOrig->aTerm[i]; p && rc==SQLITE_OK; p=p->pSynonym){
248154 if( rc==SQLITE_OK ){
248166 if( rc==SQLITE_OK && ALWAYS(sCtx.pPhrase) ){
248254 assert( pParse->rc==SQLITE_OK );
248320 if( pParse->rc==SQLITE_OK ){
248335 assert( pParse->rc!=SQLITE_OK );
248344 ** SQLITE_OK when this function is called, NULL is returned.
248399 if( pParse->rc==SQLITE_OK ){
248575 if( pParse->rc==SQLITE_OK ){
248652 assert( pParse->rc!=SQLITE_OK );
249008 if( rc==SQLITE_OK ){
249011 if( rc==SQLITE_OK ){
249028 if( rc!=SQLITE_OK ){
249117 int rc = SQLITE_OK;
249120 for(i=0; rc==SQLITE_OK && i<ArraySize(aFunc); i++){
249125 int rc = SQLITE_OK;
249269 if( rc==SQLITE_OK && (pExpr->pConfig->bTokendata || pT->bPrefix) ){
249281 return SQLITE_OK;
249385 int rc = SQLITE_OK;
249434 return SQLITE_OK;
249452 int rc = SQLITE_OK;
249578 int rc = SQLITE_OK;
249678 return SQLITE_OK;
249770 if( rc!=SQLITE_OK ) return rc;
249876 return SQLITE_OK;
249974 return SQLITE_OK;
250014 return SQLITE_OK;
250910 if( p->rc==SQLITE_OK ) p->rc = rc;
250922 if( p->rc==SQLITE_OK ){
250923 int rc = SQLITE_OK;
250934 if( rc!=SQLITE_OK ){
250937 if( rc==SQLITE_ABORT ) rc = SQLITE_OK;
250942 if( p->pReader==0 && rc==SQLITE_OK ){
250956 if( rc==SQLITE_OK ){
250969 if( rc==SQLITE_OK ){
250972 if( rc!=SQLITE_OK ){
250986 assert( (pRet==0)==(p->rc!=SQLITE_OK) );
251017 if( p->rc==SQLITE_OK ){
251039 if( p->rc!=SQLITE_OK ) return;
251063 if( p->rc!=SQLITE_OK ) return;
251101 if( p->rc==SQLITE_OK ){
251140 return SQLITE_OK;
251146 ** This function is a no-op if (*pRc) is not SQLITE_OK when it is called. If
251151 if( *pRc==SQLITE_OK && p->nRef>1 ){
251189 ** SQLITE_OK returned.
251197 int rc = SQLITE_OK;
251235 for(iLvl=0; rc==SQLITE_OK && iLvl<nLevel; iLvl++){
251252 if( rc==SQLITE_OK ){
251281 if( nSegment!=0 && rc==SQLITE_OK ) rc = FTS5_CORRUPT;
251286 if( rc!=SQLITE_OK ){
251302 assert( (ppStruct!=0 && (*ppStruct)!=0) || (*pRc)!=SQLITE_OK );
251303 if( *pRc==SQLITE_OK ){
251330 if( *pRc==SQLITE_OK ){
251359 if( p->rc==SQLITE_OK ){
251363 if( p->rc==SQLITE_OK ){
251373 if( p->rc!=SQLITE_OK ){
251385 if( p->rc==SQLITE_OK ){
251417 if( p->rc==SQLITE_OK ){
251445 if( p->rc!=SQLITE_OK ) return 0;
251496 if( p->rc==SQLITE_OK ){
251550 int rc = SQLITE_OK;
251619 if( p->rc==SQLITE_OK ){
251742 return p->rc!=SQLITE_OK || pIter->aLvl[0].bEof;
251749 for(i=pIter->nLvl-1; p->rc==SQLITE_OK && i>=0; i--){
251850 for(i=0; p->rc==SQLITE_OK && bDone==0; i++){
251870 if( p->rc==SQLITE_OK ){
251879 if( p->rc!=SQLITE_OK ){
251957 if( p->rc==SQLITE_OK ){
251993 if( p->rc==SQLITE_OK ) FTS5_CORRUPT_ITER(p, pIter);
252103 if( p->rc==SQLITE_OK ){
252110 }while( p->rc==SQLITE_OK && pIter->pLeaf && pIter->pLeaf->nn==4 );
252113 if( p->rc==SQLITE_OK && pIter->pLeaf ){
252200 while( p->rc==SQLITE_OK && pIter->iLeafPgno>pIter->iTermLeafPgno ){
252252 return (p->rc==SQLITE_OK && pSeg->pLeaf && pSeg->nPos==0);
252301 assert( p->rc==SQLITE_OK );
252563 if( p->rc==SQLITE_OK ){
252640 assert( p->rc==SQLITE_OK );
252811 if( p->rc==SQLITE_OK && (bGe==0 || (flags & FTS5INDEX_QUERY_SCANONETERM)) ){
252839 assert_nc( p->rc!=SQLITE_OK /* 1 */
252880 assert( p->rc==SQLITE_OK );
252913 assert( p->rc!=SQLITE_OK ||
252939 assert( p->rc==SQLITE_OK );
253085 if( p->rc==SQLITE_OK ){
253197 while( p->rc==SQLITE_OK ){
253265 if( bMove && p->rc==SQLITE_OK ) pIter->xNext(p, pIter, 0);
253270 }while( p->rc==SQLITE_OK );
253294 for(i=(pIter->nSeg+iChanged)/2; i>=iMinset && p->rc==SQLITE_OK; i=i/2){
253298 assert( p->rc==SQLITE_OK );
253458 while( p->rc==SQLITE_OK ){
253462 assert( p->rc==SQLITE_OK );
253496 if( p->rc==SQLITE_OK ){
253503 assert( p->rc==SQLITE_OK );
253515 && (p->rc==SQLITE_OK)
253749 ** This function is a no-op if *pRc is other than SQLITE_OK when it is
253759 if( *pRc==SQLITE_OK ){
253942 assert( pIter!=0 || (*pRc)!=SQLITE_OK );
253943 if( *pRc==SQLITE_OK ){
253983 if( p->rc==SQLITE_OK ) pSeg->xNext(p, pSeg, 0);
254030 if( p->rc==SQLITE_OK ){
254041 assert( p->rc!=SQLITE_OK );
254052 if( p->rc==SQLITE_OK ){
254084 if( p->rc==SQLITE_OK ){
254092 assert( (*ppOut)!=0 || p->rc!=SQLITE_OK );
254140 assert( pIter!=0 || p->rc!=SQLITE_OK );
254141 assert( p->rc!=SQLITE_OK
254197 if( p->rc==SQLITE_OK ){
254232 if( p->rc==SQLITE_OK ){
254257 p->flushRc = SQLITE_OK;
254308 if( p->rc==SQLITE_OK && nLvl>=pWriter->nDlidx ){
254360 if( p->rc==SQLITE_OK ){
254388 if( p->rc==SQLITE_OK ){
254436 for(i=0; p->rc==SQLITE_OK && bDone==0; i++){
254453 if( p->rc==SQLITE_OK && pDlidx[1].buf.n==0 ){
254544 assert( p->rc==SQLITE_OK );
254552 if( p->rc!=SQLITE_OK ) return;
254588 if( p->rc!=SQLITE_OK ) return;
254620 if( p->rc==SQLITE_OK ){
254660 assert( p->pConfig->pgsz>0 || p->rc!=SQLITE_OK );
254661 while( p->rc==SQLITE_OK
254691 if( p->rc==SQLITE_OK ){
254742 if( p->rc==SQLITE_OK ){
254763 for(i=0; i<pIter->nSeg && p->rc==SQLITE_OK; i++){
254796 if( p->rc==SQLITE_OK ){
254927 if( p->rc==SQLITE_OK && bTermWritten==0 ){
254956 assert( pIter!=0 || p->rc!=SQLITE_OK );
255047 while( nRem>0 && p->rc==SQLITE_OK ){
255076 if( p->rc==SQLITE_OK && pStruct->aLevel[iBestLvl].nMerge==0 ){
255099 if( p->rc==SQLITE_OK && p->pConfig->nAutomerge>0 && ALWAYS((*ppStruct)!=0) ){
255123 while( p->rc==SQLITE_OK && pStruct->aLevel[iLvl].nSeg>=nCrisis ){
255125 assert( p->rc!=SQLITE_OK || pStruct->nLevel>(iLvl+1) );
255135 p->rc = SQLITE_OK;
255196 if( p->rc==SQLITE_OK ){
255227 for(pgno=iPgno; p->rc==SQLITE_OK && pgno<=pSeg->pgnoLast; pgno++){
255570 if( p->rc==SQLITE_OK ){
255610 ** Return SQLITE_OK if successful, or an SQLite error code if an error
255631 if( p->rc==SQLITE_OK ){
255635 if( p->rc==SQLITE_OK ) p->rc = rc;
255648 if( p->rc==SQLITE_OK
255703 if( p->rc==SQLITE_OK ){
255706 while( p->rc==SQLITE_OK && 0==sqlite3Fts5HashScanEof(pHash) ){
255716 if( p->rc!=SQLITE_OK ) break;
255732 while( p->rc==SQLITE_OK && iOff<nDoclist ){
255756 if( p->rc!=SQLITE_OK || pDoclist[iOff]==0x01 ){
255763 if( p->rc==SQLITE_OK && bTermWritten==0 ){
255766 assert( p->rc!=SQLITE_OK || writer.bFirstRowidInPage==0 );
255778 if( p->rc!=SQLITE_OK ) break;
255815 while( p->rc==SQLITE_OK ){
255840 if( p->rc==SQLITE_OK ) sqlite3Fts5HashScanNext(pHash);
255844 assert( p->rc!=SQLITE_OK || bSecureDelete || pgnoLast>0 );
255852 if( p->rc==SQLITE_OK ){
255888 if( p->rc==SQLITE_OK ){
255972 assert( p->rc==SQLITE_OK );
255974 assert( p->rc!=SQLITE_OK || p->nContentlessDelete==0 );
255976 assert( p->rc!=SQLITE_OK || pStruct!=0 );
255988 while( p->rc==SQLITE_OK && pNew->aLevel[iLvl].nSeg>0 ){
256048 if( p->rc==SQLITE_OK && 0==fts5BufferGrow(&p->rc, pBuf, nByte) ){
256340 if( p->rc==SQLITE_OK ) FTS5_CORRUPT_IDX(p);
256562 if( p->rc==SQLITE_OK ){
256724 for(i=0; p->rc==SQLITE_OK && pSetup->doclist.n; i++){
256795 assert( p->rc!=SQLITE_OK || (s.aBuf && pStruct) );
256797 if( p->rc==SQLITE_OK ){
256818 if( p->rc==SQLITE_OK ){
256828 assert( pData!=0 || p->rc!=SQLITE_OK );
256836 assert( (*ppIter)!=0 || p->rc!=SQLITE_OK );
256837 if( p->rc==SQLITE_OK && s.pTokendata ){
256856 assert( p->rc==SQLITE_OK );
256883 assert( p->rc==SQLITE_OK );
256929 ** If successful, set *pp to point to the new object and return SQLITE_OK.
256938 int rc = SQLITE_OK;
256942 if( rc==SQLITE_OK ){
256950 if( rc==SQLITE_OK ){
256956 if( rc==SQLITE_OK ){
256962 assert( rc!=SQLITE_OK || p->rc==SQLITE_OK );
256974 int rc = SQLITE_OK;
257054 int rc = SQLITE_OK; /* Return code */
257057 assert( p->rc==SQLITE_OK );
257065 for(i=0; i<pConfig->nPrefix && rc==SQLITE_OK; i++){
257126 if( p->rc==SQLITE_OK ){
257297 && pIndex->rc==SQLITE_OK
257304 if( pIndex->rc==SQLITE_OK ){
257340 while( p->rc==SQLITE_OK ){
257429 if( p->rc==SQLITE_OK && pSet ){
257441 if( p->rc==SQLITE_OK ){
257538 assert( p->rc!=SQLITE_OK );
257542 if( p->rc==SQLITE_OK ){
257569 assert( pIter->pIndex->rc==SQLITE_OK );
257586 assert( pIter->pIndex->rc==SQLITE_OK );
257589 if( p->rc==SQLITE_OK ){
257645 assert( token.p!=0 || p->rc!=SQLITE_OK );
257649 if( p->rc==SQLITE_OK ){
257663 if( p->rc==SQLITE_OK ){
257700 if( rc!=SQLITE_OK ) return rc;
257740 return SQLITE_OK;
257823 if( p->rc==SQLITE_OK && pData->nn ){
257841 assert( p->rc==SQLITE_OK );
257858 ** Return SQLITE_OK if successful, or an SQLite error code if an error
257867 assert( p->rc==SQLITE_OK );
257873 if( rc==SQLITE_OK ){
257891 ** disk. If successful, SQLITE_OK is returned and (*piOrigin) set to
258121 if( p->rc==SQLITE_OK ){
258137 assert( p->rc==SQLITE_OK );
258165 assert( p->rc!=SQLITE_OK );
258182 assert( p->rc==SQLITE_OK || (nHash==0 && apHash==0) );
258203 ** rows from origin iOrigin. Return SQLITE_OK if successful, or an SQLite
258298 if( p->rc==SQLITE_OK && cksum1!=cksum2 ) p->rc = FTS5_CORRUPT;
258316 while( rc==SQLITE_OK && ALWAYS(pIter!=0) && 0==sqlite3Fts5IterEof(pIter) ){
258332 if( rc==SQLITE_OK ){
258394 && rc==SQLITE_OK
258409 if( rc==SQLITE_OK ){
258413 if( rc==SQLITE_OK && ck1!=ck2 ) rc = FTS5_CORRUPT;
258429 if( iIdx>0 && rc==SQLITE_OK ){
258433 if( rc==SQLITE_OK && ck1!=ck2 ) rc = FTS5_CORRUPT;
258435 if( iIdx>0 && rc==SQLITE_OK ){
258439 if( rc==SQLITE_OK && ck1!=ck2 ) rc = FTS5_CORRUPT;
258446 if( rc==SQLITE_OK && cksum3!=expected ){
258478 for(i=iFirst; p->rc==SQLITE_OK && i<=iLast; i++){
258499 while( ii<pLeaf->nn && p->rc==SQLITE_OK ){
258529 if( p->rc==SQLITE_OK ){
258561 while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
258681 if( p->rc==SQLITE_OK ) p->rc = rc2;
258685 if( p->rc==SQLITE_OK && iter.iLeaf!=pSeg->pgnoLast ){
258698 ** checksum does not match. Return SQLITE_OK if all checks pass without
258721 assert( p->rc!=SQLITE_OK );
258778 if( p->rc==SQLITE_OK && bUseCksum && cksum!=cksum2 ){
258788 if( p->rc==SQLITE_OK && bTestFail ){
258903 if( rc!=SQLITE_OK ){
259001 ** If *pRc is other than SQLITE_OK when this function is called, it is a
259039 if( *pRc==SQLITE_OK ){
259068 int rc = SQLITE_OK; /* Return code */
259153 while( iOff<szLeaf && rc==SQLITE_OK ){
259233 while( iPgidxOff<n && rc==SQLITE_OK ){
259279 if( rc==SQLITE_OK ){
259351 int rc = SQLITE_OK;
259358 if( rc==SQLITE_OK ){
259384 rc = SQLITE_OK;
259399 return SQLITE_OK;
259406 int rc = SQLITE_OK;
259412 return SQLITE_OK;
259422 return SQLITE_OK;
259444 return SQLITE_OK;
259462 return SQLITE_OK;
259513 return SQLITE_OK;
259528 int rc = SQLITE_OK;
259540 if( rc==SQLITE_OK ){
259557 ** If successful, SQLITE_OK is returned. If an error occurs, some other
259566 if( rc==SQLITE_OK ){
259573 if( rc==SQLITE_OK ){
259579 if( rc==SQLITE_OK ){
259611 return SQLITE_OK;
259991 return SQLITE_OK;
260000 if( rc==SQLITE_OK ){
260028 int rc = SQLITE_OK; /* Return code */
260034 if( rc==SQLITE_OK ){
260036 assert( (rc==SQLITE_OK && *pzErr==0) || pConfig==0 );
260038 if( rc==SQLITE_OK ){
260048 if( rc==SQLITE_OK ){
260053 if( rc==SQLITE_OK ){
260060 if( rc==SQLITE_OK ){
260065 if( rc==SQLITE_OK ){
260069 if( rc==SQLITE_OK && pConfig->eContent==FTS5_CONTENT_NORMAL ){
260072 if( rc==SQLITE_OK ){
260077 if( rc!=SQLITE_OK ){
260394 return SQLITE_OK;
260400 if( pCsr->base.pVtab==(sqlite3_vtab*)pTab ) return SQLITE_OK;
260416 if( rc==SQLITE_OK ){
260512 return SQLITE_OK;
260521 rc = SQLITE_OK;
260529 rc = SQLITE_OK;
260578 ** Return SQLITE_OK if successful or if no reseek was required, or an
260582 int rc = SQLITE_OK;
260592 if( rc==SQLITE_OK && iRowid!=sqlite3Fts5ExprRowid(pCsr->pExpr) ){
260611 ** Return SQLITE_OK if nothing goes wrong. SQLITE_OK is returned
260644 rc = SQLITE_OK;
260661 if( rc!=SQLITE_OK ){
260667 rc = SQLITE_OK;
260697 if( rc!=SQLITE_OK ){
260744 if( rc==SQLITE_OK ){
260751 if( rc!=SQLITE_OK ){
260784 int rc = SQLITE_OK; /* Return code */
260829 int rc = SQLITE_OK;
260841 assert( rc==SQLITE_OK || pCsr->pRankArgStmt==0 );
260842 if( rc==SQLITE_OK ){
260848 if( rc==SQLITE_OK ){
260857 assert( rc!=SQLITE_OK );
260863 if( rc==SQLITE_OK ){
260882 int rc = SQLITE_OK;
260893 if( rc==SQLITE_OK ){
260987 ** If successful, SQLITE_OK is returned and (*ppText) and (*ppLoc) set
261019 return SQLITE_OK;
261041 int rc = SQLITE_OK;
261050 if( rc==SQLITE_OK ){
261084 int rc = SQLITE_OK; /* Error code */
261127 if( rc!=SQLITE_OK ) goto filter_out;
261148 if( rc==SQLITE_OK ){
261159 if( bInternal || rc!=SQLITE_OK ) goto filter_out;
261175 if( rc==SQLITE_OK ){
261179 if( rc!=SQLITE_OK ) goto filter_out;
261212 if( rc!=SQLITE_OK ) goto filter_out;
261236 assert( rc==SQLITE_OK );
261238 if( rc==SQLITE_OK ){
261257 if( rc==SQLITE_OK ){
261321 return SQLITE_OK;
261327 ** Return SQLITE_OK if no error occurs, or an SQLite error code otherwise.
261333 int rc = SQLITE_OK;
261342 assert( rc!=SQLITE_OK || pTab->p.base.zErrMsg==0 );
261346 if( rc==SQLITE_OK && CsrFlagTest(pCsr, FTS5CSR_REQUIRE_CONTENT) ){
261355 rc = SQLITE_OK;
261359 if( rc==SQLITE_OK ){
261384 ** statement. This function returns SQLITE_OK if successful, or an SQLite
261397 int rc = SQLITE_OK;
261438 if( rc==SQLITE_OK ){
261441 if( rc==SQLITE_OK ){
261444 if( rc==SQLITE_OK ){
261453 if( rc==SQLITE_OK && bLoadConfig ){
261465 int rc = SQLITE_OK;
261481 if( rc==SQLITE_OK ){
261484 if( rc==SQLITE_OK ){
261499 ** This function returns SQLITE_OK if the UPDATE can go ahead, or an SQLite
261522 int rc = SQLITE_OK;
261574 int rc = SQLITE_OK; /* Return code */
261587 if( rc!=SQLITE_OK ) return rc;
261689 if( rc!=SQLITE_OK ) goto update_out;
261698 if( rc==SQLITE_OK ){
261704 if( rc==SQLITE_OK ){
261707 if( rc==SQLITE_OK ){
261710 if( rc==SQLITE_OK ){
261720 if( rc==SQLITE_OK ){
261756 if( rc==SQLITE_OK ){
261770 return SQLITE_OK;
261826 int rc = SQLITE_OK;
261869 ** value as utf-8 and SQLITE_OK returned. (*pnText) is set to the size of that
261884 int rc = SQLITE_OK;
261909 int rc = SQLITE_OK;
261921 if( rc==SQLITE_OK ){
261943 int rc = SQLITE_OK;
261953 return SQLITE_OK;
261961 if( rc==SQLITE_OK ){
261964 for(i=0; i<pConfig->nCol && rc==SQLITE_OK; i++){
261968 if( rc==SQLITE_OK ){
261984 if( rc==SQLITE_OK ){
262003 ** correctly for the current view. Return SQLITE_OK if successful, or an
262007 int rc = SQLITE_OK;
262024 for(i=0; i<nIter && rc==SQLITE_OK; i++){
262028 if( rc==SQLITE_OK ){
262033 if( rc==SQLITE_OK ){
262083 int rc = SQLITE_OK;
262085 || SQLITE_OK==(rc = fts5CacheInstArray(pCsr)) ){
262099 int rc = SQLITE_OK;
262101 || SQLITE_OK==(rc = fts5CacheInstArray(pCsr))
262132 return SQLITE_OK;
262139 int rc = SQLITE_OK;
262155 for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
262161 if( rc==SQLITE_OK ){
262209 int rc = SQLITE_OK;
262222 return SQLITE_OK;
262279 if( rc==SQLITE_OK ){
262325 int rc = SQLITE_OK;
262339 if( rc==SQLITE_OK ){
262348 if( rc==SQLITE_OK ){
262388 int rc = SQLITE_OK;
262390 || SQLITE_OK==(rc = fts5CacheInstArray(pCsr))
262421 int rc = SQLITE_OK;
262437 if( rc==SQLITE_OK ){
262441 if( rc==SQLITE_OK ){
262494 if( rc==SQLITE_OK ){
262502 if( rc==SQLITE_OK ){
262504 rc==SQLITE_OK && CsrFlagTest(pNew, FTS5CSR_EOF)==0;
262508 if( rc!=SQLITE_OK ){
262509 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
262615 int rc = SQLITE_OK;
262642 for(i=0; rc==SQLITE_OK && i<(nPhrase-1); i++){
262650 for(i=0; rc==SQLITE_OK && i<nPhrase; i++){
262678 int rc = SQLITE_OK;
262703 if( pCsr->pRank || SQLITE_OK==(rc = fts5FindRankFunction(pCsr)) ){
262711 if( rc==SQLITE_OK ){
262720 if( rc==SQLITE_OK ){
262788 int rc = SQLITE_OK;
262792 if( rc==SQLITE_OK ){
262805 int rc = SQLITE_OK;
262809 if( rc==SQLITE_OK ){
262823 int rc = SQLITE_OK;
262845 if( rc==SQLITE_OK ){
262877 ** If successful, SQLITE_OK is returned and a pointer to the new
262893 int rc = SQLITE_OK;
262942 int rc = SQLITE_OK;
262945 if( rc==SQLITE_OK ){
262954 if( rc!=SQLITE_OK ){
263024 int rc = SQLITE_OK;
263054 int rc = SQLITE_OK;
263100 int rc = SQLITE_OK;
263130 int rc = SQLITE_OK;
263157 int rc = SQLITE_OK;
263178 if( rc!=SQLITE_OK ){
263189 if( rc!=SQLITE_OK ){
263364 if( *pzErr==0 && rc!=SQLITE_OK ){
263368 rc = (*pzErr) ? SQLITE_OK : SQLITE_NOMEM;
263375 rc = SQLITE_OK;
263439 if( rc==SQLITE_OK ) rc = sqlite3Fts5IndexInit(db);
263440 if( rc==SQLITE_OK ) rc = sqlite3Fts5ExprInit(pGlobal, db);
263441 if( rc==SQLITE_OK ) rc = sqlite3Fts5AuxInit(&pGlobal->api);
263442 if( rc==SQLITE_OK ) rc = sqlite3Fts5TokenizerInit(&pGlobal->api);
263443 if( rc==SQLITE_OK ) rc = sqlite3Fts5VocabInit(pGlobal, db);
263444 if( rc==SQLITE_OK ){
263449 if( rc==SQLITE_OK ){
263456 if( rc==SQLITE_OK ){
263463 if( rc==SQLITE_OK ){
263476 if( rc==SQLITE_OK ){
263604 ** Return SQLITE_OK if successful, or an SQLite error code if an error
263613 int rc = SQLITE_OK;
263682 for(i=0; rc==SQLITE_OK && i<(pC->nCol+1); i++){
263691 for(i=0; rc==SQLITE_OK && i<pC->nCol; i++){
263730 if( rc!=SQLITE_OK && pzErrMsg ){
263772 ** Drop all shadow tables. Return SQLITE_OK if successful or an SQLite error
263784 if( rc==SQLITE_OK && pConfig->bColumnsize ){
263790 if( rc==SQLITE_OK && pConfig->eContent==FTS5_CONTENT_NORMAL ){
263805 if( *pRc==SQLITE_OK ){
263831 ** SQLITE_OK if successful, or an SQLite error code otherwise.
263865 ** If successful, set *pp to point to the new object and return SQLITE_OK.
263875 int rc = SQLITE_OK;
263923 if( rc==SQLITE_OK && pConfig->bColumnsize ){
263930 if( rc==SQLITE_OK ){
263935 if( rc==SQLITE_OK ){
263951 int rc = SQLITE_OK;
263999 ** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
264001 ** pSavedRow is not set and SQLITE_OK returned.
264004 int rc = SQLITE_OK;
264009 if( rc==SQLITE_OK ){
264039 int rc = SQLITE_OK; /* Return code */
264054 if( rc!=SQLITE_OK ) return rc;
264064 for(iCol=1; rc==SQLITE_OK && iCol<=pConfig->nCol; iCol++){
264093 if( rc==SQLITE_OK ){
264103 if( rc==SQLITE_OK ){
264110 if( rc==SQLITE_OK && p->aTotalSize[iCol-1]<0 ){
264118 if( rc==SQLITE_OK && p->nTotalRow<1 ){
264124 if( rc==SQLITE_OK && bSaveRow ){
264129 if( rc==SQLITE_OK ) rc = rc2;
264150 ** iDel. If successful, SQLITE_OK is returned. Or, if an error occurs,
264156 int rc = SQLITE_OK;
264166 if( rc==SQLITE_OK ){
264174 if( rc==SQLITE_OK && iOrigin!=0 ){
264194 int rc = SQLITE_OK;
264198 if( rc==SQLITE_OK ){
264206 if( rc==SQLITE_OK ){
264223 ** Return SQLITE_OK if successful, or an SQLite error code if an error
264227 int rc = SQLITE_OK;
264239 ** Return SQLITE_OK if successful, or an SQLite error code if an error
264246 int rc = SQLITE_OK;
264253 if( rc==SQLITE_OK ){
264278 if( rc==SQLITE_OK ){
264282 if( rc==SQLITE_OK ){
264285 if( rc==SQLITE_OK
264297 if( rc==SQLITE_OK && pConfig->bColumnsize ){
264299 if( rc==SQLITE_OK ){
264310 if( rc==SQLITE_OK ){
264313 if( rc==SQLITE_OK ){
264339 if( rc==SQLITE_OK && pConfig->bColumnsize ){
264345 if( rc==SQLITE_OK && pConfig->eContent==FTS5_CONTENT_UNINDEXED ){
264353 if( rc==SQLITE_OK ){
264356 if( rc==SQLITE_OK ){
264372 if( rc==SQLITE_OK ){
264376 if( rc==SQLITE_OK ){
264380 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pScan) ){
264385 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
264408 if( rc==SQLITE_OK ){
264424 if( rc==SQLITE_OK ){
264430 if( rc==SQLITE_OK ) rc = rc2;
264433 if( rc==SQLITE_OK ){
264465 if( rc==SQLITE_OK ){
264471 if( rc==SQLITE_OK ){
264488 int rc = SQLITE_OK;
264513 for(i=2; rc==SQLITE_OK && i<=pConfig->nCol+1; i++){
264535 if( rc==SQLITE_OK ){
264549 if( rc==SQLITE_OK ){
264568 int rc = SQLITE_OK; /* Return code */
264576 if( rc==SQLITE_OK ){
264579 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
264606 if( rc==SQLITE_OK ){
264621 if( rc==SQLITE_OK ){
264642 if( rc==SQLITE_OK ){
264683 int rc = SQLITE_OK;
264713 if( rc==SQLITE_OK && bPresent==0 ){
264719 for(ii=0; rc==SQLITE_OK && ii<pCtx->pConfig->nPrefix; ii++){
264737 ** table. Return SQLITE_OK if they do, or SQLITE_CORRUPT if not. Return
264743 int rc = SQLITE_OK; /* Return code */
264764 if( rc==SQLITE_OK ){
264773 if( rc==SQLITE_OK && pConfig->eDetail==FTS5_DETAIL_NONE ){
264776 for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
264803 if( rc==SQLITE_OK && pConfig->eDetail==FTS5_DETAIL_COLUMNS ){
264807 if( rc==SQLITE_OK ){
264821 if( rc==SQLITE_OK
264837 if( rc!=SQLITE_OK ) break;
264840 if( rc==SQLITE_OK ) rc = rc2;
264844 if( rc==SQLITE_OK ){
264847 for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
264854 if( rc==SQLITE_OK && pConfig->eContent==FTS5_CONTENT_NORMAL ){
264857 if( rc==SQLITE_OK && nRow!=p->nTotalRow ) rc = FTS5_CORRUPT;
264859 if( rc==SQLITE_OK && pConfig->bColumnsize ){
264862 if( rc==SQLITE_OK && nRow!=p->nTotalRow ) rc = FTS5_CORRUPT;
264869 if( rc==SQLITE_OK ){
264893 if( rc==SQLITE_OK ){
264940 ** An SQLite error code is returned if an error occurs, or SQLITE_OK
264952 assert( rc==SQLITE_OK );
264962 if( bCorrupt && rc==SQLITE_OK ){
264966 assert( rc!=SQLITE_OK );
264974 if( rc==SQLITE_OK ){
264992 if( rc==SQLITE_OK ){
265008 int rc = SQLITE_OK;
265012 if( rc==SQLITE_OK ){
265016 if( rc==SQLITE_OK ){
265036 if( rc==SQLITE_OK ){
265047 if( rc==SQLITE_OK && pVal ){
265050 if( rc==SQLITE_OK ){
265125 int rc = SQLITE_OK;
265138 for(i=0; rc==SQLITE_OK && i<nArg; i+=2){
265149 if( rc!=SQLITE_OK ){
265181 int rc = SQLITE_OK;
265192 while( is<nText && rc==SQLITE_OK ){
265226 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
265316 int rc = SQLITE_OK;
265407 return SQLITE_OK;
265418 int rc = SQLITE_OK; /* Return code */
265440 for(i=0; rc==SQLITE_OK && i<nArg; i+=2){
265445 if( rc==SQLITE_OK ){
265449 for(i=0; rc==SQLITE_OK && i<nArg; i+=2){
265477 if( rc!=SQLITE_OK ){
265506 int rc = SQLITE_OK;
265521 while( rc==SQLITE_OK ){
265598 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
265639 int rc = SQLITE_OK;
265656 if( rc==SQLITE_OK ){
265663 if( rc!=SQLITE_OK ){
266349 int rc = SQLITE_OK;
266363 for(i=0; rc==SQLITE_OK && i<nArg; i+=2){
266386 if( rc!=SQLITE_OK ){
266407 int rc = SQLITE_OK;
266422 if( zIn>=zEof ) return SQLITE_OK;
266454 if( iCode==0 || rc!=SQLITE_OK ) break;
266520 int rc = SQLITE_OK; /* Return code */
266523 for(i=0; rc==SQLITE_OK && i<ArraySize(aBuiltin); i++){
266531 if( rc==SQLITE_OK ){
267777 ** value and return SQLITE_OK. Otherwise, set *pzErr to an error message
267781 int rc = SQLITE_OK;
267783 if( rc==SQLITE_OK ){
267812 return SQLITE_OK;
267821 return SQLITE_OK;
267860 int rc = SQLITE_OK; /* Return code */
267878 if( rc==SQLITE_OK ){
267998 return SQLITE_OK;
268011 int rc = SQLITE_OK;
268029 assert( rc==SQLITE_OK || pStmt==0 );
268030 if( rc==SQLITE_ERROR ) rc = SQLITE_OK;
268039 if( rc==SQLITE_OK ){
268043 if( rc==SQLITE_OK ){
268054 if( rc==SQLITE_OK ){
268105 return SQLITE_OK;
268109 int rc = SQLITE_OK;
268132 int rc = SQLITE_OK;
268146 if( rc==SQLITE_OK ){
268169 if( rc!=SQLITE_OK ) return rc;
268196 return SQLITE_OK;
268206 while( rc==SQLITE_OK ){
268270 if( rc==SQLITE_OK ){
268275 if( rc==SQLITE_OK ){
268288 if( rc==SQLITE_OK && pCsr->bEof==0 && pTab->eType==FTS5_VOCAB_COL ){
268310 int rc = SQLITE_OK;
268351 if( rc==SQLITE_OK ){
268354 if( rc==SQLITE_OK ){
268358 if( rc==SQLITE_OK && eType==FTS5_VOCAB_INSTANCE ){
268361 if( rc==SQLITE_OK && !pCsr->bEof
268444 return SQLITE_OK;
268458 return SQLITE_OK;
268606 if( rc==SQLITE_OK ){
268621 return SQLITE_OK;
268634 return SQLITE_OK;
268653 return SQLITE_OK;
268665 return SQLITE_OK;
268684 return SQLITE_OK;
268694 return SQLITE_OK;
268768 return SQLITE_OK;
268784 return SQLITE_OK;
268822 int rc = SQLITE_OK;
268838 int rc = SQLITE_OK;
Indexes created Sun Jul 12 00:26:10 UTC 2026