Fossil with Commonmark: Changes On Branch fossil-2.3-with-older-SQLite

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Changes In Branch fossil-2.3-with-older-SQLite Excluding Merge-Ins

This is equivalent to a diff from 35f712d4d8 to 107cfe0204

2017-07-12
16:57		Be careful not to return a pointer to a webpage generator as a command-line command method. check-in: 38df2a4544 user: drh tags: trunk
11:03		merge trunk (without SQLite update to 3.20.0 beta, but WITH support for tab-completion in the SQL shell) Closed-Leaf check-in: 107cfe0204 user: jan.nijtmans tags: fossil-2.3-with-older-SQLite
03:02		Fix a typo on the security audit webpage. check-in: 35f712d4d8 user: drh tags: trunk
02:49		More documentation about what the --verbose flag does for "fossil info". check-in: 9167b2d64a user: drh tags: trunk
2017-07-06
15:32		Fix typo in auto.def Merge trunk check-in: 10c7e0fcea user: jan.nijtmans tags: fossil-2.3-with-older-SQLite

Changes to auto.def.

Changes to src/db.c.

Changes to src/sqlite3.c.

Changes to src/sqlite3.h.

Changes to www/changes.wiki.

1 2 3 4 5 6 7 8 9	1 2 3 4 5 6 7 8 9	- +	/* 2001~~-09-~~15 2001 September 15 The author disclaims copyright to this source code. In place of a legal notice, here is a blessing: May you do good and not evil. May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give.
︙
117 118 119 120 121 122 123 ~~124 125 126~~ 127 128 129 130 131 132 133	117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133	- - - + + +	string contains the date and time of the check-in (UTC) and a SHA1 or SHA3-256 hash of the entire source tree. See also: [sqlite3_libversion()], [sqlite3_libversion_number()], [sqlite3_sourceid()], [sqlite_version()] and [sqlite_source_id()]. / #define SQLITE_VERSION "3.~~20.0~~" #define SQLITE_VERSION_NUMBER 30~~20000~~ #define SQLITE_SOURCE_ID "2017-0~~7-11~~ 13:59:07 ~~95cd1d9f8baa~~6b~~e305c9a8bfa26fef2a403f2d5b3b5c9c55382ec04f0bc98d40~~" #define SQLITE_VERSION "3.19.3" #define SQLITE_VERSION_NUMBER 3019003 #define SQLITE_SOURCE_ID "2017-06-08 14:26:16 0ee482a1e0eae22e08edc8978c9733a96603d4509645f348ebf55b579e89636b" / CAPI3REF: Run-Time Library Version Numbers KEYWORDS: sqlite3_version sqlite3_sourceid These interfaces provide the same information as the [SQLITE_VERSION], ** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros
︙
231 232 233 234 235 236 237 ~~238~~ 239 240 241 242 243 244 245	231 232 233 234 235 236 237 238 239 240 241 242 243 244 245	- +	Each open SQLite database is represented by a pointer to an instance of the opaque structure named "sqlite3". It is useful to think of an sqlite3 pointer as an object. The [sqlite3_open()], [sqlite3_open16()], and [sqlite3_open_v2()] interfaces are its constructors, and [sqlite3_close()] and [sqlite3_close_v2()] are its destructors. There are many other interfaces (such as [sqlite3_prepare_v3()], [sqlite3_create_function()], and [sqlite3_prepare_v2()], [sqlite3_create_function()], and [sqlite3_busy_timeout()] to name but three) that are methods on an ** sqlite3 object. / typedef struct sqlite3 sqlite3; / ** CAPI3REF: 64-Bit Integer Types
︙
335 336 337 338 339 340 341 ~~342~~ 343 344 345 346 347 348 349	335 336 337 338 339 340 341 342 343 344 345 346 347 348 349	- +	typedef int (sqlite3_callback)(void,int,char, char); /* CAPI3REF: One-Step Query Execution Interface METHOD: sqlite3 The sqlite3_exec() interface is a convenience wrapper around [sqlite3_prepare_v3()], [sqlite3_step()], and [sqlite3_finalize()], [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()], that allows an application to run multiple statements of SQL without having to use a lot of C code. ^The sqlite3_exec() interface runs zero or more UTF-8 encoded, semicolon-separate SQL statements passed into its 2nd argument, in the context of the [database connection] passed in as its 1st ** argument. ^If the callback function of the 3rd argument to
︙
413 414 415 416 417 418 419 ~~420~~ 421 422 423 424 425 426 427 428 429 430 431 432 433 434 ~~435~~ 436 437 438 439 440 441 442 ~~443~~ 444 445 446 447 448 449 450	413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450	- + - + - +	New error codes may be added in future versions of SQLite. See also: [extended result code definitions] / #define SQLITE_OK 0 / Successful result / / beginning-of-error-codes / ~~#define SQLITE_ERROR 1 / ~~Generic~~ error /~~ #define SQLITE_ERROR 1 / SQL error or missing database / #define SQLITE_INTERNAL 2 / Internal logic error in SQLite / #define SQLITE_PERM 3 / Access permission denied / #define SQLITE_ABORT 4 / Callback routine requested an abort / #define SQLITE_BUSY 5 / The database file is locked / #define SQLITE_LOCKED 6 / A table in the database is locked / #define SQLITE_NOMEM 7 / A malloc() failed / #define SQLITE_READONLY 8 / Attempt to write a readonly database / #define SQLITE_INTERRUPT 9 / Operation terminated by sqlite3_interrupt()/ #define SQLITE_IOERR 10 / Some kind of disk I/O error occurred / #define SQLITE_CORRUPT 11 / The database disk image is malformed / #define SQLITE_NOTFOUND 12 / Unknown opcode in sqlite3_file_control() / #define SQLITE_FULL 13 / Insertion failed because database is full / #define SQLITE_CANTOPEN 14 / Unable to open the database file / #define SQLITE_PROTOCOL 15 / Database lock protocol error / ~~#define SQLITE_EMPTY 16 / ~~Not u~~sed /~~ #define SQLITE_EMPTY 16 / Database is empty / #define SQLITE_SCHEMA 17 / The database schema changed / #define SQLITE_TOOBIG 18 / String or BLOB exceeds size limit / #define SQLITE_CONSTRAINT 19 / Abort due to constraint violation / #define SQLITE_MISMATCH 20 / Data type mismatch / #define SQLITE_MISUSE 21 / Library used incorrectly / #define SQLITE_NOLFS 22 / Uses OS features not supported on host / #define SQLITE_AUTH 23 / Authorization denied / ~~#define SQLITE_FORMAT 24 / Not ~~used~~ /~~ #define SQLITE_FORMAT 24 / Auxiliary database format error / #define SQLITE_RANGE 25 / 2nd parameter to sqlite3_bind out of range / #define SQLITE_NOTADB 26 / File opened that is not a database file / #define SQLITE_NOTICE 27 / Notifications from sqlite3_log() / #define SQLITE_WARNING 28 / Warnings from sqlite3_log() / #define SQLITE_ROW 100 / sqlite3_step() has another row ready / #define SQLITE_DONE 101 / sqlite3_step() has finished executing / / end-of-error-codes */
︙
2003 2004 2005 2006 2007 2008 2009 ~~2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020~~ 2021 2022 2023 2024 2025 2026 2027 2028 2029 ~~2030~~ 2031 2032 2033 2034 2035 2036 2037	2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025	- - - - - - - - - - - -	override this behaviour. The first parameter passed to this operation is an integer - non-zero to disable checkpoints-on-close, or zero (the default) to enable them. The second parameter is a pointer to an integer into which is written 0 or 1 to indicate whether checkpoints-on-close have been disabled - 0 if they are not disabled, 1 if they are. </dd> <dt>SQLITE_DBCONFIG_ENABLE_QPSG</dt> <dd>The SQLITE_DBCONFIG_ENABLE_QPSG option activates or deactivates the [query planner stability guarantee] (QPSG). When the QPSG is active, a single SQL query statement will always use the same algorithm regardless of values of [bound parameters]. The QPSG disables some query optimizations that look at the values of bound parameters, which can make some queries slower. But the QPSG has the advantage of more predictable behavior. With the QPSG active, SQLite will always use the same query plan in the field as was used during testing in the lab. </dd> ** </dl> / #define SQLITE_DBCONFIG_MAINDBNAME 1000 / const char* / #define SQLITE_DBCONFIG_LOOKASIDE 1001 / void* int int / #define SQLITE_DBCONFIG_ENABLE_FKEY 1002 / int int* / #define SQLITE_DBCONFIG_ENABLE_TRIGGER 1003 / int int* / #define SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER 1004 / int int* / #define SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION 1005 / int int* / #define SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE 1006 / int int* / ~~#define SQLITE_DBCONFIG_ENABLE_QPSG 1007 / int int* /~~ / CAPI3REF: Enable Or Disable Extended Result Codes METHOD: sqlite3 ^The sqlite3_extended_result_codes() routine enables or disables the
︙
2687 2688 2689 2690 2691 2692 2693 ~~2694 2695~~ 2696 2697 2698 2699 2700 2701 2702 2703 ~~2704~~ 2705 2706 2707 2708 ~~2709~~ 2710 2711 2712 2713 2714 2715 2716	2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703	- - + - + - +	METHOD: sqlite3 KEYWORDS: {authorizer callback} ^This routine registers an authorizer callback with a particular [database connection], supplied in the first argument. ^The authorizer callback is invoked as SQL statements are being compiled by [sqlite3_prepare()] or its variants [sqlite3_prepare_v2()], [sqlite3_prepare_v3()], [sqlite3_prepare16()], [sqlite3_prepare16_v2()], and [sqlite3_prepare16_v3()]. ^At various [sqlite3_prepare16()] and [sqlite3_prepare16_v2()]. ^At various points during the compilation process, as logic is being created to perform various actions, the authorizer callback is invoked to see if those actions are allowed. ^The authorizer callback should return [SQLITE_OK] to allow the action, [SQLITE_IGNORE] to disallow the specific action but allow the SQL statement to continue to be compiled, or [SQLITE_DENY] to cause the entire SQL statement to be rejected with an error. ^If the authorizer callback returns any value other than [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY] then the [sqlite3_prepare_v3()] or equivalent call that triggered then the [sqlite3_prepare_v2()] or equivalent call that triggered the authorizer will fail with an error message. When the callback returns [SQLITE_OK], that means the operation requested is ok. ^When the callback returns [SQLITE_DENY], the [sqlite3_prepare_v3()] or equivalent call that triggered the [sqlite3_prepare_v2()] or equivalent call that triggered the authorizer will fail with an error message explaining that access is denied. ^The first parameter to the authorizer callback is a copy of the third parameter to the sqlite3_set_authorizer() interface. ^The second parameter to the callback is an integer [SQLITE_COPY \| action code] that specifies ** the particular action to be authorized. ^The third through sixth parameters
︙
2753 2754 2755 2756 2757 2758 2759 ~~2760~~ 2761 2762 ~~2763~~ 2764 2765 2766 2767 2768 2769 2770 2771 ~~2772~~ 2773 2774 2775 2776 2777 2778 2779	2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766	- + - + - +	^(Only a single authorizer can be in place on a database connection at a time. Each call to sqlite3_set_authorizer overrides the previous call.)^ ^Disable the authorizer by installing a NULL callback. The authorizer is disabled by default. The authorizer callback must not do anything that will modify the database connection that invoked the authorizer callback. Note that [sqlite3_prepare_v3()] and [sqlite3_step()] both modify their Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their database connections for the meaning of "modify" in this paragraph. ^When [sqlite3_prepare_v3()] is used to prepare a statement, the ^When [sqlite3_prepare_v2()] is used to prepare a statement, the statement might be re-prepared during [sqlite3_step()] due to a schema change. Hence, the application should ensure that the correct authorizer callback remains in place during the [sqlite3_step()]. ^Note that the authorizer callback is invoked only during [sqlite3_prepare()] or its variants. Authorization is not performed during statement evaluation in [sqlite3_step()], unless as stated in the previous paragraph, sqlite3_step() invokes sqlite3_prepare_v3() to reprepare a statement after a schema change. ** sqlite3_prepare_v2() to reprepare a statement after a schema change. / SQLITE_API int sqlite3_set_authorizer( sqlite3, int (xAuth)(void,int,const char,const char,const char,const char), void *pUserData );
︙
3001 3002 3003 3004 3005 3006 3007 ~~3008~~ 3009 3010 3011 3012 3013 3014 3015	2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002	- +	^If the progress callback returns non-zero, the operation is interrupted. This feature can be used to implement a "Cancel" button on a GUI progress dialog box. The progress handler callback must not do anything that will modify the database connection that invoked the progress handler. Note that [sqlite3_prepare_v3()] and [sqlite3_step()] both modify their Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their database connections for the meaning of "modify" in this paragraph. ** / SQLITE_API void sqlite3_progress_handler(sqlite3, int, int()(void), void); / ** CAPI3REF: Opening A New Database Connection
︙
3355 3356 3357 3358 3359 3360 3361 ~~3362~~ 3363 3364 3365 3366 3367 3368 3369	3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356	- +	original SQL text is source code. A prepared statement object is the compiled object code. All SQL must be converted into a prepared statement before it can be run. The life-cycle of a prepared statement object usually goes like this: <ol> <li> Create the prepared statement object using [sqlite3_prepare_v3()]. <li> Create the prepared statement object using [sqlite3_prepare_v2()]. <li> Bind values to [parameters] using the sqlite3_bind_() * interfaces. <li> Run the SQL by calling [sqlite3_step()] one or more times. <li> Reset the prepared statement using [sqlite3_reset()] then go back to step 2. Do this zero or more times. <li> Destroy the object using [sqlite3_finalize()]. ** </ol>
︙
3437 3438 3439 3440 3441 3442 3443 ~~3444~~ 3445 3446 3447 3448 3449 3450 3451	3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438	- +	<dd>The maximum depth of the parse tree on any expression.</dd>)^ [[SQLITE_LIMIT_COMPOUND_SELECT]] ^(<dt>SQLITE_LIMIT_COMPOUND_SELECT</dt> <dd>The maximum number of terms in a compound SELECT statement.</dd>)^ [[SQLITE_LIMIT_VDBE_OP]] ^(<dt>SQLITE_LIMIT_VDBE_OP</dt> <dd>The maximum number of instructions in a virtual machine program used to implement an SQL statement. If [sqlite3_prepare_v3()] or used to implement an SQL statement. If [sqlite3_prepare_v2()] or the equivalent tries to allocate space for more than this many opcodes in a single prepared statement, an SQLITE_NOMEM error is returned.</dd>)^ [[SQLITE_LIMIT_FUNCTION_ARG]] ^(<dt>SQLITE_LIMIT_FUNCTION_ARG</dt> <dd>The maximum number of arguments on a function.</dd>)^ [[SQLITE_LIMIT_ATTACHED]] ^(<dt>SQLITE_LIMIT_ATTACHED</dt>
︙
3477 3478 3479 3480 3481 3482 3483 ~~3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504~~ 3505 3506 3507 3508 3509 3510 3511 ~~3512 3513~~ ~~3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524~~ 3525 3526 3527 3528 3529 3530 ~~3531~~ ~~3532 3533 3534~~ 3535 3536 3537 3538 3539 3540 3541	3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495	- - - - - - - - - - - - - - - - - - - - - - - + + - - - - - - - - - - - - + - - - + +	#define SQLITE_LIMIT_FUNCTION_ARG 6 #define SQLITE_LIMIT_ATTACHED 7 #define SQLITE_LIMIT_LIKE_PATTERN_LENGTH 8 #define SQLITE_LIMIT_VARIABLE_NUMBER 9 #define SQLITE_LIMIT_TRIGGER_DEPTH 10 #define SQLITE_LIMIT_WORKER_THREADS 11 /* CAPI3REF: Prepare Flags These constants define various flags that can be passed into "prepFlags" parameter of the [sqlite3_prepare_v3()] and [sqlite3_prepare16_v3()] interfaces. New flags may be added in future releases of SQLite. <dl> [[SQLITE_PREPARE_PERSISTENT]] ^(<dt>SQLITE_PREPARE_PERSISTENT</dt> <dd>The SQLITE_PREPARE_PERSISTENT flag causes [sqlite3_prepare_v3()] and [sqlite3_prepare16_v3()] to optimize the resulting prepared statement to be retained for a relatively long amount of time.)^ ^Without this flag, [sqlite3_prepare_v3()] and [sqlite3_prepare16_v3()] assume that the prepared statement will be used just once or at most a few times and then destroyed using [sqlite3_finalize()] relatively soon. </dl> / ~~#define SQLITE_PREPARE_PERSISTENT 0x01~~ / CAPI3REF: Compiling An SQL Statement KEYWORDS: {SQL statement compiler} METHOD: sqlite3 CONSTRUCTOR: sqlite3_stmt To execute an SQL ~~statement~~, it must first be compiled into a byte-code program using one of these routines. ~~Or, in other words, these routines~~ To execute an SQL query, it must first be compiled into a byte-code program using one of these routines. are constructors for the [prepared statement] object. The preferred routine to use is [sqlite3_prepare_v2()]. The [sqlite3_prepare()] interface is legacy and should be avoided. [sqlite3_prepare_v3()] has an extra "prepFlags" option that is used for special purposes. The use of the UTF-8 interfaces is preferred, as SQLite currently does all parsing using UTF-8. The UTF-16 interfaces are provided as a convenience. The UTF-16 interfaces work by converting the input text into UTF-8, then invoking the corresponding UTF-8 interface. The first argument, "db", is a [database connection] obtained from a prior successful call to [sqlite3_open()], [sqlite3_open_v2()] or [sqlite3_open16()]. The database connection must not have been closed. The second argument, "zSql", is the statement to be compiled, encoded as either UTF-8 or UTF-16. The sqlite3_prepare(), sqlite3_prepare_v2(), as either UTF-8 or UTF-16. The sqlite3_prepare() and sqlite3_prepare_v2() and sqlite3_prepare_v3() interfaces use UTF-8, and sqlite3_prepare16(), sqlite3_prepare16_v2(), ~~and sqlite3_prepare16_v3()~~ use UTF-16. interfaces use UTF-8, and sqlite3_prepare16() and sqlite3_prepare16_v2() use UTF-16. ^If the nByte argument is negative, then zSql is read up to the first zero terminator. ^If nByte is positive, then it is the number of bytes read from zSql. ^If nByte is zero, then no prepared statement is generated. If the caller knows that the supplied string is nul-terminated, then there is a small performance advantage to passing an nByte parameter that
︙
3554 3555 3556 3557 3558 3559 3560 ~~3561 3562~~ ~~3563 3564 3565~~ 3566 3567 3568 3569 3570 3571 3572	3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525	- - + + - - - + +	The calling procedure is responsible for deleting the compiled SQL statement using [sqlite3_finalize()] after it has finished with it. ppStmt may not be NULL. ^On success, the sqlite3_prepare() family of routines return [SQLITE_OK]; otherwise an [error code] is returned. The sqlite3_prepare_v2()~~, sqlite3_prepare_v3(),~~ sqlite3_prepare16_v2(), ~~and sqlite3_prepare16_v3() interfaces are~~ recommended for all new programs. The sqlite3_prepare_v2() and sqlite3_prepare16_v2() interfaces are recommended for all new programs. The two older interfaces are retained The older interfaces (sqlite3_prepare() and sqlite3_prepare16()) ~~are retained~~ for backwards compatibility, but their use is discouraged. ^In the "vX" interfaces, the prepared statement for backwards compatibility, but their use is discouraged. ^In the "v2" interfaces, the prepared statement that is returned (the [sqlite3_stmt] object) contains a copy of the original SQL text. This causes the [sqlite3_step()] interface to behave differently in three ways: <ol> <li> ** ^If the database schema changes, instead of returning [SQLITE_SCHEMA] as it
︙
3591 3592 3593 3594 3595 3596 3597 ~~3598 3599 3600 3601 3602 3603~~ 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 ~~3618 3619 3620 3621 3622 3623 3624 3625~~ 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 ~~3642 3643 3644 3645 3646 3647 3648 3649~~ 3650 3651 3652 3653 3654 3655 3656 ~~3657 3658~~ 3659 3660 3661 3662 3663 3664 3665	3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595	- - - - - - - - - - - - - - - - - - - - - - - - +	a schema change, on the first [sqlite3_step()] call following any change to the [sqlite3_bind_text \| bindings] of that [parameter]. ^The specific value of WHERE-clause [parameter] might influence the choice of query plan if the parameter is the left-hand side of a [LIKE] or [GLOB] operator or if the parameter is compared to an indexed column and the [SQLITE_ENABLE_STAT3] compile-time option is enabled. </li> <p>^sqlite3_prepare_v3() differs from sqlite3_prepare_v2() only in having the extra prepFlags parameter, which is a bit array consisting of zero or ** more of the [SQLITE_PREPARE_PERSISTENT\|SQLITE_PREPARE_] flags. ^The * sqlite3_prepare_v2() interface works exactly the same as sqlite3_prepare_v3() with a zero prepFlags parameter. </ol> / SQLITE_API int sqlite3_prepare( sqlite3 db, /* Database handle / const char zSql, /* SQL statement, UTF-8 encoded / int nByte, / Maximum length of zSql in bytes. / sqlite3_stmt ppStmt, / OUT: Statement handle / const char pzTail / OUT: Pointer to unused portion of zSql / ); SQLITE_API int sqlite3_prepare_v2( sqlite3 db, /* Database handle / const char zSql, /* SQL statement, UTF-8 encoded / int nByte, / Maximum length of zSql in bytes. / sqlite3_stmt ppStmt, / OUT: Statement handle / ~~const char pzTail / OUT: Pointer to unused portion of zSql /~~ ); ~~SQLITE_API int sqlite3_prepare_v3(~~ ~~sqlite3 db, /* Database handle /~~ ~~const char zSql, /* SQL statement, UTF-8 encoded /~~ ~~int nByte, / Maximum length of zSql in bytes. /~~ ~~unsigned int prepFlags, / Zero or more SQLITE_PREPARE_ flags /~~ ~~sqlite3_stmt ppStmt, / OUT: Statement handle /~~ const char pzTail / OUT: Pointer to unused portion of zSql / ); SQLITE_API int sqlite3_prepare16( sqlite3 db, /* Database handle / const void zSql, /* SQL statement, UTF-16 encoded / int nByte, / Maximum length of zSql in bytes. / sqlite3_stmt ppStmt, / OUT: Statement handle / const void pzTail / OUT: Pointer to unused portion of zSql / ); SQLITE_API int sqlite3_prepare16_v2( sqlite3 db, /* Database handle / const void zSql, /* SQL statement, UTF-16 encoded / int nByte, / Maximum length of zSql in bytes. / sqlite3_stmt ppStmt, / OUT: Statement handle / const void pzTail / OUT: Pointer to unused portion of zSql / ); ~~SQLITE_API int sqlite3_prepare16_v3(~~ ~~sqlite3 db, /* Database handle /~~ ~~const void zSql, /* SQL statement, UTF-16 encoded /~~ ~~int nByte, / Maximum length of zSql in bytes. /~~ ~~unsigned int prepFalgs, / Zero or more SQLITE_PREPARE_ flags /~~ ~~sqlite3_stmt ppStmt, / OUT: Statement handle /~~ ~~const void pzTail / OUT: Pointer to unused portion of zSql /~~ ); / CAPI3REF: Retrieving Statement SQL METHOD: sqlite3_stmt ^The sqlite3_sql(P) interface returns a pointer to a copy of the UTF-8 SQL text used to create [prepared statement] P if P was created by [sqlite3_prepare_v2()], [sqlite3_prepare_v3()], [sqlite3_prepare16_v2()], or [sqlite3_prepare16_v3()]. created by either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()]. ^The sqlite3_expanded_sql(P) interface returns a pointer to a UTF-8 string containing the SQL text of prepared statement P with [bound parameters] expanded. ^(For example, if a prepared statement is created using the SQL text "SELECT $abc,:xyz" and if parameter $abc is bound to integer 2345 ** and parameter :xyz is unbound, then sqlite3_sql() will return
︙
3797 3798 3799 3800 3801 3802 3803 ~~3804~~ 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 ~~3823~~ 3824 3825 3826 3827 3828 3829 3830	3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760	- + - +	/* CAPI3REF: Binding Values To Prepared Statements KEYWORDS: {host parameter} {host parameters} {host parameter name} KEYWORDS: {SQL parameter} {SQL parameters} {parameter binding} METHOD: sqlite3_stmt ^(In the SQL statement text input to [sqlite3_prepare_v3()] and its variants, ^(In the SQL statement text input to [sqlite3_prepare_v2()] and its variants, literals may be replaced by a [parameter] that matches one of following templates: <ul> <li> ? <li> ?NNN <li> :VVV <li> @VVV <li> $VVV </ul> In the templates above, NNN represents an integer literal, and VVV represents an alphanumeric identifier.)^ ^The values of these parameters (also called "host parameter names" or "SQL parameters") can be set using the sqlite3_bind_() routines defined here. * ** ^The first argument to the sqlite3_bind_() routines is always * a pointer to the [sqlite3_stmt] object returned from [sqlite3_prepare_v3()] or its variants. [sqlite3_prepare_v2()] or its variants. ^The second argument is the index of the SQL parameter to be set. ^The leftmost SQL parameter has an index of 1. ^When the same named SQL parameter is used more than once, second and subsequent occurrences have the same index as the first occurrence. ^The index for named parameters can be looked up using the ** [sqlite3_bind_parameter_index()] API if desired. ^The index
︙
3953 3954 3955 3956 3957 3958 3959 ~~3960 3961~~ 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 ~~3978~~ ~~3979~~ 3980 3981 3982 3983 3984 3985 3986	3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915	- - + + - + -	and are referred to as "nameless" or "anonymous parameters". ^The first host parameter has an index of 1, not 0. ^If the value N is out of range or if the N-th parameter is nameless, then NULL is returned. ^The returned string is always in UTF-8 encoding even if the named parameter was originally specified as UTF-16 in [sqlite3_prepare16()], [sqlite3_prepare16_v2(~~)], or [sqlite3_prepare16_v3(~~)]. originally specified as UTF-16 in [sqlite3_prepare16()] or [sqlite3_prepare16_v2()]. See also: [sqlite3_bind_blob\|sqlite3_bind()], [sqlite3_bind_parameter_count()], and ** [sqlite3_bind_parameter_index()]. / SQLITE_API const char sqlite3_bind_parameter_name(sqlite3_stmt, int); / CAPI3REF: Index Of A Parameter With A Given Name METHOD: sqlite3_stmt ^Return the index of an SQL parameter given its name. ^The index value returned is suitable for use as the second parameter to [sqlite3_bind_blob\|sqlite3_bind()]. ^A zero is returned if no matching parameter is found. ^The parameter name must be given in UTF-8 even if the original statement was prepared from UTF-16 text using [sqlite3_prepare16_v2()] or was prepared from UTF-16 text using [sqlite3_prepare16_v2()]. [sqlite3_prepare16_v3()]. See also: [sqlite3_bind_blob\|sqlite3_bind()], [sqlite3_bind_parameter_count()], and ** [sqlite3_bind_parameter_name()]. / SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt, const char *zName);
︙
4126 4127 4128 4129 4130 4131 4132 ~~4133~~ ~~4134 4135~~ 4136 4137 4138 4139 ~~4140~~ ~~4141 4142 4143 4144~~ 4145 4146 4147 4148 4149 4150 4151	4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078	- + - - + - + - - - - + + +	SQLITE_API const char sqlite3_column_decltype(sqlite3_stmt,int); SQLITE_API const void sqlite3_column_decltype16(sqlite3_stmt,int); /* CAPI3REF: Evaluate An SQL Statement METHOD: sqlite3_stmt After a [prepared statement] has been prepared using ~~any of~~ After a [prepared statement] has been prepared using either [sqlite3_prepare_v2()], [sqlite3_prepare_v3()], [sqlite3_prepare16_v2()], or [sqlite3_prepare16_v3()] or one of the legacy [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] or one of the legacy interfaces [sqlite3_prepare()] or [sqlite3_prepare16()], this function must be called one or more times to evaluate the statement. The details of the behavior of the sqlite3_step() interface depend on whether the statement was prepared using the newer "vX" interfaces on whether the statement was prepared using the newer "v2" interface [sqlite3_prepare_v3()], [sqlite3_prepare_v2()], [sqlite3_prepare16_v3()], [sqlite3_prepare16_v2()] or the older legacy interfaces [sqlite3_prepare()] and [sqlite3_prepare16()]. The use of the new "vX" interface is recommended for new applications but the legacy [sqlite3_prepare_v2()] and [sqlite3_prepare16_v2()] or the older legacy interface [sqlite3_prepare()] and [sqlite3_prepare16()]. The use of the new "v2" interface is recommended for new applications but the legacy interface will continue to be supported. ^In the legacy interface, the return value will be either [SQLITE_BUSY], [SQLITE_DONE], [SQLITE_ROW], [SQLITE_ERROR], or [SQLITE_MISUSE]. ^With the "v2" interface, any of the other [result codes] or [extended result codes] might be returned as well.
︙
4198 4199 4200 4201 4202 4203 4204 ~~4205 4206~~ 4207 4208 ~~4209~~ 4210 4211 4212 4213 4214 4215 4216	4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142	- - + - +	<b>Goofy Interface Alert:</b> In the legacy interface, the sqlite3_step() API always returns a generic error code, [SQLITE_ERROR], following any error other than [SQLITE_BUSY] and [SQLITE_MISUSE]. You must call [sqlite3_reset()] or [sqlite3_finalize()] in order to find one of the specific [error codes] that better describes the error. We admit that this is a goofy design. The problem has been fixed with the "v2" interface. If you prepare all of your SQL statements using [sqlite3_prepare_v3()] or [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] or [sqlite3_prepare16_v3()] instead using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] instead of the legacy [sqlite3_prepare()] and [sqlite3_prepare16()] interfaces, then the more specific [error codes] are returned directly by sqlite3_step(). The use of the "vX" interfaces is recommended. by sqlite3_step(). The use of the "v2" interface is recommended. / SQLITE_API int sqlite3_step(sqlite3_stmt); /* CAPI3REF: Number of columns in a result set METHOD: sqlite3_stmt **
︙
4264 4265 4266 4267 4268 4269 4270 ~~4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292~~ 4293 4294 4295 ~~4296~~ 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 ~~4314 4315 4316 4317 4318 4319~~ 4320 4321 4322 ~~4323~~ ~~4324 4325 4326 4327 4328~~ ~~4329~~ 4330 4331 4332 ~~4333 4334 4335 4336~~ 4337 4338 4339 4340 4341 4342 4343	4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234	- - - - - - - - - - - - - - - - - - - - - - - + - - - - - - - + - - - - - + + + - - - - -	#define SQLITE3_TEXT 3 /* CAPI3REF: Result Values From A Query KEYWORDS: {column access functions} METHOD: sqlite3_stmt <b>Summary:</b> <blockquote><table border=0 cellpadding=0 cellspacing=0> <tr><td><b>sqlite3_column_blob</b><td>→<td>BLOB result <tr><td><b>sqlite3_column_double</b><td>→<td>REAL result <tr><td><b>sqlite3_column_int</b><td>→<td>32-bit INTEGER result <tr><td><b>sqlite3_column_int64</b><td>→<td>64-bit INTEGER result <tr><td><b>sqlite3_column_text</b><td>→<td>UTF-8 TEXT result <tr><td><b>sqlite3_column_text16</b><td>→<td>UTF-16 TEXT result <tr><td><b>sqlite3_column_value</b><td>→<td>The result as an [sqlite3_value\|unprotected sqlite3_value] object. <tr><td> <td> <td>  <tr><td><b>sqlite3_column_bytes</b><td>→<td>Size of a BLOB or a UTF-8 TEXT result in bytes <tr><td><b>sqlite3_column_bytes16  </b> <td>→  <td>Size of UTF-16 TEXT in bytes <tr><td><b>sqlite3_column_type</b><td>→<td>Default datatype of the result </table></blockquote> <b>Details:</b> ^These routines return information about a single column of the current result row of a query. ^In every case the first argument is a pointer ** to the [prepared statement] that is being evaluated (the [sqlite3_stmt] * that was returned from [sqlite3_prepare_v3()] or one of its variants) that was returned from [sqlite3_prepare_v2()] or one of its variants) and the second argument is the index of the column for which information should be returned. ^The leftmost column of the result set has the index 0. ^The number of columns in the result can be determined using [sqlite3_column_count()]. If the SQL statement does not currently point to a valid row, or if the column index is out of range, the result is undefined. These routines may only be called when the most recent call to [sqlite3_step()] has returned [SQLITE_ROW] and neither [sqlite3_reset()] nor [sqlite3_finalize()] have been called subsequently. If any of these routines are called after [sqlite3_reset()] or [sqlite3_finalize()] or after [sqlite3_step()] has returned something other than [SQLITE_ROW], the results are undefined. If [sqlite3_step()] or [sqlite3_reset()] or [sqlite3_finalize()] are called from a different thread while any of these routines are pending, then the results are undefined. The first six interfaces (_blob, _double, _int, _int64, _text, and _text16) each return the value of a result column in a specific data format. If the result column is not initially in the requested format (for example, if the query returns an integer but the sqlite3_column_text() interface is used to extract the value) then an automatic type conversion is performed. ^The sqlite3_column_type() routine returns the [SQLITE_INTEGER \| datatype code] for the initial data type of the result column. ^The returned value is one of [SQLITE_INTEGER], [SQLITE_FLOAT], [SQLITE_TEXT], [SQLITE_BLOB], or [SQLITE_NULL]. [SQLITE_FLOAT], [SQLITE_TEXT], [SQLITE_BLOB], or [SQLITE_NULL]. The value The return value of sqlite3_column_type() can be used to decide which of the first six interface should be used to extract the column value. ~~The value~~ returned by sqlite3_column_type() is only meaningful if no ~~automatic type~~ conversions have occurred for the v~~alue in quest~~ion. ~~After a type conversion,~~ the result ~~of calling~~ sqlite3_column_type() returned by sqlite3_column_type() is only meaningful if no type conversions have occurred as described below. After a type conversion, the value returned by sqlite3_column_type() is undefined. Future is undefined, though harmless. Future versions of SQLite may change the behavior of sqlite3_column_type() following a type conversion. ~~ If the result is a BLOB or a TEXT string, then the sqlite3_column_bytes() or sqlite3_column_bytes16() interfaces can be used to determine the size of that BLOB or string. ~~ ^If the result is a BLOB or UTF-8 string then the sqlite3_column_bytes() routine returns the number of bytes in that BLOB or string. ^If the result is a UTF-16 string, then sqlite3_column_bytes() converts the string to UTF-8 and then returns the number of bytes. ^If the result is a numeric value then sqlite3_column_bytes() uses [sqlite3_snprintf()] to convert that value to a UTF-8 string and returns the number of bytes in that string.
︙
4366 4367 4368 4369 4370 4371 4372 ~~4373 4374 4375 4376~~ 4377 ~~4378 4379~~ 4380 4381 4382 4383 4384 4385 4386	4257 4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273	- - - - - - + +	[unprotected sqlite3_value] object. In a multithreaded environment, an unprotected sqlite3_value object may only be used safely with [sqlite3_bind_value()] and [sqlite3_result_value()]. If the [unprotected sqlite3_value] object returned by [sqlite3_column_value()] is used in any other way, including calls to routines like [sqlite3_value_int()], [sqlite3_value_text()], or [sqlite3_value_bytes()], the behavior is not threadsafe. Hence, the sqlite3_column_value() interface is normally only useful within the implementation of [application-defined SQL functions] or [virtual tables], not within top-level application code. The ~~the~~se routines ~~may~~ attempt to convert the dat~~atyp~~e ~~of the result.~~ ~~^For~~ example, if the internal representation is FLOAT and a text result These routines attempt to convert the value where appropriate. ^For example, if the internal representation is FLOAT and a text result is requested, [sqlite3_snprintf()] is used internally to perform the conversion automatically. ^(The following table details the conversions that are applied: <blockquote> <table border="1"> ** <tr><th> Internal<br>Type <th> Requested<br>Type <th> Conversion
︙
4444 4445 4446 4447 4448 4449 4450 ~~4451~~ 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 ~~4467 4468 4469~~ 4470 4471 4472 4473 4474 4475 4476 4477	4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364	- + + + - - - +	to sqlite3_column_text() or sqlite3_column_blob() with calls to sqlite3_column_bytes16(), and do not mix calls to sqlite3_column_text16() with calls to sqlite3_column_bytes(). ^The pointers returned are valid until a type conversion occurs as described above, or until [sqlite3_step()] or [sqlite3_reset()] or [sqlite3_finalize()] is called. ^The memory space used to hold strings and BLOBs is freed automatically. Do ~~not~~ pass the pointers returned and BLOBs is freed automatically. Do <em>not</em> pass the pointers returned from [sqlite3_column_blob()], [sqlite3_column_text()], etc. into [sqlite3_free()]. ^(If a memory allocation error occurs during the evaluation of any of these routines, a default value is returned. The default value is either the integer 0, the floating point number 0.0, or a NULL pointer. Subsequent calls to [sqlite3_errcode()] will return ** [SQLITE_NOMEM].)^ / SQLITE_API const void sqlite3_column_blob(sqlite3_stmt, int iCol); SQLITE_API int sqlite3_column_bytes(sqlite3_stmt, int iCol); SQLITE_API int sqlite3_column_bytes16(sqlite3_stmt, int iCol); SQLITE_API double sqlite3_column_double(sqlite3_stmt, int iCol); SQLITE_API int sqlite3_column_int(sqlite3_stmt, int iCol); SQLITE_API sqlite3_int64 sqlite3_column_int64(sqlite3_stmt, int iCol); SQLITE_API const unsigned char sqlite3_column_text(sqlite3_stmt, int iCol); SQLITE_API const void sqlite3_column_text16(sqlite3_stmt, int iCol); ~~SQLITE_API sqlite3_value sqlite3_column_value(sqlite3_stmt, int iCol);~~ ~~SQLITE_API int sqlite3_column_bytes(sqlite3_stmt, int iCol);~~ ~~SQLITE_API int sqlite3_column_bytes16(sqlite3_stmt, int iCol);~~ SQLITE_API int sqlite3_column_type(sqlite3_stmt, int iCol); SQLITE_API sqlite3_value sqlite3_column_value(sqlite3_stmt, int iCol); / CAPI3REF: Destroy A Prepared Statement Object DESTRUCTOR: sqlite3_stmt ^The sqlite3_finalize() function is called to delete a [prepared statement]. ** ^If the most recent evaluation of the statement encountered no errors
︙
4697 4698 4699 4700 4701 4702 4703 ~~4704 4705~~ ~~4706 4707 4708 4709 4710 4711 4712~~ ~~4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725~~ 4726 ~~4727 4728 4729 4730~~ ~~4731 4732~~ 4733 4734 4735 ~~4736~~ 4737 4738 4739 4740 4741 4742 4743 4744 4745 4746 ~~4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757~~ 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773 4774 4775 4776 4777 4778 4779 4780 4781 4782 ~~4783 4784~~ 4785 4786 4787 4788 4789 4790 4791	4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 4645 4646 4647 4648 4649	- - + + - - - - - - - + - - - - - - - - - - - - - - - - - + + + + + - - + + - + - - - - - - - - - - - + + - -	void,sqlite3_int64); #endif / CAPI3REF: Obtaining SQL Values METHOD: sqlite3_value ~~<b>~~Summar~~y:</b>~~ ~~<bl~~o~~ckquo~~te~~><tabl~~e ~~bord~~er=0 ce~~llpadding=0 cellspacing=0>~~ The C-language implementation of SQL functions and aggregates uses this set of interface routines to access the parameter values on <tr><td><b>sqlite3_value_blob</b><td>→<td>BLOB value <tr><td><b>sqlite3_value_double</b><td>→<td>REAL value <tr><td><b>sqlite3_value_int</b><td>→<td>32-bit INTEGER value <tr><td><b>sqlite3_value_int64</b><td>→<td>64-bit INTEGER value <tr><td><b>sqlite3_value_text</b><td>→<td>UTF-8 TEXT value <tr><td><b>sqlite3_value_text16</b><td>→<td>UTF-16 TEXT value in the nat~~ive byteorder~~ the function or aggregate. <tr><td><b>sqlite3_value_text16be</b><td>→<td>UTF-16be TEXT value <tr><td><b>sqlite3_value_text16le</b><td>→<td>UTF-16le TEXT value <tr><td> <td> <td>  <tr><td><b>sqlite3_value_bytes</b><td>→<td>Size of a BLOB or a UTF-8 TEXT in bytes <tr><td><b>sqlite3_value_bytes16  </b> <td>→  <td>Size of UTF-16 TEXT in bytes <tr><td><b>sqlite3_value_type</b><td>→<td>Default datatype of the value <tr><td><b>sqlite3_value_numeric_type  </b> <td>→  <td>Best numeric datatype of the value </table></blockquote> <b>Details:</b> This routine extract type, size, and content information from [protected sqlite3_value] objects. Pro~~tected~~ sqlite3_value objects The xFunc (for scalar functions) or xStep (for aggregates) parameters to [sqlite3_create_function()] and [sqlite3_create_function16()] define callbacks that implement the SQL functions and aggregates. The 3rd parameter to these callbacks is an array of pointers to [protected sqlite3_value] objects. There is one [sqlite3_value] object for are used to pass parameter information into implementation of [ap~~plic~~at~~ion-defined~~ SQL functions] a~~nd [virtual tables].~~ each parameter to the SQL function. These routines are used to extract values from the [sqlite3_value] objects. These routines work only with [protected sqlite3_value] objects. Any attempt to use these routines on an [unprotected sqlite3_value] is no~~t threadsafe~~. object results in undefined behavior. ^These routines work just like the corresponding [column access functions] except that these routines take a single [protected sqlite3_value] object ** pointer instead of a [sqlite3_stmt] pointer and an integer column number. * ^The sqlite3_value_text16() interface extracts a UTF-16 string in the native byte-order of the host machine. ^The sqlite3_value_text16be() and sqlite3_value_text16le() interfaces extract UTF-16 strings as big-endian and little-endian respectively. ^(The sqlite3_value_type(V) interface returns the [SQLITE_INTEGER \| datatype code] for the initial datatype of the [sqlite3_value] object V. The returned value is one of [SQLITE_INTEGER], [SQLITE_FLOAT], [SQLITE_TEXT], [SQLITE_BLOB], or [SQLITE_NULL].)^ Other interfaces might change the datatype for an sqlite3_value object. For example, if the datatype is initially SQLITE_INTEGER and sqlite3_value_text(V) is called to extract a text value for that integer, then subsequent calls to sqlite3_value_type(V) might return SQLITE_TEXT. Whether or not a persistent internal datatype conversion occurs is undefined and may change from one release of SQLite to the next. ^(The sqlite3_value_numeric_type() interface attempts to apply numeric affinity to the value. This means that an attempt is made to convert the value to an integer or floating point. If such a conversion is possible without loss of information (in other words, if the value is a string that looks like a number) then the conversion is performed. Otherwise no conversion occurs. The [SQLITE_INTEGER \| datatype] after conversion is returned.)^ Please pay particular attention to the fact that the pointer returned from [sqlite3_value_blob()], [sqlite3_value_text()], or [sqlite3_value_text16()] can be invalidated by a subsequent call to [sqlite3_value_bytes()], [sqlite3_value_bytes16()], [sqlite3_value_text()], or [sqlite3_value_text16()]. These routines must be called from the same thread as the SQL function that supplied the [sqlite3_value] parameters. / SQLITE_API const void sqlite3_value_blob(sqlite3_value); SQLITE_API int sqlite3_value_bytes(sqlite3_value); SQLITE_API int sqlite3_value_bytes16(sqlite3_value); SQLITE_API double sqlite3_value_double(sqlite3_value); SQLITE_API int sqlite3_value_int(sqlite3_value); SQLITE_API sqlite3_int64 sqlite3_value_int64(sqlite3_value); SQLITE_API const unsigned char sqlite3_value_text(sqlite3_value); SQLITE_API const void sqlite3_value_text16(sqlite3_value); SQLITE_API const void sqlite3_value_text16le(sqlite3_value); SQLITE_API const void sqlite3_value_text16be(sqlite3_value); ~~SQLITE_API int sqlite3_value_bytes(sqlite3_value);~~ ~~SQLITE_API int sqlite3_value_bytes16(sqlite3_value);~~ SQLITE_API int sqlite3_value_type(sqlite3_value); SQLITE_API int sqlite3_value_numeric_type(sqlite3_value); / CAPI3REF: Finding The Subtype Of SQL Values METHOD: sqlite3_value **
︙
5459 5460 5461 5462 5463 5464 5465 ~~5466~~ 5467 5468 5469 5470 5471 5472 5473	5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330 5331	- +	CAPI3REF: Find The Database Handle Of A Prepared Statement METHOD: sqlite3_stmt ^The sqlite3_db_handle interface returns the [database connection] handle to which a [prepared statement] belongs. ^The [database connection] returned by sqlite3_db_handle is the same [database connection] that was the first argument to the [sqlite3_prepare_v3()] call (or its variants) that was used to to the [sqlite3_prepare_v2()] call (or its variants) that was used to create the statement in the first place. / SQLITE_API sqlite3 sqlite3_db_handle(sqlite3_stmt); / CAPI3REF: Return The Filename For A Database Connection METHOD: sqlite3
︙
5535 5536 5537 5538 5539 5540 5541 ~~5542~~ 5543 5544 5545 5546 5547 5548 5549	5393 5394 5395 5396 5397 5398 5399 5400 5401 5402 5403 5404 5405 5406 5407	- +	The commit and rollback hook callbacks are not reentrant. The callback implementation must not do anything that will modify the database connection that invoked the callback. Any actions to modify the database connection must be deferred until after the completion of the [sqlite3_step()] call that triggered the commit or rollback hook in the first place. Note that running any other SQL statements, including SELECT statements, or merely calling [sqlite3_prepare_v3()] and [sqlite3_step()] will modify or merely calling [sqlite3_prepare_v2()] and [sqlite3_step()] will modify the database connections for the meaning of "modify" in this paragraph. ^Registering a NULL function disables the callback. ^When the commit hook callback routine returns zero, the [COMMIT] operation is allowed to continue normally. ^If the commit hook returns non-zero, then the [COMMIT] is converted into a [ROLLBACK].
︙
5595 5596 5597 5598 5599 5600 5601 ~~5602~~ 5603 5604 5605 5606 5607 5608 5609	5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465 5466 5467	- +	The exceptions defined in this paragraph might change in a future release of SQLite. The update hook implementation must not do anything that will modify the database connection that invoked the update hook. Any actions to modify the database connection must be deferred until after the completion of the [sqlite3_step()] call that triggered the update hook. Note that [sqlite3_prepare_v3()] and [sqlite3_step()] both modify their Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their database connections for the meaning of "modify" in this paragraph. ^The sqlite3_update_hook(D,C,P) function returns the P argument from the previous call on the same [database connection] D, or NULL for the first call on D.
︙
5758 5759 5760 5761 5762 5763 5764 ~~5765~~ ~~5766 5767~~ 5768 5769 5770 5771 5772 5773 5774	5616 5617 5618 5619 5620 5621 5622 5623 5624 5625 5626 5627 5628 5629 5630	- + - -	interface returns SQLITE_OK and fills in the non-NULL pointers in the final five arguments with appropriate values if the specified column exists. ^The sqlite3_table_column_metadata() interface returns SQLITE_ERROR and if the specified column does not exist. ^If the column-name parameter to sqlite3_table_column_metadata() is a NULL pointer, then this routine simply checks for the existence of the table and returns SQLITE_OK if the table exists and SQLITE_ERROR if it does not. ~~If the table name parameter T in a call to~~ does not. sqlite3_table_column_metadata(X,D,T,C,...) is NULL then the result is undefined behavior. ^The column is identified by the second, third and fourth parameters to this function. ^(The second parameter is either the name of the database (i.e. "main", "temp", or an attached database) containing the specified table or NULL.)^ ^If it is NULL, then all attached databases are searched for the table using the same algorithm used by the database engine to resolve unqualified table references.
︙
7273 7274 7275 7276 7277 7278 7279 ~~7280 7281 7282 7283 7284 7285 7286 7287 7288 7289 7290 7291 7292 7293 7294 7295 7296 7297~~ 7298 7299 7300 7301 7302 7303 7304 ~~7305 7306 7307~~ 7308 7309 7310 7311 7312 7313 7314	7129 7130 7131 7132 7133 7134 7135 7136 7137 7138 7139 7140 7141 7142 7143 7144 7145 7146 7147 7148 7149	- - - - - - - - - - - - - - - - - - - - -	[[SQLITE_STMTSTATUS_VM_STEP]] <dt>SQLITE_STMTSTATUS_VM_STEP</dt> <dd>^This is the number of virtual machine operations executed by the prepared statement if that number is less than or equal to 2147483647. The number of virtual machine operations can be used as a proxy for the total work done by the prepared statement. If the number of virtual machine operations exceeds 2147483647 then the value returned by this statement status code is undefined. [[SQLITE_STMTSTATUS_REPREPARE]] <dt>SQLITE_STMTSTATUS_REPREPARE</dt> <dd>^This is the number of times that the prepare statement has been automatically regenerated due to schema changes or change to [bound parameters] that might affect the query plan. [[SQLITE_STMTSTATUS_RUN]] <dt>SQLITE_STMTSTATUS_RUN</dt> <dd>^This is the number of times that the prepared statement has been run. A single "run" for the purposes of this counter is one or more calls to [sqlite3_step()] followed by a call to [sqlite3_reset()]. The counter is incremented on the first [sqlite3_step()] call of each cycle. [[SQLITE_STMTSTATUS_MEMUSED]] <dt>SQLITE_STMTSTATUS_MEMUSED</dt> <dd>^This is the approximate number of bytes of heap memory used to store the prepared statement. ^This value is not actually a counter, and so the resetFlg parameter to sqlite3_stmt_status() is ignored when the opcode is SQLITE_STMTSTATUS_MEMUSED. </dd> ** </dl> / #define SQLITE_STMTSTATUS_FULLSCAN_STEP 1 #define SQLITE_STMTSTATUS_SORT 2 #define SQLITE_STMTSTATUS_AUTOINDEX 3 #define SQLITE_STMTSTATUS_VM_STEP 4 ~~#define SQLITE_STMTSTATUS_REPREPARE 5~~ ~~#define SQLITE_STMTSTATUS_RUN 6~~ ~~#define SQLITE_STMTSTATUS_MEMUSED 99~~ / CAPI3REF: Custom Page Cache Object The sqlite3_pcache type is opaque. It is implemented by the pluggable module. The SQLite core has no knowledge of ** its size or internal structure and never deals with the
︙

1 2 3 4 5 6 7 8 9 10	1 2 3 4 5 6 7 8 9 10	- +	/**************************************************************************** This file is an amalgamation of many separate C source files from SQLite version 3.~~20.0~~. By combining all the individual C code files into this version 3.19.3. By combining all the individual C code files into this single large file, the entire code can be compiled as a single translation unit. This allows many compilers to do optimizations that would not be possible if the files were compiled separately. Performance improvements of 5% or more are commonly seen when SQLite is compiled as a single translation unit. ** This file is all you need to compile SQLite. To use SQLite in other
︙
18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783	18 19 20 21 22 23 24 25 26 27 28 29 30 31	- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -	** separate file. This file contains only code for the core SQLite library. / #define SQLITE_CORE 1 #define SQLITE_AMALGAMATION 1 #ifndef SQLITE_PRIVATE # define SQLITE_PRIVATE static #endif ~~/*********** Begin file ctime.c ****************************************/~~ / 2010 February 23 The author disclaims copyright to this source code. In place of a legal notice, here is a blessing: May you do good and not evil. May you find forgiveness for yourself and forgive others. May you share freely, never taking more than you give. ~~*********************************************************************~~ This file implements routines used to report what compile-time options SQLite was built with. / ~~#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS~~ / Include the configuration header output by 'configure' if we're using the autoconf-based build / ~~#if defined(_HAVE_SQLITE_CONFIG_H) && !defined(SQLITECONFIG_H)~~ ~~#include "config.h"~~ ~~#define SQLITECONFIG_H 1~~ ~~#endif~~ ~~/ These macros are provided to "stringify" the value of the define~~ ** for those options in which the value is meaningful. / ~~#define CTIMEOPT_VAL_(opt) #opt~~ ~~#define CTIMEOPT_VAL(opt) CTIMEOPT_VAL_(opt)~~ / An array of names of all compile-time options. This array should be sorted A-Z. This array looks large, but in a typical installation actually uses only a handful of compile-time options, so most times this array is usually rather short and uses little memory space. / ~~static const char const sqlite3azCompileOpt[] = {~~ /* ** BEGIN CODE GENERATED BY tool/mkctime.tcl / ~~#if SQLITE_32BIT_ROWID~~ ~~"32BIT_ROWID",~~ ~~#endif~~ ~~#if SQLITE_4_BYTE_ALIGNED_MALLOC~~ ~~"4_BYTE_ALIGNED_MALLOC",~~ ~~#endif~~ ~~#if SQLITE_64BIT_STATS~~ ~~"64BIT_STATS",~~ ~~#endif~~ ~~#if SQLITE_ALLOW_COVERING_INDEX_SCAN~~ ~~"ALLOW_COVERING_INDEX_SCAN",~~ ~~#endif~~ ~~#if SQLITE_ALLOW_URI_AUTHORITY~~ ~~"ALLOW_URI_AUTHORITY",~~ ~~#endif~~ ~~#ifdef SQLITE_BITMASK_TYPE~~ ~~"BITMASK_TYPE=" CTIMEOPT_VAL(SQLITE_BITMASK_TYPE),~~ ~~#endif~~ ~~#if SQLITE_BUG_COMPATIBLE_20160819~~ ~~"BUG_COMPATIBLE_20160819",~~ ~~#endif~~ ~~#if SQLITE_CASE_SENSITIVE_LIKE~~ ~~"CASE_SENSITIVE_LIKE",~~ ~~#endif~~ ~~#if SQLITE_CHECK_PAGES~~ ~~"CHECK_PAGES",~~ ~~#endif~~ ~~#if defined(__clang__) && defined(__clang_major__)~~ ~~"COMPILER=clang-" CTIMEOPT_VAL(__clang_major__) "."~~ ~~CTIMEOPT_VAL(__clang_minor__) "."~~ ~~CTIMEOPT_VAL(__clang_patchlevel__),~~ ~~#elif defined(_MSC_VER)~~ ~~"COMPILER=msvc-" CTIMEOPT_VAL(_MSC_VER),~~ ~~#elif defined(__GNUC__) && defined(__VERSION__)~~ ~~"COMPILER=gcc-" __VERSION__,~~ ~~#endif~~ ~~#if SQLITE_COVERAGE_TEST~~ ~~"COVERAGE_TEST",~~ ~~#endif~~ ~~#if SQLITE_DEBUG~~ ~~"DEBUG",~~ ~~#endif~~ ~~#if SQLITE_DEFAULT_AUTOMATIC_INDEX~~ ~~"DEFAULT_AUTOMATIC_INDEX",~~ ~~#endif~~ ~~#if SQLITE_DEFAULT_AUTOVACUUM~~ ~~"DEFAULT_AUTOVACUUM",~~ ~~#endif~~ ~~#ifdef SQLITE_DEFAULT_CACHE_SIZE~~ ~~"DEFAULT_CACHE_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_CACHE_SIZE),~~ ~~#endif~~ ~~#if SQLITE_DEFAULT_CKPTFULLFSYNC~~ ~~"DEFAULT_CKPTFULLFSYNC",~~ ~~#endif~~ ~~#ifdef SQLITE_DEFAULT_FILE_FORMAT~~ ~~"DEFAULT_FILE_FORMAT=" CTIMEOPT_VAL(SQLITE_DEFAULT_FILE_FORMAT),~~ ~~#endif~~ ~~#ifdef SQLITE_DEFAULT_FILE_PERMISSIONS~~ ~~"DEFAULT_FILE_PERMISSIONS=" CTIMEOPT_VAL(SQLITE_DEFAULT_FILE_PERMISSIONS),~~ ~~#endif~~ ~~#if SQLITE_DEFAULT_FOREIGN_KEYS~~ ~~"DEFAULT_FOREIGN_KEYS",~~ ~~#endif~~ ~~#ifdef SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT~~ ~~"DEFAULT_JOURNAL_SIZE_LIMIT=" CTIMEOPT_VAL(SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT),~~ ~~#endif~~ ~~#ifdef SQLITE_DEFAULT_LOCKING_MODE~~ ~~"DEFAULT_LOCKING_MODE=" CTIMEOPT_VAL(SQLITE_DEFAULT_LOCKING_MODE),~~ ~~#endif~~ ~~#ifdef SQLITE_DEFAULT_LOOKASIDE~~ ~~"DEFAULT_LOOKASIDE=" CTIMEOPT_VAL(SQLITE_DEFAULT_LOOKASIDE),~~ ~~#endif~~ ~~#if SQLITE_DEFAULT_MEMSTATUS~~ ~~"DEFAULT_MEMSTATUS",~~ ~~#endif~~ ~~#ifdef SQLITE_DEFAULT_MMAP_SIZE~~ ~~"DEFAULT_MMAP_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_MMAP_SIZE),~~ ~~#endif~~ ~~#ifdef SQLITE_DEFAULT_PAGE_SIZE~~ ~~"DEFAULT_PAGE_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_PAGE_SIZE),~~ ~~#endif~~ ~~#ifdef SQLITE_DEFAULT_PCACHE_INITSZ~~ ~~"DEFAULT_PCACHE_INITSZ=" CTIMEOPT_VAL(SQLITE_DEFAULT_PCACHE_INITSZ),~~ ~~#endif~~ ~~#ifdef SQLITE_DEFAULT_PROXYDIR_PERMISSIONS~~ ~~"DEFAULT_PROXYDIR_PERMISSIONS=" CTIMEOPT_VAL(SQLITE_DEFAULT_PROXYDIR_PERMISSIONS),~~ ~~#endif~~ ~~#if SQLITE_DEFAULT_RECURSIVE_TRIGGERS~~ ~~"DEFAULT_RECURSIVE_TRIGGERS",~~ ~~#endif~~ ~~#ifdef SQLITE_DEFAULT_ROWEST~~ ~~"DEFAULT_ROWEST=" CTIMEOPT_VAL(SQLITE_DEFAULT_ROWEST),~~ ~~#endif~~ ~~#ifdef SQLITE_DEFAULT_SECTOR_SIZE~~ ~~"DEFAULT_SECTOR_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_SECTOR_SIZE),~~ ~~#endif~~ ~~#ifdef SQLITE_DEFAULT_SYNCHRONOUS~~ ~~"DEFAULT_SYNCHRONOUS=" CTIMEOPT_VAL(SQLITE_DEFAULT_SYNCHRONOUS),~~ ~~#endif~~ ~~#ifdef SQLITE_DEFAULT_WAL_AUTOCHECKPOINT~~ ~~"DEFAULT_WAL_AUTOCHECKPOINT=" CTIMEOPT_VAL(SQLITE_DEFAULT_WAL_AUTOCHECKPOINT),~~ ~~#endif~~ ~~#ifdef SQLITE_DEFAULT_WAL_SYNCHRONOUS~~ ~~"DEFAULT_WAL_SYNCHRONOUS=" CTIMEOPT_VAL(SQLITE_DEFAULT_WAL_SYNCHRONOUS),~~ ~~#endif~~ ~~#ifdef SQLITE_DEFAULT_WORKER_THREADS~~ ~~"DEFAULT_WORKER_THREADS=" CTIMEOPT_VAL(SQLITE_DEFAULT_WORKER_THREADS),~~ ~~#endif~~ ~~#if SQLITE_DIRECT_OVERFLOW_READ~~ ~~"DIRECT_OVERFLOW_READ",~~ ~~#endif~~ ~~#if SQLITE_DISABLE_DIRSYNC~~ ~~"DISABLE_DIRSYNC",~~ ~~#endif~~ ~~#if SQLITE_DISABLE_FTS3_UNICODE~~ ~~"DISABLE_FTS3_UNICODE",~~ ~~#endif~~ ~~#if SQLITE_DISABLE_FTS4_DEFERRED~~ ~~"DISABLE_FTS4_DEFERRED",~~ ~~#endif~~ ~~#if SQLITE_DISABLE_INTRINSIC~~ ~~"DISABLE_INTRINSIC",~~ ~~#endif~~ ~~#if SQLITE_DISABLE_LFS~~ ~~"DISABLE_LFS",~~ ~~#endif~~ ~~#if SQLITE_DISABLE_PAGECACHE_OVERFLOW_STATS~~ ~~"DISABLE_PAGECACHE_OVERFLOW_STATS",~~ ~~#endif~~ ~~#if SQLITE_DISABLE_SKIPAHEAD_DISTINCT~~ ~~"DISABLE_SKIPAHEAD_DISTINCT",~~ ~~#endif~~ ~~#ifdef SQLITE_ENABLE_8_3_NAMES~~ ~~"ENABLE_8_3_NAMES=" CTIMEOPT_VAL(SQLITE_ENABLE_8_3_NAMES),~~ ~~#endif~~ ~~#if SQLITE_ENABLE_API_ARMOR~~ ~~"ENABLE_API_ARMOR",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_ATOMIC_WRITE~~ ~~"ENABLE_ATOMIC_WRITE",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_CEROD~~ ~~"ENABLE_CEROD",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_COLUMN_METADATA~~ ~~"ENABLE_COLUMN_METADATA",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_COLUMN_USED_MASK~~ ~~"ENABLE_COLUMN_USED_MASK",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_COSTMULT~~ ~~"ENABLE_COSTMULT",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_CURSOR_HINTS~~ ~~"ENABLE_CURSOR_HINTS",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_DBSTAT_VTAB~~ ~~"ENABLE_DBSTAT_VTAB",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_EXPENSIVE_ASSERT~~ ~~"ENABLE_EXPENSIVE_ASSERT",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_FTS1~~ ~~"ENABLE_FTS1",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_FTS2~~ ~~"ENABLE_FTS2",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_FTS3~~ ~~"ENABLE_FTS3",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_FTS3_PARENTHESIS~~ ~~"ENABLE_FTS3_PARENTHESIS",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_FTS3_TOKENIZER~~ ~~"ENABLE_FTS3_TOKENIZER",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_FTS4~~ ~~"ENABLE_FTS4",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_FTS5~~ ~~"ENABLE_FTS5",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_HIDDEN_COLUMNS~~ ~~"ENABLE_HIDDEN_COLUMNS",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_ICU~~ ~~"ENABLE_ICU",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_IOTRACE~~ ~~"ENABLE_IOTRACE",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_JSON1~~ ~~"ENABLE_JSON1",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_LOAD_EXTENSION~~ ~~"ENABLE_LOAD_EXTENSION",~~ ~~#endif~~ ~~#ifdef SQLITE_ENABLE_LOCKING_STYLE~~ ~~"ENABLE_LOCKING_STYLE=" CTIMEOPT_VAL(SQLITE_ENABLE_LOCKING_STYLE),~~ ~~#endif~~ ~~#if SQLITE_ENABLE_MEMORY_MANAGEMENT~~ ~~"ENABLE_MEMORY_MANAGEMENT",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_MEMSYS3~~ ~~"ENABLE_MEMSYS3",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_MEMSYS5~~ ~~"ENABLE_MEMSYS5",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_MULTIPLEX~~ ~~"ENABLE_MULTIPLEX",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_NULL_TRIM~~ ~~"ENABLE_NULL_TRIM",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_OVERSIZE_CELL_CHECK~~ ~~"ENABLE_OVERSIZE_CELL_CHECK",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_PREUPDATE_HOOK~~ ~~"ENABLE_PREUPDATE_HOOK",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_QPSG~~ ~~"ENABLE_QPSG",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_RBU~~ ~~"ENABLE_RBU",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_RTREE~~ ~~"ENABLE_RTREE",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_SELECTTRACE~~ ~~"ENABLE_SELECTTRACE",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_SESSION~~ ~~"ENABLE_SESSION",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_SNAPSHOT~~ ~~"ENABLE_SNAPSHOT",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_SQLLOG~~ ~~"ENABLE_SQLLOG",~~ ~~#endif~~ ~~#if defined(SQLITE_ENABLE_STAT4)~~ ~~"ENABLE_STAT4",~~ ~~#elif defined(SQLITE_ENABLE_STAT3)~~ ~~"ENABLE_STAT3",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_STMTVTAB~~ ~~"ENABLE_STMTVTAB",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_STMT_SCANSTATUS~~ ~~"ENABLE_STMT_SCANSTATUS",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION~~ ~~"ENABLE_UNKNOWN_SQL_FUNCTION",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_UNLOCK_NOTIFY~~ ~~"ENABLE_UNLOCK_NOTIFY",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_UPDATE_DELETE_LIMIT~~ ~~"ENABLE_UPDATE_DELETE_LIMIT",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_URI_00_ERROR~~ ~~"ENABLE_URI_00_ERROR",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_VFSTRACE~~ ~~"ENABLE_VFSTRACE",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_WHERETRACE~~ ~~"ENABLE_WHERETRACE",~~ ~~#endif~~ ~~#if SQLITE_ENABLE_ZIPVFS~~ ~~"ENABLE_ZIPVFS",~~ ~~#endif~~ ~~#if SQLITE_EXPLAIN_ESTIMATED_ROWS~~ ~~"EXPLAIN_ESTIMATED_ROWS",~~ ~~#endif~~ ~~#if SQLITE_EXTRA_IFNULLROW~~ ~~"EXTRA_IFNULLROW",~~ ~~#endif~~ ~~#ifdef SQLITE_EXTRA_INIT~~ ~~"EXTRA_INIT=" CTIMEOPT_VAL(SQLITE_EXTRA_INIT),~~ ~~#endif~~ ~~#ifdef SQLITE_EXTRA_SHUTDOWN~~ ~~"EXTRA_SHUTDOWN=" CTIMEOPT_VAL(SQLITE_EXTRA_SHUTDOWN),~~ ~~#endif~~ ~~#ifdef SQLITE_FTS3_MAX_EXPR_DEPTH~~ ~~"FTS3_MAX_EXPR_DEPTH=" CTIMEOPT_VAL(SQLITE_FTS3_MAX_EXPR_DEPTH),~~ ~~#endif~~ ~~#if SQLITE_FTS5_ENABLE_TEST_MI~~ ~~"FTS5_ENABLE_TEST_MI",~~ ~~#endif~~ ~~#if SQLITE_FTS5_NO_WITHOUT_ROWID~~ ~~"FTS5_NO_WITHOUT_ROWID",~~ ~~#endif~~ ~~#if SQLITE_HAS_CODEC~~ ~~"HAS_CODEC",~~ ~~#endif~~ ~~#if HAVE_ISNAN \|\| SQLITE_HAVE_ISNAN~~ ~~"HAVE_ISNAN",~~ ~~#endif~~ ~~#if SQLITE_HOMEGROWN_RECURSIVE_MUTEX~~ ~~"HOMEGROWN_RECURSIVE_MUTEX",~~ ~~#endif~~ ~~#if SQLITE_IGNORE_AFP_LOCK_ERRORS~~ ~~"IGNORE_AFP_LOCK_ERRORS",~~ ~~#endif~~ ~~#if SQLITE_IGNORE_FLOCK_LOCK_ERRORS~~ ~~"IGNORE_FLOCK_LOCK_ERRORS",~~ ~~#endif~~ ~~#if SQLITE_INLINE_MEMCPY~~ ~~"INLINE_MEMCPY",~~ ~~#endif~~ ~~#if SQLITE_INT64_TYPE~~ ~~"INT64_TYPE",~~ ~~#endif~~ ~~#ifdef SQLITE_INTEGRITY_CHECK_ERROR_MAX~~ ~~"INTEGRITY_CHECK_ERROR_MAX=" CTIMEOPT_VAL(SQLITE_INTEGRITY_CHECK_ERROR_MAX),~~ ~~#endif~~ ~~#if SQLITE_LIKE_DOESNT_MATCH_BLOBS~~ ~~"LIKE_DOESNT_MATCH_BLOBS",~~ ~~#endif~~ ~~#if SQLITE_LOCK_TRACE~~ ~~"LOCK_TRACE",~~ ~~#endif~~ ~~#if SQLITE_LOG_CACHE_SPILL~~ ~~"LOG_CACHE_SPILL",~~ ~~#endif~~ ~~#ifdef SQLITE_MALLOC_SOFT_LIMIT~~ ~~"MALLOC_SOFT_LIMIT=" CTIMEOPT_VAL(SQLITE_MALLOC_SOFT_LIMIT),~~ ~~#endif~~ ~~#ifdef SQLITE_MAX_ATTACHED~~ ~~"MAX_ATTACHED=" CTIMEOPT_VAL(SQLITE_MAX_ATTACHED),~~ ~~#endif~~ ~~#ifdef SQLITE_MAX_COLUMN~~ ~~"MAX_COLUMN=" CTIMEOPT_VAL(SQLITE_MAX_COLUMN),~~ ~~#endif~~ ~~#ifdef SQLITE_MAX_COMPOUND_SELECT~~ ~~"MAX_COMPOUND_SELECT=" CTIMEOPT_VAL(SQLITE_MAX_COMPOUND_SELECT),~~ ~~#endif~~ ~~#ifdef SQLITE_MAX_DEFAULT_PAGE_SIZE~~ ~~"MAX_DEFAULT_PAGE_SIZE=" CTIMEOPT_VAL(SQLITE_MAX_DEFAULT_PAGE_SIZE),~~ ~~#endif~~ ~~#ifdef SQLITE_MAX_EXPR_DEPTH~~ ~~"MAX_EXPR_DEPTH=" CTIMEOPT_VAL(SQLITE_MAX_EXPR_DEPTH),~~ ~~#endif~~ ~~#ifdef SQLITE_MAX_FUNCTION_ARG~~ ~~"MAX_FUNCTION_ARG=" CTIMEOPT_VAL(SQLITE_MAX_FUNCTION_ARG),~~ ~~#endif~~ ~~#ifdef SQLITE_MAX_LENGTH~~ ~~"MAX_LENGTH=" CTIMEOPT_VAL(SQLITE_MAX_LENGTH),~~ ~~#endif~~ ~~#ifdef SQLITE_MAX_LIKE_PATTERN_LENGTH~~ ~~"MAX_LIKE_PATTERN_LENGTH=" CTIMEOPT_VAL(SQLITE_MAX_LIKE_PATTERN_LENGTH),~~ ~~#endif~~ ~~#ifdef SQLITE_MAX_MEMORY~~ ~~"MAX_MEMORY=" CTIMEOPT_VAL(SQLITE_MAX_MEMORY),~~ ~~#endif~~ ~~#ifdef SQLITE_MAX_MMAP_SIZE~~ ~~"MAX_MMAP_SIZE=" CTIMEOPT_VAL(SQLITE_MAX_MMAP_SIZE),~~ ~~#endif~~ ~~#ifdef SQLITE_MAX_MMAP_SIZE_~~ ~~"MAX_MMAP_SIZE_=" CTIMEOPT_VAL(SQLITE_MAX_MMAP_SIZE_),~~ ~~#endif~~ ~~#ifdef SQLITE_MAX_PAGE_COUNT~~ ~~"MAX_PAGE_COUNT=" CTIMEOPT_VAL(SQLITE_MAX_PAGE_COUNT),~~ ~~#endif~~ ~~#ifdef SQLITE_MAX_PAGE_SIZE~~ ~~"MAX_PAGE_SIZE=" CTIMEOPT_VAL(SQLITE_MAX_PAGE_SIZE),~~ ~~#endif~~ ~~#ifdef SQLITE_MAX_SCHEMA_RETRY~~ ~~"MAX_SCHEMA_RETRY=" CTIMEOPT_VAL(SQLITE_MAX_SCHEMA_RETRY),~~ ~~#endif~~ ~~#ifdef SQLITE_MAX_SQL_LENGTH~~ ~~"MAX_SQL_LENGTH=" CTIMEOPT_VAL(SQLITE_MAX_SQL_LENGTH),~~ ~~#endif~~ ~~#ifdef SQLITE_MAX_TRIGGER_DEPTH~~ ~~"MAX_TRIGGER_DEPTH=" CTIMEOPT_VAL(SQLITE_MAX_TRIGGER_DEPTH),~~ ~~#endif~~ ~~#ifdef SQLITE_MAX_VARIABLE_NUMBER~~ ~~"MAX_VARIABLE_NUMBER=" CTIMEOPT_VAL(SQLITE_MAX_VARIABLE_NUMBER),~~ ~~#endif~~ ~~#ifdef SQLITE_MAX_VDBE_OP~~ ~~"MAX_VDBE_OP=" CTIMEOPT_VAL(SQLITE_MAX_VDBE_OP),~~ ~~#endif~~ ~~#ifdef SQLITE_MAX_WORKER_THREADS~~ ~~"MAX_WORKER_THREADS=" CTIMEOPT_VAL(SQLITE_MAX_WORKER_THREADS),~~ ~~#endif~~ ~~#if SQLITE_MEMDEBUG~~ ~~"MEMDEBUG",~~ ~~#endif~~ ~~#if SQLITE_MIXED_ENDIAN_64BIT_FLOAT~~ ~~"MIXED_ENDIAN_64BIT_FLOAT",~~ ~~#endif~~ ~~#if SQLITE_MMAP_READWRITE~~ ~~"MMAP_READWRITE",~~ ~~#endif~~ ~~#if SQLITE_MUTEX_NOOP~~ ~~"MUTEX_NOOP",~~ ~~#endif~~ ~~#if SQLITE_MUTEX_NREF~~ ~~"MUTEX_NREF",~~ ~~#endif~~ ~~#if SQLITE_MUTEX_OMIT~~ ~~"MUTEX_OMIT",~~ ~~#endif~~ ~~#if SQLITE_MUTEX_PTHREADS~~ ~~"MUTEX_PTHREADS",~~ ~~#endif~~ ~~#if SQLITE_MUTEX_W32~~ ~~"MUTEX_W32",~~ ~~#endif~~ ~~#if SQLITE_NEED_ERR_NAME~~ ~~"NEED_ERR_NAME",~~ ~~#endif~~ ~~#if SQLITE_NOINLINE~~ ~~"NOINLINE",~~ ~~#endif~~ ~~#if SQLITE_NO_SYNC~~ ~~"NO_SYNC",~~ ~~#endif~~ ~~#if SQLITE_OMIT_ALTERTABLE~~ ~~"OMIT_ALTERTABLE",~~ ~~#endif~~ ~~#if SQLITE_OMIT_ANALYZE~~ ~~"OMIT_ANALYZE",~~ ~~#endif~~ ~~#if SQLITE_OMIT_ATTACH~~ ~~"OMIT_ATTACH",~~ ~~#endif~~ ~~#if SQLITE_OMIT_AUTHORIZATION~~ ~~"OMIT_AUTHORIZATION",~~ ~~#endif~~ ~~#if SQLITE_OMIT_AUTOINCREMENT~~ ~~"OMIT_AUTOINCREMENT",~~ ~~#endif~~ ~~#if SQLITE_OMIT_AUTOINIT~~ ~~"OMIT_AUTOINIT",~~ ~~#endif~~ ~~#if SQLITE_OMIT_AUTOMATIC_INDEX~~ ~~"OMIT_AUTOMATIC_INDEX",~~ ~~#endif~~ ~~#if SQLITE_OMIT_AUTORESET~~ ~~"OMIT_AUTORESET",~~ ~~#endif~~ ~~#if SQLITE_OMIT_AUTOVACUUM~~ ~~"OMIT_AUTOVACUUM",~~ ~~#endif~~ ~~#if SQLITE_OMIT_BETWEEN_OPTIMIZATION~~ ~~"OMIT_BETWEEN_OPTIMIZATION",~~ ~~#endif~~ ~~#if SQLITE_OMIT_BLOB_LITERAL~~ ~~"OMIT_BLOB_LITERAL",~~ ~~#endif~~ ~~#if SQLITE_OMIT_BTREECOUNT~~ ~~"OMIT_BTREECOUNT",~~ ~~#endif~~ ~~#if SQLITE_OMIT_CAST~~ ~~"OMIT_CAST",~~ ~~#endif~~ ~~#if SQLITE_OMIT_CHECK~~ ~~"OMIT_CHECK",~~ ~~#endif~~ ~~#if SQLITE_OMIT_COMPLETE~~ ~~"OMIT_COMPLETE",~~ ~~#endif~~ ~~#if SQLITE_OMIT_COMPOUND_SELECT~~ ~~"OMIT_COMPOUND_SELECT",~~ ~~#endif~~ ~~#if SQLITE_OMIT_CONFLICT_CLAUSE~~ ~~"OMIT_CONFLICT_CLAUSE",~~ ~~#endif~~ ~~#if SQLITE_OMIT_CTE~~ ~~"OMIT_CTE",~~ ~~#endif~~ ~~#if SQLITE_OMIT_DATETIME_FUNCS~~ ~~"OMIT_DATETIME_FUNCS",~~ ~~#endif~~ ~~#if SQLITE_OMIT_DECLTYPE~~ ~~"OMIT_DECLTYPE",~~ ~~#endif~~ ~~#if SQLITE_OMIT_DEPRECATED~~ ~~"OMIT_DEPRECATED",~~ ~~#endif~~ ~~#if SQLITE_OMIT_DISKIO~~ ~~"OMIT_DISKIO",~~ ~~#endif~~ ~~#if SQLITE_OMIT_EXPLAIN~~ ~~"OMIT_EXPLAIN",~~ ~~#endif~~ ~~#if SQLITE_OMIT_FLAG_PRAGMAS~~ ~~"OMIT_FLAG_PRAGMAS",~~ ~~#endif~~ ~~#if SQLITE_OMIT_FLOATING_POINT~~ ~~"OMIT_FLOATING_POINT",~~ ~~#endif~~ ~~#if SQLITE_OMIT_FOREIGN_KEY~~ ~~"OMIT_FOREIGN_KEY",~~ ~~#endif~~ ~~#if SQLITE_OMIT_GET_TABLE~~ ~~"OMIT_GET_TABLE",~~ ~~#endif~~ ~~#if SQLITE_OMIT_HEX_INTEGER~~ ~~"OMIT_HEX_INTEGER",~~ ~~#endif~~ ~~#if SQLITE_OMIT_INCRBLOB~~ ~~"OMIT_INCRBLOB",~~ ~~#endif~~ ~~#if SQLITE_OMIT_INTEGRITY_CHECK~~ ~~"OMIT_INTEGRITY_CHECK",~~ ~~#endif~~ ~~#if SQLITE_OMIT_LIKE_OPTIMIZATION~~ ~~"OMIT_LIKE_OPTIMIZATION",~~ ~~#endif~~ ~~#if SQLITE_OMIT_LOAD_EXTENSION~~ ~~"OMIT_LOAD_EXTENSION",~~ ~~#endif~~ ~~#if SQLITE_OMIT_LOCALTIME~~ ~~"OMIT_LOCALTIME",~~ ~~#endif~~ ~~#if SQLITE_OMIT_LOOKASIDE~~ ~~"OMIT_LOOKASIDE",~~ ~~#endif~~ ~~#if SQLITE_OMIT_MEMORYDB~~ ~~"OMIT_MEMORYDB",~~ ~~#endif~~ ~~#if SQLITE_OMIT_OR_OPTIMIZATION~~ ~~"OMIT_OR_OPTIMIZATION",~~ ~~#endif~~ ~~#if SQLITE_OMIT_PAGER_PRAGMAS~~ ~~"OMIT_PAGER_PRAGMAS",~~ ~~#endif~~ ~~#if SQLITE_OMIT_PARSER_TRACE~~ ~~"OMIT_PARSER_TRACE",~~ ~~#endif~~ ~~#if SQLITE_OMIT_POPEN~~ ~~"OMIT_POPEN",~~ ~~#endif~~ ~~#if SQLITE_OMIT_PRAGMA~~ ~~"OMIT_PRAGMA",~~ ~~#endif~~ ~~#if SQLITE_OMIT_PROGRESS_CALLBACK~~ ~~"OMIT_PROGRESS_CALLBACK",~~ ~~#endif~~ ~~#if SQLITE_OMIT_QUICKBALANCE~~ ~~"OMIT_QUICKBALANCE",~~ ~~#endif~~ ~~#if SQLITE_OMIT_REINDEX~~ ~~"OMIT_REINDEX",~~ ~~#endif~~ ~~#if SQLITE_OMIT_SCHEMA_PRAGMAS~~ ~~"OMIT_SCHEMA_PRAGMAS",~~ ~~#endif~~ ~~#if SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS~~ ~~"OMIT_SCHEMA_VERSION_PRAGMAS",~~ ~~#endif~~ ~~#if SQLITE_OMIT_SHARED_CACHE~~ ~~"OMIT_SHARED_CACHE",~~ ~~#endif~~ ~~#if SQLITE_OMIT_SHUTDOWN_DIRECTORIES~~ ~~"OMIT_SHUTDOWN_DIRECTORIES",~~ ~~#endif~~ ~~#if SQLITE_OMIT_SUBQUERY~~ ~~"OMIT_SUBQUERY",~~ ~~#endif~~ ~~#if SQLITE_OMIT_TCL_VARIABLE~~ ~~"OMIT_TCL_VARIABLE",~~ ~~#endif~~ ~~#if SQLITE_OMIT_TEMPDB~~ ~~"OMIT_TEMPDB",~~ ~~#endif~~ ~~#if SQLITE_OMIT_TEST_CONTROL~~ ~~"OMIT_TEST_CONTROL",~~ ~~#endif~~ ~~#if SQLITE_OMIT_TRACE~~ ~~"OMIT_TRACE",~~ ~~#endif~~ ~~#if SQLITE_OMIT_TRIGGER~~ ~~"OMIT_TRIGGER",~~ ~~#endif~~ ~~#if SQLITE_OMIT_TRUNCATE_OPTIMIZATION~~ ~~"OMIT_TRUNCATE_OPTIMIZATION",~~ ~~#endif~~ ~~#if SQLITE_OMIT_UTF16~~ ~~"OMIT_UTF16",~~ ~~#endif~~ ~~#if SQLITE_OMIT_VACUUM~~ ~~"OMIT_VACUUM",~~ ~~#endif~~ ~~#if SQLITE_OMIT_VIEW~~ ~~"OMIT_VIEW",~~ ~~#endif~~ ~~#if SQLITE_OMIT_VIRTUALTABLE~~ ~~"OMIT_VIRTUALTABLE",~~ ~~#endif~~ ~~#if SQLITE_OMIT_WAL~~ ~~"OMIT_WAL",~~ ~~#endif~~ ~~#if SQLITE_OMIT_WSD~~ ~~"OMIT_WSD",~~ ~~#endif~~ ~~#if SQLITE_OMIT_XFER_OPT~~ ~~"OMIT_XFER_OPT",~~ ~~#endif~~ ~~#if SQLITE_PCACHE_SEPARATE_HEADER~~ ~~"PCACHE_SEPARATE_HEADER",~~ ~~#endif~~ ~~#if SQLITE_PERFORMANCE_TRACE~~ ~~"PERFORMANCE_TRACE",~~ ~~#endif~~ ~~#if SQLITE_POWERSAFE_OVERWRITE~~ ~~"POWERSAFE_OVERWRITE",~~ ~~#endif~~ ~~#if SQLITE_PREFER_PROXY_LOCKING~~ ~~"PREFER_PROXY_LOCKING",~~ ~~#endif~~ ~~#if SQLITE_PROXY_DEBUG~~ ~~"PROXY_DEBUG",~~ ~~#endif~~ ~~#if SQLITE_REVERSE_UNORDERED_SELECTS~~ ~~"REVERSE_UNORDERED_SELECTS",~~ ~~#endif~~ ~~#if SQLITE_RTREE_INT_ONLY~~ ~~"RTREE_INT_ONLY",~~ ~~#endif~~ ~~#if SQLITE_SECURE_DELETE~~ ~~"SECURE_DELETE",~~ ~~#endif~~ ~~#if SQLITE_SMALL_STACK~~ ~~"SMALL_STACK",~~ ~~#endif~~ ~~#ifdef SQLITE_SORTER_PMASZ~~ ~~"SORTER_PMASZ=" CTIMEOPT_VAL(SQLITE_SORTER_PMASZ),~~ ~~#endif~~ ~~#if SQLITE_SOUNDEX~~ ~~"SOUNDEX",~~ ~~#endif~~ ~~#ifdef SQLITE_STAT4_SAMPLES~~ ~~"STAT4_SAMPLES=" CTIMEOPT_VAL(SQLITE_STAT4_SAMPLES),~~ ~~#endif~~ ~~#ifdef SQLITE_STMTJRNL_SPILL~~ ~~"STMTJRNL_SPILL=" CTIMEOPT_VAL(SQLITE_STMTJRNL_SPILL),~~ ~~#endif~~ ~~#if SQLITE_SUBSTR_COMPATIBILITY~~ ~~"SUBSTR_COMPATIBILITY",~~ ~~#endif~~ ~~#if SQLITE_SYSTEM_MALLOC~~ ~~"SYSTEM_MALLOC",~~ ~~#endif~~ ~~#if SQLITE_TCL~~ ~~"TCL",~~ ~~#endif~~ ~~#ifdef SQLITE_TEMP_STORE~~ ~~"TEMP_STORE=" CTIMEOPT_VAL(SQLITE_TEMP_STORE),~~ ~~#endif~~ ~~#if SQLITE_TEST~~ ~~"TEST",~~ ~~#endif~~ ~~#if defined(SQLITE_THREADSAFE)~~ ~~"THREADSAFE=" CTIMEOPT_VAL(SQLITE_THREADSAFE),~~ ~~#elif defined(THREADSAFE)~~ ~~"THREADSAFE=" CTIMEOPT_VAL(THREADSAFE),~~ ~~#else~~ ~~"THREADSAFE=1",~~ ~~#endif~~ ~~#if SQLITE_UNLINK_AFTER_CLOSE~~ ~~"UNLINK_AFTER_CLOSE",~~ ~~#endif~~ ~~#if SQLITE_UNTESTABLE~~ ~~"UNTESTABLE",~~ ~~#endif~~ ~~#if SQLITE_USER_AUTHENTICATION~~ ~~"USER_AUTHENTICATION",~~ ~~#endif~~ ~~#if SQLITE_USE_ALLOCA~~ ~~"USE_ALLOCA",~~ ~~#endif~~ ~~#if SQLITE_USE_FCNTL_TRACE~~ ~~"USE_FCNTL_TRACE",~~ ~~#endif~~ ~~#if SQLITE_USE_URI~~ ~~"USE_URI",~~ ~~#endif~~ ~~#if SQLITE_VDBE_COVERAGE~~ ~~"VDBE_COVERAGE",~~ ~~#endif~~ ~~#if SQLITE_WIN32_MALLOC~~ ~~"WIN32_MALLOC",~~ ~~#endif~~ ~~#if SQLITE_ZERO_MALLOC~~ ~~"ZERO_MALLOC",~~ ~~#endif~~ / ** END CODE GENERATED BY tool/mkctime.tcl / }; ~~SQLITE_PRIVATE const char sqlite3CompileOptions(int pnOpt){~~ pnOpt = sizeof(sqlite3azCompileOpt) / sizeof(sqlite3azCompileOpt[0]); ~~return (const char)sqlite3azCompileOpt;~~ } ~~#endif / SQLITE_OMIT_COMPILEOPTION_DIAGS /~~ ~~/*********** End of ctime.c *******************************************/~~ /********** Begin file sqliteInt.h ************************************/ / 2001 September 15 The author disclaims copyright to this source code. In place of a legal notice, here is a blessing: **
︙
1024 1025 1026 1027 1028 1029 1030 ~~1031~~ 1032 1033 1034 1035 1036 1037 1038	272 273 274 275 276 277 278 279 280 281 282 283 284 285 286	- +	/* The public SQLite interface. The _FILE_OFFSET_BITS macro must appear first in QNX. Also, the _USE_32BIT_TIME_T macro must appear first for MinGW. / /*********** Include sqlite3.h in the middle of sqliteInt.h ***********/ /********** Begin file sqlite3.h **************************************/ / 2001~~-09-~~15 2001 September 15 The author disclaims copyright to this source code. In place of a legal notice, here is a blessing: May you do good and not evil. May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give.
︙
1146 1147 1148 1149 1150 1151 1152 ~~1153 1154 1155~~ 1156 1157 1158 1159 1160 1161 1162	394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410	- - - + + +	string contains the date and time of the check-in (UTC) and a SHA1 or SHA3-256 hash of the entire source tree. See also: [sqlite3_libversion()], [sqlite3_libversion_number()], [sqlite3_sourceid()], [sqlite_version()] and [sqlite_source_id()]. / #define SQLITE_VERSION "3.~~20.0~~" #define SQLITE_VERSION_NUMBER 30~~20000~~ #define SQLITE_SOURCE_ID "2017-0~~7-11~~ 13:59:07 ~~95cd1d9f8baa~~6b~~e305c9a8bfa26fef2a403f2d5b3b5c9c55382ec04f0bc98d40~~" #define SQLITE_VERSION "3.19.3" #define SQLITE_VERSION_NUMBER 3019003 #define SQLITE_SOURCE_ID "2017-06-08 14:26:16 0ee482a1e0eae22e08edc8978c9733a96603d4509645f348ebf55b579e89636b" / CAPI3REF: Run-Time Library Version Numbers KEYWORDS: sqlite3_version sqlite3_sourceid These interfaces provide the same information as the [SQLITE_VERSION], ** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros
︙
1260 1261 1262 1263 1264 1265 1266 ~~1267~~ 1268 1269 1270 1271 1272 1273 1274	508 509 510 511 512 513 514 515 516 517 518 519 520 521 522	- +	Each open SQLite database is represented by a pointer to an instance of the opaque structure named "sqlite3". It is useful to think of an sqlite3 pointer as an object. The [sqlite3_open()], [sqlite3_open16()], and [sqlite3_open_v2()] interfaces are its constructors, and [sqlite3_close()] and [sqlite3_close_v2()] are its destructors. There are many other interfaces (such as [sqlite3_prepare_v3()], [sqlite3_create_function()], and [sqlite3_prepare_v2()], [sqlite3_create_function()], and [sqlite3_busy_timeout()] to name but three) that are methods on an ** sqlite3 object. / typedef struct sqlite3 sqlite3; / ** CAPI3REF: 64-Bit Integer Types
︙
1364 1365 1366 1367 1368 1369 1370 ~~1371~~ 1372 1373 1374 1375 1376 1377 1378	612 613 614 615 616 617 618 619 620 621 622 623 624 625 626	- +	typedef int (sqlite3_callback)(void,int,char, char); /* CAPI3REF: One-Step Query Execution Interface METHOD: sqlite3 The sqlite3_exec() interface is a convenience wrapper around [sqlite3_prepare_v3()], [sqlite3_step()], and [sqlite3_finalize()], [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()], that allows an application to run multiple statements of SQL without having to use a lot of C code. ^The sqlite3_exec() interface runs zero or more UTF-8 encoded, semicolon-separate SQL statements passed into its 2nd argument, in the context of the [database connection] passed in as its 1st ** argument. ^If the callback function of the 3rd argument to
︙
1442 1443 1444 1445 1446 1447 1448 ~~1449~~ 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 ~~1464~~ 1465 1466 1467 1468 1469 1470 1471 ~~1472~~ 1473 1474 1475 1476 1477 1478 1479	690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727	- + - + - +	New error codes may be added in future versions of SQLite. See also: [extended result code definitions] / #define SQLITE_OK 0 / Successful result / / beginning-of-error-codes / ~~#define SQLITE_ERROR 1 / ~~Generic~~ error /~~ #define SQLITE_ERROR 1 / SQL error or missing database / #define SQLITE_INTERNAL 2 / Internal logic error in SQLite / #define SQLITE_PERM 3 / Access permission denied / #define SQLITE_ABORT 4 / Callback routine requested an abort / #define SQLITE_BUSY 5 / The database file is locked / #define SQLITE_LOCKED 6 / A table in the database is locked / #define SQLITE_NOMEM 7 / A malloc() failed / #define SQLITE_READONLY 8 / Attempt to write a readonly database / #define SQLITE_INTERRUPT 9 / Operation terminated by sqlite3_interrupt()/ #define SQLITE_IOERR 10 / Some kind of disk I/O error occurred / #define SQLITE_CORRUPT 11 / The database disk image is malformed / #define SQLITE_NOTFOUND 12 / Unknown opcode in sqlite3_file_control() / #define SQLITE_FULL 13 / Insertion failed because database is full / #define SQLITE_CANTOPEN 14 / Unable to open the database file / #define SQLITE_PROTOCOL 15 / Database lock protocol error / ~~#define SQLITE_EMPTY 16 / ~~Not u~~sed /~~ #define SQLITE_EMPTY 16 / Database is empty / #define SQLITE_SCHEMA 17 / The database schema changed / #define SQLITE_TOOBIG 18 / String or BLOB exceeds size limit / #define SQLITE_CONSTRAINT 19 / Abort due to constraint violation / #define SQLITE_MISMATCH 20 / Data type mismatch / #define SQLITE_MISUSE 21 / Library used incorrectly / #define SQLITE_NOLFS 22 / Uses OS features not supported on host / #define SQLITE_AUTH 23 / Authorization denied / ~~#define SQLITE_FORMAT 24 / Not ~~used~~ /~~ #define SQLITE_FORMAT 24 / Auxiliary database format error / #define SQLITE_RANGE 25 / 2nd parameter to sqlite3_bind out of range / #define SQLITE_NOTADB 26 / File opened that is not a database file / #define SQLITE_NOTICE 27 / Notifications from sqlite3_log() / #define SQLITE_WARNING 28 / Warnings from sqlite3_log() / #define SQLITE_ROW 100 / sqlite3_step() has another row ready / #define SQLITE_DONE 101 / sqlite3_step() has finished executing / / end-of-error-codes */
︙
3032 3033 3034 3035 3036 3037 3038 ~~3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049~~ 3050 3051 3052 3053 3054 3055 3056 3057 3058 ~~3059~~ 3060 3061 3062 3063 3064 3065 3066	2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302	- - - - - - - - - - - -	override this behaviour. The first parameter passed to this operation is an integer - non-zero to disable checkpoints-on-close, or zero (the default) to enable them. The second parameter is a pointer to an integer into which is written 0 or 1 to indicate whether checkpoints-on-close have been disabled - 0 if they are not disabled, 1 if they are. </dd> <dt>SQLITE_DBCONFIG_ENABLE_QPSG</dt> <dd>The SQLITE_DBCONFIG_ENABLE_QPSG option activates or deactivates the [query planner stability guarantee] (QPSG). When the QPSG is active, a single SQL query statement will always use the same algorithm regardless of values of [bound parameters]. The QPSG disables some query optimizations that look at the values of bound parameters, which can make some queries slower. But the QPSG has the advantage of more predictable behavior. With the QPSG active, SQLite will always use the same query plan in the field as was used during testing in the lab. </dd> ** </dl> / #define SQLITE_DBCONFIG_MAINDBNAME 1000 / const char* / #define SQLITE_DBCONFIG_LOOKASIDE 1001 / void* int int / #define SQLITE_DBCONFIG_ENABLE_FKEY 1002 / int int* / #define SQLITE_DBCONFIG_ENABLE_TRIGGER 1003 / int int* / #define SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER 1004 / int int* / #define SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION 1005 / int int* / #define SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE 1006 / int int* / ~~#define SQLITE_DBCONFIG_ENABLE_QPSG 1007 / int int* /~~ / CAPI3REF: Enable Or Disable Extended Result Codes METHOD: sqlite3 ^The sqlite3_extended_result_codes() routine enables or disables the
︙
3716 3717 3718 3719 3720 3721 3722 ~~3723 3724~~ 3725 3726 3727 3728 3729 3730 3731 3732 ~~3733~~ 3734 3735 3736 3737 ~~3738~~ 3739 3740 3741 3742 3743 3744 3745	2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980	- - + - + - +	METHOD: sqlite3 KEYWORDS: {authorizer callback} ^This routine registers an authorizer callback with a particular [database connection], supplied in the first argument. ^The authorizer callback is invoked as SQL statements are being compiled by [sqlite3_prepare()] or its variants [sqlite3_prepare_v2()], [sqlite3_prepare_v3()], [sqlite3_prepare16()], [sqlite3_prepare16_v2()], and [sqlite3_prepare16_v3()]. ^At various [sqlite3_prepare16()] and [sqlite3_prepare16_v2()]. ^At various points during the compilation process, as logic is being created to perform various actions, the authorizer callback is invoked to see if those actions are allowed. ^The authorizer callback should return [SQLITE_OK] to allow the action, [SQLITE_IGNORE] to disallow the specific action but allow the SQL statement to continue to be compiled, or [SQLITE_DENY] to cause the entire SQL statement to be rejected with an error. ^If the authorizer callback returns any value other than [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY] then the [sqlite3_prepare_v3()] or equivalent call that triggered then the [sqlite3_prepare_v2()] or equivalent call that triggered the authorizer will fail with an error message. When the callback returns [SQLITE_OK], that means the operation requested is ok. ^When the callback returns [SQLITE_DENY], the [sqlite3_prepare_v3()] or equivalent call that triggered the [sqlite3_prepare_v2()] or equivalent call that triggered the authorizer will fail with an error message explaining that access is denied. ^The first parameter to the authorizer callback is a copy of the third parameter to the sqlite3_set_authorizer() interface. ^The second parameter to the callback is an integer [SQLITE_COPY \| action code] that specifies ** the particular action to be authorized. ^The third through sixth parameters
︙
3782 3783 3784 3785 3786 3787 3788 ~~3789~~ 3790 3791 ~~3792~~ 3793 3794 3795 3796 3797 3798 3799 3800 ~~3801~~ 3802 3803 3804 3805 3806 3807 3808	3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043	- + - + - +	^(Only a single authorizer can be in place on a database connection at a time. Each call to sqlite3_set_authorizer overrides the previous call.)^ ^Disable the authorizer by installing a NULL callback. The authorizer is disabled by default. The authorizer callback must not do anything that will modify the database connection that invoked the authorizer callback. Note that [sqlite3_prepare_v3()] and [sqlite3_step()] both modify their Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their database connections for the meaning of "modify" in this paragraph. ^When [sqlite3_prepare_v3()] is used to prepare a statement, the ^When [sqlite3_prepare_v2()] is used to prepare a statement, the statement might be re-prepared during [sqlite3_step()] due to a schema change. Hence, the application should ensure that the correct authorizer callback remains in place during the [sqlite3_step()]. ^Note that the authorizer callback is invoked only during [sqlite3_prepare()] or its variants. Authorization is not performed during statement evaluation in [sqlite3_step()], unless as stated in the previous paragraph, sqlite3_step() invokes sqlite3_prepare_v3() to reprepare a statement after a schema change. ** sqlite3_prepare_v2() to reprepare a statement after a schema change. / SQLITE_API int sqlite3_set_authorizer( sqlite3, int (xAuth)(void,int,const char,const char,const char,const char), void *pUserData );
︙
4030 4031 4032 4033 4034 4035 4036 ~~4037~~ 4038 4039 4040 4041 4042 4043 4044	3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279	- +	^If the progress callback returns non-zero, the operation is interrupted. This feature can be used to implement a "Cancel" button on a GUI progress dialog box. The progress handler callback must not do anything that will modify the database connection that invoked the progress handler. Note that [sqlite3_prepare_v3()] and [sqlite3_step()] both modify their Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their database connections for the meaning of "modify" in this paragraph. ** / SQLITE_API void sqlite3_progress_handler(sqlite3, int, int()(void), void); / ** CAPI3REF: Opening A New Database Connection
︙
4384 4385 4386 4387 4388 4389 4390 ~~4391~~ 4392 4393 4394 4395 4396 4397 4398	3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633	- +	original SQL text is source code. A prepared statement object is the compiled object code. All SQL must be converted into a prepared statement before it can be run. The life-cycle of a prepared statement object usually goes like this: <ol> <li> Create the prepared statement object using [sqlite3_prepare_v3()]. <li> Create the prepared statement object using [sqlite3_prepare_v2()]. <li> Bind values to [parameters] using the sqlite3_bind_() * interfaces. <li> Run the SQL by calling [sqlite3_step()] one or more times. <li> Reset the prepared statement using [sqlite3_reset()] then go back to step 2. Do this zero or more times. <li> Destroy the object using [sqlite3_finalize()]. ** </ol>
︙
4466 4467 4468 4469 4470 4471 4472 ~~4473~~ 4474 4475 4476 4477 4478 4479 4480	3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715	- +	<dd>The maximum depth of the parse tree on any expression.</dd>)^ [[SQLITE_LIMIT_COMPOUND_SELECT]] ^(<dt>SQLITE_LIMIT_COMPOUND_SELECT</dt> <dd>The maximum number of terms in a compound SELECT statement.</dd>)^ [[SQLITE_LIMIT_VDBE_OP]] ^(<dt>SQLITE_LIMIT_VDBE_OP</dt> <dd>The maximum number of instructions in a virtual machine program used to implement an SQL statement. If [sqlite3_prepare_v3()] or used to implement an SQL statement. If [sqlite3_prepare_v2()] or the equivalent tries to allocate space for more than this many opcodes in a single prepared statement, an SQLITE_NOMEM error is returned.</dd>)^ [[SQLITE_LIMIT_FUNCTION_ARG]] ^(<dt>SQLITE_LIMIT_FUNCTION_ARG</dt> <dd>The maximum number of arguments on a function.</dd>)^ [[SQLITE_LIMIT_ATTACHED]] ^(<dt>SQLITE_LIMIT_ATTACHED</dt>
︙
4506 4507 4508 4509 4510 4511 4512 ~~4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524 4525 4526 4527 4528 4529 4530 4531 4532 4533~~ 4534 4535 4536 4537 4538 4539 4540 ~~4541 4542~~ ~~4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553~~ 4554 4555 4556 4557 4558 4559 ~~4560~~ ~~4561 4562 4563~~ 4564 4565 4566 4567 4568 4569 4570	3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772	- - - - - - - - - - - - - - - - - - - - - - - + + - - - - - - - - - - - - + - - - + +	#define SQLITE_LIMIT_FUNCTION_ARG 6 #define SQLITE_LIMIT_ATTACHED 7 #define SQLITE_LIMIT_LIKE_PATTERN_LENGTH 8 #define SQLITE_LIMIT_VARIABLE_NUMBER 9 #define SQLITE_LIMIT_TRIGGER_DEPTH 10 #define SQLITE_LIMIT_WORKER_THREADS 11 /* CAPI3REF: Prepare Flags These constants define various flags that can be passed into "prepFlags" parameter of the [sqlite3_prepare_v3()] and [sqlite3_prepare16_v3()] interfaces. New flags may be added in future releases of SQLite. <dl> [[SQLITE_PREPARE_PERSISTENT]] ^(<dt>SQLITE_PREPARE_PERSISTENT</dt> <dd>The SQLITE_PREPARE_PERSISTENT flag causes [sqlite3_prepare_v3()] and [sqlite3_prepare16_v3()] to optimize the resulting prepared statement to be retained for a relatively long amount of time.)^ ^Without this flag, [sqlite3_prepare_v3()] and [sqlite3_prepare16_v3()] assume that the prepared statement will be used just once or at most a few times and then destroyed using [sqlite3_finalize()] relatively soon. </dl> / ~~#define SQLITE_PREPARE_PERSISTENT 0x01~~ / CAPI3REF: Compiling An SQL Statement KEYWORDS: {SQL statement compiler} METHOD: sqlite3 CONSTRUCTOR: sqlite3_stmt To execute an SQL ~~statement~~, it must first be compiled into a byte-code program using one of these routines. ~~Or, in other words, these routines~~ To execute an SQL query, it must first be compiled into a byte-code program using one of these routines. are constructors for the [prepared statement] object. The preferred routine to use is [sqlite3_prepare_v2()]. The [sqlite3_prepare()] interface is legacy and should be avoided. [sqlite3_prepare_v3()] has an extra "prepFlags" option that is used for special purposes. The use of the UTF-8 interfaces is preferred, as SQLite currently does all parsing using UTF-8. The UTF-16 interfaces are provided as a convenience. The UTF-16 interfaces work by converting the input text into UTF-8, then invoking the corresponding UTF-8 interface. The first argument, "db", is a [database connection] obtained from a prior successful call to [sqlite3_open()], [sqlite3_open_v2()] or [sqlite3_open16()]. The database connection must not have been closed. The second argument, "zSql", is the statement to be compiled, encoded as either UTF-8 or UTF-16. The sqlite3_prepare(), sqlite3_prepare_v2(), as either UTF-8 or UTF-16. The sqlite3_prepare() and sqlite3_prepare_v2() and sqlite3_prepare_v3() interfaces use UTF-8, and sqlite3_prepare16(), sqlite3_prepare16_v2(), ~~and sqlite3_prepare16_v3()~~ use UTF-16. interfaces use UTF-8, and sqlite3_prepare16() and sqlite3_prepare16_v2() use UTF-16. ^If the nByte argument is negative, then zSql is read up to the first zero terminator. ^If nByte is positive, then it is the number of bytes read from zSql. ^If nByte is zero, then no prepared statement is generated. If the caller knows that the supplied string is nul-terminated, then there is a small performance advantage to passing an nByte parameter that
︙
4583 4584 4585 4586 4587 4588 4589 ~~4590 4591~~ ~~4592 4593 4594~~ 4595 4596 4597 4598 4599 4600 4601	3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802	- - + + - - - + +	The calling procedure is responsible for deleting the compiled SQL statement using [sqlite3_finalize()] after it has finished with it. ppStmt may not be NULL. ^On success, the sqlite3_prepare() family of routines return [SQLITE_OK]; otherwise an [error code] is returned. The sqlite3_prepare_v2()~~, sqlite3_prepare_v3(),~~ sqlite3_prepare16_v2(), ~~and sqlite3_prepare16_v3() interfaces are~~ recommended for all new programs. The sqlite3_prepare_v2() and sqlite3_prepare16_v2() interfaces are recommended for all new programs. The two older interfaces are retained The older interfaces (sqlite3_prepare() and sqlite3_prepare16()) ~~are retained~~ for backwards compatibility, but their use is discouraged. ^In the "vX" interfaces, the prepared statement for backwards compatibility, but their use is discouraged. ^In the "v2" interfaces, the prepared statement that is returned (the [sqlite3_stmt] object) contains a copy of the original SQL text. This causes the [sqlite3_step()] interface to behave differently in three ways: <ol> <li> ** ^If the database schema changes, instead of returning [SQLITE_SCHEMA] as it
︙
4620 4621 4622 4623 4624 4625 4626 ~~4627 4628 4629 4630 4631 4632~~ 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 4645 4646 ~~4647 4648 4649 4650 4651 4652 4653 4654~~ 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 ~~4671 4672 4673 4674 4675 4676 4677 4678~~ 4679 4680 4681 4682 4683 4684 4685 ~~4686 4687~~ 4688 4689 4690 4691 4692 4693 4694	3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872	- - - - - - - - - - - - - - - - - - - - - - - - +	a schema change, on the first [sqlite3_step()] call following any change to the [sqlite3_bind_text \| bindings] of that [parameter]. ^The specific value of WHERE-clause [parameter] might influence the choice of query plan if the parameter is the left-hand side of a [LIKE] or [GLOB] operator or if the parameter is compared to an indexed column and the [SQLITE_ENABLE_STAT3] compile-time option is enabled. </li> <p>^sqlite3_prepare_v3() differs from sqlite3_prepare_v2() only in having the extra prepFlags parameter, which is a bit array consisting of zero or ** more of the [SQLITE_PREPARE_PERSISTENT\|SQLITE_PREPARE_] flags. ^The * sqlite3_prepare_v2() interface works exactly the same as sqlite3_prepare_v3() with a zero prepFlags parameter. </ol> / SQLITE_API int sqlite3_prepare( sqlite3 db, /* Database handle / const char zSql, /* SQL statement, UTF-8 encoded / int nByte, / Maximum length of zSql in bytes. / sqlite3_stmt ppStmt, / OUT: Statement handle / const char pzTail / OUT: Pointer to unused portion of zSql / ); SQLITE_API int sqlite3_prepare_v2( sqlite3 db, /* Database handle / const char zSql, /* SQL statement, UTF-8 encoded / int nByte, / Maximum length of zSql in bytes. / sqlite3_stmt ppStmt, / OUT: Statement handle / ~~const char pzTail / OUT: Pointer to unused portion of zSql /~~ ); ~~SQLITE_API int sqlite3_prepare_v3(~~ ~~sqlite3 db, /* Database handle /~~ ~~const char zSql, /* SQL statement, UTF-8 encoded /~~ ~~int nByte, / Maximum length of zSql in bytes. /~~ ~~unsigned int prepFlags, / Zero or more SQLITE_PREPARE_ flags /~~ ~~sqlite3_stmt ppStmt, / OUT: Statement handle /~~ const char pzTail / OUT: Pointer to unused portion of zSql / ); SQLITE_API int sqlite3_prepare16( sqlite3 db, /* Database handle / const void zSql, /* SQL statement, UTF-16 encoded / int nByte, / Maximum length of zSql in bytes. / sqlite3_stmt ppStmt, / OUT: Statement handle / const void pzTail / OUT: Pointer to unused portion of zSql / ); SQLITE_API int sqlite3_prepare16_v2( sqlite3 db, /* Database handle / const void zSql, /* SQL statement, UTF-16 encoded / int nByte, / Maximum length of zSql in bytes. / sqlite3_stmt ppStmt, / OUT: Statement handle / const void pzTail / OUT: Pointer to unused portion of zSql / ); ~~SQLITE_API int sqlite3_prepare16_v3(~~ ~~sqlite3 db, /* Database handle /~~ ~~const void zSql, /* SQL statement, UTF-16 encoded /~~ ~~int nByte, / Maximum length of zSql in bytes. /~~ ~~unsigned int prepFalgs, / Zero or more SQLITE_PREPARE_ flags /~~ ~~sqlite3_stmt ppStmt, / OUT: Statement handle /~~ ~~const void pzTail / OUT: Pointer to unused portion of zSql /~~ ); / CAPI3REF: Retrieving Statement SQL METHOD: sqlite3_stmt ^The sqlite3_sql(P) interface returns a pointer to a copy of the UTF-8 SQL text used to create [prepared statement] P if P was created by [sqlite3_prepare_v2()], [sqlite3_prepare_v3()], [sqlite3_prepare16_v2()], or [sqlite3_prepare16_v3()]. created by either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()]. ^The sqlite3_expanded_sql(P) interface returns a pointer to a UTF-8 string containing the SQL text of prepared statement P with [bound parameters] expanded. ^(For example, if a prepared statement is created using the SQL text "SELECT $abc,:xyz" and if parameter $abc is bound to integer 2345 ** and parameter :xyz is unbound, then sqlite3_sql() will return
︙
4826 4827 4828 4829 4830 4831 4832 ~~4833~~ 4834 4835 4836 4837 4838 4839 4840 4841 4842 4843 4844 4845 4846 4847 4848 4849 4850 4851 ~~4852~~ 4853 4854 4855 4856 4857 4858 4859	4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037	- + - +	/* CAPI3REF: Binding Values To Prepared Statements KEYWORDS: {host parameter} {host parameters} {host parameter name} KEYWORDS: {SQL parameter} {SQL parameters} {parameter binding} METHOD: sqlite3_stmt ^(In the SQL statement text input to [sqlite3_prepare_v3()] and its variants, ^(In the SQL statement text input to [sqlite3_prepare_v2()] and its variants, literals may be replaced by a [parameter] that matches one of following templates: <ul> <li> ? <li> ?NNN <li> :VVV <li> @VVV <li> $VVV </ul> In the templates above, NNN represents an integer literal, and VVV represents an alphanumeric identifier.)^ ^The values of these parameters (also called "host parameter names" or "SQL parameters") can be set using the sqlite3_bind_() routines defined here. * ** ^The first argument to the sqlite3_bind_() routines is always * a pointer to the [sqlite3_stmt] object returned from [sqlite3_prepare_v3()] or its variants. [sqlite3_prepare_v2()] or its variants. ^The second argument is the index of the SQL parameter to be set. ^The leftmost SQL parameter has an index of 1. ^When the same named SQL parameter is used more than once, second and subsequent occurrences have the same index as the first occurrence. ^The index for named parameters can be looked up using the ** [sqlite3_bind_parameter_index()] API if desired. ^The index
︙
4982 4983 4984 4985 4986 4987 4988 ~~4989 4990~~ 4991 4992 4993 4994 4995 4996 4997 4998 4999 5000 5001 5002 5003 5004 5005 5006 ~~5007~~ ~~5008~~ 5009 5010 5011 5012 5013 5014 5015	4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192	- - + + - + -	and are referred to as "nameless" or "anonymous parameters". ^The first host parameter has an index of 1, not 0. ^If the value N is out of range or if the N-th parameter is nameless, then NULL is returned. ^The returned string is always in UTF-8 encoding even if the named parameter was originally specified as UTF-16 in [sqlite3_prepare16()], [sqlite3_prepare16_v2(~~)], or [sqlite3_prepare16_v3(~~)]. originally specified as UTF-16 in [sqlite3_prepare16()] or [sqlite3_prepare16_v2()]. See also: [sqlite3_bind_blob\|sqlite3_bind()], [sqlite3_bind_parameter_count()], and ** [sqlite3_bind_parameter_index()]. / SQLITE_API const char sqlite3_bind_parameter_name(sqlite3_stmt, int); / CAPI3REF: Index Of A Parameter With A Given Name METHOD: sqlite3_stmt ^Return the index of an SQL parameter given its name. ^The index value returned is suitable for use as the second parameter to [sqlite3_bind_blob\|sqlite3_bind()]. ^A zero is returned if no matching parameter is found. ^The parameter name must be given in UTF-8 even if the original statement was prepared from UTF-16 text using [sqlite3_prepare16_v2()] or was prepared from UTF-16 text using [sqlite3_prepare16_v2()]. [sqlite3_prepare16_v3()]. See also: [sqlite3_bind_blob\|sqlite3_bind()], [sqlite3_bind_parameter_count()], and ** [sqlite3_bind_parameter_name()]. / SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt, const char *zName);
︙
5155 5156 5157 5158 5159 5160 5161 ~~5162~~ ~~5163 5164~~ 5165 5166 5167 5168 ~~5169~~ ~~5170 5171 5172 5173~~ 5174 5175 5176 5177 5178 5179 5180	4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355	- + - - + - + - - - - + + +	SQLITE_API const char sqlite3_column_decltype(sqlite3_stmt,int); SQLITE_API const void sqlite3_column_decltype16(sqlite3_stmt,int); /* CAPI3REF: Evaluate An SQL Statement METHOD: sqlite3_stmt After a [prepared statement] has been prepared using ~~any of~~ After a [prepared statement] has been prepared using either [sqlite3_prepare_v2()], [sqlite3_prepare_v3()], [sqlite3_prepare16_v2()], or [sqlite3_prepare16_v3()] or one of the legacy [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] or one of the legacy interfaces [sqlite3_prepare()] or [sqlite3_prepare16()], this function must be called one or more times to evaluate the statement. The details of the behavior of the sqlite3_step() interface depend on whether the statement was prepared using the newer "vX" interfaces on whether the statement was prepared using the newer "v2" interface [sqlite3_prepare_v3()], [sqlite3_prepare_v2()], [sqlite3_prepare16_v3()], [sqlite3_prepare16_v2()] or the older legacy interfaces [sqlite3_prepare()] and [sqlite3_prepare16()]. The use of the new "vX" interface is recommended for new applications but the legacy [sqlite3_prepare_v2()] and [sqlite3_prepare16_v2()] or the older legacy interface [sqlite3_prepare()] and [sqlite3_prepare16()]. The use of the new "v2" interface is recommended for new applications but the legacy interface will continue to be supported. ^In the legacy interface, the return value will be either [SQLITE_BUSY], [SQLITE_DONE], [SQLITE_ROW], [SQLITE_ERROR], or [SQLITE_MISUSE]. ^With the "v2" interface, any of the other [result codes] or [extended result codes] might be returned as well.
︙
5227 5228 5229 5230 5231 5232 5233 ~~5234 5235~~ 5236 5237 ~~5238~~ 5239 5240 5241 5242 5243 5244 5245	4402 4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419	- - + - +	<b>Goofy Interface Alert:</b> In the legacy interface, the sqlite3_step() API always returns a generic error code, [SQLITE_ERROR], following any error other than [SQLITE_BUSY] and [SQLITE_MISUSE]. You must call [sqlite3_reset()] or [sqlite3_finalize()] in order to find one of the specific [error codes] that better describes the error. We admit that this is a goofy design. The problem has been fixed with the "v2" interface. If you prepare all of your SQL statements using [sqlite3_prepare_v3()] or [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] or [sqlite3_prepare16_v3()] instead using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] instead of the legacy [sqlite3_prepare()] and [sqlite3_prepare16()] interfaces, then the more specific [error codes] are returned directly by sqlite3_step(). The use of the "vX" interfaces is recommended. by sqlite3_step(). The use of the "v2" interface is recommended. / SQLITE_API int sqlite3_step(sqlite3_stmt); /* CAPI3REF: Number of columns in a result set METHOD: sqlite3_stmt **
︙