This function is called as part of restating an RBU vacuum when the current operation is writing content to an index.

Allocate or return the aggregate context for a user function.

Return the number of times the Step function of an aggregate has been called.

Register a statically linked extension that is automatically loaded by every new database connection.

Register a function to be invoked prior to each autovacuum that determines the number of pages to vacuum.

Release all resources associated with an sqlite3_backup* handle.

Create an sqlite3_backup process to copy the contents of zSrcDb from connection handle pSrcDb to zDestDb in pDestDb.

Return the total number of pages in the source database as of the most recent call to sqlite3_backup_step().

Return the number of pages still to be backed up as of the most recent call to sqlite3_backup_step().

Copy nPage pages from the source b-tree to the destination.

Bind a blob value to an SQL statement variable.

Return the number of wildcards that can be potentially bound to.

Return the name of a wildcard parameter.

Query a blob handle for the size of the data.

Close a blob handle that was previously created using sqlite3_blob_open().

Open a blob handle.

Read data from a blob handle.

Move an existing blob handle to point to a different row of the same database table.

Write data to a blob handle.

This routine sets the busy callback for an Sqlite database to the given callback function with the given argument.

This routine installs a default busy handler that waits for the specified number of milliseconds before returning 0.

Cancel a prior call to sqlite3_auto_extension.

Return the number of changes in the most recent call to sqlite3_exec().

Set all the parameters in the compiled SQL statement to NULL.

Two variations on the public interface for closing a database connection.

Register a collation sequence factory callback with the database handle db.

Register a collation sequence factory callback with the database handle db.

*************************** sqlite3_column_ ******************************* The following routines are used to access elements of the current row in the result set.

Return the number of columns in the result set for the statement pStmt.

Return the name of the database from which a result column derives.

Return the column declaration type (if applicable) of the 'i'th column of the result set of SQL statement pStmt.

Return the name of the Nth column of the result set returned by SQL statement pStmt.

Return the name of the table column from which a result column derives.

Return the name of the table from which a result column derives.

Register a function to be invoked when a transaction commits.

Return the N-th compile-time option string.

Given the name of a compile-time option, return true if that option was used and false if not.

Return TRUE if the given SQL string ends in a semicolon.

This routine is the same as the sqlite3_complete() routine described above, except that the parameter is required to be UTF-16 encoded, not UTF-8.

This API allows applications to modify the global configuration of the SQLite library at run-time.

Extract the user data from a sqlite3_context structure and return a pointer to it.

Register a new collation sequence with the database handle db.

Register a new collation sequence with the database handle db.

Register a new collation sequence with the database handle db.

Allocate memory to hold names for a database, journal file, WAL file, and query parameters.

Create new user functions.

External API function used to create a new virtual-table module.

External API function used to create a new virtual-table module.

Return the number of values available from the current row of the currently executing statement pStmt.

Return the sqlite3_file for the main database given the name of the corresonding WAL or Journal name as passed into xOpen.

Flush any dirty pages in the pager-cache for any attached database to disk.

Configuration settings for an individual database connection.

Return the filename of the database associated with a database connection.

Return the sqlite3* database handle to which the prepared statement given in the argument belongs.

Return the mutex associated with a database connection.

Return 1 if database is read-only or 0 if read/write.

Free up as much memory as we can from the given database connection.

Query status information for a single database connection.

This function is used to set the schema of a virtual table.

Convert zSchema to a MemDB and initialize its content.

External API to drop all virtual-table modules, except those named on the azNames list.

Enable or disable extension loading.

Enable or disable the shared pager and schema features.

Return the most recent error code generated by an SQLite routine.

Return UTF-8 encoded English language explanation of the most recent error.

Return UTF-16 encoded English language explanation of the most recent error.

Return a string that describes the kind of error specified in the argument.

Execute SQL code.

Return the SQL associated with a prepared statement with bound parameters expanded.

Return TRUE (non-zero) of the statement supplied as an argument needs to be recompiled.

Enable or disable the extended result codes.

Invoke the xFileControl method on a particular database.

Translate a filename that was handed to a VFS routine into the corresponding database, journal, or WAL file.

The following routine destroys a virtual machine that is created by the sqlite3_compile() routine.

Free memory previously obtained from sqlite3Malloc().

Free memory obtained from sqlite3_create_filename().

This routine frees the space the sqlite3_get_table() malloced.

Test to see whether or not the database connection is in autocommit mode.

Return the auxiliary data pointer, if any, for the iArg'th argument to the user-function defined by pCtx.

Query the database.

This function is now an anachronism.

Set the hard heap-size limit for the library.

Initialize SQLite.

Cause any pending operation to stop at its earliest opportunity.

Return the ROWID of the most recent insert.

IMPLEMENTATION-OF: R-53536-42575 The sqlite3_libversion() function returns a pointer to the to the sqlite3_version[] string constant.

IMPLEMENTATION-OF: R-35210-63508 The sqlite3_libversion_number() function returns an integer equal to SQLITE_VERSION_NUMBER.

Change the value of a limit.

Format and write a message to the log if logging is enabled.

This version of the memory allocation is for use by the application.

Deprecated external interface.

Return the maximum amount of memory that has ever been checked out since either the beginning of this process or since the most recent reset.

Return the amount of memory currently checked out.

Print into memory obtained from sqlite3_malloc()().

Retrieve a pointer to a static mutex or allocate a new dynamic one.

Obtain the mutex p.

Free a dynamic mutex.

The sqlite3_mutex_leave() routine exits a mutex that was previously entered by the same thread.

Obtain the mutex p.

Return a pointer to the next prepared statement after pStmt associated with database connection pDb.

Open a new database handle.

Open a new database handle.

Shutdown the operating system interface.

Initialize the operating system interface.

Declare that a function has been overloaded by a virtual table.

Two versions of the official API.

Two versions of the official API.

This function is designed to be called from within a pre-update callback only.

This function is called from within a pre-update callback to retrieve the number of columns in the row being updated, deleted or inserted.

This function is designed to be called from within a pre-update callback only.

Register a callback to be invoked each time a row is updated, inserted or deleted using this database connection.

This function is called from within a pre-update callback to retrieve a field of the row currently being updated or inserted.

This function is called from within a pre-update callback to retrieve a field of the row currently being updated or deleted.

Register a profile function.

This routine sets the progress callback for an Sqlite database to the given callback function with the given argument.

Return N random bytes.

The public interface to sqlite3Realloc.

Attempt to release up to n bytes of non-essential memory currently held by SQLite.

Terminate the current execution of an SQL statement and reset it back to its starting state so that it can be reused.

Reset the automatic extension loading mechanism.

An SQLITE_NOMEM error.

Force an SQLITE_TOOBIG error.

Register a callback to be invoked each time a transaction is rolled back by this database connection.

Register a new geometry function for use with the r-tree MATCH operator.

Register a new 2nd-generation geometry function for use with the r-tree MATCH operator.

Return the serialization of a database.

Set or clear the access authorization function.

Set the auxiliary data pointer and delete function, for the iArg'th argument to the user-function defined by pCtx.

Set the value returned by the sqlite3_last_insert_rowid() API function.

Undo the effects of sqlite3_initialize().

Sleep for a little while.

Return a +ve value if snapshot p1 is newer than p2.

Free a snapshot handle obtained from sqlite3_snapshot_get().

Obtain a snapshot handle for the snapshot of database zDb currently being read by handle db.

Open a read-transaction on the snapshot idendified by pSnapshot.

Recover as many snapshots as possible from the wal file associated with schema zDb of database db.

Set the soft heap-size limit for the library.

************* End of stmt.c *********************************************** Return the source-id for this library.

Return the SQL associated with a prepared statement.

Query status information.

This is the top-level implementation of sqlite3_step().

Return true if the prepared statement is in need of being reset.

Return 1 if the statement is an EXPLAIN and return 2 if the statement is an EXPLAIN QUERY PLAN.

Return true if the prepared statement is guaranteed to not modify the database.

Return the value of a status counter for a prepared statement.

Append N bytes of text from z to the StrAccum object.

Append the complete text of zero-terminated string z[] to the p string.

Append N copies of character c to the given string buffer.

variable-argument wrapper around sqlite3_str_vappendf().

Return any error code associated with p.

Finalize a string created using sqlite3_str_new().

Return the current length of p in bytes.

Allocate and initialize a new dynamic string object.

Reset an StrAccum string.

Return the current value for p.

Render a string given by "fmt" into the StrAccum object.

The sqlite3_strglob() interface.

Some systems have stricmp().

The sqlite3_strlike() interface.

Return meta information about a specific column of a database table.

Interface to the testing logic.

This is a convenience routine that makes sure that all thread-specific data for this thread has been deallocated.

IMPLEMENTATION-OF: R-20790-14025 The sqlite3_threadsafe() function returns zero if and only if SQLite was compiled with mutexing code omitted due to the SQLITE_THREADSAFE compile-time option being set to 0.

Return the number of changes since the database handle was opened.

Register a trace function.

Register a trace callback using the version-2 interface.

Deprecated external interface.

Return the transaction state for a single databse, or the maximum transaction state over all attached databases if zSchema is null.

Register an unlock-notify callback.

Register a callback to be invoked each time a row is updated, inserted or deleted using this database connection.

Return a boolean value for a query parameter.

Return a 64-bit integer value for a query parameter.

Return a pointer to the name of Nth query parameter of the filename.

This is a utility routine, useful to VFS implementations, that checks to see if a database file was a URI that contained a specific query parameter, and if so obtains the value of the query parameter.

Extract the user data from a sqlite3_context structure and return a pointer to it.

*************************** sqlite3_value_ ******************************* The following routines extract information from a Mem or sqlite3_value structure.

Make a copy of an sqlite3_value object.

Destroy an sqlite3_value object previously obtained from sqlite3_value_dup().

Return true if a parameter value originated from an sqlite3_bind().

Return true if a parameter to xUpdate represents an unchanged column.

Try to convert the type of a function argument or a result column into a numeric representation.

EVIDENCE-OF: R-12793-43283 Every value in SQLite has one of five fundamental datatypes: 64-bit signed integer 64-bit IEEE floating point number string BLOB NULL.

Locate a VFS by name.

Register a VFS with the system.

Unregister a VFS so that it is no longer accessible.

Print into memory obtained from sqlite3_malloc().

sqlite3_snprintf() works like snprintf() except that it ignores the current locale settings.

If this function is invoked from within an xBestIndex() callback, it returns a pointer to a buffer containing the name of the collation sequence associated with element iCons of the sqlite3_index_info.aConstraint array.

Call from within the xCreate() or xConnect() methods to provide the SQLite core with additional information about the behavior of the virtual table being implemented.

If this routine is invoked from within an xColumn method of a virtual table, then it returns true if and only if the the call is during an UPDATE operation and the value of the column will not be modified by the UPDATE.

Return the ON CONFLICT resolution mode in effect for the virtual table update operation currently in progress.

Configure an sqlite3_wal_hook() callback to automatically checkpoint a database after committing a transaction if there are nFrame or more frames in the log file.

Checkpoint database zDb.

Checkpoint database zDb.

Register a callback to be invoked each time a transaction is written into the write-ahead-log by this database connection.

Compute the absolute value of a 32-bit signed integer, of possible.

Add a new CHECK constraint to the table currently under construction.

Set the collation function of the most recently parsed table column to the CollSeq given.

Add a new column to the table currently being constructed.

The expression is the default value for the most recently added column of the table currently under construction.

Change the most recently parsed column to be a GENERATED ALWAYS AS column.

Attempt to add, substract, or multiply the 64-bit signed value iB against the other 64-bit signed integer at *pA and store the result in *pA.

This routine is called by the parser while in the middle of parsing a CREATE TABLE statement.

Designate the PRIMARY KEY for the table.

Add the RETURNING clause to the parse currently underway.

Scan the column type name zType (length nType) and return the associated affinity type.

Initialize a Walker object so that will persist AggInfo entries referenced by the tree that is walked.

Allocate heap space to hold an Index object with nCol columns.

This function is called by the parser after the table-name in an "ALTER TABLE <table-name> ADD" statement is parsed.

This function is called by the parser upon parsing an ALTER TABLE pSrc DROP COLUMN pName statement.

This function is called after an "ALTER TABLE ..

Register built-in functions used to help implement ALTER TABLE.

Handles the following parser reduction: cmd ::= ALTER TABLE pSrc RENAME COLUMN pOld TO pNew.

Generate code to implement the "ALTER TABLE xxx RENAME TO yyy" command.

Load the content of the sqlite_stat1 and sqlite_stat4 tables.

Generate code for the ANALYZE command.

This function must be called before exiting any API function (i.e.

pArray is a pointer to an array of objects.

The string z[] is an text representation of a real number.

Return a 32-bit integer value extracted from a string.

Convert zNum to a 64-bit signed integer.

Called by the parser to compile an ATTACH statement.

Do an authorization check using the code and arguments given.

Pop an authorization context that was previously pushed by sqlite3AuthContextPush.

Push an authorization context.

The pExpr should be a TK_COLUMN expression.

Invoke the authorization callback for permission to read column zCol from table zTab in database zDb.

This routine generates code that will initialize all of the register used by the autoincrement tracker.

Load all automatic extensions.

Restart the backup process.

This (sqlite3EndBenignMalloc()) is called by SQLite code to indicate that subsequent malloc failures are benign.

Generate VDBE code for a BEGIN statement.

This is called by the parser when it sees a CREATE TRIGGER statement up to the point of the BEGIN before the trigger actions.

Generate VDBE code that prepares for doing an operation that might change the database.

Register hooks to call when sqlite3BeginBenignMalloc() and sqlite3EndBenignMalloc() are called, respectively.

Return a pointer to the collation sequence that should be used by a binary comparison operator comparing pLeft and pRight.

This routine runs an extensive test of the Bitvec code.

Clear the i-th bit.

Create a new bitmap object able to handle bits between 0 and iSize, inclusive.

Destroy a bitmap object.

Set the i-th bit.

Return the value of the iSize parameter specified when Bitvec *p was created.

Check to see if the i-th bit is set.

Compare two blobs.

Start a statement subtransaction.

Attempt to start a new transaction.

Run a checkpoint on the Btree passed as the first argument.

Clear the current cursor position.

Delete all information from a single table in the database.

Delete all information from the single table that pCur is open on.

Close an open database and invalidate all cursors.

Close a cursor.

Do both phases of a commit.

This routine does the first phase of a two-phase commit.

Commit the transaction currently in progress.

Return the number of connections to the BtShared object accessed by the Btree handle passed as the only argument.

Copy the complete content of pBtFrom into pBtTo.

The first argument, pCur, is a cursor opened on some b-tree.

Return true if the cursor has a hint specified.

Determine whether or not a cursor has moved from the position where it was last placed, or has been invalidated for any other reason.

Provide flag hints to the cursor.

Pin or unpin a cursor.

This routine restores a cursor back to its original position after it has been moved by some outside activity (such as a btree rebalance or a row having been deleted out from under the cursor).

Return the size of a BtCursor object in bytes.

Initialize memory that will be converted into a BtCursor object.

Delete the entry that the cursor is pointing to.

Enter a mutex on the given BTree object.

Enter a mutex on a Btree given a cursor owned by that Btree.

Return TRUE if the cursor is not pointing at an entry of the table.

Return a pointer to a fake BtCursor object that will always answer false to the sqlite3BtreeCursorHasMoved() routine above.

Move the cursor to the first entry in the table.

Return the value of the 'auto-vacuum' property.

Return the full pathname of the underlying database file.

Return the pathname of the journal file for this database.

This function may only be called if the b-tree connection already has a read or write transaction open on the database.

Return the currently defined page size.

Return the number of bytes of space at the end of every page that are intentually left unused.

This function is similar to sqlite3BtreeGetReserve(), except that it may only be called if it is guaranteed that the b-tree mutex is already held.

Mark this cursor as an incremental blob cursor.

A write-transaction must be opened before calling this function.

Move the cursor so that it points to an entry in an index table near the key pIdxKey.

Insert a new record into the BTree.

Return the value of the integer key or "rowid" for a table btree.

This routine does a complete check of the given BTree file.

Return true if there is currently a backup running on Btree p.

Return true if the given Btree is read-only.

Move the cursor to the last entry in the table.

Exit the recursive mutex on a Btree.

Obtain a lock on the table whose root page is iTab.

Set the maximum page count for a database if mxPage is positive.

Return an upper bound on the size of any record for the table that the cursor is pointing into.

Initialize the first page of the database file (creating a database consisting of a single page and no schema objects).

Return the offset into the database file for the start of the payload to which the cursor is pointing.

Open a database file.

Return the pager associated with a BTree.

Read part of the payload for the row at which that cursor pCur is currently pointing.

For the entry that cursor pCur is point to, return as many bytes of the key or data as are available on the local b-tree page.

Return the number of bytes of payload for the entry that pCur is currently pointing to.

Argument pCsr must be a cursor opened for writing on an INTKEY table currently pointing at a valid table entry.

Rollback the transaction in progress.

Return an estimate for the number of rows in the table that pCur is pointing to.

The second argument to this function, op, is always SAVEPOINT_ROLLBACK or SAVEPOINT_RELEASE.

This function returns a pointer to a blob of memory associated with a single shared-btree.

Return SQLITE_LOCKED_SHAREDCACHE if another user of the same shared btree as the argument handle holds an exclusive lock on the sqlite_schema table.

Change the values for the BTS_SECURE_DELETE and BTS_OVERWRITE flags: newFlag==0 Both BTS_SECURE_DELETE and BTS_OVERWRITE are cleared newFlag==1 BTS_SECURE_DELETE set and BTS_OVERWRITE is cleared newFlag==2 BTS_SECURE_DELETE cleared and BTS_OVERWRITE is set newFlag==(-1) No changes This routine acts as a query if newFlag is less than zero With BTS_OVERWRITE set, deleted content is overwritten by zeros, but freelist leaf pages are not written back to the database.

Change the 'auto-vacuum' property of the database.

Change the "soft" limit on the number of pages in the cache.

Change the limit on the amount of the database file that may be memory mapped.

Change the way data is synced to disk in order to increase or decrease how well the database resists damage due to OS crashes and power failures.

Change the default pages size and the number of reserved bytes per page.

Change the "spill" limit on the number of pages in the cache.

Set both the "read version" (single byte at byte offset 18) and "write version" (single byte at byte offset 19) fields in the database header to iVersion.

Return true if the Btree passed as the only argument is sharable.

Move the cursor so that it points to an entry in a table (a.k.a INTKEY) table near the key intKey.

This function is used as part of copying the current row from cursor pSrc into cursor pDest.

This routine sets the state to CURSOR_FAULT and the error code to errCode for every cursor on any BtShared that pBtree references.

Return one of SQLITE_TXN_NONE, SQLITE_TXN_READ, or SQLITE_TXN_WRITE to describe the current transaction state of Btree p.

Write meta-information back into the database.

Generate code that will increment the schema cookie.

Add the changeset currently stored in buffer pData, size nData bytes, to changeset-group p.

Streaming versions of changegroup_add().

Delete a changegroup object.

Allocate a new, empty, sqlite3_changegroup.

Obtain a buffer containing a changeset representing the concatenation of all changesets added to the group so far.

Streaming versions of changegroup_output().

Apply the changeset passed via pChangeset/nChangeset to the main database attached to handle "db".

Apply the changeset passed via pChangeset/nChangeset to the main database attached to handle "db".

Apply the changeset passed via xInput/pIn to the main database attached to handle "db".

Combine two changesets together.

Streaming version of sqlite3changeset_concat().

This function may only be called with a changeset iterator that has been passed to an SQLITE_CHANGESET_DATA or SQLITE_CHANGESET_CONFLICT conflict-handler function.

Finalize an iterator allocated with sqlite3changeset_start().

This function may only be called with an iterator passed to an SQLITE_CHANGESET_FOREIGN_KEY conflict handler callback.

Invert a changeset object.

Streaming version of sqlite3changeset_invert().

This function may only be called while the iterator is pointing to an SQLITE_UPDATE or SQLITE_INSERT change (see sqlite3changeset_op()).

Advance an iterator created by sqlite3changeset_start() to the next change in the changeset.

This function may only be called while the iterator is pointing to an SQLITE_UPDATE or SQLITE_DELETE change (see sqlite3changeset_op()).

The following function extracts information on the current change from a changeset iterator.

Return information regarding the PRIMARY KEY and number of columns in the database table affected by the change that pIter currently points to.

Create an iterator used to iterate through the contents of a changeset.

Streaming version of sqlite3changeset_start().

This routine is called on a collation sequence before it is used to check that it is defined.

This routine is used to check if the UTF-8 string zName is a legal unqualified name for a new schema object (table, index, view or trigger).

Run a checkpoint on database iDb.

Mark all temporary registers as being unavailable for reuse.

Call this routine when the database connection is closing in order to clean up loaded extensions.

Close all open savepoints.

Generate code to drop a table.

Generate code that will construct an ephemeral table containing all terms in the RHS of an IN operator.

This is called to code the required FOR EACH ROW triggers for an operation on table pTab.

Generate code for the trigger program associated with trigger p on table pTab.

Generate code for scalar subqueries used as a subquery expression or EXISTS operator: (SELECT a FROM b) -- subquery EXISTS (SELECT a FROM b) -- EXISTS subquery The pExpr parameter is the SELECT or EXISTS operator to be coded.

If argument zDb is NULL, then call sqlite3CodeVerifySchema() for each attached database.

Look through the list of open database files in db->aDb[] and if any have been closed, remove them from the list.

Return the collating squence name for a column.

The most recently coded instruction was an OP_Column to retrieve the i-th column of table pTab.

Return the expression associated with a column.

Return the index of a column in a table.

Set the collating sequence name for a column.

Set the expression associated with a column.

Given an expression list (which is really the list of expressions that form the result set of a SELECT statement) compute appropriate column names for a table that would hold the expression list.

Return the declared type of a column.

This routine is called when a commit occurs.

pExpr is an operand of a comparison operator.

This routine generates code to finish the INSERT or UPDATE operation that was started by a prior call to sqlite3GenerateConstraintChecks.

All regular columns for table pTab have been puts into registers starting with iRegStore.

This function is called while stepping or preparing a statement associated with connection db.

This is called when the database connection passed as an argument is being closed.

This function is called when the transaction opened by database db has just finished.

Allocate and return a pointer to an expression to load the column iCol from datasource iSrc in SrcList pSrc.

This routine is called to create a new foreign key on the table currently under construction.

This function is exactly the same as sqlite3_create_function(), except that it is designed to be called by internal code.

Create a new index for an SQL table.

The parser calls this routine in order to create a new VIEW.

Free the contents of the CTE object passed as the second argument.

Create a new CTE object.

Free memory that might be associated with a particular database connection.

Return true if zName points to a name that may be used to refer to database iDb attached to handle db.

Allocate memory, either lookaside (if possible) or heap.

Allocate and zero memory.

Return the Btree pointer identified by zDbName.

Invoke this routine to register the "dbpage" virtual table module.

Resize the block of memory pointed to by p to n bytes.

Attempt to reallocate p.

The text between zStart and zEnd represents a phrase within a larger SQL statement.

Invoke this routine to register the "dbstat" virtual table module.

Make a copy of a string in memory obtained from sqliteMalloc().

A version of printf() that understands %lld.

Transform a UTF-8 integer literal, in either decimal or hexadecimal, into a 64-bit signed integer.

If compiled with SQLITE_MUTEX_NOOP, then the no-op mutex implementation is used regardless of the run-time threadsafety setting.

Fill the Index.aiRowEst[] array with default information - information to be used when we have not run the ANALYZE command.

This routine is called when an INITIALLY IMMEDIATE or INITIALLY DEFERRED clause is seen as part of a foreign key definition.

Delete memory allocated for the column names of a table or view (the Table.aCol[] array).

Generate code for a DELETE FROM statement.

If the Index.aSample variable is not NULL, delete the aSample[] array and its contents.

Recursively delete a Trigger structure.

Delete a linked list of TriggerStep structures.

Convert an SQL-style quoted string into a normal string by removing the quote characters.

If the input token p is quoted, try to adjust the token to remove the quotes.

Called by the parser to compile a DETACH statement.

This routine will drop an existing named index.

This routine is called to do the work of a DROP TABLE statement.

This function is called to drop a trigger from the database schema.

Drop a trigger given a pointer to that trigger.

This routine is called to report the final ")" that terminates a CREATE TABLE statement.

Generate VDBE code for a COMMIT or ROLLBACK statement.

Return a static string containing the name corresponding to the error code specified in the argument.

Set the current error code to err_code and clear any prior error message.

The equivalent of sqlite3Error(db, SQLITE_OK).

Add an error message to pParse->zErrMsg and increment pParse->nErr.

If database connection db is currently parsing SQL, then transfer error code errCode to that parser if the parser has not already encountered some other kind of error.

Set the most recent error code and error string for the sqlite handle "db".

Return a static string that describes the kind of error specified in the argument.

The SrcList_item structure passed as the second argument represents a sub-query in the FROM clause of a SELECT statement.

Mark every prepared statement associated with a database connection as expired.

Allocate a new expression node from a zero-terminated token that has already been dequoted.

Set the collating sequence for expression pExpr to be the collating sequence named by pToken.

Return the 'affinity' of the expression pExpr if any.

This routine is the core allocator for Expr nodes.

Call sqlite3ExprAnalyzeAggregates() for every expression in an expression list.

Analyze the pExpr expression looking for aggregate functions and for variables that need to be added to AggInfo object that pNC->pAggInfo points to.

Join two expressions using an AND operator.

Assign a variable number to an expression that encodes a wildcard in the original SQL statement.

Attach subtrees pLeft and pRight to the Expr node pRoot.

Return FALSE if there is no chance that the expression can be NULL.

Check that argument nHeight is less than or equal to the maximum expression depth allowed.

Expr pIn is an IN(...) expression.

Generate code that will evaluate expression pExpr and store the results in register target.

Make a transient copy of expression pExpr and then code it using sqlite3ExprCode().

Generate code that pushes the value of every element of the given expression list into a sequence of registers beginning at target.

Generate code that will evaluate expression pExpr and store the results in register target.

Generate code that will compute the value of generated column pCol and store the result in register regOut.

Generate code that will extract the iColumn-th column from table pTab and store the column value in register iReg.

Generate code to extract the value of the iCol-th column of a table.

Generate code that will load into register regOut a value that is appropriate for the iIdxCol-th column of index pIdx.

Generate code to move content from registers iFrom...iFrom+nReg-1 over to iTo..iTo+nReg-1.

Generate code that will evaluate expression pExpr just one time per prepared statement execution.

Generate code into the current Vdbe to evaluate the given expression.

Generate code to evaluate an expression and store the results into a register.

Return the collation sequence for the expression pExpr.

Return TRUE if the two expressions have equivalent collating sequences.

The argument is guaranteed to be a non-NULL Expr node of type TK_COLUMN.

Do a deep comparison of two expression trees.

Expresssion p is a comparison operator.

Like sqlite3ExprCompare() except COLLATE operators at the top-level are ignored.

Determine if an index pIdx on table with cursor iCur contains will the expression pExpr.

Arrange to cause pExpr to be deleted when the pParse is deleted.

The following group of routines make deep copies of expressions, expression lists, ID lists, and select statements.

Compute and return a new Expr object which when passed to sqlite3ExprCode() will generate all necessary code to compute the iField-th column of the vector expression pVector.

Construct a new expression node for a function with multiple arguments.

Check to see if a function is usable according to current access rules: SQLITE_FUNC_DIRECT - Only usable from top-level SQL SQLITE_FUNC_UNSAFE - Usable if TRUSTED_SCHEMA or from top-level SQL If the function is not usable, create an error.

If the input expression is an ID with the name "true" or "false" then convert it into an TK_TRUEFALSE term.

Generate code for a boolean expression such that a jump is made to the label "dest" if the expression is false but execution continues straight thru if the expression is true.

Like sqlite3ExprIfFalse() except that a copy is made of pExpr before code generation, and that copy is deleted after code generation.

Generate code for a boolean expression such that a jump is made to the label "dest" if the expression is true but execution continues straight thru if the expression is false.

Return true if we can prove the pE2 will always be true if pE1 is true.

Return true (non-zero) if expression p can only be true if at least one column of table iTab is non-null.

Walk an expression tree.

Walk an expression tree.

Walk an expression tree for the DEFAULT field of a column definition in a CREATE TABLE statement.

Walk the expression tree passed as the first argument.

If the expression p codes a constant integer that is small enough to fit in a 32-bit integer, return 1 and put the value of the integer in *pValue.

Walk an expression tree.

Return true if expression pExpr is a vector, or false otherwise.

pColumns and pExpr form a vector assignment which is part of the SET clause of an UPDATE statement.

If the expression list pEList contains more than iLimit elements, leave an error message in pParse.

Compare two ExprList objects.

Return the bitwise-OR of all Expr.flags fields in the given ExprList.

Set the ExprList.a[].zEName element of the most recently added item on the expression list.

Set the sort order for the last element on the given ExprList.

Set the ExprList.a[].zSpan element of the most recently added item on the expression list.

Expression list pEList is a list of vector values.

Return TRUE if the given expression is a constant which would be unchanged by OP_Affinity with the affinity given in the second argument.

Return the collation sequence for the expression pExpr.

pExpr is a CHECK constraint on a row that is being UPDATE-ed.

Set the Expr.nHeight variable using the exprSetHeight() function.

If pExpr is an AND or OR expression, try to simplify it by eliminating terms that are always true or false.

Skip over any TK_COLLATE operators.

Skip over any TK_COLLATE operators and/or any unlikely() or likelihood() or likely() functions at the root of an expression.

The argument must be a TK_TRUEFALSE Expr node.

Invoke sqlite3RenameExprUnmap() and sqlite3ExprDelete() on the expression.

If the expression passed as the only argument is of type TK_VECTOR return the number of expressions in the vector.

No-op routine for the parse-tree walker.

Calls to sqlite3FaultSim() are used to simulate a failure during testing, or to bypass normal error detection during testing in order to let execute proceed futher downstream.

Parameter zName points to a UTF-8 encoded string nName bytes long.

The token *pName contains the name of a database (either "main" or "temp" or the name of an attached db).

Parameter zName points to a nul-terminated buffer containing the name of a database ("main", "temp" or the name of an attached db).

Locate a user function given a name, a number of arguments and a flag indicating whether the function prefers UTF-16 over UTF-8.

Locate the in-memory structure that describes a particular index given the name of that index and the name of the database that contains the index.

This function is used by the implementation of the IN (...) operator.

Locate the in-memory structure that describes a particular database table given the name of that table and (optionally) the name of the database containing the table.

This routine is called after a single SQL statement has been parsed and a VDBE program to execute that statement has been prepared.

This routine is called after all of the trigger actions have been parsed in order to complete the process of building the trigger.

Initialize a DbFixer structure.

The following set of routines walk through the parse tree and assign a specific database to all table references where the database name was left unspecified in the original SQL statement.

This function is called when deleting or updating a row to implement any required CASCADE, SET NULL or SET DEFAULT actions.

This function is called when inserting, deleting or updating a row of table pTab to generate VDBE code to perform foreign key constraint processing for the operation.

Free all memory associated with foreign key definitions attached to table pTab.

This function is called to generate code that runs when table pTab is being dropped from the database.

A foreign key constraint requires that the key columns in the parent table are collectively subject to a UNIQUE or PRIMARY KEY constraint.

This function is called before generating code to update or delete a row contained in table pTab.

This function returns a linked list of FKey objects (connected by FKey.pNextTo) holding all children of table pTab.

This function is called before generating code to update or delete a row contained in table pTab.

Reclaim the memory used by an index.

The following functions are used to register the module with SQLite.

Search a FuncDefHash for a function with the given name.

Compute the column names for a SELECT statement.

Generate code to do constraint checks prior to an INSERT or an UPDATE on table pTab.

Generate code that will assemble an index key and stores it in register regOut.

This routine generates VDBE code that causes a single row of a single table to be deleted.

This routine generates VDBE code that causes the deletion of all index entries associated with a single row of a single table, pTab Preconditions: 1.

Read or write a four-byte big-endian integer value.

Interpret the given string as a boolean value.

This function is responsible for invoking the collation factory callback or substituting a collation sequence of a different encoding when the requested collation sequence is not available in the desired encoding.

If zNum represents an integer that will fit in 32-bits, then set *pValue to that integer and return true.

Allocate or deallocate a block of nReg consecutive registers.

Allocate a single new register for use to hold some intermediate result.

Return the length (in bytes) of the token that begins at z[0].

Try to convert z into an unsigned 32-bit integer.

Read a 64-bit variable-length integer from memory starting at p[0].

Read a 32-bit variable-length integer from memory starting at p[0].

Get a VDBE for the given parser context.

pTab is a pointer to a Table structure representing a virtual-table.

Code an OP_Halt that causes the vdbe to return an SQLITE_CONSTRAINT error.

If expression list pList contains an expression that was parsed with an explicit "NULLS FIRST" or "NULLS LAST" clause, leave an error in pParse and return non-zero.

Remove all entries from a hash table.

Attempt to locate an element of the hash table pH with a key that matches pKey.

Turn bulk memory into a hash table object by initializing the fields of the Hash structure.

Insert an element into the hash table pH.

Return the size of the header added to each page by this module.

Return the size of the header added by this middleware layer in the page-cache hierarchy.

Return the size of the header on each page of this PCACHE implementation.

Return true if the heap is currently under memory pressure - in other words if the amount of heap used is close to the limit set by sqlite3_soft_heap_limit().

Convert a BLOB literal of the form "x'hhhhhh'" into its binary value.

Translate a single byte of Hex into an integer.

Append a new element to the given IdList.

Delete an IdList.

Return the index in pList of the identifier named zId.

pExpr is a comparison expression, eg.

Return a pointer to the column affinity string associated with index pIdx.

Return the affinity for a single column of an index.

If the source-list item passed as an argument was augmented with an INDEXED BY clause, then try to locate the specified index.

Check to see if any sibling index (another index on the same table) of pIndex has the same root page number, and if it does, return true.

Initialize all database files - the main database file, the file used to store temporary tables, and any additional database files created using ATTACH statements.

This is the callback routine for the code that initializes the database.

Attempt to read the database schema and initialize internal data structures for a single database file.

This routine is called to handle SQL of the following forms: insert into TABLE (IDLIST) values(EXPRLIST),(EXPRLIST),..

Insert a new FuncDef into a FuncDefHash hash table.

Render an signed 64-bit integer as text.

Do a comparison between a 64-bit signed integer and a 64-bit floating-point number.

Invoke the given busy handler.

Return true if CollSeq is the default built-in BINARY.

Make the IdChar function accessible from ctime.c and alter.c.

pExpr points to an expression which implements a function.

Return true if the floating point value is Not a Number (NaN).

Check to make sure the given table is writable.

Return TRUE if the given string is a row-id column name.

Return true if pTab is a virtual table and zName is a shadow table name for that virtual table.

Check the input string to see if it is "true" or "false" (in any case).

Given 1 to 3 identifiers preceding the JOIN keyword, determine the type of join.

The file-handle passed as the only argument is open on a journal file.

Parameter eMode must be one of the PAGER_JOURNALMODE_XXX constants defined in pager.h.

Open a journal file.

Return the number of bytes required to store a JournalFile that uses vfs pVfs to create the underlying on-disk files.

Allocate a KeyInfo object sufficient for an index of N key columns and X extra columns.

Given an expression list, generate a KeyInfo structure that records the collating sequence for each expression in that expression list.

Return a KeyInfo structure that is appropriate for the given Index.

Make a new pointer to a KeyInfo object.

Deallocate a KeyInfo object.

Close the mutex on database connection db.

This function returns the collation sequence for database native text encoding identified by the string zName.

Locate the in-memory structure that describes a particular database table given the name of that table and (optionally) the name of the database containing the table.

Locate the table identified by *p.

Convert an integer into a LogEst.

Find (an approximate) sum of two LogEst values.

Convert a double into a LogEst In other words, compute an approximation for 10*log2(x).

Convert a LogEst into an integer.

Count the number of slots of lookaside memory that are outstanding.

Allocate memory.

Deinitialize the memory allocation subsystem.

Initialize the memory allocation subsystem.

Return the memory allocator mutex.

Return the size of a memory allocation previously obtained from sqlite3Malloc() or sqlite3_malloc().

Allocate and zero memory.

Table pTab is a virtual table.

Subqueries stores the original database, table and column names for their result sets in ExprList.a[].zSpan, in the form "DATABASE.TABLE.COLUMN".

Evaluate a view and store its result in an ephemeral table.

The code generator calls this routine if is discovers that it is possible to abort a statement prior to completion.

Compare the values contained by the two memory cells, returning negative, zero or positive if pMem1 is less than, equal to, or greater than pMem2.

This routine is called when the extension is loaded.

Open an in-memory journal file.

This routine is the only routine in this file with external linkage.

Print into memory obtained from sqliteMalloc().

Indicate that the statement currently under construction might write more than one entry (example: deleting one row then inserting another, inserting multiple rows in a table, or inserting a row and index entries.) If an abort occurs after some of these writes have completed, then it will be necessary to undo the completed writes.

Shutdown the mutex system.

Initialize the mutex system.

Given a token, return a string that consists of the text of that token.

Run the parser and code generator recursively in order to generate code for the SQL statement given onto the end of the pParse context currently under construction.

A no-op destructor.

Cause a function to throw an error if it was call from OP_PureFunc rather than OP_Function.

This routine reactivates the memory allocator and clears the db->mallocFailed flag as necessary.

Call this routine to record the fact that an OOM (out-of-memory) error has happened.

************* End of hash.c ************************************************************ Begin file opcodes.c **************************************** Automatically generated.

Open the sqlite_schema table stored in database number iDb for writing.

Generate code that will (1) acquire a lock for table pTab then (2) open pTab as cursor iCur.

Allocate cursors for the pTab table and all its indices and generate code to open and initialized those cursors.

Make sure the TEMP database is open and available for use.

The following routines are convenience wrappers around methods of the sqlite3_file object.

The real implementation of xFetch and xUnfetch.

Use sqlite3OsFileControl() when we are doing something that might fail and we need to know about the failures.

This function is a wrapper around the OS specific implementation of sqlite3_os_init().

The next group of routines are convenience wrappers around the VFS methods.

Free an allocated buffer obtained from sqlite3PageMalloc().

Malloc function used by SQLite to obtain space from the buffer configured using sqlite3_config(SQLITE_CONFIG_PAGECACHE) option.

Return a pointer to the pPager->pBackup variable.

Begin a write-transaction on the specified pager object.

Parameter eStat must be one of SQLITE_DBSTATUS_CACHE_HIT, _MISS, _WRITE, or _WRITE+1.

This function is called when the user invokes "PRAGMA wal_checkpoint", "PRAGMA wal_blocking_checkpoint" or calls the sqlite3_wal_checkpoint() or wal_blocking_checkpoint() API functions.

Unless this is an in-memory or temporary database, clear the pager cache.

Shutdown the page cache.

This function is called to close the connection to the log file prior to switching from WAL to rollback mode.

Sync the database file for the pager pPager.

When this function is called, the database file has been completely updated to reflect the changes made by the current transaction and synced to disk.

Return the pPager->iDataVersion value.

A call to this routine tells the pager that it is not necessary to write the information on page pPg back to the disk, even though that page might be marked as dirty.

This function may only be called while a write-transaction is active in rollback.

Return the file handle for the database file associated with the pager.

Return the full pathname of the database file.

Flush all unreferenced dirty pages to disk.

Dispatch all page fetch requests to the appropriate getter method.

Return a pointer to the data for the specified page.

Return a pointer to the Pager.nExtra bytes of "extra" space allocated along with the specified page.

Return the current journal mode.

Return true if this is an in-memory or temp-file backed pager.

Return TRUE if the database file is opened read-only.

Return the full pathname of the journal file.

Get/set the size-limit used for persistent journal files.

Return the file handle for the journal file (if it exists).

Get/set the locking-mode for this pager.

Acquire a page if it is already in the in-memory cache.

Attempt to set the maximum database page count if mxPage is positive.

Return the approximate number of bytes of memory currently used by the pager and its associated cache.

Move the page pPg to location pgno in the file.

Return TRUE if the pager is in a state where it is OK to change the journalmode.

Allocate and initialize a new Pager object and put a pointer to it in *ppPager.

The caller must be holding a SHARED lock on the database file to call this function.

This function may only be called when a read-transaction is open on the pager.

Return the page number for page pPg.

Return the number of references to the specified page.

Read the first N bytes from the beginning of the file into memory that pDest points to.

Increment the reference count for page pPg.

The page handle passed as the first argument refers to a dirty page with a page number other than iNew.

If a write transaction is open, then all changes made within the transaction are reverted and the current write-transaction is closed.

This function is called to rollback or release (commit) a savepoint.

Set the busy handler function.

Change the maximum number of in-memory pages that are allowed before attempting to recycle clean and unused pages.

Adjust settings of the pager to those specified in the pgFlags parameter.

Set the journal-mode for this pager.

Change the maximum size of any memory mapping made of the database file.

Change the page size used by the Pager object.

Change the maximum number of in-memory pages that are allowed before attempting to spill pages to journal.

This function is called to obtain a shared lock on the database file.

Free as much memory as possible from the pager.

The caller currently has a read transaction open on the database.

If this is a WAL database, obtain a snapshot handle for the snapshot currently open.

If this is a WAL database, store a pointer to pSnapshot.

If this is a WAL database, call sqlite3WalSnapshotRecover().

Release a lock obtained by an earlier successful call to sqlite3PagerSnapshotCheck().

This routine is used for testing and analysis only.

Sync the database file to disk.

Return a pointer to the "temporary page" buffer held internally by the pager.

Truncate the in-memory database file image to nPage pages.

Release a page reference.

Return the VFS structure for the pager.

Return true if the underlying VFS for the given pager supports the primitives necessary for write-ahead logging.

Mark a data page as writeable.

The main parser program.

Add a new cleanup operation to a Parser.

Return the fallback token corresponding to canonical token iToken, or 0 if iToken has no fallback.

Clear all secondary memory allocations from the parser.

Initialize a new parser that has already been allocated.

Free all memory allocations in the pParse object.

This function is used to parse both URIs and non-URI filenames passed by the user to API functions sqlite3_open() or sqlite3_open_v2(), and for database URIs specified as part of ATTACH statements.

Return the global mutex used by this PCACHE implementation.

This function is called during initialization if a static buffer is supplied to use for the page-cache by passing the SQLITE_CONFIG_PAGECACHE verb to sqlite3_config().

Make every page in the cache clean.

Discard the contents of the cache.

Clear the PGHDR_NEED_SYNC flag from all dirty pages.

Clear the PGHDR_NEED_SYNC and PGHDR_WRITEABLE flag from all dirty pages.

Close a cache.

Return a list of all dirty pages in the cache, sorted by page number.

Drop a page from the cache.

Try to obtain a page from the cache.

This routine converts the sqlite3_pcache_page object returned by sqlite3PcacheFetch() into an initialized PgHdr object.

If the sqlite3PcacheFetch() routine is unable to allocate a new page because no clean pages are available for reuse and the cache size limit has been reached, then this routine can be invoked to try harder to allocate a page.

Get the suggested cache-size value.

************************************************** General Interfaces ****** Initialize and shutdown the page cache subsystem.

Make sure the page is marked as clean.

Make sure the page is marked as dirty.

Change the page number of page p to newPgno.

Create a new PCache object.

Return the total number of pages in the cache.

Return the number of references to the page supplied as an argument.

Return the number of dirty pages currently in the cache, as a percentage of the configured cache size.

Increase the reference count of a supplied page by 1.

Return the total number of references to all pages held by the cache.

Decrement the reference count on a page.

This function is called to free superfluous dynamically allocated memory held by the pager system.

Set the suggested cache-size value.

This function is called during initialization (sqlite3_initialize()) to install the default pluggable cache module, assuming the user has not already provided an alternative.

Change the page size for PCache object.

Set the suggested cache-spill value.

Free up as much memory as possible from the page cache.

Return the size in bytes of a PCache object.

This function is used by test procedures to inspect the internal state of the global cache.

Drop every cache entry whose page number is greater than "pgno".

Allocate an Expr node which joins as many as two subtrees.

Add pSelect to the Expr.x.pSelect field.

Process a pragma statement.

Check to see if zTabName is really the name of a pragma.

Return the preferred table name for system tables.

Return the PRIMARY KEY index of a table.

Return permyriadage progress indications for the two main stages of an RBU update.

Close the RBU handle.

Create an RBU VFS named zName that accesses the underlying file-system via existing VFS zParent.

Return the database handle used by pRbu.

Deregister and destroy an RBU vfs created by an earlier call to sqlite3rbu_create_vfs().

Open and return a new RBU handle.

Return the total number of key-value operations (inserts, deletes or updates) that have been performed on the target database since the current RBU update was started.

Return the current state of the RBU vacuum or update operation.

Step the RBU object.

Configure the aggregate temp file size limit for this RBU handle.

Open a handle to begin or resume an RBU VACUUM operation.

Return TRUE if shadow tables should be read-only in the current context.

This routine is a no-op if the database schema is already initialized.

Change the size of an existing memory allocation.

Compare a floating point value to an integer.

Call this one or more times to configure a rebaser.

Create a new rebaser object.

Destroy a rebaser object.

Rebase a changeset according to current rebaser configuration.

Rebase a changeset according to current rebaser configuration.

Check to see if pExpr references any tables in pSrcList.

All of the FuncDef structures in the aBuiltinFunc[] array above to the global function hash table.

This function registered all of the above C functions as SQL functions.

Re-register the built-in LIKE functions.

This routine does per-connection function registration.

Generate code for the REINDEX command.

Deallocate a register, making available for reuse for some other purpose.

Remove all nodes that are part of expression-list pEList from the rename list.

Remove all nodes that are part of expression pExpr from the rename list.

Remember that the parser tree element pPtr was created using the token pToken.

It is assumed that there is already a RenameToken object associated with parse tree element pFrom.

The following routines are substitutes for constants SQLITE_CORRUPT, SQLITE_MISUSE, SQLITE_CANTOPEN, SQLITE_NOMEM and possibly other error constants.

Rerun the compilation of a statement after a schema change.

Erase all schema information from all attached databases (including "main" and "temp") for a single database connection.

Reset the schema for the database at index iDb.

Resolve all names for all expression in an expression list.

This routine walks an expression tree and resolves references to table columns and result-set columns.

Check every term in the ORDER BY or GROUP BY clause pOrderBy of the SELECT statement pSelect.

If a prior call to sqlite3GenerateIndexKey() generated a jump-over label because it was a partial index, then this routine should be called to resolve that label.

Resolve all names in all expressions of a SELECT and in all decendents of the SELECT, including compounds off of p->pPrior, subqueries in expressions, and subqueries used as FROM clause terms.

Resolve names in expressions that can only reference a single table or which cannot reference any tables at all.

Force the INT64 value currently stored as the result to be a MEM_IntReal value.

Given a SELECT statement, generate a Table structure that describes the result set of that SELECT.

Use the content of the StrAccum passed as the second argument as the result of an SQL function.

Rollback all database files.

This function is called by the VDBE to adjust the internal schema used by SQLite when the btree layer moves a table root page.

Code an OP_Halt due to non-unique rowid.

Deallocate all chunks from a RowSet.

Deallocate all chunks from a RowSet.

Allocate a RowSet object.

Insert a new value into a RowSet.

Extract the smallest element from the RowSet.

Check to see if element iRowid was inserted into the rowset as part of any insert batch prior to iBatch.

Register the r-tree module with database handle db.

Run the parser on the given SQL string.

This routine implements the OP_Vacuum opcode of the VDBE.

Check to make sure we have a valid db pointer.

This function is called by the parser when it parses a command to create, release or rollback an SQL savepoint.

Free all resources held by the schema structure.

Find and return the schema associated with a BTree.

Convert a schema pointer into the iDb index that indicates which database file in db->aDb[] the schema refers to.

Return a sanitized version of the sector-size of OS file pFile.

Generate code for the SELECT statement given in the p argument.

Add type and collation information to a column list based on a SELECT statement.

Delete the given Select structure and all of its substructures.

Initialize a SelectDest structure.

Return the maximum height of any expression tree referenced by the select statement passed as an argument.

Allocate a new Select structure and return a pointer to that structure.

Name of the connection operator, used for error messages.

If the SELECT passed as the second argument has an associated WITH clause, pop it from the stack stored as part of the Parse object.

This routine sets up a SELECT statement for processing.

This is a SELECT-node callback for the expression walker that always "fails".

No-op routine for the parse-tree walker for SELECT statements.

Error message for when two or more terms of a compound select have different size result sets.

Attach a table to a session.

Obtain a changeset object containing all changes recorded by the session object passed as the first argument.

Return the maximum size of sqlite3session_changeset() output.

Streaming version of sqlite3session_changeset().

Global configuration.

Create a session object.

Delete a session object previously allocated using sqlite3session_create().

Enable or disable the session object passed as the first argument.

Enable or disable the session object passed as the first argument.

Return true if there have been no changes to monitored tables recorded by the session object passed as the only argument.

Return the amount of heap memory in use.

Configure the session object passed as the first argument.

Obtain a patchset object containing all changes recorded by the session object passed as the first argument.

Streaming version of sqlite3session_patchset().

Set a table filter on a Session Object.

Set the EP_FromJoin property on all terms of the given expression.

Free any prior content in *pz and replace it with a copy of zNew.

Change the text encoding for a database connection.

Return true if zName is a shadow table name in the current database connection.

Append a new table name to the given SrcList.

This routine is called by the parser to add a new term to the end of a growing FROM clause.

Append the contents of SrcList p2 to SrcList p1 and return the resulting SrcList.

Assign VdbeCursor index numbers to all tables in a SrcList.

Delete an entire SrcList including all its substructure.

If cursors, triggers, views and subqueries are all omitted from the build, then none of the following routines, except for sqlite3SelectDup(), can be called.

Expand the space allocated for the given SrcList object by creating nExtra new slots beginning at iStart.

Add the list of function arguments to the SrcList entry for a table-valued-function.

Add an INDEXED BY or NOT INDEXED clause to the most recently added element of the source-list passed as the second argument.

While a SrcList can in general represent multiple tables and subqueries (as in the FROM clause of a SELECT statement) in this case it contains the name of a single table, as one might find in an INSERT, DELETE, or UPDATE statement.

When building up a FROM clause in the parser, the join operator is initially attached to the left operand.

Begin constructing a new table representation in memory.

Extract the iCol-th column from the nRec-byte record in pRec.

Unless it is NULL, the argument must be an UnpackedRecord object returned by an earlier call to sqlite3Stat4ProbeSetValue().

This function is used to allocate and populate UnpackedRecord structures intended to be compared against sample index keys stored in the sqlite_stat4 table.

Attempt to extract a value from expression pExpr using the methods as described for sqlite3Stat4ProbeSetValue() above.

Adjust the highwater mark if necessary.

Add N to the value of a status record.

Return the current value of a status parameter.

Return the current time for a statement.

Convert a storage column number into a table column number.

Initialize a string accumulator.

Set the StrAccum object to an error mode.

Compute an 8-bit hash on a string that is insensitive to case differences.

Compute a string length that is limited to what can be stored in lower 30 bits of a 32-bit signed integer.

Load the Parse object passed as the first argument with an error message of the form: "sub-select returns N columns - expected M".

Load the sqlite3.iSysErrno field if that is an appropriate thing to do based on the SQLite error code in rc.

Make changes to the evolving bytecode to do affinity transformations of values that are about to be gathered into a row for table pTab.

Return the affinity character for a single column of a table.

Convert an table column number into a index column number.

Convert a table column number into a storage column number.

This function returns true if main-memory should be used instead of a temporary file for transient pager files and statement journals.

Create a new thread.

Get the results of the thread.

Generate a Token object from a string.

Transfer all bindings from the first statement over to the second.

Triggers may access values stored in the old.* or new.* pseudo-table.

Construct a trigger step that implements a DELETE statement and return a pointer to that trigger step.

Build a trigger step out of an INSERT statement.

Given table pTab, return a list of all the triggers attached to the table.

Turn a SELECT statement (that the pSelect parameter points to) into a trigger step.

Return a list of all triggers on table pTab if there exists at least one trigger that must be fired when an operation of type 'op' is performed on the table, and, if that operation is an UPDATE, if at least one of the columns in pChanges is being modified.

Convert the pStep->zTarget string into a SrcList and return a pointer to that SrcList.

Construct a trigger step that implements an UPDATE statement and return a pointer to that trigger step.

The table or view or trigger name is passed to this routine via tokens pName1 and pName2.

Code an OP_Halt due to UNIQUE or PRIMARY KEY constraint violation.

For the index called zIdxName which is found in the database iDb, unlike that index from its Table then remove the index from the index hash table and free all memory structures associated with the index.

Unlink the given table from the hash tables and the delete the table structure with all its indices and foreign keys.

Remove a trigger from the hash tables of the sqlite* pointer.

Process an UPDATE statement.

Analyze the ON CONFLICT clause described by pUpsert.

Generate bytecode that does an UPDATE as part of an upsert.

Duplicate an Upsert object.

Create a new Upsert object.

Return true if pUpsert is the last ON CONFLICT clause with a conflict target, or if pUpsert is followed by another ON CONFLICT clause that targets the INTEGER PRIMARY KEY.

Given the list of ON CONFLICT clauses described by pUpsert, and a particular index pIdx, return a pointer to the particular ON CONFLICT clause that applies to the index.

zIn is a UTF-16 encoded unicode string at least nChar characters long.

Convert a UTF-16 string in the native encoding into a UTF-8 string.

pZ is a UTF-8 encoded unicode string.

Translate a single UTF-8 character.

This routine is called from the TCL test function "translate_selftest".

The VACUUM command is used to clean up the database, collapse free space, etc.

Exported version of applyAffinity().

Free an sqlite3_value object.

Create a new sqlite3_value object, containing the value of pExpr.

Create a new sqlite3_value object.

Change the string value of an sqlite3_value object.

This function is only available internally, it is not part of the external API.

Return the number of bytes that will be needed to store the given 64-bit integer.

Add an OP_Function or OP_PureFunc opcode.

Add an opcode that includes the p4 value as a pointer.

Add an opcode that includes the p4 value with a P4_INT64 or P4_REAL type.

Add an opcode that includes the p4 value as an integer.

Add a whole list of operations to the operation stack.

Add an OP_ParseSchema opcode.

This routine is used to allocate sufficient space for an UnpackedRecord structure large enough to be used with sqlite3VdbeRecordUnpack() if the first argument is a pointer to KeyInfo structure pKeyInfo.

Change the P4 operand of the most recently coded instruction to the value defined by the arguments.

Return 1 if pMem represents true, and return 0 if pMem represents false.

If pMem is an object with a valid string representation, this routine ensures the internal encoding for the string representation is 'desiredEnc', one of SQLITE_UTF8, SQLITE_UTF16LE or SQLITE_UTF16BE.

Change the value of the opcode, or P1, P2, P3, or P5 operands for a specific instruction.

Change the opcode at addr into OP_Noop.

This function is called when a transaction opened by the database handle associated with the VM passed as an argument is about to be committed.

Free all memory associated with the Vdbe passed as the second argument, except for object itself, which is preserved.

Set a flag in the vdbe to update the change counter when it is finalised or reset.

Create a new virtual database engine.

Return the address of the next instruction to be inserted.

Make sure the cursor p is ready to read or write the row to which it was last positioned.

Check to ensure that the cursor is valid.

Return the database associated with the Vdbe.

Delete an entire VDBE.

If parameter iOp is less than zero, then invoke the destructor for all auxiliary data pointers currently cached by the VM passed as the first argument.

If the last opcode is "op" and it is not a jump destination, then remove it.

Compute a string for the "comment" field of a VDBE opcode listing.

Compute a string that describes the P4 parameter for an opcode.

Insert the end of a co-routine.

If SQLite is compiled to support shared-cache mode and to be threadsafe, this routine obtains the mutex associated with each BtShared structure that may be accessed by the VM passed as an argument.

Change the error string stored in Vdbe.zErrMsg.

Execute as much of a VDBE program as we can.

This function returns a pointer to a nul-terminated string in memory obtained from sqlite3DbMalloc().

Add a new OP_Explain opcode.

Return the address of the current EXPLAIN QUERY PLAN baseline.

Pop the EXPLAIN QUERY PLAN stack one level.

Clean up and delete a VDBE after execution.

Return a pointer to an sqlite3VdbeRecordCompare() compatible function suitable for comparing serialized records to the unpacked record passed as the only argument.

The cursor "p" has a pending seek operation that has not yet been carried out.

Delete a VdbeFrame object and its contents.

This is a destructor on a Mem object (which is really an sqlite3_value) that deletes the Frame object that is attached to it as a blob.

Copy the values stored in the VdbeFrame structure to its Vdbe.

Close a VDBE cursor and release all the resources that cursor happens to hold.

Return a pointer to an sqlite3_value structure containing the value bound parameter iVar of VM v.

Return the opcode for a given address.

Generate code for an unconditional jump to instruction iDest.

This routine is called the when a VDBE tries to halt.

Return true if the given Vdbe has any SubPrograms.

Compare the key of the index entry that cursor pC is pointing to against the key string in pUnpacked.

pCur points at an index entry created using the OP_MakeRecord opcode.

The MEM structure is already a MEM_Real.

Change the P2 operand of instruction addr so that it points to the address of the next instruction to be coded.

Change the P2 operand of the jump instruction at addr so that the jump lands on the next opcode.

Link the SubProgram object passed as the second argument into the linked list at Vdbe.pSubProgram.

Give a listing of the program in the virtual machine.

Generate code to cause the string zStr to be loaded into register iDest.

Create a new symbolic label for an instruction that has yet to be coded.

Prepare a virtual machine for execution for the first time after creating the virtual machine.

Memory cell pAccum contains the context of an aggregate function.

Cast the datatype of the value in pMem according to the affinity "aff".

Change the pMem->zMalloc allocation to be at least szNew bytes.

Make a full copy of pFrom into pTo.

If the given Mem* has a zero-filled tail, turn it into an ordinary blob stored in dynamically allocated space.

Memory cell pMem contains the context of an aggregate function.

Move data out of a btree key or data field and into a Mem structure.

Make sure pMem->z points to a writable allocation of at least n bytes.

This routine checks for a byte-order mark at the beginning of the UTF-16 string stored in *pMem.

Initialize bulk memory to be a consistent Mem object.

Convert pMem to type integer.

Change pMem so that its MEM_Str or MEM_Blob value is stored in MEM.zMalloc, where it can be safely written.

Transfer the contents of pFrom to pTo.

Make sure the given Mem is \u0000 terminated.

Convert pMem so that it has type MEM_Real or MEM_Int.

Convert pMem so that it is of type MEM_Real.

Release any memory resources held by the Mem.

Delete any previous value and set the value stored in *pMem to val, manifest type REAL.

Delete any previous value and set the value stored in *pMem to val, manifest type INTEGER.

Delete any previous value and set the value stored in *pMem to NULL.

Set the value stored in *pMem should already be a NULL.

Delete any previous value and set the value of pMem to be an empty boolean index.

Change the value of a Mem to be a string or a BLOB.

Delete any previous value and set the value to be a BLOB of length n containing all zeros.

Add MEM_Str to the set of representations for the given Mem.

Return true if the Mem object contains a TEXT or BLOB that is too large - whose size exceeds SQLITE_MAX_LENGTH.

This routine transforms the internal text encoding used by pMem to desiredEnc.

Generate code that initializes multiple registers to string or integer constants.

Locate the next opcode to be displayed in EXPLAIN or EXPLAIN QUERY PLAN output.

Given a wildcard parameter name, return the index of the variable with that name.

Return the Parse object that owns a Vdbe object.

Return the SQLITE_PREPARE flags for a Vdbe.

Invoke the pre-update hook.

This function compares the two table rows or index records specified by {nKey1, pKey1} and pPKey2.

Given the nKey-byte encoding of a record in pKey[], populate the UnpackedRecord structure indicated by the fourth argument with the contents of the decoded record.

Clean up a VDBE after execution but do not delete the VDBE just yet.

Each VDBE holds the result of the most recent sqlite3_step() call in p->rc.

Mark the VDBE as one that can only be run multiple times.

Rewind the VDBE back to the beginning in preparation for running it.

Mark the VDBE as one that can only be run one time.

Write the serialized data blob for the value stored in pMem into buf.

Return the length of the data corresponding to the supplied serial-type.

This routine sets the value to be returned by subsequent calls to sqlite3_changes() on the database handle 'db'.

Set the name of the idx'th column to be returned by the SQL statement.

Set the number of result columns that will be returned by this SQL statement.

Set the P4 on the most recently added opcode to the KeyInfo for the index given.

Remember the SQL string for a prepared statement.

Configure SQL variable iVar so that binding a new value to it signals to sqlite3_reoptimize() that re-preparing the statement may result in a better query plan.

Free any cursor components allocated by sqlite3VdbeSorterXXX routines.

Compare the key in memory cell pVal with the key that the sorter cursor passed as the first argument currently points to.

Initialize the temporary index cursor just opened as a sorter cursor.

Advance to the next element in the sorter.

Reset a sorting cursor back to its original empty state.

Once the sorter has been populated by calls to sqlite3VdbeSorterWrite, this function is called to prepare for iterating through the records in sorted order.

Copy the current sorter key into the memory cell pOut.

Add a record to the sorter.

Swap all content between two VDBE structures.

This function returns a pointer to the array of opcodes associated with the Vdbe passed as the first argument.

Copy the error code and error message belonging to the VDBE passed as the first argument to its database handle (so that they will be returned by calls to sqlite3_errcode() and sqlite3_errmsg()).

Declare to the Vdbe that the BTree object at db->aDb[i] is used.

Expression pExpr is a vector that has been used in a context where it is not permitted.

Return a pointer to a subexpression of pVector that is the i-th column of the vector (numbered starting with 0).

The Table structure pTable is really a VIEW.

Add a new name/number pair to a VList.

Return the number of the variable named zName, if it is in VList.

Return a pointer to the name of a variable in the given VList that has the value iVal.

Print into memory obtained from sqliteMalloc().

The parser calls this routine for each token after the first token in an argument to the module name in a CREATE VIRTUAL TABLE statement.

The parser calls this routine when it sees the first token of an argument to the module name in a CREATE VIRTUAL TABLE statement.

If the virtual table pVtab supports the transaction interface (xBegin/xRollback/xCommit and optionally xSync) and a transaction is not currently open, invoke the xBegin method now.

The parser calls this routine when it first sees a CREATE VIRTUAL TABLE statement.

This function is invoked by the parser to call the xConnect() method of the virtual table pTab.

This function is invoked by the vdbe to call the xCreate method of the virtual table named zTab in database iDb.

This function is invoked by the vdbe to call the xDestroy method of the virtual table named zTab in database iDb.

Clear any and all virtual-table information from the Table record.

Invoke the xCommit method of all virtual tables in the sqlite3.aVTrans array.

Construct and install a Module object for a virtual table.

Table *p is a virtual table.

Erase the eponymous virtual table instance associated with virtual table module pMod, if it exists.

Check to see if virtual table module pMod can be have an eponymous virtual table instance.

The parser calls this routine after the CREATE VIRTUAL TABLE statement has been completely parsed.

Transfer error message text from an sqlite3_vtab.zErrMsg (text stored in memory obtained from sqlite3_malloc) into a Vdbe.zErrMsg (text stored in memory obtained from sqlite3DbMalloc).

Lock the virtual table so that it cannot be disconnected.

Make sure virtual table pTab is contained in the pParse->apVirtualLock[] array so that an OP_VBegin will get generated for it.

Decrement the reference count on a Module object.

The first parameter (pDef) is a function implementation.

Invoke the xRollback method of all virtual tables in the sqlite3.aVTrans array.

Invoke either the xSavepoint, xRollbackTo or xRelease method of all virtual tables that currently have an open transaction.

Invoke the xSync method of all virtual tables in the sqlite3.aVTrans array.

Decrement the ref-count on a virtual table object.

Disconnect all the virtual table objects in the sqlite3.pDisconnect list.

Begin a read transaction on the database.

This function starts a write transaction on the WAL.

Return the value to pass to a sqlite3_wal_hook callback, the number of frames in the WAL at the point of the last commit since sqlite3WalCallback() was called.

This routine is called to implement sqlite3_wal_checkpoint() and related interfaces.

Close a connection to a log file.

Return the size of the database in pages (or zero, if unknown).

The sqlite3_wal_hook() callback registered by sqlite3_wal_autocheckpoint().

Finish with a read transaction.

End a write transaction.

This function is called to change the WAL subsystem into or out of locking_mode=EXCLUSIVE.

Return the sqlite3_file object for the WAL file.

Search the wal file for page pgno.

Write a set of frames to the log.

Return true if the argument is non-NULL and the WAL module is using heap-memory for the wal-index.

Increase the walkerDepth when entering a subquery, and descrease when leaving the subquery.

Call sqlite3WalkExpr() for every expression in list p or until an abort request is seen.

Call sqlite3WalkExpr() for every expression in Select statement p.

Walk all expressions associated with SELECT statement p.

Walk the parse trees associated with all subqueries in the FROM clause of SELECT statement p.

This is a no-op callback for Walker->xSelectCallback2.

Change the size to which the WAL file is trucated on each reset.

Open a connection to the WAL file zWalName.

Read the contents of frame iRead from the wal file into buffer pOut (which is nOut bytes in size).

Argument aWalData must point to an array of WAL_SAVEPOINT_NDATA u32 values.

Move the write position of the WAL back to the point identified by the values in the aWalData[] array.

The caller currently has a read transaction open on the database.

Create a snapshot object.

Try to open on pSnapshot when the next read-transaction starts.

Attempt to reduce the value of the WalCkptInfo.nBackfillAttempted variable so that older snapshots can be accessed.

Release a lock obtained by an earlier successful call to sqlite3WalSnapshotCheck().

If any data has been written (but not committed) to the log file, this function moves the write-pointer back to the start of the transaction.

Generate the beginning of the loop used for WHERE clause processing.

Return the VDBE address or label to jump to in order to break out of a WHERE loop.

Deallocate a WhereClause structure.

Initialize a preallocated WhereClause structure.

Generate code for the start of the iLevel-th loop in the WHERE clause implementation described by pWInfo.

Return the VDBE address or label to jump to in order to continue immediately with the next row of a WHERE clause.

Generate the end of the WHERE loop.

This function is a no-op unless currently processing an EXPLAIN QUERY PLAN command, or if either SQLITE_DEBUG or SQLITE_ENABLE_STMT_SCANSTATUS was defined at compile-time.

Call exprAnalyze on all terms in a WHERE clause.

These routines walk (recursively) an expression tree and generate a bitmask indicating which tables are used in that expression tree.

Search for a term in the WHERE clause that is of the form "X <op> <expr>" where X is a reference to the iColumn of table iCur or of index pIdx if pIdx!=0 and <op> is one of the WO_xx operator codes specified by the op parameter.

Return the bitmask for the given cursor number.

Return one of the WHERE_DISTINCT_xxxxx values to indicate how this WHERE clause returns outputs for DISTINCT processing.

Return the number of ORDER BY terms that are satisfied by the WHERE clause.

If the WHERE_GROUPBY flag is set in the mask passed to sqlite3WhereBegin(), the planner assumes that the specified pOrderBy list is actually a GROUP BY clause - and so any order that groups rows as required satisfies the request.

While generating code for the min/max optimization, after handling the aggregate-step call to min() or max(), check to see if any additional looping is required.

Return ONEPASS_OFF (0) if an UPDATE or DELETE statement is unable to operate directly on the rowids returned by a WHERE clause.

In the ORDER BY LIMIT optimization, if the inner-most loop is known to emit rows in increasing order, and if the last row emitted by the inner-most loop did not fit within the sorter, then we can skip all subsequent rows for the current iteration of the inner loop (because they will not fit in the sorter either) and continue with the second inner loop - the loop immediately outside the inner-most.

Return the estimated number of output rows from a WHERE clause.

This routine identifies subexpressions in the WHERE clause where each subexpression is separated by the AND operator or some other operator specified in the op parameter.

For table-valued-functions, transform the function arguments into new WHERE clause terms.

Return TRUE if the WHERE loop uses the OP_DeferredSeek opcode to move the data cursor to the row selected by the index cursor.

Allocate and return a new Window object describing a Window Definition.

Attach PARTITION and ORDER BY clauses pPartition and pOrderBy to window pWin.

Attach window object pWin to expression p.

Window *pWin has just been created from a WINDOW clause.

This is called by code in select.c before it calls sqlite3WhereBegin() to begin iterating through the sub-query results.

sqlite3WhereBegin() has already been called for the SELECT statement passed as the second argument when this function is invoked.

Return 0 if the two window objects are identical, 1 if they are different, or 2 if it cannot be determined if the objects are identical or not.

Free the Window object passed as the second argument.

Allocate and return a duplicate of the Window object indicated by the third argument.

Register those built-in window functions that are not also aggregates.

Possibly link window pWin into the list at pSel->pWin (window functions to be processed as part of SELECT statement pSel).

Free the linked list of Window objects starting at the second argument.

Return a copy of the linked list of Window objects passed as the second argument.

If the SELECT statement passed as the second argument does not invoke any SQL window functions, this function is a no-op.

Unlink the Window object from the Select to which it is attached, if it is attached.

This function is called immediately after resolving the function name for a window function within a SELECT statement.

This routine is invoked once per CTE by the parser while parsing a WITH clause.

Free the contents of the With object passed as the second argument.

Create and return a deep copy of the object passed as the second argument.

The code generator maintains a stack of active WITH clauses with the inner-most WITH clause being at the top of the stack.

True if PRAGMA writable_schema is ON.

Owner types.

Process group.

Process.

Kernel thread.

All floating-point numbers can be put in one of these categories.

Rounding direction macros for fromfp functions.

Rounding direction macros for fromfp functions.

Rounding direction macros for fromfp functions.

Rounding direction macros for fromfp functions.

Rounding direction macros for fromfp functions.

All floating-point numbers can be put in one of these categories.

All floating-point numbers can be put in one of these categories.

All floating-point numbers can be put in one of these categories.

All floating-point numbers can be put in one of these categories.

Timers run when the process is executing and when the system is executing on behalf of the process.

Timers run in real time.

Timers run only when the process is executing.