Lines Matching defs:code
3 ** version 3.40.1. By combining all the individual C code files into this
4 ** single large file, the entire code can be compiled as a single translation
15 ** of the embedded sqlite3.h header file.) Additional code files may be needed
17 ** language. The code for the "sqlite3" command-line shell is also in a
18 ** separate file. This file contains only code for the core SQLite library.
33 ** The author disclaims copyright to this source code. In place of
54 ** used on lines of code that actually
76 ** only used by test code and Tcl integration code.
93 ** The author disclaims copyright to this source code. In place of
102 ** This file contains code that is specific to MSVC.
143 ** The author disclaims copyright to this source code. In place of
152 ** This file contains code that is specific to Wind River's VxWorks
182 ** system #includes. Hence, this block of code must be the very first
183 ** code in all source files.
187 ** on a recent machine (ex: Red Hat 7.2) but you want your code to work
190 ** in Red Hat 6.0, so the code won't work. Hence, for maximum binary
314 ** The author disclaims copyright to this source code. In place of
445 ** SQLite source code has been stored in the
451 ** or SHA3-256 hash of the entire source tree. If the source code has
534 ** SQLite was compiled with mutexing code omitted due to the
680 ** without having to use a lot of C code.
745 ** KEYWORDS: {result code definitions}
747 ** Many SQLite functions return an integer result code from the set shown
752 ** See also: [extended result code definitions]
790 ** KEYWORDS: {extended result code definitions}
801 ** [sqlite3_extended_result_codes()] API. Or, the extended code for
1015 ** only make a difference on Mac OSX for the default SQLite code.
1337 ** any result code other than [SQLITE_OK] or [SQLITE_NOTFOUND], that means
1632 ** searches the list. Neither the application code nor the VFS
1730 ** non-zero error code if there is an I/O error or if the name of
1762 ** by some VFSes to facilitate testing of the VFS code. By overriding
1910 ** as a mutex) it returns an [error code] other than [SQLITE_OK].
1947 ** must return [SQLITE_OK] on success and some other [error code] upon
1984 ** then this routine returns a non-zero [error code].
1998 ** [SQLITE_DBCONFIG_LOOKASIDE | configuration verb] - an integer code
2091 ** should check the return code from [sqlite3_config()] to make sure that
2093 ** non-zero [error code] if a discontinued or unsupported configuration option
2295 ** [sqlite3_log()] call and is intended to be a [result code] or an
2296 ** [extended result code]. ^The third parameter passed to the logger is
2327 ** disable the optimization allows the older, buggy application code to work
2332 ** <dd> These options are obsolete and should not be used by new code.
2473 ** should check the return code from [sqlite3_db_config()] to make sure that
2475 ** non-zero [error code] if a discontinued or unsupported configuration option
3402 ** to the callback is an integer [SQLITE_COPY | action code] that specifies
3409 ** ^If the action code is [SQLITE_READ]
3420 ** ^If the action code is [SQLITE_DELETE] and the callback returns
3487 ** second parameter to the callback is an integer code that specifies
3491 ** These action code values signify what kind of operation is to be
3499 ** top-level SQL code.
3713 ** [SQLITE_OK] is returned. Otherwise an [error code] is returned.)^ ^The
3788 ** <dd>The database connection comes up in "extended result code mode".
3792 ** the extended result code mode, this flag also causes [sqlite3_open_v2()]
3793 ** to return an extended result code.</dd>
4170 ** returns the numeric [result code] or [extended result code] for that
4174 ** [extended result code] even when extended result codes are
4180 ** change the value of the error code. The error-code preserving
4199 ** that describes the [result code], as UTF-8.
4222 ** error code and message may or may not be set.
4239 ** original SQL text is source code. A prepared statement object
4240 ** is the compiled object code. All SQL must be converted into a
4399 ** to return an error (error code SQLITE_ERROR) if the statement uses
4413 ** To execute an SQL statement, it must first be compiled into a byte-code
4460 ** otherwise an [error code] is returned.
4482 ** [sqlite3_step()] would only return a generic [SQLITE_ERROR] result code
4707 ** for maximum code portability it is recommended that applications
4869 ** [error code] if anything goes wrong.
5143 ** ^With the legacy interface, a more specific error code (for example,
5147 ** the more specific error code is returned directly by sqlite3_step().
5170 ** API always returns a generic error code, [SQLITE_ERROR], following any
5295 ** [SQLITE_INTEGER | datatype code] for the initial data type
5354 ** top-level application code.
5472 ** sqlite3_finalize(S) returns the appropriate [error code] or
5473 ** [extended error code].
5512 ** [sqlite3_reset(S)] returns an appropriate [error code].
5774 ** backwards compatibility with older code, these functions continue
5850 ** [SQLITE_INTEGER | datatype code] for the initial datatype of the
6169 ** ^The sqlite3_result_error_code() function changes the error code
6171 ** the error code is SQLITE_ERROR. ^A subsequent call to sqlite3_result_error()
6172 ** or sqlite3_result_error16() resets the error code to SQLITE_ERROR.
6383 ** check the return code and dispose of the application data pointer
6457 ** The code to implement this API is not available in the public release
6475 ** The code to implement this API is not available in the public release
6903 ** be some other error code if something goes wrong. The current
7012 ** successfully. An [error code] is returned otherwise.)^
7191 ** ^If the specified table is actually a view, an [error code] is returned.
7325 ** and return an appropriate [error code]. ^SQLite ensures that *pzErrMsg
7479 ** virtual table and might not be checked again by the byte code.)^ ^(The
7482 ** checked separately in byte code. If the omit flag is change to true, then
7483 ** the constraint may or may not be checked in byte code. In other words,
7485 ** not be checked again using byte code.)^
7550 unsigned char omit; /* Do not code a test for this constraint */
7817 ** in *ppBlob. Otherwise an [error code] is returned and, unless the error
7818 ** code is SQLITE_MISUSE, *ppBlob is set to NULL.)^ ^This means that, provided
7839 ** [database connection] error code and message accessible via
7855 ** an expired BLOB handle fail with a return code of [SQLITE_ABORT].
7901 ** SQLite error code is returned and the blob handle is considered aborted.
7907 ** ^This function sets the database handle error code and message.
7916 ** unconditionally. Even if this routine returns an error code, the
7923 ** code is returned and the transaction rolled back.
7965 ** error code of [SQLITE_ABORT].
7968 ** Otherwise, an [error code] or an [extended error code] is returned.)^
7988 ** Otherwise, an [error code] or an [extended error code] is returned.)^
7990 ** [database connection] error code and message accessible via
8006 ** error code of [SQLITE_ABORT]. ^Writes to the BLOB that occurred
8059 ** use by SQLite, code that links against SQLite is
8062 ** The SQLite source code contains multiple implementations
8362 ** code is not remembered and will not be recalled by [sqlite3_errcode()]
8377 ** purposes. ^The first parameter is an operation code that determines
8394 ** These constants are the valid operation code parameters used
8575 ** These methods do not return a result code. ^If an error occurs, that fact
8594 ** an appropriate error code. ^The [sqlite3_str_errcode(X)] method returns
8624 ** highwater marks. ^The first argument is an integer code for
8637 ** SQLITE_OK on success and a non-zero [error code] on failure.
8751 ** non-zero [error code] on failure.
8765 ** might be discontinued. Applications should check the return code from
8767 ** The [sqlite3_db_status()] interface will return a non-zero error code
8900 ** is an integer code for a specific [SQLITE_STMTSTATUS counter]
8943 ** then the value returned by this statement status code is undefined.
9273 ** returned and an error code and error message are stored in the
9275 ** ^The error code and message for the failed call to sqlite3_backup_init()
9294 ** then an [error code] is returned. ^As well as [SQLITE_OK] and
9297 ** [SQLITE_IOERR_ACCESS | SQLITE_IOERR_XXX] extended error code.
9358 ** sqlite3_backup_finish() returns the corresponding [error code].
9392 ** and so no error code is reported, but the operations may malfunction
9530 ** One way around this problem is to check the extended error code returned
9532 ** extended error code is set to SQLITE_LOCKED_SHAREDCACHE. Otherwise, in
9533 ** the special "DROP TABLE/INDEX" case, the extended error code is just
9637 ** code is returned, that error will propagate back up through the
9638 ** SQLite code base to cause the statement that provoked the callback
9641 ** that does not correspond to any valid SQLite error code, the results
9786 ** and the error code is returned to the caller immediately. ^If no error
10170 ** of the IN constraint using code like the following:
10219 ** can return an result code other than SQLITE_OK or SQLITE_NOTFOUND if
10252 ** [SQLITE_ABORT] is also a [result code].
10257 /* #define SQLITE_ABORT 4 // Also an error code */
10387 ** abandoned and an SQLite [error code] is returned to the caller immediately.
10391 ** ^This function does not set the database handle error code or message
10510 ** CAPI3REF: Low-level system error code
10513 ** ^Attempt to return the underlying operating system error code or error
10604 ** on success or an appropriate [error code] if it fails.
10621 ** is returned. If another error code - for example SQLITE_PROTOCOL or an
10622 ** SQLITE_IOERR error code - is returned, then the final state of the
10705 ** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
10855 ** The author disclaims copyright to this source code. In place of
11006 ** error code (e.g. SQLITE_NOMEM) is returned.
11161 ** occurs, an SQLite error code (e.g. SQLITE_NOMEM) is returned.
11225 ** zero and return an SQLite error code.
11395 ** error code. In this case, if argument pzErrMsg is not NULL, *pzErrMsg
11475 ** SQLite error code is returned.
11554 ** If an error occurs, an SQLite error code is returned. Possible error
11589 ** SQLite error code is returned. The values of the output variables may not
11654 ** If some other error occurs (e.g. an OOM condition), an SQLite error code
11688 ** If some other error occurs (e.g. an OOM condition), an SQLite error code
11716 ** If some other error occurs (e.g. an OOM condition), an SQLite error code
11757 ** [SQLITE_NOMEM] in [sqlite3changeset_new()]) then an error code corresponding
11759 ** returned. This is to allow the following pattern (pseudo-code):
11793 ** zeroed and an SQLite error code returned.
11816 ** following code fragment:
11863 ** sqlite3changegroup_delete(). If an error occurs, an SQLite error code
11985 ** If an error occurs, an SQLite error code is returned and the output
12035 ** via the sqlite3_log() mechanism with the error code SQLITE_SCHEMA. At most
12143 ** SQLite error code returned.
12421 ** occurs, return an SQLite error code (e.g. SQLITE_NOMEM) and set (*ppNew)
12452 ** are set to zero and an SQLite error code returned.
12519 ** error code should be returned. In all cases, if an xInput callback returns
12521 ** returns a copy of the error code to the caller.
12527 ** immediately fail with the same error code as returned by xInput.
12552 ** it should return some other SQLite error code. In this case processing
12554 ** of the xOutput error code to the application.
12673 ** This function returns SQLITE_OK if successful, or an SQLite error code
12697 ** The author disclaims copyright to this source code. In place of
12762 ** an OOM condition or IO error), an appropriate SQLite error code is
12776 ** an OOM condition or IO error), an appropriate SQLite error code is
12787 ** if an error occurs, an SQLite error code is returned and the final values
12800 ** an error code (i.e. SQLITE_NOMEM) if an error occurs.
12816 ** code (i.e. SQLITE_NOMEM) if an error occurs.
12845 ** Otherwise, the error code is propagated upwards.
12849 ** the callback, an SQLite error code is returned.
12873 ** the auxiliary data is set to NULL and an error code returned. If the
12901 ** through instances of phrase iPhrase, use the following code:
13081 ** may abandon the tokenization and return any error code other than
13293 ** The author disclaims copyright to this source code. In place of
13360 ** The code generator for compound SELECT statements does one
13506 #pragma warn -rch /* unreachable code */
13698 ** Setting NDEBUG makes the code smaller and faster by disabling the
13699 ** assert() statements in the code. So we want the default action
13728 ** where multiple cases go to the same block of code, testcase()
13742 ** other bits of code that are needed to support the arguments
13752 ** Sometimes we need a small amount of code such as a variable initialization
13753 ** to setup for a later assert() statement. We do not want this code to
13755 ** used to contain that setup code. The "VVA" acronym stands for
13757 ** code within VVA_ONLY() will only run during verification processes.
13776 ** expressions could be omitted from the code completely. But they
13778 ** of SQLite to unexpected behavior - to make the code "self-healing"
13782 ** In other words, ALWAYS and NEVER are added for defensive code.
13785 ** be true and false so that the unreachable code they specify will
13786 ** not be counted as untested code.
13880 ** in theory, be used by the compiler to generate better code, but
13891 ** The author disclaims copyright to this source code. In place of
13911 ** code should not attempt to access or modify the fields of this structure
14217 ** to omit code used by TEMP tables without messy #ifndef statements.
14543 ** macro is used only within assert() to verify that the code gets
14694 ** this magic value that the code knows to handle differently. Any
14705 ** throughout the SQLite code must become constants instead. The SQLITE_WSD
14853 ** The author disclaims copyright to this source code. In place of
14862 ** This header file (together with is companion C source-code file
14881 ** The author disclaims copyright to this source code. In place of
15010 ** anybody smart enough to figure out the code is also likely smart
15171 ** The author disclaims copyright to this source code. In place of
15279 ** that make up the Pager sub-system API. See source code comments for
15426 ** The author disclaims copyright to this source code. In place of
15435 ** subsystem. See comments in the source code for a detailed description
15609 ** the SQLite parser and code generator but substitute their own storage
15723 ** organized and understandable, and it also helps the resulting code to
15845 ** The author disclaims copyright to this source code. In place of
15916 u32 iSrcLine; /* Source-code line that generated this opcode
16379 ** comments in VDBE programs that show key decision points in the code
16432 ** is responsible for keeping track of this and reporting byte-code branches
16483 ** The author disclaims copyright to this source code. In place of
16678 ** The author disclaims copyright to this source code. In place of
16689 ** to all source files. We break it out in an effort to keep the code
16699 ** Figure out what version of the code to use. The choices are
17023 int errCode; /* Most recent error code (SQLITE_*) */
17132 ** mutex, not by sqlite3.mutex. They are used by code in notify.c.
17282 ** code. The argument is a Parse object for the code generator.
17347 ** are assert() statements in the code to verify this.
17414 ** byte code rather than by the usual callbacks. The iFuncId
17420 ** byte code rather than by the usual callbacks. The iFuncId
17576 unsigned notNull :4; /* An OE_ code for handling a NOT NULL constraint */
17924 ** the operation in progress stops and returns an error code. But prior
18078 ** generate VDBE code (as opposed to parsing one read from an sqlite_schema
18181 ** code for a SELECT that contains aggregate functions.
18186 ** code for that node.
18247 ** code representing the ">=" operator. This same integer code is reused
18797 ** while generating code. The fields below are owned by the INSERT
18808 ** needed to generate code for a single SELECT statement.
18997 ** During code generation of statements that do inserts into AUTOINCREMENT
19000 ** the code generator needs. We have to keep per-table autoincrement
19063 ** During code generation, while generating code to evaluate expressions,
19095 ** The structure is divided into two parts. When the parser and code
19110 int rc; /* Return code from execution */
19113 u8 nested; /* Number of nested calls to the parser/code generator */
19435 int rc; /* Result code stored here */
19563 u16 eCode; /* A small processing code */
19624 ** Return code from the parse-tree walking primitives and their
19663 ** of code generation. (The query flattener or other parser tree
19670 ** until the end of code generation.
19700 ** plus additional fields used during code generation.
19903 ** The alloca() routine never returns NULL. This will cause code paths
20834 ** The interface to the code in fault.c used for identifying "benign"
20992 ** The author disclaims copyright to this source code. In place of
21001 ** This file contains macros and a little bit of code that is common to
21014 ** switch. The following code should catch this problem at compile-time.
21027 ** hwtime.h contains inline assembler code for implementing
21035 ** The author disclaims copyright to this source code. In place of
21044 ** This file contains inline asm code for retrieving "high-performance"
21134 ** of code will give us the ability to simulate a disk I/O error. This
21201 ** The author disclaims copyright to this source code. In place of
21989 ** The author disclaims copyright to this source code. In place of
22058 ** this order: NE EQ GT LE LT GE. Various assert()s throughout the code
22325 ** a different position in the file. This allows code that has to
22394 ** The author disclaims copyright to this source code. In place of
22412 ** The author disclaims copyright to this source code. In place of
22422 ** source code file "vdbe.c". When that file became too big (over
22461 /* Opaque type used by code in vdbesort.c */
22784 int isError; /* Error code returned by the function. */
23311 int rc = SQLITE_OK; /* Return code */
23507 ** The author disclaims copyright to this source code. In place of
23520 ** All other code has file scope.
24867 ** The author disclaims copyright to this source code. In place of
24876 ** This file contains OS interface code that is common to all
24883 ** of code will give us the ability to simulate a disk I/O error. This
25012 ** to the cksumvfs. Their return code is meaningless and is ignored
25317 ** The author disclaims copyright to this source code. In place of
25326 ** This file contains code to support the concept of "benign"
25332 ** abandons the current operation and returns an error code (usually
25383 ** This (sqlite3EndBenignMalloc()) is called by SQLite code to indicate that
25407 ** The author disclaims copyright to this source code. In place of
25469 ** The author disclaims copyright to this source code. In place of
25763 ** The author disclaims copyright to this source code. In place of
25808 ** The application code sees only a pointer to the allocation. We have
25820 u8 eType; /* Allocation type code */
26098 ** higher level code is using pointer to the old allocation, it is
26294 ** The author disclaims copyright to this source code. In place of
26509 ** will already be held (obtained by code in malloc.c) if
26984 ** The author disclaims copyright to this source code. In place of
27572 ** The author disclaims copyright to this source code. In place of
27582 ** This file contains code that is common across all mutex implementations.
27936 ** The author disclaims copyright to this source code. In place of
28154 ** The author disclaims copyright to this source code. In place of
28167 ** The code in this file is only used if we are compiling threadsafe
28551 ** The author disclaims copyright to this source code. In place of
28565 ** Include code that is common to all os_*.c files
28577 ** The author disclaims copyright to this source code. In place of
28586 ** This file contains code that is specific to Windows.
28668 ** The code in this file is only used if we are compiling multithreaded
29045 ** The author disclaims copyright to this source code. In place of
29667 ** code that do things like this:
29922 ** If an OOM as occurred, then the connection error-code (the value
29941 ** The "printf" code that follows dates from the 1980's. It is in
29946 ** This file contains code for a set of "printf"-like routines. These
29990 char fmttype; /* The format field code letter */
30060 ** Return the ascii code for the leading digit of *val, then
31079 /* Return any error code associated with p */
31335 ** The author disclaims copyright to this source code. In place of
31344 ** This file contains C code to implement the TreeView debugging routines.
32628 ** The author disclaims copyright to this source code. In place of
32636 ** This file contains code to implement a pseudo-random number
32788 ** The author disclaims copyright to this source code. In place of
32822 #define SQLITE_THREADS_IMPLEMENTED 1 /* Prevent the single-thread code below */
32894 #define SQLITE_THREADS_IMPLEMENTED 1 /* Prevent the single-thread code below */
33065 ** The author disclaims copyright to this source code. In place of
33603 ** The author disclaims copyright to this source code. In place of
33637 ** The integer argument to sqlite3FaultSim() is a code to identify which
33639 ** should have a unique code. To prevent legacy testing applications from
33712 ** Set the current error code to err_code and clear any prior error message.
33739 ** to do based on the SQLite error code in rc.
33750 ** Set the most recent error code and error string for the sqlite
33751 ** handle "db". The error code is set to "err_code".
33815 ** error code errCode to that parser if the parser has not already
34311 int rc; /* Baseline return code */
34346 ** the code a little larger and slower, and no harm comes from omitting
34761 ** single-byte case. All code should use the MACRO version as
34833 /* For following code (kept for historical record only) shows an
34834 ** unrolling for the 3- and 4-byte varint cases. This code is
35244 ** During code generation, pointers to the variable names within the
35321 ** The author disclaims copyright to this source code. In place of
35799 ** The author disclaims copyright to this source code. In place of
36084 ** and JS code dynamically creates the mapping of members based on
36774 ** The author disclaims copyright to this source code. In place of
36794 ** KEEP THE STRUCTURE OF THIS FILE INTACT. New code should be placed
36961 ** Only set the lastErrno if the error code is a real error and not
36962 ** a normal expected return code of SQLITE_BUSY or SQLITE_OK
37068 ** Include code that is common to all os_*.c files
37595 ** command-line option on the compiler. This code is normally
37672 ** This routine translates a standard POSIX errno code into something
38033 ** The first argument passed to the macro should be the error code that
38041 int errcode, /* SQLite error code */
38065 ** If the code incorrectly assumes that it is the POSIX version that is
38177 ** Return an appropriate error code.
38183 int rc; /* System call return code */
38784 int tErrno; /* Error code from system call errors */
39601 ** Third-party implementations of AFP are available. But this code here
40062 ** The code above is the AFP lock implementation. The code is specific
40087 ** The code above is the NFS lock implementation. The code is specific
40301 ** or some other error code on failure.
40461 ** up the real code with the UNUSED_PARAMETER() macros.
40740 /* The code below is handling the return value of osFallocate()
41088 ** SQLite code assumes this function cannot fail. It also assumes that
41123 ** This function should not be called directly by other code in this file.
41222 ** SQLite error code. The final value of *piOut is undefined in this
41265 int rc = SQLITE_OK; /* Result code form fcntl() */
41384 ** code otherwise.
41406 ** version of this code attempted the SHARED lock at this point. But
41482 int rc = SQLITE_OK; /* Result code */
41608 ** If an error occurs, an error code is returned and *pp is set to NULL.
41805 int rc = SQLITE_OK; /* Result code */
42135 ** code otherwise.
42168 ** Finally, if an error does occur, return an SQLite error code. The final
42886 ** written to *pMode. If an IO error occurs, an SQLite error code is
43126 ** writable, change the error code to indicate that. */
43714 ** during SQLite operation. Only the integer return code is currently
44419 int code = errno;
44421 cmode, code, strerror(code));
44426 int code = errno;
44428 err, code, strerror(code));
44498 int rc = SQLITE_OK; /* Subroutine return code */
45077 ** The author disclaims copyright to this source code. In place of
45086 ** This file contains code that is specific to Windows.
45092 ** Include code that is common to all os_*.c files
45246 ** [sometimes] not used by the code (e.g. via conditional compilation).
45320 ** with some code of our own.
46798 ** code page.
46827 ** using the ANSI or OEM code page.
47149 ** error code and, if possible, the human-readable equivalent from
47152 ** The first argument passed to the macro should be the error code that
47159 int errcode, /* SQLite error code */
47199 ** error code obtained via GetLastError() is eligible to be retried. It
47200 ** must accept the error code DWORD as its only argument and should return
47201 ** non-zero if the error code is transient in nature and the operation
47302 ** This section contains code for WinCE only.
47580 ** End of the special code for wince
47871 ** or some other error code on failure.
47984 int rc = SQLITE_OK; /* Return code for this function */
48001 ** but involves adding a few branches in the common write code path which
48317 int rc = SQLITE_OK; /* Return code from subroutines */
48363 ** If you are using this code as a model for alternative VFSes, do not
48438 ** return the appropriate result code.
48721 ** SQLite code assumes this function cannot fail. It also assumes that
48872 int rc = 0; /* Result code form Lock/UnlockFileEx() */
48959 ** code otherwise.
48997 int rc = SQLITE_OK; /* Result code */
49154 int rc = SQLITE_OK; /* Result code */
49272 ** If an error occurs, an error code is returned and *pp is set to NULL.
49486 ** code otherwise.
49580 ** Finally, if an error does occur, return an SQLite error code. The final
51275 ** The author disclaims copyright to this source code. In place of
52199 ** The author disclaims copyright to this source code. In place of
52353 ** Set the i-th bit. Return 0 on success and an error code if
52503 ** This routine runs an extensive test of the Bitvec code.
52613 ** The author disclaims copyright to this source code. In place of
53538 ** The author disclaims copyright to this source code. In place of
53640 ** corrupt, code at the b-tree layer may overread the page buffer and
53777 ** All code in this file should access the global structure above via the
54821 ** The author disclaims copyright to this source code. In place of
54879 ** to simplify the code.
55222 ** capability was not used by the code generator, it was removed
55223 ** for code economy.
55326 ** The author disclaims copyright to this source code. In place of
55350 ** The author disclaims copyright to this source code. In place of
55764 ** SQLITE_IOERR_NOMEM) occurs at a point in the code that makes it
55808 ** code were simply returned to the user, the b-tree layer would not
55879 ** to xLock(EXCLUSIVE). Also, the code to do the OPEN->SHARED state transition
56023 ** while it is being traversed by code in pager_playback(). The SPILLFLAG_OFF
56275 ** out code that would never execute.
56605 ** error code is something goes wrong.
56626 ** on success or an error code is something goes wrong.
56807 ** error code is returned.
56810 int rc; /* Return code */
56895 ** If an IO error occurs, abandon processing and return the IO error code.
56899 int rc = SQLITE_OK; /* Return code */
56949 int rc = SQLITE_OK; /* Return code */
57064 ** cannot be read from the journal file an error code is returned.
57073 int rc; /* Return code */
57091 ** SQLITE_DONE. If an IO error occurs, return an error code. Otherwise,
57106 ** of the transaction. Return an error code if anything goes wrong.
57192 int rc; /* Return code */
57225 ** an error occurs, return the error code to the caller.
57241 ** dangerous because the code to rollback a hot-journal file
57298 int rc = SQLITE_OK; /* Result code */
57344 int rc; /* Error code returned by pagerUnlockDb() */
57375 ** without clearing the error code. This is intentional - the error
57376 ** code is cleared and the cache reset in the block below.
57410 ** the error-code about to be returned by a pager API function. The
57414 ** IOERR sub-codes, the pager enters the ERROR state and the error code
57512 ** database then the IO error code is returned to the user. If the
57513 ** operation to finalize the journal file fails, then the code still
57515 ** unlock operation fails as well, then the first error code related
57520 int rc = SQLITE_OK; /* Error code from journal finalization operation */
57521 int rc2 = SQLITE_OK; /* Error code from db file unlock operation */
57761 ** to the database file, then the IO error code is returned. If data
57817 ** file. Return an error code to the caller if an IO error occurs.
57872 ** not dirty. Since this code is only executed in PAGER_OPEN state for
58037 ** If an IO error within this function, an error code is returned. This
58049 int rc; /* Return code */
58163 ** the database file, return the error code to the caller.
58300 ** and an error code is returned.
58315 int rc; /* Result code of a subroutine */
58440 ** code. This will cause the pager to enter the error state
58531 int rc = SQLITE_OK; /* Return code */
58620 ** return an SQLite error code. Otherwise, SQLITE_OK.
58695 int rc; /* Return code */
58757 int rc; /* Return code */
58786 ** in pages is stored in *pnPage. Otherwise, an error code (perhaps
58841 ** Return SQLITE_OK or an error code.
58919 int rc = SQLITE_OK; /* Return code */
59172 ** or some other error code if we fail. The OS will automatically
59188 int rc; /* Return code */
59241 ** is a no-op. The value returned is the error state error code (i.e.
59242 ** one of SQLITE_IOERR, an SQLITE_IOERR_xxx sub-code or SQLITE_FULL).
59364 ** and generate no code.
59393 ** the error code is returned to the caller and the contents of the
59441 ** Return SQLITE_OK on success and an error code if we cannot obtain
59446 int rc; /* Return code */
59521 /* At one point the code here called assertTruncateConstraint() to
59545 ** an SQLite error code.
59563 ** and return SQLITE_OK. Otherwise, return an SQLite error code and set
59638 ** code from sqlite3OsAccess()) if the database has gone missing.
59773 ** Or, in pseudo-code:
59785 ** error is encountered, then the IO error code is returned to the caller.
59788 int rc; /* Return code */
59927 ** occurs, an IO error code is returned. Or, if the EXCLUSIVE lock cannot
59931 int rc = SQLITE_OK; /* Return code */
59966 ** make the file smaller (presumably by auto-vacuum code). Do not write
60019 ** SQLITE_IOERR_XXX error code is returned if a call to sqlite3OsOpen()
60044 ** error code if the attempt to write to the sub-journal fails, or
60113 ** page clean, the IO error code is returned. If the page cannot be
60239 ** and error code returned. This function may return SQLITE_NOMEM
60254 int rc = SQLITE_OK; /* Return code */
60654 ** code is returned and the value of *pExists is undefined.
60658 int rc = SQLITE_OK; /* Return code */
60774 ** rolling back a journal file, the IO error code is returned.
60777 int rc = SQLITE_OK; /* Return code */
60824 ** this point in the code and fail to obtain its own EXCLUSIVE lock
61047 ** an appropriate error code is returned and *ppPage is set to NULL.
61336 ** an IO error code if opening or writing the journal file fails.
61339 int rc = SQLITE_OK; /* Return code */
61452 ** PAGER_RESERVED state. Otherwise, return an error code to the caller.
61474 ** This is because in those states the code to roll back savepoint
61648 int rc = SQLITE_OK; /* Return code */
61738 ** If an error occurs, SQLITE_NOMEM or an IO error code is returned
61905 ** function returns SQLITE_OK. Otherwise, an IO error code is returned.
61927 ** Otherwise, either SQLITE_BUSY or an SQLITE_IOERR_XXX error code is
61977 int rc = SQLITE_OK; /* Return code */
62199 ** If an error occurs, an IO error code is returned and the pager
62203 int rc = SQLITE_OK; /* Return code */
62207 ** called, just return the same error code without doing anything. */
62269 int rc = SQLITE_OK; /* Return code */
62274 ** attempted here. Instead, the error code is returned to the caller.
62416 ** occurs while opening the sub-journal file, then an IO error code is
62420 int rc = SQLITE_OK; /* Return code */
62504 ** or an IO error code if an IO error occurs while rolling back a
62693 ** This function may return SQLITE_NOMEM or an IO error code if an error
62699 int rc; /* Return code */
63098 int rc; /* Return code */
63133 ** (e.g. due to malloc() failure), return an error code.
63155 ** not support the xShmXXX() methods, return an error code. *pbOpen is
63166 int rc = SQLITE_OK; /* Return code */
63244 ** Return an SQLite error code if an error occurs, or SQLITE_OK otherwise.
63365 ** The author disclaims copyright to this source code. In place of
63936 ** This functionality is used by the checkpoint code (see walCheckpoint()).
64372 int rc; /* Return code */
64495 int rc; /* Return code */
64832 ** an SQLite error code is returned and *ppWal is left unmodified.
65135 ** return SQLITE_OK. Otherwise, return an error code. If this routine
65249 ** an SQLite error code if an error occurs, or SQLITE_OK otherwise. It is not
65407 int rc = SQLITE_OK; /* Return code */
65534 /* Reset the return code so as not to report a checkpoint failure
65752 ** Otherwise an SQLite error code.
65755 int rc; /* Return code */
65876 ** If an error occurs, an SQLite error code is returned.
65886 int rc; /* Return code */
66032 ** recovery) return a positive error code.
66081 int rc = SQLITE_OK; /* Return code */
66138 ** code that determines whether or not the shared-memory region
66305 ** SQLITE_OK is returned if successful, or an SQLite error code if an
66381 int rc; /* Return code */
66397 ** concurrent with this code. If this is the case, it may be that the
66501 ** Return SQLITE_OK if successful, or an error code if an error occurs. If an
66532 ** This code might run concurrently to the code in walIndexAppend()
66558 int rc; /* Error code */
66606 ** error code otherwise.
66713 ** other than SQLITE_OK, it is not invoked again and the error code is
66807 ** or not pWal->hdr.mxFrame is modified). An SQLite error code is returned
66904 int rc; /* Result code from subfunctions */
66930 ** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
66934 int rc = SQLITE_OK; /* Return code */
67237 int rc; /* Return code */
67551 ** The author disclaims copyright to this source code. In place of
67560 ** This file contains code used to implement mutexes on Btree objects.
67561 ** This code really belongs in btree.c. But btree.c is getting too
67570 ** The author disclaims copyright to this source code. In place of
67946 # error wrong numeric code for no-transaction
67949 # error wrong numeric code for read-transaction
67952 # error wrong numeric code for write-transaction
68089 ** FAULT skipNext holds the cursor fault error code.
68097 ** Error code if eState==CURSOR_FAULT */
68158 ** should return the error code stored in BtCursor.skipNext
68598 ** The author disclaims copyright to this source code. In place of
69120 ** statements only and for the purpose of double-checking that the btree code
69276 ** code otherwise.
69437 int rc; /* Status code */
69610 ** a no-op. If an error occurs, the appropriate error code is written
69618 int rc; /* Return code from subfunctions */
69670 ** An error code is returned if something goes wrong, otherwise SQLITE_OK.
69826 /* The next block of code is equivalent to:
69830 ** The code is inlined to avoid a function call.
69842 /* The next block of code is equivalent to:
69846 ** The code is inlined and the loop is unrolled for performance.
70310 ** an error code (usually SQLITE_CORRUPT).
70323 int rc = SQLITE_OK; /* Integer return code */
71081 int rc = SQLITE_OK; /* Result code from this function */
71191 ** even when they are not. This exercises the locking code and
71648 ** This is useful in one special case in the backup API code where it is
71813 int rc; /* Result code from subfunctions */
72081 ** if successful, or an SQLite error code otherwise.
72224 ** code to SQLITE_BUSY. */
72310 int rc; /* Return code */
72497 ** occurs, return some other error code.
72635 ** SQLITE_OK is returned. Otherwise an SQLite error code.
72866 ** functions return code. So, even if an error occurs in the pager layer,
72919 ** code to errCode for every cursor on any BtShared that pBtree
72941 ** saving a cursor position, an SQLite error code.
73449 ** If an error occurs an SQLite error code is returned. Otherwise:
73528 ** SQLITE_OK is returned on success, otherwise an error code.
73780 ** Return SQLITE_OK on success or an error code if anything goes
74181 ** table near the key intKey. Return a success code.
74409 ** near the key pIdxKey. Return a success code.
74648 ** have been deleted? This API will need to change to return an error code
74939 /* The code within this loop is run only once if the 'searchList' variable
75414 ** STore the result code (SQLITE_OK or some error code) in rc.
75633 int rc; /* The return code */
75694 int *pRC /* Read and write return code from here */
76309 ** operations fails, the return code is set, but the contents
76310 ** of the parent page are still manipulated by thh code below.
76312 ** be marked as dirty. Returning an error code will cause a
76361 ** it is sometimes activated temporarily while debugging code responsible
76512 int rc = SQLITE_OK; /* The return code */
76860 ** The next block of code attempts to adjust the packing of siblings to
77135 ** is important, as this code needs to avoid disrupting any page from which
77289 ** an error code is returned and *ppChild is set to 0.
77552 int rc; /* Return code */
77940 ** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
78059 int rc; /* Return code */
78714 ** corruption) an SQLite error code is returned.
78718 int rc; /* Return code */
78777 /* An error has occurred. Return an error code. */
79035 int rc; /* Result code from subroutine call */
79069 "unable to get the page. error code=%d", rc);
79073 /* Clear MemPage.isInit to make sure the corruption detection code in
79080 "btreeInitPage() returns error code %d", rc);
79524 ** a single shared-btree. The memory is used by client code for its own
79666 int rc; /* Return code */
79750 ** The author disclaims copyright to this source code. In place of
79777 int rc; /* Backup process error code */
79883 ** If an error occurs, NULL is returned and an error code and error message
79959 ** Argument rc is an SQLite error code. Return true if this error is
80041 ** and the pager code use this trick (clearing the first byte
80064 ** code if an error occurs.
80376 /* Set the error code of the destination database handle. */
80528 ** or an error code. */
80552 ** The author disclaims copyright to this source code. In place of
80561 ** This file contains code use to manipulate "Mem" structure. A "Mem"
80846 ** Return SQLITE_OK on success or an error code (probably SQLITE_NOMEM)
81824 int rc = SQLITE_OK; /* Return code */
82001 ** NULL and an SQLite error code returned.
82017 int rc = SQLITE_OK; /* Return code */
82359 ** occur, an SQLite error code is returned.
82403 ** does occur, return an SQLite error code. The final value of *ppVal
82430 u32 t = 0; /* a column type code */
82538 ** The author disclaims copyright to this source code. In place of
82546 ** This file contains code used for creating, destroying, and populating
82652 ** Swap byte-code between two VDBE structures.
82657 ** so that pB can be run again. The old pB byte code is
82824 /* Generate code for an unconditional jump to instruction iDest
82830 /* Generate code to cause the string zStr to be loaded into
82838 ** Generate code that initializes multiple registers to string or integer
82961 ** monitor the EXPLAIN QUERY PLAN code generation.
83434 ** the subroutine. If a jump outside the subroutine is detected, add code
83453 Vdbe *v, /* The byte-code program under construction */
83540 ** by code in pragma.c to ensure that the implementation of certain
83554 ** Generate code (a single OP_Abortable opcode) that will
83720 ** strives to omit useless byte-code like this:
84020 ** makes the code easier to read during debugging. None of this happens
84070 ** dummy will never be written to. This is verified by code inspection and
84494 /* NB: The sqlite3OpcodeName() function is implemented by code created
84564 ** The justification for duplicating code is that according to
84640 int rc = SQLITE_OK; /* Result code */
84758 ** running the code, it invokes the callback once for each instruction.
84778 int rc = SQLITE_OK; /* Return code */
85529 ** may be lying around. Returning an error code won't help matters.
85588 ** If an IO error occurs, an SQLITE_IOERR_XXX error code is returned.
85680 ** Return an error code. If the commit could not complete because of
85714 int mrc; /* Primary error code from p->rc */
85732 /* If the query was read-only and the error code is SQLITE_INTERRUPT,
85826 ** error code is SQLITE_OK or SQLITE_CONSTRAINT, then promote the
85827 ** current statement error code.
85895 ** Copy the error code and error message belonging to the VDBE passed
85899 ** This function does not clear the VDBE error code or message, just
85943 ** Write any error messages into *pzErrMsg. Return the result code.
85966 /* If the VDBE has been run even partially, then transfer the error code
86039 ** the result code. Write any error message text into *pzErrMsg.
86163 ** the appropriate error code.
86223 ** encapsulate the code that serializes values for storage in SQLite
86263 ** opcode in the byte-code engine. But by moving this routine in-line, we
86266 ** ended. The code is kept here for historical reference only.
86395 ** rather than a 64-bit float. Frank assures us that the code here
86645 ** in assert() statements to ensure that the optimized code in
87346 ** this code. Including it causes gcc to generate a faster switch
87348 ** is contiguous) but does not cause any duplicate code to be generated
87504 ** Return SQLITE_OK if everything works, or an error code otherwise.
87520 ** this code can safely assume that nCellKey is 32-bits
87866 ** The author disclaims copyright to this source code. In place of
87875 ** This file contains code use to implement APIs that are part of the
87955 ** success/failure code that describes the result of executing the virtual
87958 ** This routine sets the error code and string returned by
87984 ** back to its starting state so that it can be reused. A success code from
87987 ** This routine sets the error code and string returned by
88522 ** error has occurred, then return the error code in p->rc to the
88523 ** caller. Set the error code in the database handle to the same
88623 ** error has occurred, then return the error code in p->rc to the
88624 ** caller. Set the error code in the database handle to the same value.
88942 ** access code.
88992 ** This function is deprecated. Do not use it for new code. It is
88993 ** provide only to avoid breaking legacy code. New aggregate function
89029 ** running with SQLITE_DEBUG defined the SQLite code sometimes assert()s
89086 ** code of statement pStmt set to SQLITE_NOMEM.
89102 ** sqlite3_column_XXX API, then set the return code of the statement to
89336 ** The error code stored in database p->db is overwritten with the return
89637 ** Deprecated external interface. Internal/core SQLite code
90079 ** The author disclaims copyright to this source code. In place of
90088 ** This file contains code used to insert the values of host parameters
90274 ** The author disclaims copyright to this source code. In place of
90282 ** The code in this file implements the function that runs the
90287 ** of the code in this file is, therefore, important. See other comments
90289 ** commenting and indentation practices when changing or adding code.
90430 ** iSrcLine is the source code line (from the __LINE__ macro) that
90432 ** code line number is in the lower 24 bits of iSrcLine and the upper
90893 ** hwtime.h contains inline assembler code for implementing
91205 ** that is a lot of wasted space on the left margin. So the code within
91207 ** big comment (similar to this one) will mark the point in the code where
91271 ** This code uses unstructured "goto" statements and does not look clean.
91272 ** But that is not due to sloppy coding habits. The code is written this
91283 ** a return code SQLITE_ABORT.
91329 ** P2 is not used by the byte-code engine. However, if P2 is positive
91334 ** value is a byte-code indentation hint. See tag-20220407a in
91447 ** P1 is the result code returned by sqlite3_exec(), sqlite3_reset(),
91669 ** only to make the byte code easier to read and verify.
91916 ** with an SQLITE_ROW return code and it sets up the sqlite3_stmt
92591 ** operator actually is. The next block of code depends on the fact
92893 ** encountered on each invocation of the byte-code program. Jump to P2
92904 ** because the self-altering code trick does not work for recursive
93120 ** code generator. The P1, P2, and P3 operands to this opcode are the
93183 u32 t; /* A type code from the record header */
93277 ** accept it for historical reasons. When aOffset[0]==0, the code this
94340 ** discard the database schema, as the user code implementing the
94536 assert( pCur->iDb==pOp->p3 ); /* Guaranteed by the code generator */
95092 /* The next line of code computes as follows, only faster:
95217 ** to setup code prior to the OP_IdxGT or OP_IdxGE opcode that checks for
96262 ** would fail. Should this ever change (because of changes in the code
97901 ** might change from one evaluation to the next. The next block of code
98289 ** code will be set to SQLITE_LOCKED.
98568 ** data is available) and the error code returned when xColumn or
98796 ** might change from one evaluation to the next. The next block of code
99079 ** However, there are places in the code generator will release registers
99140 /* The following code adds nothing to the actual functionality
99159 /* Never happens. This code exists to avoid a harmless linkage
99261 ** The author disclaims copyright to this source code. In place of
99270 ** This file contains code used to implement incremental BLOB I/O.
99302 ** blob handle was opened, then an error code is returned and *pzErr may
99312 int rc; /* Error code */
99509 ** of writing code to use the b-tree layer directly is that the
99677 ** same way as an SQLITE_DELETE (the SQLITE_DELETE code is actually
99737 ** contain a blob or text value, then an error code is returned and the
99738 ** database handle error code and message set. If this happens, then all
99780 ** The author disclaims copyright to this source code. In place of
99788 ** This file contains code for the VdbeSorter object, used in concert with
100257 ** error code.
100284 int rc; /* sqlite3OsRead() return code */
100333 int rc; /* vdbePmaReadBlob() return code */
100386 ** Or, if an error occurs, return an SQLite error code. The final value of
100404 ** if successful, or an SQLite error code if an error occurs.
100451 ** no error occurs, or an SQLite error code if one does.
100702 ** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
101079 ** Otherwise, set *ppFd to 0 and return an SQLite error code.
101175 ** SQLITE_OK if successful, or an SQLite error code (i.e. SQLITE_NOMEM) if
101249 ** if successful, or an SQLite error code if an error occurs.
101279 ** required. Otherwise, return an SQLite error code.
101301 ** SQLITE_OK if successful, or an SQLite error code if an error occurs.
101313 ** successful, or an SQLite error code otherwise.
101326 int rc = SQLITE_OK; /* Return code */
101386 ** Return SQLITE_OK if successful or an error code if an error occurs.
101461 int rc; /* Return code */
101729 ** SQLITE_OK is returned on success, or an SQLite error code otherwise.
101888 ** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
101895 int rc = SQLITE_OK; /* Return code */
101964 ** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
102056 int rc = SQLITE_OK; /* Return code */
102076 ** to NULL and return an SQLite error code.
102139 ** code is returned and pLeaf is freed.
102194 ** error occurs, an SQLite error code is returned and the final value
102274 ** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
102277 int rc; /* Return code */
102360 int rc = SQLITE_OK; /* Return code */
102412 int rc; /* Return code */
102500 ** If an error occurs, return an SQLite error code (i.e. SQLITE_NOMEM).
102549 ** The author disclaims copyright to this source code. In place of
102976 ** The author disclaims copyright to this source code. In place of
102985 ** This file contains code use to implement an in-memory rollback journal.
103338 ** case none of the code in this module is executed as a result of calls
103419 ** The author disclaims copyright to this source code. In place of
103679 ** The author disclaims copyright to this source code. In place of
105040 int rc; /* Return code from subprocedures */
105159 ** actual expression. This allows the code in alter.c to modify
105817 ** The author disclaims copyright to this source code. In place of
105826 ** for generating VDBE code that evaluates expressions in SQLite.
106192 ** Generate code for a comparison operator.
106195 Parse *pParse, /* The parsing (and code generating) context */
106286 ** sqlite3ExprCode() will generate all necessary code to compute
106354 ** If expression pExpr is of type TK_SELECT, generate code to evaluate
106377 ** If pVector is a TK_SELECT expression, then code for it must have
106382 ** If pVector is of type TK_VECTOR, then code for the requested field
106922 Parse *pParse, /* Parsing and code generating context */
107568 ** to be used by the code generator. */
107692 ** we can do the size check, so defer the size check until code generation.
107723 ** the RHS and LHS sizes match during code generation. */
108435 ** Generate code that checks the left-most column of index table iCur to see if
108843 ** Generate code that will construct an ephemeral table containing all terms
108891 /* If this routine has already been coded, but the previous code
108941 ** Generate code to write the results of the select into the temporary
109013 ** this code only executes once. Because for a non-constant
109014 ** expression we need to rerun this code each time.
109050 ** Generate code for scalar subqueries used as a subquery expression
109106 ** If all of the above are false, then we can run this code just once
109113 /* For a SELECT, generate code to put the values for all columns of
109204 ** Generate code for an IN expression.
109220 ** This routine generates code that jumps to destIfFalse if the LHS is not
109229 Parse *pParse, /* Parsing and code generating context */
109246 int destStep6 = 0; /* Start of code for Step 6 */
109299 ** by code generated below. */
109539 /* Generate code that will load into register regOut a value that is
109564 ** Generate code that will compute the value of generated column pCol
109591 ** Generate code to extract the value of the iCol-th column of a table.
109643 ** Generate code that will extract the iColumn-th column from
109647 ** is called. If iColumn<0 then code is generated that extracts the rowid.
109650 Parse *pParse, /* Parsing and code generating context */
109667 ** Generate code to move content from registers iFrom...iFrom+nReg-1
109735 ** Generate code to implement special SQL functions that are implemented
109901 ** Generate code into the current Vdbe to evaluate the given
109908 ** must check the return code and move the results to the desired
110690 ** Generate code that will evaluate expression pExpr just one time
110694 ** guard them with an OP_Once opcode to ensure that the code is only executed
110695 ** once. If no functions are involved, then factor the code out and put it at
110702 ** code to the same register, if they do not contain function calls and hence
110708 Expr *pExpr, /* The expression to code when the VDBE initializes */
110753 ** Generate code to evaluate an expression and store the results
110762 ** code to fill the register in the initialization section of the
110789 ** Generate code that will evaluate expression pExpr and store the
110813 ** Make a transient copy of expression pExpr and then code it using
110825 ** Generate code that will evaluate expression pExpr and store the
110828 ** might choose to code the expression at initialization time.
110839 ** Generate code that pushes the value of every element of the given
110850 ** factored out into initialization code.
110914 ** Generate code for a BETWEEN operator.
110934 Parse *pParse, /* Parsing and code generating context */
110992 ** Generate code for a boolean expression such that a jump is made
110999 ** This code depends on the fact that certain token values (ex: TK_EQ)
111002 ** the make process cause these values to align. Assert()s in the code
111140 ** Generate code for a boolean expression such that a jump is made
111318 ** code generation, and that copy is deleted after code generation. This
111389 ** just might result in some slightly slower code. But returning
111980 ** will not generate any code in the preamble.
112293 ** that might be invoked from other parts of the code, to ensure that
112294 ** the sub/co-routine does not use registers in common with the code that
112330 ** The author disclaims copyright to this source code. In place of
112338 ** This file contains C code routines that used to generate VDBE code
112344 ** The code in this file only exists if we are not omitting the
112373 ** Generate code to verify that the schemas of database zDb and, if
112410 ** Generate VM code to replace any double-quoted strings (but not double-quoted
112434 ** Generate code to reload the schema for database iDb. And, if iDb!=1, for
112447 ** Generate code to implement the "ALTER TABLE xxx RENAME TO yyy"
112616 ** Write code that will raise an error if the table described by
113158 ** and SF_Resolved) below. And the parser code that uses the with-stack
113504 ** pCtx and an SQLite error code returned.
113610 ** successful. Otherwise, return an SQLite error code and leave an error
113994 ** This C function implements an SQL user function that is used by SQL code
114610 ** The author disclaims copyright to this source code. In place of
114618 ** This file contains code associated with the ANALYZE command.
114760 ** This routine generates code that opens the sqlite_statN tables.
114770 ** If zWhere==0, then code is generated to delete all stat table entries.
115303 ** if it wants the byte-code to do special processing.
115573 ** Generate code to do an analysis of all indices associated with
115678 ** Pseudo-code for loop that calls stat_push():
115935 ** Generate code that will cause the most recent index analysis to
115946 ** Generate code that will do an analysis of an entire database
115971 ** Generate code that will do an analysis of a single table in
115995 ** Generate code for the ANALYZE command. The parser calls this routine
116017 ** and code in pParse and return NULL. */
116471 ** code may be ignored.
116550 ** The author disclaims copyright to this source code. In place of
116558 ** This file contains code used to implement the ATTACH and DETACH commands.
116907 ** This procedure generates VDBE code for a single invocation of either the
117190 ** The author disclaims copyright to this source code. In place of
117198 ** This file contains code used to implement the sqlite3_set_authorizer()
117206 ** All of the code in this file may be omitted by defining a single
117298 int rc; /* Auth callback return code */
117378 ** Do an authorization check using the code and arguments given. Return
117385 int code,
117412 rc = db->xAuth(db->pAuthArg, code, zArg1, zArg2, zArg3, pParse->zAuthContext
117461 ** The author disclaims copyright to this source code. In place of
117469 ** This file contains C code routines that are called by the SQLite parser
117503 ** code to make the lock occur is generated by a later call to
117595 ** no VDBE code was generated.
117612 /* Begin by generating some termination code at the end of the
117662 ** set for each database that is used. Generate code to start a
117708 ** expressions have iConstExprReg==0. Do not generate code for
117727 /* Finally, jump back to the beginning of the executable code. */
117747 ** Run the parser and code generator recursively in order to generate
117748 ** code for the SQL statement given onto the end of the pParse context
117900 ** and code in pParse and return NULL. */
118461 Parse *pParse, /* Parsing and code generating context */
118797 /* Begin generating the code that will insert the table record into
118836 ** by the real entry in code generated at sqlite3EndTable().
118840 ** The rowid and root page number values are needed by the code that
118910 ** TK_RETURNING instead of TK_SELECT, so that the trigger code generator
119498 ** Generate code that will increment the schema cookie.
119787 ** internal schema data structures and the generated VDBE code so that they
119874 ** code assumes the PRIMARY KEY contains no repeated columns.
119895 ** code for a CREATE TABLE (not when parsing one as part of reading
120047 ** not pass them into code generator routines by mistake.
120215 ** expression to a NULL. This prevents code generators that operate
120716 ** Write code to erase the table with root-page iTable from database iDb.
120717 ** Also write code to modify the sqlite_schema table and internal schema
120730 ** location iTable. The following code modifies the sqlite_schema table to
120746 ** Write VDBE code to erase table pTab and all associated indices on disk.
120821 ** Generate code to drop a table.
120966 int code;
120975 code = SQLITE_DROP_TEMP_VIEW;
120977 code = SQLITE_DROP_VIEW;
120981 code = SQLITE_DROP_VTABLE;
120986 code = SQLITE_DROP_TEMP_TABLE;
120988 code = SQLITE_DROP_TABLE;
120991 if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
121018 /* Generate code to remove the table from the schema table
121196 ** Generate code that will erase and refill index *pIdx. This is
121215 Vdbe *v; /* Generate code into this virtual machine */
121847 ** emit code to allocate the index rootpage on disk and make an entry for
121869 ** doing so, code a Noop instruction and store its address in
121873 ** the Noop with a Goto to jump over the VDBE code generated below. */
122063 int code = SQLITE_DROP_INDEX;
122070 if( !OMIT_TEMPDB && iDb==1 ) code = SQLITE_DROP_TEMP_INDEX;
122071 if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
122077 /* Generate code to remove the index and from the schema table */
122538 ** is initially attached to the left operand. But the code generator
122555 ** code generator can easily tell that the table is part of
122582 ** Generate VDBE code for a BEGIN statement.
122616 ** Generate VDBE code for a COMMIT or ROLLBACK statement.
122618 ** code is generated for a COMMIT.
122693 ** for database iDb. The code to actually verify the schema cookie
122730 ** Generate VDBE code that prepares for doing an operation that
122762 ** The code generator calls this routine if is discovers that it is
122772 ** makes it more difficult to prove that the code is correct (in
122789 int errCode, /* extended error code */
122928 ** Generate code for the REINDEX command.
122952 ** and code in pParse and return NULL. */
123159 ** The author disclaims copyright to this source code. In place of
123701 ** The author disclaims copyright to this source code. In place of
123709 ** This file contains C code routines that are called by the parser
123710 ** in order to generate code for DELETE FROM statements.
123744 /* Generate byte-code that will report the number of rows modified
123968 ** Generate code for a DELETE FROM statement.
124101 /* Begin generating code.
124152 ** IMPLEMENTATION-OF: R-17228-37124 If the action code is SQLITE_DELETE and
124243 ** delete code. */
124361 ** generating code because of a call to sqlite3NestedParse(), do not
124390 ** This routine generates VDBE code that causes a single row of a
124445 int iLabel; /* Label resolved to end of generated code */
124565 ** This routine generates VDBE code that causes the deletion of all
124583 Parse *pParse, /* Parsing and code generating context */
124617 ** Generate code that will assemble an index key and stores it in register
124720 ** The author disclaims copyright to this source code. In place of
124810 ** the datatype code for the initial datatype of the sqlite3_value object
125225 ** as VDBE code so that unused argument values do not have to be computed.
125687 ** that identifies the particular version of the source code used to build
125858 ** The unicode() function. Return the integer unicode code-point value
126200 int code = iCode[zIn[i]&0x7f];
126201 if( code>0 ){
126202 if( code!=prevcode ){
126203 prevcode = code;
126204 zResult[j++] = code + '0';
127127 ** The author disclaims copyright to this source code. In place of
127135 ** This file contains code used by the compiler to add foreign key
127229 ** Before coding an UPDATE or DELETE row operation, the code-generator
127232 ** row are required by the FK processing VDBE code (i.e. if FKs were
127234 ** accessed). No information is required by the code-generator before
127236 ** generation code to query for this information are:
127425 ** Each time it is called, this function generates VDBE code to locate the
127456 Vdbe *v = sqlite3GetVdbe(pParse); /* Vdbe to add code to */
127570 ** incrementing a counter. This is necessary as the VM code is being
127596 Parse *pParse, /* Parsing and code generating context */
127644 ** This function is called to generate code executed when a row is deleted
127647 ** code for an SQL UPDATE operation, this function may be called twice -
127654 ** The code generated by this function scans through the rows in the child
127843 ** This function is called to generate code that runs when table pTab is
127848 ** Normally, no code is required. However, if either
127870 ** generating any VDBE code. If one can be found, then jump over
127975 ** used to code a trigger that is really a "SET NULL" action belonging
127993 ** table pTab to generate VDBE code to perform foreign key constraint
128211 ** This function is called before generating code to update or delete a
128241 ** This function is called before generating code to update or delete a
128313 ** require no special handling by the triggers sub-system, code for them is
128606 ** The author disclaims copyright to this source code. In place of
128614 ** This file contains C code routines that are called by the parser
128620 ** Generate code that will
128629 Parse *pParse, /* Generate code into this VDBE */
128750 ** Otherwise if iReg>0 then code an OP_Affinity opcode that will set the
128944 ** Companion code in the TK_COLUMN case of sqlite3ExprCodeTarget() will
129052 ** This routine generates code that will initialize all of the
129123 ** This routine generates the code needed to write autoincrement
129127 ** routine just before the "exit" code.
129206 ** The code generated follows one of four templates. For a simple
129207 ** insert with data coming from a single-row VALUES clause, the code executes
129208 ** once straight down through. Pseudo-code follows (we call this
129242 ** The generated code follows this template:
129296 Vdbe *v; /* Generate code into this virtual machine */
129516 int rc; /* Result code */
129549 ** and add it to a transient table srcTab. The code generated
129930 /* Generate code to check constraints and generate index keys and
130021 ** generating code because of a call to sqlite3NestedParse(), do not
130178 ** Generate code to do constraint checks prior to an INSERT or an UPDATE
130206 ** The code generated by this routine will store new index entries into
130212 ** (2019-05-07) The generated code also creates a new record for the
130228 ** This routine also generates code to check constraints. NOT NULL,
130237 ** return code of SQLITE_CONSTRAINT.
130245 ** return code of SQLITE_CONSTRAINT. The
130496 ** Constraint checking code is generated in this order:
130581 ** The uniqueness rechecking code will create a series of tests to run
130889 /* Generate code to handle collisions */
130946 /* Generate code that executes if the new index entry is not unique */
130998 /* Here we insert code that will be invoked after all constraint
131009 /* Copy the constraint check code from above, except change
131122 ** PK index. This function adds code to invoke the pre-update hook,
131146 ** This routine generates code to finish the INSERT or UPDATE operation
131223 ** code to open and initialized those cursors.
131368 ** embedded in the code for details.
131373 ** case, this routine generates code for the xfer optimization but also
131375 ** xfer optimization code if the test fails. In that case, this routine
131622 ** DBFLAG_Vacuum flag is set, this block generates code to make
131767 ** The author disclaims copyright to this source code. In place of
131784 ** Execute SQL code. Return one of the SQLITE_ success/failure
131800 int rc = SQLITE_OK; /* Return code */
131911 ** The author disclaims copyright to this source code. In place of
131919 ** This file contains code used to dynamically load extensions into
131931 ** The author disclaims copyright to this source code. In place of
133535 ** The author disclaims copyright to this source code. In place of
133543 ** This file contains code used to implement the PRAGMA command.
134279 ** to support legacy SQL code. The safety level used to be boolean
134425 ** Generate code to return a single integer value.
134433 ** Generate code to return a single text value.
134591 ** Generate code to output a single-column result row with a value of the
135394 /* Many of the flag-pragmas modify the code generated by the SQL
135817 /* Generate code to read the child key values into registers
135828 /* Generate code to query the parent index for a matching parent
135842 /* Generate code to report an FK violation to the caller. */
136039 ** by the OP_IsType code, so it is a required step.
136136 /* VDBE byte code will fall thru */
137147 ** The author disclaims copyright to this source code. In place of
137225 ** This is the callback routine for the code that initializes the
137261 ** But because db->init.busy is set to 1, no VDBE code is generated
137273 TESTONLY(int rcp); /* Return code from sqlite3_prepare() */
137574 ** created using ATTACH statements. Return a success code. If an
137610 ** Otherwise, the schema is loaded. An error code is returned.
137687 /* If pSchema is NULL, then return -32768. This happens when code in
137754 ** pParse->earlyCleanup flag is set in that case. Calling code show verify
137829 int rc = SQLITE_OK; /* Result code */
138214 ** The author disclaims copyright to this source code. In place of
138222 ** This file contains C code routines that are called by the parser
138474 u8 code; /* Join type mask */
138493 jointype |= aKeyword[j].code;
138894 ** Generate code that will push the record in registers regData
139037 ** Add code to implement the OFFSET
139040 Vdbe *v, /* Generate code into this VM */
139051 ** Add code that will check to make sure the array of registers starting at
139062 ** be opened before the VM code generated by this routine is executed.
139094 Parse *pParse, /* Parsing and code generating context */
139178 Parse *pParse, /* Parsing and code generating context */
139291 ** This routine generates the code for the inside of the inner loop
139843 ** is provided when SQLITE_OMIT_EXPLAIN is defined. This allows the code
139846 ** code with #ifndef directives.
139861 ** routine generates the code needed to do that.
140145 /* At one time, code such as "SELECT new.x" within a trigger would
140147 ** trigger code is generated and so this condition is no longer
140251 ** Generate code that will tell the VDBE the declaration types of columns
140768 ** This routine generates VDBE code to compute the content of a WITH RECURSIVE
140822 int rc; /* Result code */
141057 int rc = SQLITE_OK; /* Success code from a subroutine */
141059 Vdbe *v; /* Generate code to this VDBE */
141120 /* Generate code for the left and right SELECT statements.
141310 /* Generate code to take the intersection of the two temporary
141431 ** if there has been no previous output. If regPrev>0 then code is
141561 ** Alternative compound select code generator for cases when there
141569 ** is to code both <selectA> and <selectB> with the ORDER BY clause as
141655 Vdbe *v; /* Generate code to this VDBE */
141689 assert( pKeyDup==0 ); /* "Managed" code needs this. Ticket #3382. */
141896 /* Generate code to handle the case of A<B
141903 /* Generate code to handle the case of A==B
141917 /* Generate code to handle the case of A>B
141927 /* This code runs once to initialize everything.
142325 ** The code generated for this simplification gives the same result
142370 ** (**) Restriction (10) was removed from the code on 2005-02-05 but we
142417 ** SELECT statement, but all the code here does is make sure that no
142441 ** parent to a compound query confuses the code that handles
142739 ** subquery until code generation is
142767 ** iParent. The iParent cursor will never be used. Subsequent code
142797 ** block of code will expand the outer query FROM clause to 4 slots.
143340 #if 0 /* Legacy code. Checks now done by sqlite3ExprIsTableConstraint() */
143531 ** above that generates the code for a compound SELECT with an ORDER BY clause
143646 /* The code generator maintains a stack of active WITH clauses
144106 ** list. The following code just has to locate the TK_ASTERISK
144462 ** routine generates code that stores NULLs in all of those memory
144883 ** Generate code for the SELECT statement given in the p argument.
144911 DistinctCtx sDistinct; /* Info on how to code the DISTINCT keyword */
144912 SortCtx sSort; /* Info on how to code the ORDER BY clause */
145196 ** (2) Generate code for all sub-queries
145228 /* Generate code for all sub-queries in the FROM clause
145233 /* The code for a subquery should only be generated once. */
145268 /* Generate code to implement the subquery
145303 /* This is a CTE for which materialization code has already been
145877 /* Generate code that runs whenever the GROUP BY changes.
145878 ** Changes in the GROUP BY are detected by the previous code
145881 ** This code copies current group by terms in b0,b1,b2,...
146030 ** The code generated by updateAccumulator() uses this to ensure
146123 ** set the return code to 1. Otherwise 0. */
146165 ** The author disclaims copyright to this source code. In place of
146195 int rc; /* Return code from sqlite3_exec() */
146365 ** The author disclaims copyright to this source code. In place of
146595 int code = SQLITE_CREATE_TRIGGER;
146598 if( iTabDb==1 || isTemp ) code = SQLITE_CREATE_TEMP_TRIGGER;
146599 if( sqlite3AuthCheck(pParse, code, zName, pTab->zName, zDbTrig) ){
146610 ** INSTEAD OF trigger into a BEFORE trigger. It simplifies code
147040 int code = SQLITE_DROP_TRIGGER;
147043 if( iDb==1 ) code = SQLITE_DROP_TEMP_TRIGGER;
147044 if( sqlite3AuthCheck(pParse, code, pTrigger->zName, pTable->zName, zDb) ||
147051 /* Generate code to destroy the database record of the trigger.
147312 ** Generate code for the RETURNING trigger. Unlike other triggers
147313 ** that invoke a subprogram in the bytecode, the code for RETURNING
147319 Table *pTab, /* The table to code triggers from */
147389 ** Generate VDBE code for the statements inside the body of a single
147476 ** program. It is not used in production code, only for debugging.
147514 Trigger *pTrigger, /* Trigger to code */
147516 int orconf /* ON CONFLICT policy to code trigger program with */
147576 /* If one was specified, code the WHEN clause. If it evaluates to false
147628 Trigger *pTrigger, /* Trigger to code */
147656 ** Generate code for the trigger program associated with trigger p on
147663 Trigger *p, /* Trigger to code */
147664 Table *pTab, /* The table to code triggers from */
147694 ** This is called to code the required FOR EACH ROW triggers for an operation
147695 ** on table pTab. The operation to code triggers for (INSERT, UPDATE or DELETE)
147739 Table *pTab, /* The table to code triggers from */
147760 /* Determine whether we should code this trigger. One of two choices:
147809 Table *pTab, /* The table to code triggers from */
147844 ** The author disclaims copyright to this source code. In place of
147852 ** This file contains C code routines that are called by the parser
147991 ** generates VM code to run the query:
148232 ** clause if this function is being called to generate code for part of
148295 /* Begin generating code. */
148558 ** that is to be updated. So bypass the code that searches for the
149004 ** Generate code for an UPDATE of a virtual table.
149195 ** The author disclaims copyright to this source code. In place of
149203 ** This file contains code to implement various aspects of UPSERT
149278 ** Return SQLITE_OK if everything works, or an error code is something
149287 int rc; /* Result code */
149446 Parse *pParse, /* The parsing and code-generating context */
149514 ** The author disclaims copyright to this source code. In place of
149522 ** This file contains code used to implement the VACUUM command.
149524 ** Most of the code in this file may be omitted by defining the
149659 int rc = SQLITE_OK; /* Return code from service routines */
149940 ** The author disclaims copyright to this source code. In place of
149948 ** This file contains code used to help implement virtual tables.
150624 ** of the virtual table pTab. If an error occurs, an error code is returned
150699 ** description of the error and an SQLITE_XXX error code is returned.
150904 ** array. Return the error code for the first error that occurs, or
151008 ** If any virtual table method returns an error code other than SQLITE_OK,
151288 ** The author disclaims copyright to this source code. In place of
151296 ** This module contains C code that generates VDBE code used to process
151301 ** that actually generate the bulk of the WHERE loop code. The original where.c
151302 ** file retains the code that does query planning and analysis.
151310 ** The author disclaims copyright to this source code. In place of
151599 #define TERM_VIRTUAL 0x0002 /* Added by the optimizer. Do not code */
151769 Parse *pParse; /* Parsing and code generating context */
152308 ** in zAff are SQLITE_AFF_BLOB or SQLITE_AFF_NONE, then no code gets generated.
152471 ** Generate code for a single equality term of the WHERE clause. An equality
152482 ** straight-line code. For constraints of the form X IN (...)
152644 ** Generate code that will evaluate all == and IN constraints for an
152651 ** constraints are coded. This routine will generate code to evaluate
152666 ** the index of the first memory cell in that range. The code that
152695 u16 nEq; /* The number of == or IN constraints to code */
152903 ** 1) allocate a register and code an OP_Column instruction to read
153051 ** function generates code to do a deferred seek of cursor iCur to the
153081 Vdbe *v = pParse->pVdbe; /* Vdbe to generate code within */
153111 ** code to write the first nReg elements of the vector into an array
153115 ** this case, generate code to evaluate the expression and leave the
153239 ** Generate code for the start of the iLevel-th loop in the WHERE clause
153420 /* Generate code that will continue to the next row if
153746 /* Generate code to evaluate all constraint terms using == or IN
153873 ** we have to make the top of the loop be code that sets the end
154030 ** Gosub opcode and jumps straight to the code generated by WhereEnd().
154037 ** Following the above, code to terminate the loop. Label A, the target
154107 ** correct response for the end-of-loop code (the OP_Return) is to
154332 ** loop. The byte-code formatter will use that P2 value as a hint to
154369 /* Insert code to test every subexpression that can be completely
154459 /* Insert code to test for implied constraints based on transitivity
154464 ** then we cannot use the "t1.a=t2.b" constraint, but we can code
154515 /* pTab is the right-hand table of the RIGHT JOIN. Generate code that
154546 /* For a LEFT OUTER JOIN, generate code that will record the fact that
154559 /* Create a subroutine used to process all interior loops and code
154561 ** be in-line with the rest of the code. But at the end, a separate
154607 ** Generate the code for the loop that finds all non-matched terms
154701 ** The author disclaims copyright to this source code. In place of
154709 ** This module contains C code that generates VDBE code used to process
154870 Parse *pParse, /* Parsing and code generating context */
154885 int rc; /* Result code to return */
156297 ** LIMIT and OFFSET terms are ignored by most of the planner code. They
156554 ** The author disclaims copyright to this source code. In place of
156562 ** This module contains C code that generates VDBE code used to process
156564 ** generating the code that loops through a table looking for applicable
156643 ** that might make the code run a little faster, but should not change
156659 ** While generating code for the min/max optimization, after handling
156663 ** code an OP_Goto to by pass subsequent processing.
157206 ** Convert OP_Column opcodes to OP_Copy in previously generated code.
157208 ** This routine runs over generated VDBE code and translates OP_Column
157366 ** Generate code to construct the Index object for an automatic index
157367 ** and to set up the WhereLevel object pLevel so that the code generator
157401 /* Generate code to skip over the creation and initialization of the
157596 ** sqlite3WhereCodeOneLoopStart() will generate code to test the Bloom filter
157935 ** appropriate error code is returned. A return of SQLITE_CONSTRAINT from
158025 ** the code actually searches this set:
158088 /* The following assert statements check that the binary search code
158236 ** If an error occurs, an SQLite error code is returned. Otherwise,
158240 Parse *pParse, /* Parsing & code generating context */
158352 Parse *pParse, /* Parsing & code generating context */
158533 Parse *pParse, /* Parsing & code generating context */
158541 int rc; /* Subfunction return code */
158597 Parse *pParse, /* Parsing & code generating context */
158605 int rc = SQLITE_OK; /* Subfunction return code */
159355 int rc = SQLITE_OK; /* Return code */
159692 ** the code). And, even if it is not, it should not be too much slower.
159936 int rc = SQLITE_OK; /* Return code */
160550 int rc = SQLITE_OK; /* Return code */
161971 ** This block of code merely checks to see if a Bloom filter would be
161974 ** down where the code for each WhereLoop is generated.
162033 ** each of the expressions in the index so that the expression code generator
162099 ** Then the code generated is conceptually like the following:
162117 ** And so forth. This routine generates code to open those VDBE cursors
162118 ** and sqlite3WhereEnd() generates the code to close them.
162120 ** The code that sqlite3WhereBegin() generates leaves the cursors named
162121 ** in pTabList pointing at their appropriate entries. The [...] code
162129 ** code will run much faster. Most of the work of this routine is checking
162193 int rc; /* Return code */
162224 ** only generate code for the first table in pTabList and assume that
162332 ** generated code if the result is not true.
162704 /* Generate the code to do the search. Each iteration of the for
162705 ** loop below generates code for a single nested loop of the VM
162816 /* Generate loop termination code.
162982 /* Do RIGHT JOIN processing. Generate code that will output the
163002 /* If this scan uses an index, make VDBE code substitutions to read data
163007 ** Calls to the code generator in between sqlite3WhereBegin and
163008 ** sqlite3WhereEnd will have created code that references the table
163009 ** directly. This loop scans all that code looking for opcodes
163130 ** The author disclaims copyright to this source code. In place of
163206 ** When processing the rewritten SELECT statement, code in select.c calls
163212 ** sqlite3WindowCodeStep() generates VM code so that, for each row returned
163225 ** This detail is encapsulated within this file, the code generated by
164510 ** This is called by code in select.c before it calls sqlite3WhereBegin()
164598 ** code to check that the value is a non-negative integer and throws an
164737 ** Generate VM code to read the window frames peer values from cursor csr into
164759 ** Generate VM code to invoke either xStep() (if bInverse is 0) or
164763 ** inline VM code.
164889 ** Generate VM code to invoke either xValue() (bFin==0) or xFinalize()
164892 ** API, generate the equivalent VM code.
164928 ** Generate code to calculate the current values of all window functions in the
165027 ** Invoke the sub-routine at regGosub (generated by code in select.c) to
165030 ** OP_Gosub instruction is all that this routine generates. Extra VM code
165111 ** Generate code to set the accumulator register for each window function
165166 ** pOrderBy->nExpr. This function generates code to compare the two
165201 ** code equivalent to:
165206 ** operator in the above pseudo-code is replaced with ">" or "<=", respectively.
165212 ** is OP_Ge, the generated code is equivalent to:
165264 ** reg2 are NULL are handled separately in the following block. The code
165307 ** then leave reg1 as it is. In pseudo-code, this is implemented as:
165348 ** generates VM code for a single RETURN_ROW, AGGSTEP or AGGINVERSE
165571 ** code to populate the Window.regResult register for each window function
165576 ** require slightly different processing. The following pseudo code is
165621 ** The pseudo-code above uses the following shorthand:
165712 ** conditions that are always true are omitted from the VM code. The only
165748 ** To handle this case, the pseudo-code programs depicted above are modified
165771 ** ROWS. The VM code is modified slightly so that:
165900 ** The text above leaves out many details. Refer to the code and comments
165927 int lblWhereEnd; /* Label just before sqlite3WhereEnd() code */
166029 ** VM code to check if the input row is the start of a new partition.
166238 ** The author disclaims copyright to this source code. In place of
166248 ** The canonical source code to this file ("parse.y") is a Lemon grammar
166252 ** this comment as part of the translated C-code. Edits should be made
166686 ** YYERRORSYMBOL is the code number of the error symbol. If not
166694 ** YY_ERROR_ACTION The yy_action[] code for syntax error
166695 ** YY_ACCEPT_ACTION The yy_action[] code for accept
166696 ** YY_NO_ACTION The yy_action[] code for no-op
166764 ** to a macro that can assist in verifying code coverage. For production
166765 ** code the yytestcase() macro should be turned off. But it is useful
167660 YYCODETYPE major; /* The major token value. This is the code
168559 ** or nonterminal. "yymajor" is the symbol code, and "yypminor" is
168560 ** a pointer to the value to be deleted. The code used to do the
168566 YYCODETYPE yymajor, /* Type code for object to destroy */
168580 ** inside the C code.
168888 /* Here code is inserted which will execute if the parser
168890 /******** Begin %stack_overflow code ******************************************/
168893 /******** End %stack_overflow code ********************************************/
169814 ** { ... } // User supplied code
171359 ** The following code executes when the parse fails
171373 /* Here code is inserted which will be executed whenever the
171375 /************ Begin %parse_failure code ***************************************/
171376 /************ End %parse_failure code *****************************************/
171383 ** The following code executes when a syntax error first occurs.
171393 /************ Begin %syntax_error code ****************************************/
171401 /************ End %syntax_error code ******************************************/
171423 /* Here code is inserted which will be executed whenever the
171425 /*********** Begin %parse_accept code *****************************************/
171426 /*********** End %parse_accept code *******************************************/
171452 int yymajor, /* The major token code number */
171682 ** The author disclaims copyright to this source code. In place of
171692 ** This file contains C code that splits an SQL input string up into
171817 ** it is a keyword. If it is a keyword, the token code of that keyword is
171828 /***** This file contains automatically generated code ******
171830 ** The code in this file has been automatically generated by
171834 ** The code in this file implements a function that determines whether
171837 ** But by using this automatically generated code, the size of the code
171955 /* aKWCode[i] is the parser symbol code for the i-th keyword */
172118 ** parser symbol code for that keyword into *pType. Always
172870 ** structure built up in pParse->pNewTable. The calling code (see vtab.c)
173024 ** The author disclaims copyright to this source code. In place of
173034 ** This file contains C code that implements the sqlite3_complete() API.
173035 ** This code used to be part of the tokenizer.c source file. But by
173036 ** separating it out, the code will be automatically omitted from
173317 ** The author disclaims copyright to this source code. In place of
173338 ** The author disclaims copyright to this source code. In place of
173371 ** The author disclaims copyright to this source code. In place of
173408 ** The author disclaims copyright to this source code. In place of
173531 ** zero if and only if SQLite was compiled with mutexing code omitted due to
173609 int rc; /* Result code */
173743 ** been compiled correctly. It is important to run this code, but
173749 /* This section of code's only "output" is via assert() statements. */
174783 /* Tell the code in notify.c that the connection no longer holds any
174902 ** Return a static string containing the name corresponding to the error code
175239 ** that it is designed to be called by internal code. The difference is
175240 ** that if a malloc() fails in sqlite3_create_function(), an error code
175859 int rc; /* Return code */
175926 ** an error occurs while running the checkpoint, an SQLite error code is
175941 int rc = SQLITE_OK; /* Return code */
176087 ** Return the most recent error code generated by an SQLite routine. If NULL is
176332 ** If an error occurs, then an SQLite error code is returned and *pzErrMsg
176634 int rc; /* Return code */
176668 ** dealt with in the previous code block. Besides these, the only
176724 ** the temporary files used to do external sorts (see code in vdbesort.c)
177189 ** 2. Invoke sqlite3_log() to provide the source code location where
177729 ** testing causes certain assert() statements in the code to be activated
177836 ** return code SQLITE_ERROR.
177935 ** checked-in code.
178371 ** The author disclaims copyright to this source code. In place of
178640 ** code to the caller is insufficient, as even if an error code
178706 ** The author disclaims copyright to this source code. In place of
178719 ** The code in this file is only compiled if:
178998 ** The author disclaims copyright to this source code. In place of
179044 ** The author disclaims copyright to this source code.
179111 ** code. If SQLITE_OK is returned, then *ppTokenizer should be set
179149 ** the end of the buffer has been reached, or an SQLite error code.
179210 ** The author disclaims copyright to this source code. In place of
179232 ** code should not attempt to access or modify the fields of this structure
179466 ** other bits of code that are needed to support the arguments
179686 ** parsed (by code in fts3_expr.c). Below this point the variables are
179966 ** assert() conditions in the fts3 code are activated - conditions that are
180209 ** and then evaluate those statements. The success code is written
180215 int *pRc, /* Success code */
180239 int rc = SQLITE_OK; /* Return code */
180259 ** Otherwise, return an SQLite error code.
180271 ** Otherwise, if an error occurs, an SQLite error code is stored in *pRc
180277 int rc; /* Return code */
180330 int rc = SQLITE_OK; /* Return code */
180391 ** Otherwise, if an error occurs, an SQLite error code is stored in *pRc
180396 int rc; /* Return code */
180454 int *pRc, /* IN/OUT: Error code */
180664 ** array. If an error does occur, an SQLite error code is returned.
180734 ** If the table cannot be found, an error code is returned and the output
180747 int rc = SQLITE_OK; /* Return code */
180824 int rc = SQLITE_OK; /* Return code */
181451 ** it. If an error occurs, return an SQLite error code.
181536 int rc = SQLITE_OK; /* Return code */
181652 ** If an error occurs, an error code other than SQLITE_OK is returned.
181663 int rc = SQLITE_OK; /* Return code */
182210 ** Using this makes it easier to write code that can merge doclists that are
182227 ** If an error occurs, an SQLite error code is returned. The output values
182507 ** SQLite error code (SQLITE_NOMEM) if an error occurs.
182604 ** This function returns SQLITE_OK if successful, or an SQLite error code
182618 int rc = SQLITE_OK; /* Error code */
182711 ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
182730 ** an SQLite error code.
182735 ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
182746 int rc = SQLITE_NOMEM; /* Return code */
182811 int rc; /* Return code */
183208 ** to 0 or 1). Return SQLITE_OK if successful, or an SQLite error code
183425 int rc; /* Return code */
183780 /* An error has occurred. Delete the hash table and return the error code. */
183809 int *pRc /* IN/OUT: Error code */
183908 ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
183945 ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
184061 ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
184065 int rc = SQLITE_OK; /* Error code */
184274 ** If an error occurs, return an SQLite error code. Otherwise, return
184326 ** If an error occurs, return an SQLite error code. Otherwise, return
184423 ** If an error occurs, return an SQLite error code. Otherwise, return
184467 ** code before returning.
184472 int *pRc /* IN/OUT: Error code */
184520 ** SQLite error code.
184528 int *pRc /* IN/OUT: Error code */
184568 ** an SQLite error code.
184634 ** called on each token to defer. Otherwise, an SQLite error code is
184645 int rc = SQLITE_OK; /* Return code */
184892 ** If an error occurs, *pRc is set to an SQLite error code. Otherwise, if
184929 int *pRc /* IN/OUT: Error code */
185148 ** the appropriate SQLite error code. In this case the returned value is
185154 int *pRc /* IN/OUT: Error code */
185333 ** SQLite error code before returning.
185418 ** populated. Otherwise, if an error occurs, an SQLite error code is returned.
185424 int rc = SQLITE_OK; /* Return code */
185764 ** The author disclaims copyright to this source code. In place of
186281 ** if successful or an error code if sqlite3_create_module() fails.
186310 int rc; /* Return code */
186323 ** The author disclaims copyright to this source code. In place of
186332 ** This module contains code that implements a parser for fts3 query strings
186708 ** Returns an SQLite error code. SQLITE_OK if everything works, SQLITE_NOMEM
186722 unsigned char eType; /* Keyword code */
187103 ** Otherwise, if an error occurs, an SQLite error code is returned and
187107 int rc = SQLITE_OK; /* Return code */
187424 ** Everything after this point is just test code.
187619 ** The author disclaims copyright to this source code. In place of
187633 ** The code in this file is only compiled if:
187767 ** For help in interpreted the obscure C code in the function definition,
188005 ** The author disclaims copyright to this source code. In place of
188018 ** The code in this file is only compiled if:
188670 ** The author disclaims copyright to this source code. In place of
188684 ** The code in this file is only compiled if:
189077 ** can be used as designed by the C-code in the queryTokenizer and
189193 ** The author disclaims copyright to this source code. In place of
189206 ** The code in this file is only compiled if:
189430 ** The author disclaims copyright to this source code. In place of
189439 ** This file contains code for the "fts3tokenize" virtual table module.
189531 ** in this case. Or, if an error occurs, an SQLite error code is returned.
189539 int rc = SQLITE_OK; /* Return code */
189740 int rc; /* Return code */
189847 ** if successful or an error code if sqlite3_create_module() fails.
189876 int rc; /* Return code */
189891 ** The author disclaims copyright to this source code. In place of
189901 ** this file contains code to insert, update and delete rows from FTS3
189902 ** tables. It also contains code to merge FTS3 b-tree segments. Some
189904 ** code in fts3.c.
189938 ** The code is written so that the hard lower-limit for each of these values
190010 ** this structure are only manipulated by code in this file, opaque handles
190011 ** of type Fts3SegReader* are also used by code in fts3.c to iterate through
190089 ** the leaf nodes). These functions and type are only ever used by code
190167 ** Otherwise, an SQLite error code is returned and *pp is set to 0.
190325 int rc; /* Return code */
190379 ** SQLite error code otherwise.
190382 int *pRC, /* Result code */
190471 ** return an SQLite error code.
190521 ** if successful, or an SQLite error code otherwise.
190580 int *pRc /* OUT: Return code */
190673 ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error code.
190847 int rc; /* Return code */
190917 int rc = SQLITE_OK; /* Return code */
190952 int *pRC, /* Result code */
191011 ** returned. Otherwise, an SQLite error code is returned.
191070 ** an SQLite error code is returned. Otherwise, SQLITE_OK is returned. If
191091 int rc; /* Return code */
191147 int rc; /* Return code */
191197 ** SQLITE_DONE. Otherwise, an SQLite error code.
191204 int rc; /* Return code of various sub-routines */
191398 /* The following line of code (and the "p++" below the while() loop) is
191832 ** set *pnMax to zero and return an SQLite error code.
192049 ** blocks were written to the db). Otherwise, an SQLite error code is
192119 ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error code.
192270 ** returned. Otherwise, an SQLite error code.
192278 int rc; /* Return code */
192325 ** error occurs, an SQLite error code is returned.
192352 ** Return SQLITE_OK if successful, or an SQLite error code if not.
192387 ** is returned. If an error occurs, an error code is returned and the
192422 int rc = SQLITE_OK; /* Return code */
192448 ** SQLITE_OK is returned if successful, otherwise an SQLite error code.
193104 ** an SQLite error code is returned.
193112 int rc; /* Return code */
193281 int *pRC, /* Result code */
193288 int rc; /* Result code from subfunctions */
193325 int *pRC, /* The result code */
193336 int rc; /* Result code from subfunctions */
193656 ** Return an error code if an error occurs (SQLITE_NOMEM is possible).
193666 int rc = SQLITE_OK; /* Return code */
193714 ** error code is returned.
193843 ** If an error (i.e. OOM condition) occurs, an SQLite error code is
193854 int rc = SQLITE_OK; /* Return code */
193895 ** Return SQLITE_OK if successful, or an SQLite error code otherwise.
193906 int rc = SQLITE_OK; /* Return code */
193980 ** flushing buffers to disk, *pRc is set to an SQLite error code before
193986 int *pRc /* IN/OUT: Error code */
193991 int rc = *pRc; /* Error code */
194097 ** error code. The final value of *pbRes is undefined in this case.
194106 int rc; /* Return code */
194142 int rc; /* Return code */
194152 int rc2; /* Return code from sqlite3_reset() */
194282 ** If an error occurs, return an SQLite error code. The final value of
194327 ** In the actual code below, the value "16" is replaced with the
194400 int rc; /* Return code */
194423 int rc; /* Return code */
194504 int rc = SQLITE_OK; /* Return code */
194550 ** SQLite error code otherwise.
194559 int rc = SQLITE_OK; /* Return code */
194569 int rc2; /* sqlite3_reset() return code */
194691 int rc; /* Return code */
194711 ** SQLite error code.
194747 ** set *pRc to an SQLite error code before returning.
194753 int *pRc /* IN/OUT: Error code */
194801 int rc; /* Return code */
195091 ** Otherwise, if an error occurs, *pRc is set to an SQLite error code. The
195098 int *pRc /* OUT: Return code */
195170 ** code. The final value of *pbOk is undefined in this case.
195173 int rc = SQLITE_OK; /* Return code */
195260 ** error code.
195263 ** prefix in the document set, a 64-bit checksum is calculated (by code
195277 ** The integrity-check code calculates the same checksum in two ways:
195381 int rc = SQLITE_OK; /* Return code */
195497 int rc = SQLITE_OK; /* Return code */
195708 ** The author disclaims copyright to this source code. In place of
195807 ** (nElem * sizeof(u32)) bytes in size. See the MatchinfoBuffer code below
195833 ** Start of MatchinfoBuffer code.
195920 ** End of MatchinfoBuffer code.
195959 int rc; /* Return code */
195981 ** the iteration is abandoned and the error code returned immediately.
196434 int rc; /* Return code */
196470 ** in the FTS code the variable that the third argument to xNext points to
196476 ** Extreme care is required when writing code to depend on this
196478 ** If a tokenizer is used directly by any code outside of FTS, this
196842 ** Otherwise, if an error occurs, an SQLite error code is returned and the
196930 ** Return SQLITE_OK if successful, or an SQLite error code if an error
197462 ** The author disclaims copyright to this source code. In place of
197862 ** The author disclaims copyright to this source code. In place of
198248 ** The author disclaims copyright to this source code. In place of
200950 ** The author disclaims copyright to this source code. In place of
200958 ** This file contains code for implementations of the r-tree and r*-tree
201722 ** field on the node is too large. If so, set the return code to
202150 int rc; /* Callback return code */
202720 ** to zero and return an SQLite error code.
203677 int rc2 = SQLITE_OK; /* sqlite3_reset() return code */
203999 int rc; /* Return code */
204584 ** code is returned and the value of *piVal after returning is not defined.
204605 ** Otherwise, an SQLite error code is returned.
204894 int rc; /* Return code */
204903 ** and RtreeCheck.rc==SQLITE_OK, set RtreeCheck.rc to the error code.
204916 ** NULL is returned and an error code left in RtreeCheck.rc.
204968 ** This function is a no-op if there is already an error code stored
204977 ** Or, if an error does occur, NULL is returned and an error code left
205347 /* Conditionally include the geopoly code */
205354 ** The author disclaims copyright to this source code. In place of
205418 #endif /* JSON NULL - back to original code */
205980 int *pRc /* Error code here */
207353 ** The author disclaims copyright to this source code. In place of
207409 UErrorCode e /* Error code returned by ICU function */
207437 ** code file utf8.c.
207821 int rc; /* Return code from sqlite3_create_collation_x() */
207911 ** The author disclaims copyright to this source code. In place of
208176 ** The author disclaims copyright to this source code. In place of
208267 ** The author disclaims copyright to this source code. In place of
208458 ** format used by the fossil source-code management system. In this case
208533 /* #include "sqlite3.h" ** Required for error code definitions ** */
208669 ** this function may return NULL. The error code and message may be collected
208682 ** the RBU update. If an error does occur, some other error code is
208699 ** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
208712 ** SQLite error code is returned. Additionally, if pzErrmsg is not NULL,
208800 ** immediately return the SQLite error code associated with the error.
208824 ** success. If an error occurs, it should return an SQLite error code.
209286 ** are lifted from the fossil source code (http://fossil-scm.org). They
209474 ** End of code taken from fossil.
209534 ** an SQLite error code. Additionally, set output variable *pzErrmsg to
209575 ** Otherwise, if an error occurs, *ppStmt is set to NULL and an error code
209669 ** pointing to the next entry. Otherwise, an error code and message is
209671 ** error code is returned.
209785 ** pointing to the first entry. Otherwise, an error code and message is
209787 ** error code is returned.
209817 ** an error code is stored in the RBU handle passed as the first argument.
209821 ** stored error code. In this case it still calls sqlite3_free() on any
209845 ** If an error occurs, an error code and error message is stored in the
209871 ** error code in the rbu handle passed as the first argument. Or, if an
209874 ** error code.
209894 ** error code in the RBU handle passed as the first argument.
209943 ** rbu handle error code is not already set, set the error code and error
210130 ** Return SQLITE_OK if successful, or an SQLite error code otherwise. If
210131 ** an error does occur, an error code and error message are also left in
210500 int rc = p->rc; /* Error code */
210501 int rc2; /* sqlite3_finalize() return code */
210683 ** stored in the (p->nCol+1)'th column. Set the error code and error message
210704 ** string, an error code is left in the rbu handle passed as the first
210707 ** attempting the allocation or modifying the stored error code.
210758 ** string, an error code is left in the rbu handle passed as the first
210761 ** attempting the allocation or modifying the stored error code.
210906 ** occurs during the execution of this function, it sets the error code
211498 ** If an error occurs, leave an error code and message in the rbu handle
211576 ** error occurs, leave an error code and message in the RBU handle.
211956 ** successful, or an SQLite error code otherwise.
212010 ** If an error occurs, leave an error code and error message in the rbu
212090 ** If the rbu_control field contains an invalid value, an error code and
212228 ** If no error occurs, SQLITE_OK is returned. Otherwise, an error code
212229 ** and message is left in the RBU handle and a copy of the error code
212603 ** If an error occurs, an error code and error message are left in the
212637 ** leave an error code and error message in the rbu handle.
212941 ** error code, which is set to SQLITE_MISUSE.
212996 ** If the error code currently stored in the RBU handle is SQLITE_CONSTRAINT,
214188 ** The author disclaims copyright to this source code. In place of
214717 ** if successful, or an SQLite error code otherwise.
215091 ** The author disclaims copyright to this source code. In place of
215612 int rc; /* Iterator error code */
215905 ** floating point values (e.g. ARM7). This code probably should
216026 ** If an error occurs, an SQLite error code is returned and the final values
216377 int rc; /* Error code from preupdate_new/old */
216611 ** free any allocation made. An error code will be returned in this case.
216634 ** If an error occurs, an error code is stored in sqlite3_session.rc and
217552 ** Otherwise, if an error occurs, *pRc is set to an SQLite error code
217646 int *pRc /* IN/OUT: Error code */
217665 int *pRc /* IN/OUT: Error code */
217691 int *pRc /* IN/OUT: Error code */
217959 ** error code (e.g. SQLITE_NOMEM) otherwise.
218030 ** SQLite error code before returning.
218036 int *pRc /* IN/OUT: Error code */
218052 ** occurs, an SQLite error code is returned and both output variables set
218066 int rc; /* Return code */
218424 ** Return an SQLite error code if an error occurs, or SQLITE_OK otherwise.
218486 /* In theory this code could just pass SQLITE_TRANSIENT as the final
218489 ** error. Hence the code to create the copy externally. */
218518 ** If an error occurs, an SQLite error code (e.g. SQLITE_NOMEM) is returned.
218598 ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error code.
218641 ** the record in bytes. Otherwise, an SQLite error code is returned. The
218684 ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error code
218835 ** new.* to old.*, to accommodate the code that reads these arrays. */
218883 ** error code if an error occurs, or SQLITE_DONE if there are no further
219021 ** code is returned. Otherwise, SQLITE_OK.
219659 ** An SQLite error code is returned if an error occurs. Otherwise, SQLITE_OK.
219674 ** in the code below. */
219700 ** error occurs, the statement is reset and an SQLite error code is returned.
219716 int rc; /* Return code */
219743 ** Return SQLITE_OK if successful, or an SQLite error code otherwise.
220180 int rc = SQLITE_OK; /* Return code */
220470 int rc; /* Error code */
220782 ** error code. If an error occurs and xOutput is NULL, (*ppOut) and (*pnOut)
220837 int rc = SQLITE_OK; /* Return code */
220855 int rc; /* Return code */
220886 int rc; /* Return code */
220993 int *pRc /* IN/OUT: error code */
221101 ** If an error occurs, an SQLite error code is returned. If ppOut and
221259 int rc; /* Return code */
221357 ** The author disclaims copyright to this source code. In place of
221423 ** an OOM condition or IO error), an appropriate SQLite error code is
221437 ** an OOM condition or IO error), an appropriate SQLite error code is
221448 ** if an error occurs, an SQLite error code is returned and the final values
221461 ** an error code (i.e. SQLITE_NOMEM) if an error occurs.
221477 ** code (i.e. SQLITE_NOMEM) if an error occurs.
221506 ** Otherwise, the error code is propagated upwards.
221510 ** the callback, an SQLite error code is returned.
221534 ** the auxiliary data is set to NULL and an error code returned. If the
221562 ** through instances of phrase iPhrase, use the following code:
221742 ** may abandon the tokenization and return any error code other than
221933 ** The author disclaims copyright to this source code. In place of
222069 ** Interface to code in fts5_config.c. fts5_config.c contains contains code
222189 ** End of interface to code in fts5_config.c.
222193 ** Interface to code in fts5_buffer.c.
222282 ** End of interface to code in fts5_buffer.c.
222286 ** Interface to code in fts5_index.c. fts5_index.c contains contains code
222458 ** End of interface to code in fts5_index.c.
222462 ** Interface to code in fts5_varint.c.
222482 ** End of interface to code in fts5_varint.c.
222487 ** Interface to code in fts5_main.c.
222513 ** End of interface to code in fts5.c.
222517 ** Interface to code in fts5_hash.c.
222563 ** End of interface to code in fts5_hash.c.
222567 ** Interface to code in fts5_storage.c. fts5_storage.c contains contains
222568 ** code to access the data stored in the %_content and %_docsize tables.
222611 ** End of interface to code in fts5_storage.c.
222616 ** Interface to code in fts5_expr.c.
222684 ** C code in this module. The interfaces below this point are called by
222685 ** the parser code in fts5parse.y. */
222735 ** End of interface to code in fts5_expr.c.
222741 ** Interface to code in fts5_aux.c.
222746 ** End of interface to code in fts5_aux.c.
222750 ** Interface to code in fts5_tokenizer.c.
222759 ** End of interface to code in fts5_tokenizer.c.
222763 ** Interface to code in fts5_vocab.c.
222769 ** End of interface to code in fts5_vocab.c.
222774 ** Interface to automatically generated code in fts5_unicode2.c.
222783 ** End of interface to code in fts5_unicode2.c.
222809 ** The author disclaims copyright to this source code. In place of
222917 ** fts5YYERRORSYMBOL is the code number of the error symbol. If not
222925 ** fts5YY_ERROR_ACTION The fts5yy_action[] code for syntax error
222926 ** fts5YY_ACCEPT_ACTION The fts5yy_action[] code for accept
222927 ** fts5YY_NO_ACTION The fts5yy_action[] code for no-op
222980 ** to a macro that can assist in verifying code coverage. For production
222981 ** code the fts5yytestcase() macro should be turned off. But it is useful
223129 fts5YYCODETYPE major; /* The major token value. This is the code
223359 ** or nonterminal. "fts5yymajor" is the symbol code, and "fts5yypminor" is
223360 ** a pointer to the value to be deleted. The code used to do the
223366 fts5YYCODETYPE fts5yymajor, /* Type code for object to destroy */
223380 ** inside the C code.
223624 /* Here code is inserted which will execute if the parser
223626 /******** Begin %stack_overflow code ******************************************/
223629 /******** End %stack_overflow code ********************************************/
223796 ** { ... } // User supplied code
223967 ** The following code executes when the parse fails
223981 /* Here code is inserted which will be executed whenever the
223983 /************ Begin %parse_failure code ***************************************/
223984 /************ End %parse_failure code *****************************************/
223991 ** The following code executes when a syntax error first occurs.
224001 /************ Begin %syntax_error code ****************************************/
224007 /************ End %syntax_error code ******************************************/
224029 /* Here code is inserted which will be executed whenever the
224031 /*********** Begin %parse_accept code *****************************************/
224032 /*********** End %parse_accept code *******************************************/
224058 int fts5yymajor, /* The major token code number */
224286 ** The author disclaims copyright to this source code. In place of
224334 ** an SQLite error code if an error occurs, or SQLITE_OK otherwise.
224414 ** *pRc is set to an error code before returning.
224665 int rc = SQLITE_OK; /* Return code */
224848 int rc = SQLITE_OK; /* Return code */
224925 int rc; /* Error code */
224983 int rc = SQLITE_OK; /* Return code */
225001 ** The author disclaims copyright to this source code. In place of
225037 ** pBuf. If an OOM error occurs, set the error code in p.
225057 ** the error code in p. If an error has already occurred when this function
225150 ** the error code in p. If an error has already occurred when this function
225410 ** The author disclaims copyright to this source code. In place of
225636 ** an error occurs, an SQLite error code is returned and an error message
225802 ** code if an error occurs.
225825 int *pRc, /* IN/OUT: Error code */
225920 ** new Fts5Config object. If an error occurs, an SQLite error code is
225933 int rc = SQLITE_OK; /* Return code */
226074 ** an SQLite error code if an error occurs.
226115 ** This function returns SQLITE_OK if successful or an SQLite error code
226120 ** to be an SQLite error code and returned to the caller.
226376 ** The author disclaims copyright to this source code. In place of
226670 ** code.
226908 ** SQLITE_OK is returned if an error occurs, or an SQLite error code
226909 ** otherwise. It is not considered an error code if the current rowid is
227146 ** an error occurs, set *pRc to an error code. If either *pbEof or *pRc
227153 int *pRc, /* OUT: Error code */
227179 int *pRc /* OUT: Error code */
227260 ** If an error occurs, return an SQLite error code. Otherwise, return
227397 ** SQLITE_OK is returned if an error occurs, or an SQLite error code
227398 ** otherwise. It is not considered an error code if an iterator reaches
227468 ** Return SQLITE_OK if successful, or an SQLite error code if an error
227797 ** Return an SQLite error code if an error occurs, or SQLITE_OK otherwise.
227856 ** Return SQLITE_OK if successful, or an SQLite error code otherwise. It
227861 int rc; /* Return code */
227887 ** Return SQLITE_OK if successful, or an SQLite error code otherwise. It
228147 int rc; /* Tokenize return code */
228198 int rc = SQLITE_OK; /* Return code */
228329 ** If an OOM error occurs, store an error code in pParse and return NULL.
228640 ** OOM error), leave an error code in pParse and return NULL.
229115 ** unicode code point, 1 is returned. Otherwise 0.
229448 ** The author disclaims copyright to this source code. In place of
230009 ** The author disclaims copyright to this source code. In place of
230297 int rc; /* Current error code */
230572 ** If an OOM error is encountered, return NULL and set the error code in
230853 ** an error occurs, (*pRc) is set to an SQLite error code before returning.
230893 ** If an error occurs, *ppOut is set to NULL and an SQLite error code
231094 ** If an error occurs, NULL is returned and an error code left in the
231177 ** If an error occurs, leave an error code in the Fts5Index object. If an
231756 ** If an error occurs, Fts5Index.rc is set to an appropriate error code. If
232029 ** If an error occurs, Fts5Index.rc is set to an appropriate error code. It
232141 ** code is inlined. */
232288 Fts5Index *p, /* Leave any error code here */
232429 ** If an error occurs, Fts5Index.rc is set to an appropriate error code. If
232512 ** If an error occurs, Fts5Index.rc is set to an appropriate error code. If
232915 ** If an error occurs, an error code is left in Fts5Index.rc. It is not
233834 ** If an error occurs, an error code is left in Fts5Index.rc. If an error
233986 ** If an error occurs, set the Fts5Index.rc error code. If an error has
234498 ** If an error occurs, set the Fts5Index.rc error code. If an error has
234575 ** If an error occurs, set the Fts5Index.rc error code. If an error has
235407 ** Otherwise, set *pp to NULL and return an SQLite error code.
235529 int rc = SQLITE_OK; /* Return code */
235757 ** Return SQLITE_OK if successful, or an SQLite error code if an error
235761 int rc; /* Return code */
236228 ** error, or some other SQLite error code if another error (e.g. OOM)
236369 int *pRc, /* IN/OUT: error code */
236400 int *pRc, /* IN/OUT: error code */
236404 int rc; /* Return code */
236427 int *pRc, /* IN/OUT: error code */
236508 ** set to an SQLite error code before returning. The final state of buffer
236512 int *pRc, /* IN/OUT: Error code */
236554 int rc = SQLITE_OK; /* Return code */
236793 ** SQLite error code is returned instead.
236832 ** The author disclaims copyright to this source code. In place of
236850 ** assert() conditions in the fts5 code are activated - conditions that are
237195 int rc = SQLITE_OK; /* Return code */
237526 int rc; /* Return code */
237692 ** error code if an error occurred.
237882 int rc = SQLITE_OK; /* Return code */
238043 int rc = SQLITE_OK; /* Error code */
238278 ** Return SQLITE_OK if no error occurs, or an SQLite error code otherwise.
238339 ** error code if an error occurs.
238453 int rc = SQLITE_OK; /* Return code */
238737 ** SQLite error code otherwise.
239759 ** The author disclaims copyright to this source code. In place of
239806 ** Return SQLITE_OK if successful, or an SQLite error code if an error
239938 ** code otherwise.
239966 int *pRc, /* IN/OUT: Error code */
239996 ** SQLITE_OK if successful, or an SQLite error code otherwise.
240031 ** Otherwise, set *pp to NULL and return an SQLite error code.
240154 int rc; /* Return code */
240155 int rc2; /* sqlite3_reset() return code */
240243 ** Return SQLITE_OK if successful, or an SQLite error code if an error
240259 ** Return SQLITE_OK if successful, or an SQLite error code if an error
240494 int rc = SQLITE_OK; /* Return code */
240640 ** some other SQLite error code if an error occurs while attempting to
240645 int rc = SQLITE_OK; /* Return code */
240810 ** An SQLite error code is returned if an error occurs, or SQLITE_OK
240928 ** The author disclaims copyright to this source code. In place of
241280 int rc = SQLITE_OK; /* Return code */
242326 int rc = SQLITE_OK; /* Return code */
242344 ** The author disclaims copyright to this source code. In place of
243123 ** The author disclaims copyright to this source code. In place of
243468 ** The author disclaims copyright to this source code. In place of
243648 int rc = SQLITE_OK; /* Return code */
244266 ** The author disclaims copyright to this source code. In place of