**** <dt>SQLITE_CONFIG_HEAP</dt>** <dd>This option specifies a static memory buffer that SQLite will use** for all of its dynamic memory allocation needs beyond those provided** for by [SQLITE_CONFIG_SCRATCH] and [SQLITE_CONFIG_PAGECACHE].** There are three arguments: A pointer to the memory, the number of** bytes in the memory buffer, and the minimum allocation size.  If** the first pointer (the memory pointer) is NULL, then SQLite reverts** to using its default memory allocator (the system malloc() implementation),** undoing any prior invocation of [SQLITE_CONFIG_MALLOC].  If the** memory pointer is not NULL and either [SQLITE_ENABLE_MEMSYS3] or** [SQLITE_ENABLE_MEMSYS5] are defined, then the alternative memory** allocator is engaged to handle all of SQLites memory allocation needs.</dd>**** <dt>SQLITE_CONFIG_MUTEX</dt>** <dd>This option takes a single argument which is a pointer to an** instance of the [sqlite3_mutex_methods] structure.  The argument specifies** alternative low-level mutex routines to be used in place** the mutex routines built into SQLite.</dd>**** <dt>SQLITE_CONFIG_GETMUTEX</dt>** <dd>This option takes a single argument which is a pointer to an** instance of the [sqlite3_mutex_methods] structure.  The** [sqlite3_mutex_methods]** structure is filled with the currently defined mutex routines.** This option can be used to overload the default mutex allocation** routines with a wrapper used to track mutex usage for performance** profiling or testing, for example.</dd>**** <dt>SQLITE_CONFIG_LOOKASIDE</dt>** <dd>This option takes two arguments that determine the default** memory allcation lookaside optimization.  The first argument is the** size of each lookaside buffer slot and the second is the number of** slots allocated to each database connection.</dd>**** </dl>*/#define SQLITE_CONFIG_SINGLETHREAD  1  /* nil */#define SQLITE_CONFIG_MULTITHREAD   2  /* nil */#define SQLITE_CONFIG_SERIALIZED    3  /* nil */#define SQLITE_CONFIG_MALLOC        4  /* sqlite3_mem_methods* */#define SQLITE_CONFIG_GETMALLOC     5  /* sqlite3_mem_methods* */#define SQLITE_CONFIG_SCRATCH       6  /* void*, int sz, int N */#define SQLITE_CONFIG_PAGECACHE     7  /* void*, int sz, int N */#define SQLITE_CONFIG_HEAP          8  /* void*, int nByte, int min */#define SQLITE_CONFIG_MEMSTATUS     9  /* boolean */#define SQLITE_CONFIG_MUTEX        10  /* sqlite3_mutex_methods* */#define SQLITE_CONFIG_GETMUTEX     11  /* sqlite3_mutex_methods* */#define SQLITE_CONFIG_CHUNKALLOC   12  /* int threshold */#define SQLITE_CONFIG_LOOKASIDE    13  /* int int *//*** CAPI3REF: Configuration Options {H10170} <S20000>** EXPERIMENTAL**** These constants are the available integer configuration options that** can be passed as the second argument to the [sqlite3_db_config()] interface.**** New configuration options may be added in future releases of SQLite.** Existing configuration options might be discontinued.  Applications** should check the return code from [sqlite3_db_config()] to make sure that** the call worked.  The [sqlite3_db_config()] interface will return a** non-zero [error code] if a discontinued or unsupported configuration option** is invoked.**** <dl>** <dt>SQLITE_DBCONFIG_LOOKASIDE</dt>** <dd>This option takes three additional arguments that determine the ** [lookaside memory allocator] configuration for the [database connection].** The first argument (the third parameter to [sqlite3_db_config()] is a** pointer to a memory buffer to use for lookaside memory.  The first** argument may be NULL in which case SQLite will allocate the lookaside** buffer itself using [sqlite3_malloc()].  The second argument is the** size of each lookaside buffer slot and the third argument is the number of** slots.  The size of the buffer in the first argument must be greater than** or equal to the product of the second and third arguments.</dd>**** </dl>*/#define SQLITE_DBCONFIG_LOOKASIDE    1001  /* void* int int *//*** CAPI3REF: Enable Or Disable Extended Result Codes {H12200} <S10700>**** The sqlite3_extended_result_codes() routine enables or disables the** [extended result codes] feature of SQLite. The extended result** codes are disabled by default for historical compatibility considerations.**** INVARIANTS:**** {H12201} Each new [database connection] shall have the**          [extended result codes] feature disabled by default.**** {H12202} The [sqlite3_extended_result_codes(D,F)] interface shall enable**          [extended result codes] for the  [database connection] D**          if the F parameter is true, or disable them if F is false.*/int sqlite3_extended_result_codes(sqlite3*, int onoff);/*** CAPI3REF: Last Insert Rowid {H12220} <S10700>**** Each entry in an SQLite table has a unique 64-bit signed** integer key called the "rowid". The rowid is always available** as an undeclared column named ROWID, OID, or _ROWID_ as long as those** names are not also used by explicitly declared columns. If** the table has a column of type INTEGER PRIMARY KEY then that column** is another alias for the rowid.**** This routine returns the rowid of the most recent** successful INSERT into the database from the [database connection]** in the first argument.  If no successful INSERTs** have ever occurred on that database connection, zero is returned.**** If an INSERT occurs within a trigger, then the rowid of the inserted** row is returned by this routine as long as the trigger is running.** But once the trigger terminates, the value returned by this routine** reverts to the last value inserted before the trigger fired.**** An INSERT that fails due to a constraint violation is not a** successful INSERT and does not change the value returned by this** routine.  Thus INSERT OR FAIL, INSERT OR IGNORE, INSERT OR ROLLBACK,** and INSERT OR ABORT make no changes to the return value of this** routine when their insertion fails.  When INSERT OR REPLACE** encounters a constraint violation, it does not fail.  The** INSERT continues to completion after deleting rows that caused** the constraint problem so INSERT OR REPLACE will always change** the return value of this interface.**** For the purposes of this routine, an INSERT is considered to** be successful even if it is subsequently rolled back.**** INVARIANTS:**** {H12221} The [sqlite3_last_insert_rowid()] function returns the rowid**          of the most recent successful INSERT performed on the same**          [database connection] and within the same or higher level**          trigger context, or zero if there have been no qualifying inserts.**** {H12223} The [sqlite3_last_insert_rowid()] function returns the**          same value when called from the same trigger context**          immediately before and after a ROLLBACK.**** ASSUMPTIONS:**** {A12232} If a separate thread performs a new INSERT on the same**          database connection while the [sqlite3_last_insert_rowid()]**          function is running and thus changes the last insert rowid,**          then the value returned by [sqlite3_last_insert_rowid()] is**          unpredictable and might not equal either the old or the new**          last insert rowid.*/sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*);/*** CAPI3REF: Count The Number Of Rows Modified {H12240} <S10600>**** This function returns the number of database rows that were changed** or inserted or deleted by the most recently completed SQL statement** on the [database connection] specified by the first parameter.** Only changes that are directly specified by the INSERT, UPDATE,** or DELETE statement are counted.  Auxiliary changes caused by** triggers are not counted. Use the [sqlite3_total_changes()] function** to find the total number of changes including changes caused by triggers.**** A "row change" is a change to a single row of a single table** caused by an INSERT, DELETE, or UPDATE statement.  Rows that** are changed as side effects of REPLACE constraint resolution,** rollback, ABORT processing, DROP TABLE, or by any other** mechanisms do not count as direct row changes.**** A "trigger context" is a scope of execution that begins and** ends with the script of a trigger.  Most SQL statements are** evaluated outside of any trigger.  This is the "top level"** trigger context.  If a trigger fires from the top level, a** new trigger context is entered for the duration of that one** trigger.  Subtriggers create subcontexts for their duration.**** Calling [sqlite3_exec()] or [sqlite3_step()] recursively does** not create a new trigger context.**** This function returns the number of direct row changes in the** most recent INSERT, UPDATE, or DELETE statement within the same** trigger context.**** Thus, when called from the top level, this function returns the** number of changes in the most recent INSERT, UPDATE, or DELETE** that also occurred at the top level.  Within the body of a trigger,** the sqlite3_changes() interface can be called to find the number of** changes in the most recently completed INSERT, UPDATE, or DELETE** statement within the body of the same trigger.** However, the number returned does not include changes** caused by subtriggers since those have their own context.**** SQLite implements the command "DELETE FROM table" without a WHERE clause** by dropping and recreating the table.  (This is much faster than going** through and deleting individual elements from the table.)  Because of this** optimization, the deletions in "DELETE FROM table" are not row changes and** will not be counted by the sqlite3_changes() or [sqlite3_total_changes()]** functions, regardless of the number of elements that were originally** in the table.  To get an accurate count of the number of rows deleted, use** "DELETE FROM table WHERE 1" instead.**** INVARIANTS:**** {H12241} The [sqlite3_changes()] function shall return the number of**          row changes caused by the most recent INSERT, UPDATE,**          or DELETE statement on the same database connection and**          within the same or higher trigger context, or zero if there have**          not been any qualifying row changes.**** {H12243} Statements of the form "DELETE FROM tablename" with no**          WHERE clause shall cause subsequent calls to**          [sqlite3_changes()] to return zero, regardless of the**          number of rows originally in the table.**** ASSUMPTIONS:**** {A12252} If a separate thread makes changes on the same database connection**          while [sqlite3_changes()] is running then the value returned**          is unpredictable and not meaningful.*/int sqlite3_changes(sqlite3*);/*** CAPI3REF: Total Number Of Rows Modified {H12260} <S10600>**** This function returns the number of row changes caused by INSERT,** UPDATE or DELETE statements since the [database connection] was opened.** The count includes all changes from all trigger contexts.  However,** the count does not include changes used to implement REPLACE constraints,** do rollbacks or ABORT processing, or DROP table processing.** The changes are counted as soon as the statement that makes them is** completed (when the statement handle is passed to [sqlite3_reset()] or** [sqlite3_finalize()]).**** SQLite implements the command "DELETE FROM table" without a WHERE clause** by dropping and recreating the table.  (This is much faster than going** through and deleting individual elements from the table.)  Because of this** optimization, the deletions in "DELETE FROM table" are not row changes and** will not be counted by the sqlite3_changes() or [sqlite3_total_changes()]** functions, regardless of the number of elements that were originally** in the table.  To get an accurate count of the number of rows deleted, use** "DELETE FROM table WHERE 1" instead.**** See also the [sqlite3_changes()] interface.**** INVARIANTS:**** {H12261} The [sqlite3_total_changes()] returns the total number**          of row changes caused by INSERT, UPDATE, and/or DELETE**          statements on the same [database connection], in any**          trigger context, since the database connection was created.**** {H12263} Statements of the form "DELETE FROM tablename" with no**          WHERE clause shall not change the value returned**          by [sqlite3_total_changes()].**** ASSUMPTIONS:**** {A12264} If a separate thread makes changes on the same database connection**          while [sqlite3_total_changes()] is running then the value**          returned is unpredictable and not meaningful.*/int sqlite3_total_changes(sqlite3*);/*** CAPI3REF: Interrupt A Long-Running Query {H12270} <S30500>**** This function causes any pending database operation to abort and** return at its earliest opportunity. This routine is typically** called in response to a user action such as pressing "Cancel"** or Ctrl-C where the user wants a long query operation to halt** immediately.**** It is safe to call this routine from a thread different from the** thread that is currently running the database operation.  But it** is not safe to call this routine with a [database connection] that** is closed or might close before sqlite3_interrupt() returns.**** If an SQL operation is very nearly finished a