System.Data.SQLite

Defines a source code identifier custom attribute for an assembly manifest.

Constructs an instance of this attribute class using the specified source code identifier value.

The source code identifier value to use.

Gets the source code identifier value.

Defines a source code time-stamp custom attribute for an assembly manifest.

Constructs an instance of this attribute class using the specified source code time-stamp value.

The source code time-stamp value to use.

Gets the source code time-stamp value.

This is the method signature for the SQLite core library logging callback function for use with sqlite3_log() and the SQLITE_CONFIG_LOG. WARNING: This delegate is used more-or-less directly by native code, do not modify its type signature.

The extra data associated with this message, if any. The error code associated with this message. The message string to be logged.

This class implements SQLiteBase completely, and is the guts of the code that interop's SQLite with .NET

This internal class provides the foundation of SQLite support. It defines all the abstract members needed to implement a SQLite data provider, and inherits from SQLiteConvert which allows for simple translations of string to and from SQLite.

This base class provides datatype conversion services for the SQLite provider.

The fallback default database type when one cannot be obtained from an existing connection instance.

The format string for DateTime values when using the InvariantCulture or CurrentCulture formats.

The fallback default database type name when one cannot be obtained from an existing connection instance.

The value for the Unix epoch (e.g. January 1, 1970 at midnight, in UTC).

The value of the OLE Automation epoch represented as a Julian day.

An array of ISO-8601 DateTime formats that we support parsing.

The internal default format for UTC DateTime values when converting to a string.

The internal default format for local DateTime values when converting to a string.

An UTF-8 Encoding instance, so we can convert strings to and from UTF-8

The default DateTime format for this instance.

The default DateTimeKind for this instance.

The default DateTime format string for this instance.

Initializes the conversion class

The default date/time format to use for this instance The DateTimeKind to use. The DateTime format string to use.

Converts a string to a UTF-8 encoded byte array sized to include a null-terminating character.

The string to convert to UTF-8 A byte array containing the converted string plus an extra 0 terminating byte at the end of the array.

Convert a DateTime to a UTF-8 encoded, zero-terminated byte array.

This function is a convenience function, which first calls ToString() on the DateTime, and then calls ToUTF8() with the string result. The DateTime to convert. The UTF-8 encoded string, including a 0 terminating byte at the end of the array.

Converts a UTF-8 encoded IntPtr of the specified length into a .NET string

The pointer to the memory where the UTF-8 string is encoded The number of bytes to decode A string containing the translated character(s)

Converts a UTF-8 encoded IntPtr of the specified length into a .NET string

The pointer to the memory where the UTF-8 string is encoded The number of bytes to decode A string containing the translated character(s)

Converts a string into a DateTime, using the DateTimeFormat, DateTimeKind, and DateTimeFormatString specified for the connection when it was opened.

Acceptable ISO8601 DateTime formats are: THHmmssK THHmmK HH:mm:ss.FFFFFFFK HH:mm:ssK HH:mmK yyyy-MM-dd HH:mm:ss.FFFFFFFK yyyy-MM-dd HH:mm:ssK yyyy-MM-dd HH:mmK yyyy-MM-ddTHH:mm:ss.FFFFFFFK yyyy-MM-ddTHH:mmK yyyy-MM-ddTHH:mm:ssK yyyyMMddHHmmssK yyyyMMddHHmmK yyyyMMddTHHmmssFFFFFFFK THHmmss THHmm HH:mm:ss.FFFFFFF HH:mm:ss HH:mm yyyy-MM-dd HH:mm:ss.FFFFFFF yyyy-MM-dd HH:mm:ss yyyy-MM-dd HH:mm yyyy-MM-ddTHH:mm:ss.FFFFFFF yyyy-MM-ddTHH:mm yyyy-MM-ddTHH:mm:ss yyyyMMddHHmmss yyyyMMddHHmm yyyyMMddTHHmmssFFFFFFF yyyy-MM-dd yyyyMMdd yy-MM-dd If the string cannot be matched to one of the above formats -OR- the DateTimeFormatString if one was provided, an exception will be thrown. The string containing either a long integer number of 100-nanosecond units since System.DateTime.MinValue, a Julian day double, an integer number of seconds since the Unix epoch, a culture-independent formatted date and time string, a formatted date and time string in the current culture, or an ISO8601-format string. A DateTime value

Converts a string into a DateTime, using the specified DateTimeFormat, DateTimeKind and DateTimeFormatString.

Converts a julianday value into a DateTime

The value to convert A .NET DateTime

Converts a julianday value into a DateTime

The value to convert The DateTimeKind to use. A .NET DateTime

Converts the specified number of seconds from the Unix epoch into a value.

The number of whole seconds since the Unix epoch. Either Utc or Local time. The new value.

Converts the specified number of ticks since the epoch into a value.

The number of whole ticks since the epoch. Either Utc or Local time. The new value.

Converts a DateTime struct to a JulianDay double

The DateTime to convert The JulianDay value the Datetime represents

Converts a DateTime struct to the whole number of seconds since the Unix epoch.

The DateTime to convert The whole number of seconds since the Unix epoch

Returns the DateTime format string to use for the specified DateTimeKind. If is not null, it will be returned verbatim.

The DateTimeKind to use. The DateTime format string to use. The DateTime format string to use for the specified DateTimeKind.

Converts a string into a DateTime, using the DateTimeFormat, DateTimeKind, and DateTimeFormatString specified for the connection when it was opened.

The DateTime value to convert Either a string containing the long integer number of 100-nanosecond units since System.DateTime.MinValue, a Julian day double, an integer number of seconds since the Unix epoch, a culture-independent formatted date and time string, a formatted date and time string in the current culture, or an ISO8601-format date/time string.

Converts a string into a DateTime, using the DateTimeFormat, DateTimeKind, and DateTimeFormatString specified for the connection when it was opened.

The DateTime value to convert The SQLiteDateFormats to use. The DateTimeKind to use. The DateTime format string to use. Either a string containing the long integer number of 100-nanosecond units since System.DateTime.MinValue, a Julian day double, an integer number of seconds since the Unix epoch, a culture-independent formatted date and time string, a formatted date and time string in the current culture, or an ISO8601-format date/time string.

Internal function to convert a UTF-8 encoded IntPtr of the specified length to a DateTime.

This is a convenience function, which first calls ToString() on the IntPtr to convert it to a string, then calls ToDateTime() on the string to return a DateTime. A pointer to the UTF-8 encoded string The length in bytes of the string The parsed DateTime value

Smart method of splitting a string. Skips quoted elements, removes the quotes.

This split function works somewhat like the String.Split() function in that it breaks apart a string into pieces and returns the pieces as an array. The primary differences are: Only one character can be provided as a separator character Quoted text inside the string is skipped over when searching for the separator, and the quotes are removed. Thus, if splitting the following string looking for a comma:
One,Two, "Three, Four", Five

The resulting array would contain
[0] One
[1] Two
[2] Three, Four
[3] Five

Note that the leading and trailing spaces were removed from each item during the split. Source string to split apart Separator character A string array of the split up elements

Splits the specified string into multiple strings based on a separator and returns the result as an array of strings.

The string to split into pieces based on the separator character. If this string is null, null will always be returned. If this string is empty, an array of zero strings will always be returned. The character used to divide the original string into sub-strings. This character cannot be a backslash or a double-quote; otherwise, no work will be performed and null will be returned. If this parameter is non-zero, all double-quote characters will be retained in the returned list of strings; otherwise, they will be dropped. Upon failure, this parameter will be modified to contain an appropriate error message. The new array of strings or null if the input string is null -OR- the separator character is a backslash or a double-quote -OR- the string contains an unbalanced backslash or double-quote character.

Queries and returns the string representation for an object, using the specified (or current) format provider.

The object instance to return the string representation for. The format provider to use -OR- null if the current format provider for the thread should be used instead. The string representation for the object instance -OR- null if the object instance is also null.

Attempts to convert an arbitrary object to the Boolean data type. Null object values are converted to false. Throws an exception upon failure.

The object value to convert. The format provider to use. If non-zero, a string value will be converted using the method; otherwise, the method will be used. The converted boolean value.

Convert a value to true or false.

A string or number representing true or false

Convert a string to true or false.

A string representing true or false "yes", "no", "y", "n", "0", "1", "on", "off" as well as Boolean.FalseString and Boolean.TrueString will all be converted to a proper boolean value.

Converts a SQLiteType to a .NET Type object

The SQLiteType to convert Returns a .NET Type object

For a given intrinsic type, return a DbType

The native type to convert The corresponding (closest match) DbType

Returns the ColumnSize for the given DbType

The DbType to get the size of

Determines the default database type name to be used when a per-connection value is not available.

The connection context for type mappings, if any. The default database type name to use.

If applicable, issues a trace log message warning about falling back to the default database type name.

The database value type. The flags associated with the parent connection object. The textual name of the database type.

If applicable, issues a trace log message warning about falling back to the default database value type.

The textual name of the database type. The flags associated with the parent connection object. The database value type.

For a given database value type, return the "closest-match" textual database type name.

The connection context for custom type mappings, if any. The database value type. The flags associated with the parent connection object. The type name or an empty string if it cannot be determined.

Convert a DbType to a Type

The DbType to convert from The closest-match .NET type

For a given type, return the closest-match SQLite TypeAffinity, which only understands a very limited subset of types.

The type to evaluate The SQLite type affinity for that type.

Builds and returns a map containing the database column types recognized by this provider.

A map containing the database column types recognized by this provider.

Determines if a database type is considered to be a string.

The database type to check. Non-zero if the database type is considered to be a string, zero otherwise.

Determines and returns the runtime configuration setting string that should be used in place of the specified object value.

The object value to convert to a string. Either the string to use in place of the object value -OR- null if it cannot be determined.

Determines the default value to be used when a per-connection value is not available.

The connection context for type mappings, if any. The default value to use.

Determines if the specified textual value appears to be a value.

The textual value to inspect. Non-zero if the text looks like a value, zero otherwise.

Determines if the specified textual value appears to be an value.

The textual value to inspect. Non-zero if the text looks like an value, zero otherwise.

Determines if the specified textual value appears to be a value.

The textual value to inspect. Non-zero if the text looks like a value, zero otherwise.

Determines if the specified textual value appears to be a value.

The object instance configured with the chosen format. The textual value to inspect. Non-zero if the text looks like a in the configured format, zero otherwise.

For a given textual database type name, return the "closest-match" database type. This method is called during query result processing; therefore, its performance is critical.

The connection context for custom type mappings, if any. The textual name of the database type to match. The flags associated with the parent connection object. The .NET DBType the text evaluates to.

The error code used for logging exceptions caught in user-provided code.

Sets the status of the memory usage tracking subsystem in the SQLite core library. By default, this is enabled. If this is disabled, memory usage tracking will not be performed. This is not really a per-connection value, it is global to the process.

Non-zero to enable memory usage tracking, zero otherwise. A standard SQLite return code (i.e. zero for success and non-zero for failure).

Attempts to free as much heap memory as possible for the database connection.

A standard SQLite return code (i.e. zero for success and non-zero for failure).

Shutdown the SQLite engine so that it can be restarted with different config options. We depend on auto initialization to recover.

Determines if the associated native connection handle is open.

Non-zero if a database connection is open.

Opens a database.

Implementers should call SQLiteFunction.BindFunctions() and save the array after opening a connection to bind all attributed user-defined functions and collating sequences to the new connection. The filename of the database to open. SQLite automatically creates it if it doesn't exist. The flags associated with the parent connection object The open flags to use when creating the connection The maximum size of the pool for the given filename If true, the connection can be pulled from the connection pool

Closes the currently-open database.

After the database has been closed implemeters should call SQLiteFunction.UnbindFunctions() to deallocate all interop allocated memory associated with the user-defined functions and collating sequences tied to the closed connection. Non-zero if the operation is allowed to throw exceptions, zero otherwise.

Sets the busy timeout on the connection. SQLiteCommand will call this before executing any command.

The number of milliseconds to wait before returning SQLITE_BUSY

Returns the text of the last error issued by SQLite

Returns the text of the last error issued by SQLite -OR- the specified default error text if none is available from the SQLite core library.

The error text to return in the event that one is not available from the SQLite core library. The error text.

When pooling is enabled, force this connection to be disposed rather than returned to the pool

When pooling is enabled, returns the number of pool entries matching the current file name.

The number of pool entries matching the current file name.

Prepares a SQL statement for execution.

The source connection preparing the command. Can be null for any caller except LINQ The SQL command text to prepare The previous statement in a multi-statement command, or null if no previous statement exists The timeout to wait before aborting the prepare The remainder of the statement that was not processed. Each call to prepare parses the SQL up to to either the end of the text or to the first semi-colon delimiter. The remaining text is returned here for a subsequent call to Prepare() until all the text has been processed. Returns an initialized SQLiteStatement.

Steps through a prepared statement.

The SQLiteStatement to step through True if a row was returned, False if not.

Resets a prepared statement so it can be executed again. If the error returned is SQLITE_SCHEMA, transparently attempt to rebuild the SQL statement and throw an error if that was not possible.

The statement to reset Returns -1 if the schema changed while resetting, 0 if the reset was sucessful or 6 (SQLITE_LOCKED) if the reset failed due to a lock

Attempts to interrupt the query currently executing on the associated native database connection.

This function binds a user-defined functions to the connection.

The object instance containing the metadata for the function to be bound. The object instance that implements the function to be bound. The flags associated with the parent connection object.

Calls the native SQLite core library in order to create a disposable module containing the implementation of a virtual table.

The module object to be used when creating the native disposable module. The flags for the associated object instance.

Calls the native SQLite core library in order to cleanup the resources associated with a module containing the implementation of a virtual table.

The module object previously passed to the method. The flags for the associated object instance.

Calls the native SQLite core library in order to declare a virtual table in response to a call into the or virtual table methods.

The virtual table module that is to be responsible for the virtual table being declared. The string containing the SQL statement describing the virtual table to be declared. Upon success, the contents of this parameter are undefined. Upon failure, it should contain an appropriate error message. A standard SQLite return code.

Calls the native SQLite core library in order to declare a virtual table function in response to a call into the or virtual table methods.

The virtual table module that is to be responsible for the virtual table function being declared. The number of arguments to the function being declared. The name of the function being declared. Upon success, the contents of this parameter are undefined. Upon failure, it should contain an appropriate error message. A standard SQLite return code.

Enables or disabled extension loading by SQLite.

True to enable loading of extensions, false to disable.

Loads a SQLite extension library from the named file.

The name of the dynamic link library file containing the extension. The name of the exported function used to initialize the extension. If null, the default "sqlite3_extension_init" will be used.

Enables or disabled extened result codes returned by SQLite

true to enable extended result codes, false to disable.

Returns the numeric result code for the most recent failed SQLite API call associated with the database connection.

Result code

Returns the extended numeric result code for the most recent failed SQLite API call associated with the database connection.

Extended result code

Add a log message via the SQLite sqlite3_log interface.

Error code to be logged with the message. String to be logged. Unlike the SQLite sqlite3_log() interface, this should be pre-formatted. Consider using the String.Format() function.

Checks if the SQLite core library has been initialized in the current process.

Non-zero if the SQLite core library has been initialized in the current process, zero otherwise.

Creates a new SQLite backup object based on the provided destination database connection. The source database connection is the one associated with this object. The source and destination database connections cannot be the same.

The destination database connection. The destination database name. The source database name. The newly created backup object.

Copies up to N pages from the source database to the destination database associated with the specified backup object.

The backup object to use. The number of pages to copy or negative to copy all remaining pages. Set to true if the operation needs to be retried due to database locking issues. True if there are more pages to be copied, false otherwise.

Returns the number of pages remaining to be copied from the source database to the destination database associated with the specified backup object.

The backup object to check. The number of pages remaining to be copied.

Returns the total number of pages in the source database associated with the specified backup object.

The backup object to check. The total number of pages in the source database.

Destroys the backup object, rolling back any backup that may be in progess.

The backup object to destroy.

Returns the error message for the specified SQLite return code using the internal static lookup table.

The SQLite return code. The error message or null if it cannot be found.

Returns the error message for the specified SQLite return code using the sqlite3_errstr() function, falling back to the internal lookup table if necessary.

The SQLite return code. The error message or null if it cannot be found.

Returns a string representing the active version of SQLite

Returns an integer representing the active version of SQLite

Returns the rowid of the most recent successful INSERT into the database from this connection.

Returns the number of changes the last executing insert/update caused.

Returns the amount of memory (in bytes) currently in use by the SQLite core library. This is not really a per-connection value, it is global to the process.

Returns the maximum amount of memory (in bytes) used by the SQLite core library since the high-water mark was last reset. This is not really a per-connection value, it is global to the process.

Returns non-zero if the underlying native connection handle is owned by this instance.

Returns non-zero if the given database connection is in autocommit mode. Autocommit mode is on by default. Autocommit mode is disabled by a BEGIN statement. Autocommit mode is re-enabled by a COMMIT or ROLLBACK.

The opaque pointer returned to us by the sqlite provider

The user-defined functions registered on this connection

The modules created using this connection.

Constructs the object used to interact with the SQLite core library using the UTF-8 text encoding.

The DateTime format to be used when converting string values to a DateTime and binding DateTime parameters. The to be used when creating DateTime values. The format string to be used when parsing and formatting DateTime values. The native handle to be associated with the database connection. The fully qualified file name associated with . Non-zero if the newly created object instance will need to dispose of when it is no longer needed.

This method attempts to dispose of all the derived object instances currently associated with the native database connection.

Attempts to interrupt the query currently executing on the associated native database connection.

This function binds a user-defined function to the connection.

The object instance containing the metadata for the function to be bound. The object instance that implements the function to be bound. The flags associated with the parent connection object.

Attempts to free as much heap memory as possible for the database connection.

A standard SQLite return code (i.e. zero for success and non-zero for failure).

Attempts to free N bytes of heap memory by deallocating non-essential memory allocations held by the database library. Memory used to cache database pages to improve performance is an example of non-essential memory. This is a no-op returning zero if the SQLite core library was not compiled with the compile-time option SQLITE_ENABLE_MEMORY_MANAGEMENT. Optionally, attempts to reset and/or compact the Win32 native heap, if applicable.

The requested number of bytes to free. Non-zero to attempt a heap reset. Non-zero to attempt heap compaction. The number of bytes actually freed. This value may be zero. This value will be non-zero if the heap reset was successful. The size of the largest committed free block in the heap, in bytes. This value will be zero unless heap compaction is enabled. A standard SQLite return code (i.e. zero for success and non-zero for failure).

Shutdown the SQLite engine so that it can be restarted with different configuration options. We depend on auto initialization to recover.

Returns a standard SQLite result code.

Shutdown the SQLite engine so that it can be restarted with different configuration options. We depend on auto initialization to recover.

Non-zero to reset the database and temporary directories to their default values, which should be null for both. This parameter has no effect on non-Windows operating systems. Returns a standard SQLite result code.

Determines if the associated native connection handle is open.

Non-zero if the associated native connection handle is open.

Calls the native SQLite core library in order to create a disposable module containing the implementation of a virtual table.

The module object to be used when creating the native disposable module. The flags for the associated object instance.

Calls the native SQLite core library in order to cleanup the resources associated with a module containing the implementation of a virtual table.

The module object previously passed to the method. The flags for the associated object instance.

Calls the native SQLite core library in order to declare a virtual table in response to a call into the or virtual table methods.

Calls the native SQLite core library in order to declare a virtual table function in response to a call into the or virtual table methods.

Enables or disabled extension loading by SQLite.

True to enable loading of extensions, false to disable.

Loads a SQLite extension library from the named file.

The name of the dynamic link library file containing the extension. The name of the exported function used to initialize the extension. If null, the default "sqlite3_extension_init" will be used. Enables or disabled extended result codes returned by SQLite Gets the last SQLite error code Gets the last SQLite extended error code Add a log message via the SQLite sqlite3_log interface. Add a log message via the SQLite sqlite3_log interface.

Allows the setting of a logging callback invoked by SQLite when a log event occurs. Only one callback may be set. If NULL is passed, the logging callback is unregistered.

The callback function to invoke. Returns a result code

The destination database connection. The destination database name. The source database name. The newly created backup object.

Copies up to N pages from the source database to the destination database associated with the specified backup object.

The backup object to use. The number of pages to copy, negative to copy all remaining pages. Set to true if the operation needs to be retried due to database locking issues; otherwise, set to false. True if there are more pages to be copied, false otherwise.

Returns the number of pages remaining to be copied from the source database to the destination database associated with the specified backup object.

The backup object to check. The number of pages remaining to be copied.

Returns the total number of pages in the source database associated with the specified backup object.

The backup object to check. The total number of pages in the source database.

Destroys the backup object, rolling back any backup that may be in progess.

The backup object to destroy.

Determines if the SQLite core library has been initialized for the current process.

A boolean indicating whether or not the SQLite core library has been initialized for the current process.

Determines if the SQLite core library has been initialized for the current process.

A boolean indicating whether or not the SQLite core library has been initialized for the current process.

Helper function to retrieve a column of data from an active statement.

The statement being step()'d through The flags associated with the connection. The column index to retrieve The type of data contained in the column. If Uninitialized, this function will retrieve the datatype information. Returns the data in the column

Returns non-zero if the underlying native connection handle is owned by this instance.

Alternate SQLite3 object, overriding many text behaviors to support UTF-16 (Unicode)

Constructs the object used to interact with the SQLite core library using the UTF-8 text encoding.

Overrides SQLiteConvert.ToString() to marshal UTF-16 strings instead of UTF-8

A pointer to a UTF-16 string The length (IN BYTES) of the string A .NET string

Represents a single SQL backup in SQLite.

The underlying SQLite object this backup is bound to.

The actual backup handle.

The destination database for the backup.

The destination database name for the backup.

The source database for the backup.

The source database name for the backup.

The last result from the StepBackup method of the SQLite3 class. This is used to determine if the call to the FinishBackup method of the SQLite3 class should throw an exception when it receives a non-Ok return code from the core SQLite library.

Initializes the backup.

The base SQLite object. The backup handle. The destination database for the backup. The destination database name for the backup. The source database for the backup. The source database name for the backup.

Disposes and finalizes the backup.

Creates temporary tables on the connection so schema information can be queried.

The connection upon which to build the schema tables.

The extra behavioral flags that can be applied to a connection.

No extra flags.

Enable logging of all SQL statements to be prepared.

Enable logging of all bound parameter types and raw values.

Enable logging of all bound parameter strongly typed values.

Enable logging of all exceptions caught from user-provided managed code called from native code via delegates.

Enable logging of backup API errors.

Skip adding the extension functions provided by the native interop assembly.

When binding parameter values with the type, use the interop method that accepts an value.

When binding parameter values, always bind them as though they were plain text (i.e. no numeric, date/time, or other conversions should be attempted).

When returning column values, always return them as though they were plain text (i.e. no numeric, date/time, or other conversions should be attempted).

Prevent this object instance from loading extensions.

Prevent this object instance from creating virtual table modules.

Skip binding any functions provided by other managed assemblies when opening the connection.

Skip setting the logging related properties of the object instance that was passed to the method.

Enable logging of all virtual table module errors seen by the method.

Enable logging of certain virtual table module exceptions that cannot be easily discovered via other means.

Enable tracing of potentially important [non-fatal] error conditions that cannot be easily reported through other means.

When binding parameter values, always use the invariant culture when converting their values from strings.

When binding parameter values, always use the invariant culture when converting their values to strings.

Disable using the connection pool by default. If the "Pooling" connection string property is specified, its value will override this flag. The precise outcome of combining this flag with the flag is unspecified; however, one of the flags will be in effect.

Enable using the connection pool by default. If the "Pooling" connection string property is specified, its value will override this flag. The precise outcome of combining this flag with the flag is unspecified; however, one of the flags will be in effect.

Enable using per-connection mappings between type names and values. Also see the , , and methods. These per-connection mappings, when present, override the corresponding global mappings.

Disable using global mappings between type names and values. This may be useful in some very narrow cases; however, if there are no per-connection type mappings, the fallback defaults will be used for both type names and their associated values. Therefore, use of this flag is not recommended.

When the property is used, it should return non-zero if there were ever any rows in the associated result sets.

Enable "strict" transaction enlistment semantics. Setting this flag will cause an exception to be thrown if an attempt is made to enlist in a transaction with an unavailable or unsupported isolation level. In the future, more extensive checks may be enabled by this flag as well.

Enable mapping of unsupported transaction isolation levels to the closest supported transaction isolation level.

When returning column values, attempt to detect the affinity of textual values by checking if they fully conform to those of the , , , or types.

When returning column values, attempt to detect the type of string values by checking if they fully conform to those of the , , , or types.

Skip querying runtime configuration settings for use by the class, including the default value and default database type name. NOTE: If the and/or properties are not set explicitly nor set via their connection string properties and repeated calls to determine these runtime configuration settings are seen to be a problem, this flag should be set.

When binding parameter values or returning column values, always treat them as though they were plain text (i.e. no numeric, date/time, or other conversions should be attempted).

When binding parameter values, always use the invariant culture when converting their values to strings or from strings.

When binding parameter values or returning column values, always treat them as though they were plain text (i.e. no numeric, date/time, or other conversions should be attempted) and always use the invariant culture when converting their values to strings.

Enable all logging.

The default extra flags for new connections.

The default extra flags for new connections with all logging enabled.

SQLite implementation of DbCommand.

The default connection string to be used when creating a temporary connection to execute a command via the static or methods.

The command text this command is based on

The connection the command is associated with

The version of the connection the command is associated with

Indicates whether or not a DataReader is active on the command.

The timeout for the command, kludged because SQLite doesn't support per-command timeout values

Designer support

Used by DbDataAdapter to determine updating behavior

The collection of parameters for the command

The SQL command text, broken into individual SQL statements as they are executed

Unprocessed SQL text that has not been executed

Transaction associated with this command

Constructs a new SQLiteCommand

Default constructor

Initializes the command with the given command text

The SQL command text

Initializes the command with the given SQL command text and attach the command to the specified connection.

The SQL command text The connection to associate with the command

Initializes the command and associates it with the specified connection.

The connection to associate with the command

Initializes a command with the given SQL, connection and transaction

The SQL command text The connection to associate with the command The transaction the command should be associated with

Disposes of the command and clears all member variables

Whether or not the class is being explicitly or implicitly disposed

This method attempts to query the flags associated with the database connection in use. If the database connection is disposed, the default flags will be returned.

The command containing the databse connection to query the flags from. The connection flags value.

Clears and destroys all statements currently prepared

Builds an array of prepared statements for each complete SQL statement in the command text

Not implemented

Forwards to the local CreateParameter() function

Create a new parameter

This function ensures there are no active readers, that we have a valid connection, that the connection is open, that all statements are prepared and all parameters are assigned in preparation for allocating a data reader.

Creates a new SQLiteDataReader to execute/iterate the array of SQLite prepared statements

The behavior the data reader should adopt Returns a SQLiteDataReader object

This method creates a new connection, executes the query using the given execution type, closes the connection, and returns the results. If the connection string is null, a temporary in-memory database connection will be used.

The text of the command to be executed. The execution type for the command. This is used to determine which method of the command object to call, which then determines the type of results returned, if any. The connection string to the database to be opened, used, and closed. If this parameter is null, a temporary in-memory databse will be used. The SQL parameter values to be used when building the command object to be executed, if any. The results of the query -OR- null if no results were produced from the given execution type.

This method creates a new connection, executes the query using the given execution type and command behavior, closes the connection, and returns the results. If the connection string is null, a temporary in-memory database connection will be used.

The text of the command to be executed. The execution type for the command. This is used to determine which method of the command object to call, which then determines the type of results returned, if any. The command behavior flags for the command. The connection string to the database to be opened, used, and closed. If this parameter is null, a temporary in-memory databse will be used. The SQL parameter values to be used when building the command object to be executed, if any. The results of the query -OR- null if no results were produced from the given execution type.

Overrides the default behavior to return a SQLiteDataReader specialization class

The flags to be associated with the reader. A SQLiteDataReader

Overrides the default behavior of DbDataReader to return a specialized SQLiteDataReader class

A SQLiteDataReader

Called by the SQLiteDataReader when the data reader is closed.

Execute the command and return the number of rows inserted/updated affected by it.

The number of rows inserted/updated affected by it.

Execute the command and return the number of rows inserted/updated affected by it.

The flags to be associated with the reader. The number of rows inserted/updated affected by it.

Execute the command and return the first column of the first row of the resultset (if present), or null if no resultset was returned.

The first column of the first row of the first resultset from the query.

Execute the command and return the first column of the first row of the resultset (if present), or null if no resultset was returned.

The flags to be associated with the reader. The first column of the first row of the first resultset from the query.

Does nothing. Commands are prepared as they are executed the first time, and kept in prepared state afterwards.

Clones a command, including all its parameters

A new SQLiteCommand with the same commandtext, connection and parameters

The SQL command text associated with the command

The amount of time to wait for the connection to become available before erroring out

The type of the command. SQLite only supports CommandType.Text

The connection associated with this command

Forwards to the local Connection property

Returns the SQLiteParameterCollection for the given command

Forwards to the local Parameters property

The transaction associated with this command. SQLite only supports one transaction per connection, so this property forwards to the command's underlying connection.

Forwards to the local Transaction property

Sets the method the SQLiteCommandBuilder uses to determine how to update inserted or updated rows in a DataTable.

Determines if the command is visible at design time. Defaults to True.

SQLite implementation of DbCommandBuilder.

Default constructor

Initializes the command builder and associates it with the specified data adapter.

Minimal amount of parameter processing. Primarily sets the DbType for the parameter equal to the provider type in the schema

The parameter to use in applying custom behaviors to a row The row to apply the parameter to The type of statement Whether the application of the parameter is part of a WHERE clause

Returns a valid named parameter

The name of the parameter Error

Returns a named parameter for the given ordinal

The i of the parameter Error

Returns a placeholder character for the specified parameter i.

The index of the parameter to provide a placeholder for Returns a named parameter

Sets the handler for receiving row updating events. Used by the DbCommandBuilder to autogenerate SQL statements that may not have previously been generated.

A data adapter to receive events on.

Returns the automatically-generated SQLite command to delete rows from the database

Returns the automatically-generated SQLite command to update rows in the database

Returns the automatically-generated SQLite command to insert rows into the database

Places brackets around an identifier

The identifier to quote The bracketed identifier

Removes brackets around an identifier

The quoted (bracketed) identifier The undecorated identifier

Override helper, which can help the base command builder choose the right keys for the given query

Gets/sets the DataAdapter for this CommandBuilder

Overridden to hide its property from the designer

Event data for connection event handlers.

The type of event being raised.

The associated with this event, if any.

The transaction associated with this event, if any.

The command associated with this event, if any.

The data reader associated with this event, if any.

The critical handle associated with this event, if any.

Command or message text associated with this event, if any.

Extra data associated with this event, if any.

Constructs the object.

The type of event being raised. The base associated with this event, if any. The transaction associated with this event, if any. The command associated with this event, if any. The data reader associated with this event, if any. The critical handle associated with this event, if any. The command or message text, if any. The extra data, if any.

Raised when an event pertaining to a connection occurs.

The connection involved. Extra information about the event.

SQLite implentation of DbConnection.

The property can contain the following parameter(s), delimited with a semi-colon: Parameter Values Required Default Data Source This may be a file name, the string ":memory:", or any supported URI (starting with SQLite 3.7.7). Starting with release 1.0.86.0, in order to use more than one consecutive backslash (e.g. for a UNC path), each of the adjoining backslash characters must be doubled (e.g. "\\Network\Share\test.db" would become "\\\\Network\Share\test.db"). Y Version 3 N 3 UseUTF16Encoding True
False N False DateTimeFormat Ticks - Use the value of DateTime.Ticks.
ISO8601 - Use the ISO-8601 format. Uses the "yyyy-MM-dd HH:mm:ss.FFFFFFFK" format for UTC DateTime values and "yyyy-MM-dd HH:mm:ss.FFFFFFF" format for local DateTime values).
JulianDay - The interval of time in days and fractions of a day since January 1, 4713 BC.
UnixEpoch - The whole number of seconds since the Unix epoch (January 1, 1970).
InvariantCulture - Any culture-independent string value that the .NET Framework can interpret as a valid DateTime.
CurrentCulture - Any string value that the .NET Framework can interpret as a valid DateTime using the current culture. N ISO8601 DateTimeKind Unspecified - Not specified as either UTC or local time.
Utc - The time represented is UTC.
Local - The time represented is local time. N Unspecified DateTimeFormatString The exact DateTime format string to use for all formatting and parsing of all DateTime values for this connection. N null BaseSchemaName Some base data classes in the framework (e.g. those that build SQL queries dynamically) assume that an ADO.NET provider cannot support an alternate catalog (i.e. database) without supporting alternate schemas as well; however, SQLite does not fit into this model. Therefore, this value is used as a placeholder and removed prior to preparing any SQL statements that may contain it. N sqlite_default_schema BinaryGUID True - Store GUID columns in binary form
False - Store GUID columns as text N True Cache Size {size in bytes} N 2000 Synchronous Normal - Normal file flushing behavior
Full - Full flushing after all writes
Off - Underlying OS flushes I/O's N Full Page Size {size in bytes} N 1024 Password {password} - Using this parameter requires that the CryptoAPI based codec be enabled at compile-time for both the native interop assembly and the core managed assemblies; otherwise, using this parameter may result in an exception being thrown when attempting to open the connection. N HexPassword {hexPassword} - Must contain a sequence of zero or more hexadecimal encoded byte values without a leading "0x" prefix. Using this parameter requires that the CryptoAPI based codec be enabled at compile-time for both the native interop assembly and the core managed assemblies; otherwise, using this parameter may result in an exception being thrown when attempting to open the connection. N Enlist Y - Automatically enlist in distributed transactions
N - No automatic enlistment N Y Pooling True - Use connection pooling.
False - Do not use connection pooling.

WARNING: When using the default connection pool implementation, setting this property to True should be avoided by applications that make use of COM (either directly or indirectly) due to possible deadlocks that can occur during the finalization of some COM objects. N False FailIfMissing True - Don't create the database if it does not exist, throw an error instead
False - Automatically create the database if it does not exist N False Max Page Count {size in pages} - Limits the maximum number of pages (limits the size) of the database N 0 Legacy Format True - Use the more compatible legacy 3.x database format
False - Use the newer 3.3x database format which compresses numbers more effectively N False Default Timeout {time in seconds}
The default command timeout N 30 Journal Mode Delete - Delete the journal file after a commit
Persist - Zero out and leave the journal file on disk after a commit
Off - Disable the rollback journal entirely N Delete Read Only True - Open the database for read only access
False - Open the database for normal read/write access N False Max Pool Size The maximum number of connections for the given connection string that can be in the connection pool N 100 Default IsolationLevel The default transaciton isolation level N Serializable Foreign Keys Enable foreign key constraints N False Flags Extra behavioral flags for the connection. See the enumeration for possible values. N Default SetDefaults True - Apply the default connection settings to the opened database.
False - Skip applying the default connection settings to the opened database. N True ToFullPath True - Attempt to expand the data source file name to a fully qualified path before opening.
False - Skip attempting to expand the data source file name to a fully qualified path before opening. N True

The "invalid value" for the enumeration used by the property. This constant is shared by this class and the SQLiteConnectionStringBuilder class.

The default "stub" (i.e. placeholder) base schema name to use when returning column schema information. Used as the initial value of the BaseSchemaName property. This should start with "sqlite_*" because those names are reserved for use by SQLite (i.e. they cannot be confused with the names of user objects).

The managed assembly containing this type.

Object used to synchronize access to the static instance data for this class.

The extra connection flags to be used for all opened connections.

Used to hold the active library version number of SQLite.

State of the current connection

The connection string

Nesting level of the transactions open on the connection

If set, then the connection is currently being disposed.

The default isolation level for new transactions

Whether or not the connection is enlisted in a distrubuted transaction

The per-connection mappings between type names and values. These mappings override the corresponding global mappings.

The base SQLite object to interop with

The database filename minus path and extension

Temporary password storage, emptied after the database has been opened

The "stub" (i.e. placeholder) base schema name to use when returning column schema information.

The extra behavioral flags for this connection, if any. See the enumeration for a list of possible values.

The cached values for all settings that have been fetched on behalf of this connection. This cache may be cleared by calling the method.

The default databse type for this connection. This value will only be used if the flag is set.

The default databse type name for this connection. This value will only be used if the flag is set.

Default command timeout

Non-zero if the built-in (i.e. framework provided) connection string parser should be used when opening the connection.

Constructs a new SQLiteConnection object

Default constructor

Initializes the connection with the specified connection string.

The connection string to use.

Initializes the connection with a pre-existing native connection handle. This constructor overload is intended to be used only by the private method.

The native connection handle to use. The file name corresponding to the native connection handle. Non-zero if this instance owns the native connection handle and should dispose of it when it is no longer needed.

Initializes the connection with the specified connection string.

The connection string to use. Non-zero to parse the connection string using the built-in (i.e. framework provided) parser when opening the connection.

Clones the settings and connection string from an existing connection. If the existing connection is already open, this function will open its own connection, enumerate any attached databases of the original connection, and automatically attach to them.

The connection to copy the settings from.

Raises the event.

The connection associated with this event. If this parameter is not null and the specified connection cannot raise events, then the registered event handlers will not be invoked. A that contains the event data.

Creates and returns a new managed database connection handle. This method is intended to be used by implementations of the interface only. In theory, it could be used by other classes; however, that usage is not supported.

This must be a native database connection handle returned by the SQLite core library and it must remain valid and open during the entire duration of the calling method. The new managed database connection handle or null if it cannot be created.

Backs up the database, using the specified database connection as the destination.

The destination database connection. The destination database name. The source database name. The number of pages to copy or negative to copy all remaining pages. The method to invoke between each step of the backup process. This parameter may be null (i.e. no callbacks will be performed). The number of milliseconds to sleep after encountering a locking error during the backup process. A value less than zero means that no sleep should be performed.

Clears the per-connection cached settings.

The total number of per-connection settings cleared.

Queries and returns the value of the specified setting, using the cached setting names and values for this connection, when available.

The name of the setting. The value to be returned if the setting has not been set explicitly or cannot be determined. The value of the cached setting is stored here if found; otherwise, the value of is stored here. Non-zero if the cached setting was found; otherwise, zero.

Adds or sets the cached setting specified by to the value specified by .

The name of the cached setting to add or replace. The new value of the cached setting.

Clears the per-connection type mappings.

The total number of per-connection type mappings cleared.

Returns the per-connection type mappings.

The per-connection type mappings -OR- null if they are unavailable.

Adds a per-connection type mapping, possibly replacing one or more that already exist.

The case-insensitive database type name (e.g. "MYDATE"). The value of this parameter cannot be null. Using an empty string value (or a string value consisting entirely of whitespace) for this parameter is not recommended. The value that should be associated with the specified type name. Non-zero if this mapping should be considered to be the primary one for the specified . A negative value if nothing was done. Zero if no per-connection type mappings were replaced (i.e. it was a pure add operation). More than zero if some per-connection type mappings were replaced.

Attempts to bind the specified object instance to this connection.

The object instance containing the metadata for the function to be bound. The object instance that implements the function to be bound.

Creates a clone of the connection. All attached databases and user-defined functions are cloned. If the existing connection is open, the cloned connection will also be opened.

Creates a database file. This just creates a zero-byte file which SQLite will turn into a database when the file is opened properly.

The file to create

Raises the state change event when the state of the connection changes

The new connection state. If this is different from the previous state, the event is raised. The event data created for the raised event, if it was actually raised.

Determines and returns the fallback default isolation level when one cannot be obtained from an existing connection instance.

The fallback default isolation level for this connection instance -OR- if it cannot be determined.

Determines and returns the default isolation level for this connection instance.

The default isolation level for this connection instance -OR- if it cannot be determined.

OBSOLETE. Creates a new SQLiteTransaction if one isn't already active on the connection.

This parameter is ignored. When TRUE, SQLite defers obtaining a write lock until a write operation is requested. When FALSE, a writelock is obtained immediately. The default is TRUE, but in a multi-threaded multi-writer environment, one may instead choose to lock the database immediately to avoid any possible writer deadlock. Returns a SQLiteTransaction object.

OBSOLETE. Creates a new SQLiteTransaction if one isn't already active on the connection.

When TRUE, SQLite defers obtaining a write lock until a write operation is requested. When FALSE, a writelock is obtained immediately. The default is false, but in a multi-threaded multi-writer environment, one may instead choose to lock the database immediately to avoid any possible writer deadlock. Returns a SQLiteTransaction object.

Creates a new if one isn't already active on the connection.

Supported isolation levels are Serializable, ReadCommitted and Unspecified. Unspecified will use the default isolation level specified in the connection string. If no isolation level is specified in the connection string, Serializable is used. Serializable transactions are the default. In this mode, the engine gets an immediate lock on the database, and no other threads may begin a transaction. Other threads may read from the database, but not write. With a ReadCommitted isolation level, locks are deferred and elevated as needed. It is possible for multiple threads to start a transaction in ReadCommitted mode, but if a thread attempts to commit a transaction while another thread has a ReadCommitted lock, it may timeout or cause a deadlock on both threads until both threads' CommandTimeout's are reached. Returns a SQLiteTransaction object.

Creates a new if one isn't already active on the connection.

Returns the new transaction object.

Forwards to the local function

Supported isolation levels are Unspecified, Serializable, and ReadCommitted

This method is not implemented; however, the event will still be raised.

When the database connection is closed, all commands linked to this connection are automatically reset.

Clears the connection pool associated with the connection. Any other active connections using the same database file will be discarded instead of returned to the pool when they are closed.

Clears all connection pools. Any active connections will be discarded instead of sent to the pool when they are closed.

Create a new and associate it with this connection.

Returns a new command object already assigned to this connection.

Forwards to the local function.

Parses the connection string into component parts using the custom connection string parser.

The connection string to parse An array of key-value pairs representing each parameter of the connection string

Parses a connection string using the built-in (i.e. framework provided) connection string parser class and returns the key/value pairs. An exception may be thrown if the connection string is invalid or cannot be parsed. When compiled for the .NET Compact Framework, the custom connection string parser is always used instead because the framework provided one is unavailable there.

The connection string to parse. Non-zero to throw an exception if any connection string values are not of the type. The list of key/value pairs.

Manual distributed transaction enlistment support

The distributed transaction to enlist in

Looks for a key in the array of key/values of the parameter string. If not found, return the specified default value

The list to look in The key to find The default value to return if the key is not found The value corresponding to the specified key, or the default value if not found.

Attempts to convert the string value to an enumerated value of the specified type.

The enumerated type to convert the string value to. The string value to be converted. Non-zero to make the conversion case-insensitive. The enumerated value upon success or null upon error.

Attempts to convert an input string into a byte value.

The string value to be converted. The number styles to use for the conversion. Upon sucess, this will contain the parsed byte value. Upon failure, the value of this parameter is undefined. Non-zero upon success; zero on failure.

Enables or disabled extension loading.

True to enable loading of extensions, false to disable.

Loads a SQLite extension library from the named dynamic link library file.

The name of the dynamic link library file containing the extension.

Loads a SQLite extension library from the named dynamic link library file.

The name of the dynamic link library file containing the extension. The name of the exported function used to initialize the extension. If null, the default "sqlite3_extension_init" will be used.

Creates a disposable module containing the implementation of a virtual table.

The module object to be used when creating the disposable module.

Parses a string containing a sequence of zero or more hexadecimal encoded byte values and returns the resulting byte array. The "0x" prefix is not allowed on the input string.

The input string containing zero or more hexadecimal encoded byte values. A byte array containing the parsed byte values or null if an error was encountered.

Creates and returns a string containing the hexadecimal encoded byte values from the input array.

The input array of bytes. The resulting string or null upon failure.

Parses a string containing a sequence of zero or more hexadecimal encoded byte values and returns the resulting byte array. The "0x" prefix is not allowed on the input string.

The input string containing zero or more hexadecimal encoded byte values. Upon failure, this will contain an appropriate error message. A byte array containing the parsed byte values or null if an error was encountered.

This method figures out what the default connection pool setting should be based on the connection flags. When present, the "Pooling" connection string property value always overrides the value returned by this method.

Non-zero if the connection pool should be enabled by default; otherwise, zero.

Determines the transaction isolation level that should be used by the caller, primarily based upon the one specified by the caller. If mapping of transaction isolation levels is enabled, the returned transaction isolation level may be significantly different than the originally specified one.

The originally specified transaction isolation level. The transaction isolation level that should be used.

Opens the connection using the parameters found in the .

Opens the connection using the parameters found in the and then returns it.

The current connection object.

This method 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 any thread. However, it is not safe to call this routine with a database connection that is closed or might close before this method returns.

Returns various global memory statistics for the SQLite core library via a dictionary of key/value pairs. Currently, only the "MemoryUsed" and "MemoryHighwater" keys are returned and they have values that correspond to the values that could be obtained via the and connection properties.

This dictionary will be populated with the global memory statistics. It will be created if necessary.

Attempts to free as much heap memory as possible for this database connection.

Non-zero to enable memory usage tracking, zero otherwise. A standard SQLite return code (i.e. zero for success and non-zero for failure).

Passes a shutdown request to the SQLite core library. Does not throw an exception if the shutdown request fails.

A standard SQLite return code (i.e. zero for success and non-zero for failure).

Passes a shutdown request to the SQLite core library. Throws an exception if the shutdown request fails and the no-throw parameter is non-zero.

Non-zero to reset the database and temporary directories to their default values, which should be null for both. When non-zero, throw an exception if the shutdown request fails. Enables or disabled extended result codes returned by SQLite Enables or disabled extended result codes returned by SQLite Enables or disabled extended result codes returned by SQLite Add a log message via the SQLite sqlite3_log interface. Add a log message via the SQLite sqlite3_log interface.

Change the password (or assign a password) to an open database.

No readers or writers may be active for this process. The database must already be open and if it already was password protected, the existing password must already have been supplied. The new password to assign to the database

Change the password (or assign a password) to an open database.

Sets the password for a password-protected database. A password-protected database is unusable for any operation until the password has been set.

The password for the database

Sets the password for a password-protected database. A password-protected database is unusable for any operation until the password has been set.

The password for the database

Queries or modifies the number of retries or the retry interval (in milliseconds) for certain I/O operations that may fail due to anti-virus software.

The number of times to retry the I/O operation. A negative value will cause the current count to be queried and replace that negative value. The number of milliseconds to wait before retrying the I/O operation. This number is multiplied by the number of retry attempts so far to come up with the final number of milliseconds to wait. A negative value will cause the current interval to be queried and replace that negative value. Zero for success, non-zero for error.

Sets the chunk size for the primary file associated with this database connection.

The new chunk size for the main database, in bytes. Zero for success, non-zero for error.

Removes one set of surrounding single -OR- double quotes from the string value and returns the resulting string value. If the string is null, empty, or contains quotes that are not balanced, nothing is done and the original string value will be returned.

The string value to process. The string value, modified to remove one set of surrounding single -OR- double quotes, if applicable.

Expand the filename of the data source, resolving the |DataDirectory| macro as appropriate.

The database filename to expand Non-zero if the returned file name should be converted to a full path (except when using the .NET Compact Framework). The expanded path and filename of the filename The following commands are used to extract schema information out of the database. Valid schema types are: MetaDataCollections DataSourceInformation Catalogs Columns ForeignKeys Indexes IndexColumns Tables Views ViewColumns

Returns the MetaDataCollections schema

A DataTable of the MetaDataCollections schema

Returns schema information of the specified collection

The schema collection to retrieve A DataTable of the specified collection

Retrieves schema information using the specified constraint(s) for the specified collection

The collection to retrieve The restrictions to impose A DataTable of the specified collection

Builds a MetaDataCollections schema datatable

DataTable

Builds a DataSourceInformation datatable

DataTable

Build a Columns schema

The catalog (attached database) to query, can be null The table to retrieve schema information for, must not be null The column to retrieve schema information for, can be null DataTable

Returns index information for the given database and catalog

The catalog (attached database) to query, can be null The name of the index to retrieve information for, can be null The table to retrieve index information for, can be null DataTable

Retrieves table schema information for the database and catalog

The catalog (attached database) to retrieve tables on The table to retrieve, can be null The table type, can be null DataTable

Retrieves view schema information for the database

The catalog (attached database) to retrieve views on The view name, can be null DataTable

Retrieves catalog (attached databases) schema information for the database

The catalog to retrieve, can be null DataTable

Returns the base column information for indexes in a database

The catalog to retrieve indexes for (can be null) The table to restrict index information by (can be null) The index to restrict index information by (can be null) The source column to restrict index information by (can be null) A DataTable containing the results

Returns detailed column information for a specified view

The catalog to retrieve columns for (can be null) The view to restrict column information by (can be null) The source column to restrict column information by (can be null) A DataTable containing the results

Retrieves foreign key information from the specified set of filters

An optional catalog to restrict results on An optional table to restrict results on An optional foreign key name to restrict results on A DataTable with the results of the query

Static variable to store the connection event handlers to call.

This event is raised whenever the database is opened or closed.

This event is raised when events related to the lifecycle of a SQLiteConnection object occur.

This property is used to obtain or set the custom connection pool implementation to use, if any. Setting this property to null will cause the default connection pool implementation to be used.

Returns the number of pool entries for the file name associated with this connection.

The connection string containing the parameters for the connection

Parameter Values Required Default Data Source This may be a file name, the string ":memory:", or any supported URI (starting with SQLite 3.7.7). Starting with release 1.0.86.0, in order to use more than one consecutive backslash (e.g. for a UNC path), each of the adjoining backslash characters must be doubled (e.g. "\\Network\Share\test.db" would become "\\\\Network\Share\test.db"). Y Version 3 N 3 UseUTF16Encoding True
False N False DateTimeFormat Ticks - Use the value of DateTime.Ticks.
ISO8601 - Use the ISO-8601 format. Uses the "yyyy-MM-dd HH:mm:ss.FFFFFFFK" format for UTC DateTime values and "yyyy-MM-dd HH:mm:ss.FFFFFFF" format for local DateTime values).
JulianDay - The interval of time in days and fractions of a day since January 1, 4713 BC.
UnixEpoch - The whole number of seconds since the Unix epoch (January 1, 1970).
InvariantCulture - Any culture-independent string value that the .NET Framework can interpret as a valid DateTime.
CurrentCulture - Any string value that the .NET Framework can interpret as a valid DateTime using the current culture. N ISO8601 DateTimeKind Unspecified - Not specified as either UTC or local time.
Utc - The time represented is UTC.
Local - The time represented is local time. N Unspecified DateTimeFormatString The exact DateTime format string to use for all formatting and parsing of all DateTime values for this connection. N null BaseSchemaName Some base data classes in the framework (e.g. those that build SQL queries dynamically) assume that an ADO.NET provider cannot support an alternate catalog (i.e. database) without supporting alternate schemas as well; however, SQLite does not fit into this model. Therefore, this value is used as a placeholder and removed prior to preparing any SQL statements that may contain it. N sqlite_default_schema BinaryGUID True - Store GUID columns in binary form
False - Store GUID columns as text N True Cache Size {size in bytes} N 2000 Synchronous Normal - Normal file flushing behavior
Full - Full flushing after all writes
Off - Underlying OS flushes I/O's N Full Page Size {size in bytes} N 1024 Password {password} - Using this parameter requires that the CryptoAPI based codec be enabled at compile-time for both the native interop assembly and the core managed assemblies; otherwise, using this parameter may result in an exception being thrown when attempting to open the connection. N HexPassword {hexPassword} - Must contain a sequence of zero or more hexadecimal encoded byte values without a leading "0x" prefix. Using this parameter requires that the CryptoAPI based codec be enabled at compile-time for both the native interop assembly and the core managed assemblies; otherwise, using this parameter may result in an exception being thrown when attempting to open the connection. N Enlist Y - Automatically enlist in distributed transactions
N - No automatic enlistment N Y Pooling True - Use connection pooling.
False - Do not use connection pooling.

WARNING: When using the default connection pool implementation, setting this property to True should be avoided by applications that make use of COM (either directly or indirectly) due to possible deadlocks that can occur during the finalization of some COM objects. N False FailIfMissing True - Don't create the database if it does not exist, throw an error instead
False - Automatically create the database if it does not exist N False Max Page Count {size in pages} - Limits the maximum number of pages (limits the size) of the database N 0 Legacy Format True - Use the more compatible legacy 3.x database format
False - Use the newer 3.3x database format which compresses numbers more effectively N False Default Timeout {time in seconds}
The default command timeout N 30 Journal Mode Delete - Delete the journal file after a commit
Persist - Zero out and leave the journal file on disk after a commit
Off - Disable the rollback journal entirely N Delete Read Only True - Open the database for read only access
False - Open the database for normal read/write access N False Max Pool Size The maximum number of connections for the given connection string that can be in the connection pool N 100 Default IsolationLevel The default transaciton isolation level N Serializable Foreign Keys Enable foreign key constraints N False Flags Extra behavioral flags for the connection. See the enumeration for possible values. N Default SetDefaults True - Apply the default connection settings to the opened database.
False - Skip applying the default connection settings to the opened database. N True ToFullPath True - Attempt to expand the data source file name to a fully qualified path before opening.
False - Skip attempting to expand the data source file name to a fully qualified path before opening. N True

Returns the data source file name without extension or path.

Returns the string "main".

Gets/sets the default command timeout for newly-created commands. This is especially useful for commands used internally such as inside a SQLiteTransaction, where setting the timeout is not possible. This can also be set in the ConnectionString with "Default Timeout"

Non-zero if the built-in (i.e. framework provided) connection string parser should be used when opening the connection.

Gets/sets the extra behavioral flags for this connection. See the enumeration for a list of possible values.

Gets/sets the default database type for this connection. This value will only be used when not null.

Gets/sets the default database type name for this connection. This value will only be used when not null.

Returns non-zero if the underlying native connection handle is owned by this instance.

Returns the version of the underlying SQLite database engine

Returns the rowid of the most recent successful INSERT into the database from this connection.

Returns the number of rows changed by the last INSERT, UPDATE, or DELETE statement executed on this connection.

Returns the amount of memory (in bytes) currently in use by the SQLite core library.

Returns the maximum amount of memory (in bytes) used by the SQLite core library since the high-water mark was last reset.

Returns a string containing the define constants (i.e. compile-time options) used to compile the core managed assembly, delimited with spaces.

Returns the version of the underlying SQLite core library.

This method returns the string whose value is the same as the SQLITE_SOURCE_ID C preprocessor macro used when compiling the SQLite core library.

Returns a string containing the compile-time options used to compile the SQLite core native library, delimited with spaces.

This method returns the version of the interop SQLite assembly used. If the SQLite interop assembly is not in use or the necessary information cannot be obtained for any reason, a null value may be returned.

This method returns the string whose value contains the unique identifier for the source checkout used to build the interop assembly. If the SQLite interop assembly is not in use or the necessary information cannot be obtained for any reason, a null value may be returned.

Returns a string containing the compile-time options used to compile the SQLite interop assembly, delimited with spaces.

This method returns the version of the managed components used to interact with the SQLite core library. If the necessary information cannot be obtained for any reason, a null value may be returned.

This method returns the string whose value contains the unique identifier for the source checkout used to build the managed components currently executing. If the necessary information cannot be obtained for any reason, a null value may be returned.

The extra connection flags to be used for all opened connections.

Returns the state of the connection.

This event is raised whenever SQLite encounters an action covered by the authorizer during query preparation. Changing the value of the property will determine if the specific action will be allowed, ignored, or denied. For the entire duration of the event, the associated connection and statement objects must not be modified, either directly or indirectly, by the called code.

This event is raised whenever SQLite makes an update/delete/insert into the database on this connection. It only applies to the given connection.

This event is raised whenever SQLite is committing a transaction. Return non-zero to trigger a rollback.

This event is raised whenever SQLite statement first begins executing on this connection. It only applies to the given connection.

This event is raised whenever SQLite is rolling back a transaction.

Returns the instance.

The I/O file cache flushing behavior for the connection

Normal file flushing at critical sections of the code

Full file flushing after every write operation

Use the default operating system's file flushing, SQLite does not explicitly flush the file buffers after writing

Raised when authorization is required to perform an action contained within a SQL query.

The connection performing the action. A that contains the event data.

Raised when a transaction is about to be committed. To roll back a transaction, set the rollbackTrans boolean value to true.

The connection committing the transaction Event arguments on the transaction

Raised when data is inserted, updated and deleted on a given connection

The connection committing the transaction The event parameters which triggered the event

Raised when a statement first begins executing on a given connection

The connection executing the statement Event arguments of the trace

Raised between each backup step.

The source database connection. The source database name. The destination database connection. The destination database name. The number of pages copied with each step. The number of pages remaining to be copied. The total number of pages in the source database. Set to true if the operation needs to be retried due to database locking issues; otherwise, set to false. True to continue with the backup process or false to halt the backup process, rolling back any changes that have been made so far.

The data associated with a call into the authorizer.

The user-defined native data associated with this event. Currently, this will always contain the value of .

The action code responsible for the current call into the authorizer.

The first string argument for the current call into the authorizer. The exact value will vary based on the action code, see the enumeration for possible values.

The second string argument for the current call into the authorizer. The exact value will vary based on the action code, see the enumeration for possible values.

The database name for the current call into the authorizer, if applicable.

The name of the inner-most trigger or view that is responsible for the access attempt or a null value if this access attempt is directly from top-level SQL code.

The return code for the current call into the authorizer.

Constructs an instance of this class with default property values.

Constructs an instance of this class with specific property values.

The user-defined native data associated with this event. The authorizer action code. The first authorizer argument. The second authorizer argument. The database name, if applicable. The name of the inner-most trigger or view that is responsible for the access attempt or a null value if this access attempt is directly from top-level SQL code. The authorizer return code.

Whenever an update event is triggered on a connection, this enum will indicate exactly what type of operation is being performed.

A row is being deleted from the given database and table

A row is being inserted into the table.

A row is being updated in the table.

Passed during an Update callback, these event arguments detail the type of update operation being performed on the given connection.

The name of the database being updated (usually "main" but can be any attached or temporary database)

The name of the table being updated

The type of update being performed (insert/update/delete)

The RowId affected by this update.

Event arguments raised when a transaction is being committed

Set to true to abort the transaction and trigger a rollback

Passed during an Trace callback, these event arguments contain the UTF-8 rendering of the SQL statement text

SQL statement text as the statement first begins executing

This interface represents a custom connection pool implementation usable by System.Data.SQLite.

Counts the number of pool entries matching the specified file name.

The file name to match or null to match all files. The pool entry counts for each matching file. The total number of connections successfully opened from any pool. The total number of connections successfully closed from any pool. The total number of pool entries for all matching files.

Disposes of all pooled connections associated with the specified database file name.

The database file name.

Disposes of all pooled connections.

Adds a connection to the pool of those associated with the specified database file name.

The database file name. The database connection handle. The connection pool version at the point the database connection handle was received from the connection pool. This is also the connection pool version that the database connection handle was created under.

Removes a connection from the pool of those associated with the specified database file name with the intent of using it to interact with the database.

The database file name. The new maximum size of the connection pool for the specified database file name. The connection pool version associated with the returned database connection handle, if any. The database connection handle associated with the specified database file name or null if it cannot be obtained.

This default method implementations in this class should not be used by applications that make use of COM (either directly or indirectly) due to possible deadlocks that can occur during finalization of some COM objects.

This field is used to synchronize access to the private static data in this class.

When this field is non-null, it will be used to provide the implementation of all the connection pool methods; otherwise, the default method implementations will be used.

The dictionary of connection pools, based on the normalized file name of the SQLite database.

The default version number new pools will get.

The number of connections successfully opened from any pool. This value is incremented by the Remove method.

The number of connections successfully closed from any pool. This value is incremented by the Add method.

Counts the number of pool entries matching the specified file name.

Disposes of all pooled connections associated with the specified database file name.

The database file name.

Disposes of all pooled connections.

Adds a connection to the pool of those associated with the specified database file name.

Removes a connection from the pool of those associated with the specified database file name with the intent of using it to interact with the database.

This method is used to obtain a reference to the custom connection pool implementation currently in use, if any.

The custom connection pool implementation or null if the default connection pool implementation should be used.

This method is used to set the reference to the custom connection pool implementation to use, if any.

The custom connection pool implementation to use or null if the default connection pool implementation should be used.

We do not have to thread-lock anything in this function, because it is only called by other functions above which already take the lock.

The pool queue to resize. If a function intends to add to the pool, this is true, which forces the resize to take one more than it needs from the pool.

Keeps track of connections made on a specified file. The PoolVersion dictates whether old objects get returned to the pool or discarded when no longer in use.

The queue of weak references to the actual database connection handles.

This pool version associated with the database connection handles in this pool queue.

The maximum size of this pool queue.

Constructs a connection pool queue using the specified version and maximum size. Normally, all the database connection handles in this pool are associated with a single database file name.

The initial pool version for this connection pool queue. The initial maximum size for this connection pool queue.

SQLite implementation of DbConnectionStringBuilder.

Properties of this class

Constructs a new instance of the class

Default constructor

Constructs a new instance of the class using the specified connection string.

The connection string to parse

Private initializer, which assigns the connection string and resets the builder

The connection string to assign

Helper function for retrieving values from the connectionstring

The keyword to retrieve settings for The resulting parameter value Returns true if the value was found and returned

Fallback method for MONO, which doesn't implement DbConnectionStringBuilder.GetProperties()

The hashtable to fill with property descriptors

Gets/Sets the default version of the SQLite engine to instantiate. Currently the only valid value is 3, indicating version 3 of the sqlite library.

Gets/Sets the synchronization mode (file flushing) of the connection string. Default is "Normal".

Gets/Sets the encoding for the connection string. The default is "False" which indicates UTF-8 encoding.

Gets/Sets whether or not to use connection pooling. The default is "False"

Gets/Sets whethor not to store GUID's in binary format. The default is True which saves space in the database.

Gets/Sets the filename to open on the connection string.

An alternate to the data source property

An alternate to the data source property that uses the SQLite URI syntax.

Gets/sets the default command timeout for newly-created commands. This is especially useful for commands used internally such as inside a SQLiteTransaction, where setting the timeout is not possible.

Determines whether or not the connection will automatically participate in the current distributed transaction (if one exists)

If set to true, will throw an exception if the database specified in the connection string does not exist. If false, the database will be created automatically.

If enabled, uses the legacy 3.xx format for maximum compatibility, but results in larger database sizes.

When enabled, the database will be opened for read-only access and writing will be disabled.

Gets/sets the database encryption password

Gets/sets the database encryption hexadecimal password

Gets/Sets the page size for the connection.

Gets/Sets the maximum number of pages the database may hold

Gets/Sets the cache size for the connection.

Gets/Sets the DateTime format for the connection.

Gets/Sets the DateTime kind for the connection.

Gets/sets the DateTime format string used for formatting and parsing purposes.

Gets/Sets the placeholder base schema name used for .NET Framework compatibility purposes.

Determines how SQLite handles the transaction journal file.

Sets the default isolation level for transactions on the connection.

Gets/sets the default database type for the connection.

Gets/sets the default type name for the connection.

If enabled, use foreign key constraints

Gets/Sets the extra behavioral flags.

If enabled, apply the default connection settings to opened databases.

If enabled, attempt to resolve the provided data source file name to a full path before opening.

If enabled, skip using the configured shared connection flags.

SQLite has very limited types, and is inherently text-based. The first 5 types below represent the sum of all types SQLite understands. The DateTime extension to the spec is for internal use only.

Not used

All integers in SQLite default to Int64

All floating point numbers in SQLite default to double

The default data type of SQLite is text

Typically blob types are only seen when returned from a function

Null types can be returned from functions

Used internally by this provider

These are the event types associated with the delegate (and its corresponding event) and the class.

Not used.

The connection is being opened.

The connection string has been parsed.

The connection was opened.

The method was called on the connection.

A transaction was created using the connection.

The connection was enlisted into a transaction.

A command was created using the connection.

A data reader was created using the connection.

An instance of a derived class has been created to wrap a native resource.

The connection is being closed.

The connection was closed.

A command is being disposed.

A data reader is being disposed.

A data reader is being closed.

This implementation of SQLite for ADO.NET can process date/time fields in databases in one of six formats.

ISO8601 format is more compatible, readable, fully-processable, but less accurate as it does not provide time down to fractions of a second. JulianDay is the numeric format the SQLite uses internally and is arguably the most compatible with 3rd party tools. It is not readable as text without post-processing. Ticks less compatible with 3rd party tools that query the database, and renders the DateTime field unreadable as text without post-processing. UnixEpoch is more compatible with Unix systems. InvariantCulture allows the configured format for the invariant culture format to be used and is human readable. CurrentCulture allows the configured format for the current culture to be used and is also human readable. The preferred order of choosing a DateTime format is JulianDay, ISO8601, and then Ticks. Ticks is mainly present for legacy code support.

Use the value of DateTime.Ticks. This value is not recommended and is not well supported with LINQ.

Use the ISO-8601 format. Uses the "yyyy-MM-dd HH:mm:ss.FFFFFFFK" format for UTC DateTime values and "yyyy-MM-dd HH:mm:ss.FFFFFFF" format for local DateTime values).

The interval of time in days and fractions of a day since January 1, 4713 BC.

The whole number of seconds since the Unix epoch (January 1, 1970).

Any culture-independent string value that the .NET Framework can interpret as a valid DateTime.

Any string value that the .NET Framework can interpret as a valid DateTime using the current culture.

The default format for this provider.

This enum determines how SQLite treats its journal file.

By default SQLite will create and delete the journal file when needed during a transaction. However, for some computers running certain filesystem monitoring tools, the rapid creation and deletion of the journal file can cause those programs to fail, or to interfere with SQLite. If a program or virus scanner is interfering with SQLite's journal file, you may receive errors like "unable to open database file" when starting a transaction. If this is happening, you may want to change the default journal mode to Persist.

The default mode, this causes SQLite to use the existing journaling mode for the database.

SQLite will create and destroy the journal file as-needed.

When this is set, SQLite will keep the journal file even after a transaction has completed. It's contents will be erased, and the journal re-used as often as needed. If it is deleted, it will be recreated the next time it is needed.

This option disables the rollback journal entirely. Interrupted transactions or a program crash can cause database corruption in this mode!

SQLite will truncate the journal file to zero-length instead of deleting it.

SQLite will store the journal in volatile RAM. This saves disk I/O but at the expense of database safety and integrity. If the application using SQLite crashes in the middle of a transaction when the MEMORY journaling mode is set, then the database file will very likely go corrupt.

SQLite uses a write-ahead log instead of a rollback journal to implement transactions. The WAL journaling mode is persistent; after being set it stays in effect across multiple database connections and after closing and reopening the database. A database in WAL journaling mode can only be accessed by SQLite version 3.7.0 or later.

Possible values for the "synchronous" database setting. This setting determines how often the database engine calls the xSync method of the VFS.

Use the default "synchronous" database setting. Currently, this should be the same as using the FULL mode.

The database engine continues without syncing as soon as it has handed data off to the operating system. If the application running SQLite crashes, the data will be safe, but the database might become corrupted if the operating system crashes or the computer loses power before that data has been written to the disk surface.

The database engine will still sync at the most critical moments, but less often than in FULL mode. There is a very small (though non-zero) chance that a power failure at just the wrong time could corrupt the database in NORMAL mode.

The database engine will use the xSync method of the VFS to ensure that all content is safely written to the disk surface prior to continuing. This ensures that an operating system crash or power failure will not corrupt the database. FULL synchronous is very safe, but it is also slower.

The requested command execution type. This controls which method of the object will be called.

Do nothing. No method will be called.

The command is not expected to return a result -OR- the result is not needed. The or method will be called.

The command is expected to return a scalar result -OR- the result should be limited to a scalar result. The or method will be called.

The command is expected to return result. The or method will be called.

Use the default command execution type. Using this value is the same as using the value.

The action code responsible for the current call into the authorizer.

No action is being performed. This value should not be used from external code.

No longer used.

An index will be created. The action-specific arguments are the index name and the table name.

A table will be created. The action-specific arguments are the table name and a null value.

A temporary index will be created. The action-specific arguments are the index name and the table name.

A temporary table will be created. The action-specific arguments are the table name and a null value.

A temporary trigger will be created. The action-specific arguments are the trigger name and the table name.

A temporary view will be created. The action-specific arguments are the view name and a null value.

A trigger will be created. The action-specific arguments are the trigger name and the table name.

A view will be created. The action-specific arguments are the view name and a null value.

A DELETE statement will be executed. The action-specific arguments are the table name and a null value.

An index will be dropped. The action-specific arguments are the index name and the table name.

A table will be dropped. The action-specific arguments are the tables name and a null value.

A temporary index will be dropped. The action-specific arguments are the index name and the table name.

A temporary table will be dropped. The action-specific arguments are the table name and a null value.

A temporary trigger will be dropped. The action-specific arguments are the trigger name and the table name.

A temporary view will be dropped. The action-specific arguments are the view name and a null value.

A trigger will be dropped. The action-specific arguments are the trigger name and the table name.

A view will be dropped. The action-specific arguments are the view name and a null value.

An INSERT statement will be executed. The action-specific arguments are the table name and a null value.

A PRAGMA statement will be executed. The action-specific arguments are the name of the PRAGMA and the new value or a null value.

A table column will be read. The action-specific arguments are the table name and the column name.

A SELECT statement will be executed. The action-specific arguments are both null values.

A transaction will be started, committed, or rolled back. The action-specific arguments are the name of the operation (BEGIN, COMMIT, or ROLLBACK) and a null value.

An UPDATE statement will be executed. The action-specific arguments are the table name and the column name.

A database will be attached to the connection. The action-specific arguments are the database file name and a null value.

A database will be detached from the connection. The action-specific arguments are the database name and a null value.

The schema of a table will be altered. The action-specific arguments are the database name and the table name.

An index will be deleted and then recreated. The action-specific arguments are the index name and a null value.

A table will be analyzed to gathers statistics about it. The action-specific arguments are the table name and a null value.

A virtual table will be created. The action-specific arguments are the table name and the module name.

A virtual table will be dropped. The action-specific arguments are the table name and the module name.

A SQL function will be called. The action-specific arguments are a null value and the function name.

A savepoint will be created, released, or rolled back. The action-specific arguments are the name of the operation (BEGIN, RELEASE, or ROLLBACK) and the savepoint name.

A recursive query will be executed. The action-specific arguments are two null values.

The return code for the current call into the authorizer.

The action will be allowed.

The overall action will be disallowed and an error message will be returned from the query preparation method.

The specific action will be disallowed; however, the overall action will continue. The exact effects of this return code vary depending on the specific action, please refer to the SQLite core library documentation for futher details.

Class used internally to determine the datatype of a column in a resultset

The DbType of the column, or DbType.Object if it cannot be determined

The affinity of a column, used for expressions or when Type is DbType.Object

Constructs a default instance of this type.

Constructs an instance of this type with the specified field values.

The type affinity to use for the new instance. The database type to use for the new instance.

SQLite implementation of DbDataAdapter.

This class is just a shell around the DbDataAdapter. Nothing from DbDataAdapter is overridden here, just a few constructors are defined.

Default constructor.

Constructs a data adapter using the specified select command.

The select command to associate with the adapter.

Constructs a data adapter with the supplied select command text and associated with the specified connection.

The select command text to associate with the data adapter. The connection to associate with the select command.

Constructs a data adapter with the specified select command text, and using the specified database connection string.

The select command text to use to construct a select command. A connection string suitable for passing to a new SQLiteConnection, which is associated with the select command.

Constructs a data adapter with the specified select command text, and using the specified database connection string.

The select command text to use to construct a select command. A connection string suitable for passing to a new SQLiteConnection, which is associated with the select command. Non-zero to parse the connection string using the built-in (i.e. framework provided) parser when opening the connection.

Raised by the underlying DbDataAdapter when a row is being updated

The event's specifics

Raised by DbDataAdapter after a row is updated

The event's specifics

Row updating event handler

Row updated event handler

Gets/sets the select command for this DataAdapter

Gets/sets the insert command for this DataAdapter

Gets/sets the update command for this DataAdapter

Gets/sets the delete command for this DataAdapter

SQLite implementation of DbDataReader.

Underlying command this reader is attached to

The flags pertaining to the associated connection (via the command).

Index of the current statement in the command being processed

Current statement being Read()

State of the current statement being processed. -1 = First Step() executed, so the first Read() will be ignored 0 = Actively reading 1 = Finished reading 2 = Non-row-returning statement, no records

Number of records affected by the insert/update statements executed on the command

Count of fields (columns) in the row-returning statement currently being processed

The number of calls to Step() that have returned true (i.e. the number of rows that have been read in the current result set).

Maps the field (column) names to their corresponding indexes within the results.

Datatypes of active fields (columns) in the current statement, used for type-restricting data

The behavior of the datareader

If set, then dispose of the command object when the reader is finished

If set, then raise an exception when the object is accessed after being disposed.

An array of rowid's for the active statement if CommandBehavior.KeyInfo is specified

Matches the version of the connection.

The "stub" (i.e. placeholder) base schema name to use when returning column schema information. Matches the base schema name used by the associated connection.

Internal constructor, initializes the datareader and sets up to begin executing statements

The SQLiteCommand this data reader is for The expected behavior of the data reader

Dispose of all resources used by this datareader.

Closes the datareader, potentially closing the connection as well if CommandBehavior.CloseConnection was specified.

Throw an error if the datareader is closed

Throw an error if a row is not loaded

Enumerator support

Returns a DbEnumerator object.

Forces the connection flags cached by this data reader to be refreshed from the underlying connection.

SQLite is inherently un-typed. All datatypes in SQLite are natively strings. The definition of the columns of a table and the affinity of returned types are all we have to go on to type-restrict data in the reader. This function attempts to verify that the type of data being requested of a column matches the datatype of the column. In the case of columns that are not backed into a table definition, we attempt to match up the affinity of a column (int, double, string or blob) to a set of known types that closely match that affinity. It's not an exact science, but its the best we can do.

This function throws an InvalidTypeCast() exception if the requested type doesn't match the column's definition or affinity. The index of the column to type-check The type we want to get out of the column

Retrieves the column as a boolean value

The index of the column to retrieve bool

Retrieves the column as a single byte value

The index of the column to retrieve byte

Retrieves a column as an array of bytes (blob)

The index of the column to retrieve The zero-based index of where to begin reading the data The buffer to write the bytes into The zero-based index of where to begin writing into the array The number of bytes to retrieve The actual number of bytes written into the array To determine the number of bytes in the column, pass a null value for the buffer. The total length will be returned.

Returns the column as a single character

The index of the column to retrieve char

Retrieves a column as an array of chars (blob)

The index of the column to retrieve The zero-based index of where to begin reading the data The buffer to write the characters into The zero-based index of where to begin writing into the array The number of bytes to retrieve The actual number of characters written into the array To determine the number of characters in the column, pass a null value for the buffer. The total length will be returned.

Retrieves the name of the back-end datatype of the column

The index of the column to retrieve string

Retrieve the column as a date/time value

The index of the column to retrieve DateTime

Retrieve the column as a decimal value

The index of the column to retrieve decimal

Returns the column as a double

The index of the column to retrieve double

Returns the .NET type of a given column

The index of the column to retrieve Type

Returns a column as a float value

The index of the column to retrieve float

Returns the column as a Guid

The index of the column to retrieve Guid

Returns the column as a short

The index of the column to retrieve Int16

Retrieves the column as an int

The index of the column to retrieve Int32

Retrieves the column as a long

The index of the column to retrieve Int64

Retrieves the name of the column

The index of the column to retrieve string

Retrieves the i of a column, given its name

The name of the column to retrieve The int i of the column

Schema information in SQLite is difficult to map into .NET conventions, so a lot of work must be done to gather the necessary information so it can be represented in an ADO.NET manner.

Returns a DataTable containing the schema information for the active SELECT statement being processed.

Retrieves the column as a string

The index of the column to retrieve string

Retrieves the column as an object corresponding to the underlying datatype of the column

The index of the column to retrieve object

Retreives the values of multiple columns, up to the size of the supplied array

The array to fill with values from the columns in the current resultset The number of columns retrieved

Returns a collection containing all the column names and values for the current row of data in the current resultset, if any. If there is no current row or no current resultset, an exception may be thrown.

The collection containing the column name and value information for the current row of data in the current resultset or null if this information cannot be obtained.

Returns True if the specified column is null

The index of the column to retrieve True or False

Moves to the next resultset in multiple row-returning SQL command.

True if the command was successful and a new resultset is available, False otherwise.

This method attempts to query the database connection associated with the data reader in use. If the underlying command or connection is unavailable, a null value will be returned.

The connection object -OR- null if it is unavailable.

Retrieves the SQLiteType for a given column and row value.

The original SQLiteType structure, based only on the column. The textual value of the column for a given row. The SQLiteType structure.

Retrieves the SQLiteType for a given column, and caches it to avoid repetetive interop calls.

The flags associated with the parent connection object. The index of the column to retrieve A SQLiteType structure

Reads the next row from the resultset

True if a new row was successfully loaded and is ready for processing

Not implemented. Returns 0

Returns the number of columns in the current resultset

Returns the number of rows seen so far in the current result set.

Returns the number of visible fields in the current resultset

Returns True if the resultset has rows that can be fetched

Returns True if the data reader is closed

Retrieve the count of records affected by an update/insert command. Only valid once the data reader is closed!

Indexer to retrieve data from a column given its name

The name of the column to retrieve data for The value contained in the column

Indexer to retrieve data from a column given its i

The index of the column to retrieve The value contained in the column

SQLite exception class.

Private constructor for use with serialization.

Holds the serialized object data about the exception being thrown. Contains contextual information about the source or destination.

Public constructor for generating a SQLite exception given the error code and message.

The SQLite return code to report. Message text to go along with the return code message text.

Public constructor that uses the base class constructor for the error message.

Error message text.

Public constructor that uses the default base class constructor.

Public constructor that uses the base class constructor for the error message and inner exception.

Error message text. The original (inner) exception.

Adds extra information to the serialized object data specific to this class type. This is only used for serialization.

Holds the serialized object data about the exception being thrown. Contains contextual information about the source or destination.

Returns the error message for the specified SQLite return code.

The SQLite return code. The error message or null if it cannot be found.

Returns the composite error message based on the SQLite return code and the optional detailed error message.

The SQLite return code. Optional detailed error message. Error message text for the return code.

Gets the associated SQLite result code for this exception as a . This property returns the same underlying value as the property.

Gets the associated SQLite return code for this exception as an . For desktop versions of the .NET Framework, this property overrides the property of the same name within the class. This property returns the same underlying value as the property.

SQLite error codes. Actually, this enumeration represents a return code, which may also indicate success in one of several ways (e.g. SQLITE_OK, SQLITE_ROW, and SQLITE_DONE). Therefore, the name of this enumeration is something of a misnomer.

The error code is unknown. This error code is only used by the managed wrapper itself.

Successful result

SQL error or missing database

Internal logic error in SQLite

Access permission denied

Callback routine requested an abort

The database file is locked

A table in the database is locked

A malloc() failed

Attempt to write a readonly database

Operation terminated by sqlite3_interrupt()

Some kind of disk I/O error occurred

The database disk image is malformed

Unknown opcode in sqlite3_file_control()

Insertion failed because database is full

Unable to open the database file

Database lock protocol error

Database is empty

The database schema changed

String or BLOB exceeds size limit

Abort due to constraint violation

Data type mismatch

Library used incorrectly

Uses OS features not supported on host

Authorization denied

Auxiliary database format error

2nd parameter to sqlite3_bind out of range

File opened that is not a database file

Notifications from sqlite3_log()

Warnings from sqlite3_log()

sqlite3_step() has another row ready

sqlite3_step() has finished executing

Used to mask off extended result codes

SQLite implementation of .

Constructs a new instance.

Static instance member which returns an instanced class.

Creates and returns a new object.

The new object.

Creates and returns a new object.

The new object.

Creates and returns a new object.

The new object.

Creates and returns a new object.

The new object.

Creates and returns a new object.

The new object.

Creates and returns a new object.

The new object.

Will provide a object in .NET 3.5.

The class or interface type to query for.

This event is raised whenever SQLite raises a logging event. Note that this should be set as one of the first things in the application. This event is provided for backward compatibility only. New code should use the class instead.

This abstract class is designed to handle user-defined functions easily. An instance of the derived class is made for each connection to the database.

Although there is one instance of a class derived from SQLiteFunction per database connection, the derived class has no access to the underlying connection. This is necessary to deter implementers from thinking it would be a good idea to make database calls during processing. It is important to distinguish between a per-connection instance, and a per-SQL statement context. One instance of this class services all SQL statements being stepped through on that connection, and there can be many. One should never store per-statement information in member variables of user-defined function classes. For aggregate functions, always create and store your per-statement data in the contextData object on the 1st step. This data will be automatically freed for you (and Dispose() called if the item supports IDisposable) when the statement completes.

The base connection this function is attached to

Internal array used to keep track of aggregate function context data

The connection flags associated with this object (this should be the same value as the flags associated with the parent connection object).

Holds a reference to the callback function for user functions

Holds a reference to the callbakc function for stepping in an aggregate function

Holds a reference to the callback function for finalizing an aggregate function

Holds a reference to the callback function for collation sequences

Current context of the current callback. Only valid during a callback

This static list contains all the user-defined functions declared using the proper attributes.

Internal constructor, initializes the function's internal variables.

Constructs an instance of this class using the specified data-type conversion parameters.

The DateTime format to be used when converting string values to a DateTime and binding DateTime parameters. The to be used when creating DateTime values. The format string to be used when parsing and formatting DateTime values. Non-zero to create a UTF-16 data-type conversion context; otherwise, a UTF-8 data-type conversion context will be created.

Disposes of any active contextData variables that were not automatically cleaned up. Sometimes this can happen if someone closes the connection while a DataReader is open.

Placeholder for a user-defined disposal routine

True if the object is being disposed explicitly

Scalar functions override this method to do their magic.

Parameters passed to functions have only an affinity for a certain data type, there is no underlying schema available to force them into a certain type. Therefore the only types you will ever see as parameters are DBNull.Value, Int64, Double, String or byte[] array. The arguments for the command to process You may return most simple types as a return value, null or DBNull.Value to return null, DateTime, or you may return an Exception-derived class if you wish to return an error to SQLite. Do not actually throw the error, just return it!

Aggregate functions override this method to do their magic.

Typically you'll be updating whatever you've placed in the contextData field and returning as quickly as possible. The arguments for the command to process The 1-based step number. This is incrememted each time the step method is called. A placeholder for implementers to store contextual data pertaining to the current context.

Aggregate functions override this method to finish their aggregate processing.

If you implemented your aggregate function properly, you've been recording and keeping track of your data in the contextData object provided, and now at this stage you should have all the information you need in there to figure out what to return. NOTE: It is possible to arrive here without receiving a previous call to Step(), in which case the contextData will be null. This can happen when no rows were returned. You can either return null, or 0 or some other custom return value if that is the case. Your own assigned contextData, provided for you so you can return your final results. You may return most simple types as a return value, null or DBNull.Value to return null, DateTime, or you may return an Exception-derived class if you wish to return an error to SQLite. Do not actually throw the error, just return it!

User-defined collation sequences override this method to provide a custom string sorting algorithm.

The first string to compare The second strnig to compare 1 if param1 is greater than param2, 0 if they are equal, or -1 if param1 is less than param2

Converts an IntPtr array of context arguments to an object array containing the resolved parameters the pointers point to.

Parameters passed to functions have only an affinity for a certain data type, there is no underlying schema available to force them into a certain type. Therefore the only types you will ever see as parameters are DBNull.Value, Int64, Double, String or byte[] array. The number of arguments A pointer to the array of arguments An object array of the arguments once they've been converted to .NET values

Takes the return value from Invoke() and Final() and figures out how to return it to SQLite's context.

The context the return value applies to The parameter to return to SQLite

Internal scalar callback function, which wraps the raw context pointer and calls the virtual Invoke() method. WARNING: Must not throw exceptions.

A raw context pointer Number of arguments passed in A pointer to the array of arguments

Internal collation sequence function, which wraps up the raw string pointers and executes the Compare() virtual function. WARNING: Must not throw exceptions.

Not used Length of the string pv1 Pointer to the first string to compare Length of the string pv2 Pointer to the second string to compare Returns -1 if the first string is less than the second. 0 if they are equal, or 1 if the first string is greater than the second. Returns 0 if an exception is caught.

Internal collation sequence function, which wraps up the raw string pointers and executes the Compare() virtual function. WARNING: Must not throw exceptions.

The internal aggregate Step function callback, which wraps the raw context pointer and calls the virtual Step() method. WARNING: Must not throw exceptions.

This function takes care of doing the lookups and getting the important information put together to call the Step() function. That includes pulling out the user's contextData and updating it after the call is made. We use a sorted list for this so binary searches can be done to find the data. A raw context pointer Number of arguments passed in A pointer to the array of arguments

An internal aggregate Final function callback, which wraps the context pointer and calls the virtual Final() method. WARNING: Must not throw exceptions.

A raw context pointer

Using reflection, enumerate all assemblies in the current appdomain looking for classes that have a SQLiteFunctionAttribute attribute, and registering them accordingly.

Manual method of registering a function. The type must still have the SQLiteFunctionAttributes in order to work properly, but this is a workaround for the Compact Framework where enumerating assemblies is not currently supported.

The type of the function to register

Called by SQLiteBase derived classes, this function binds all user-defined functions to a connection. It is done this way so that all user-defined functions will access the database using the same encoding scheme as the connection (UTF-8 or UTF-16).

The wrapper functions that interop with SQLite will create a unique cookie value, which internally is a pointer to all the wrapped callback functions. The interop function uses it to map CDecl callbacks to StdCall callbacks. The base object on which the functions are to bind The flags associated with the parent connection object Returns a logical list of functions which the connection should retain until it is closed.

This function binds a user-defined functions to a connection.

The object instance associated with the that the function should be bound to. The object instance containing the metadata for the function to be bound. The object instance that implements the function to be bound. The flags associated with the parent connection object.

Returns a reference to the underlying connection's SQLiteConvert class, which can be used to convert strings and DateTime's into the current connection's encoding schema.

Extends SQLiteFunction and allows an inherited class to obtain the collating sequence associated with a function call.

User-defined functions can call the GetCollationSequence() method in this class and use it to compare strings and char arrays.

Obtains the collating sequence in effect for the given function.

The type of user-defined function to declare

Scalar functions are designed to be called and return a result immediately. Examples include ABS(), Upper(), Lower(), etc.

Aggregate functions are designed to accumulate data until the end of a call and then return a result gleaned from the accumulated data. Examples include SUM(), COUNT(), AVG(), etc.

Collation sequences are used to sort textual data in a custom manner, and appear in an ORDER BY clause. Typically text in an ORDER BY is sorted using a straight case-insensitive comparison function. Custom collating sequences can be used to alter the behavior of text sorting in a user-defined manner.

An internal callback delegate declaration.

Raw native context pointer for the user function. Total number of arguments to the user function. Raw native pointer to the array of raw native argument pointers.

An internal final callback delegate declaration.

Raw context pointer for the user function

Internal callback delegate for implementing collation sequences

The type of collating sequence

The built-in BINARY collating sequence

The built-in NOCASE collating sequence

The built-in REVERSE collating sequence

A custom user-defined collating sequence

The encoding type the collation sequence uses

The collation sequence is UTF8

The collation sequence is UTF16 little-endian

The collation sequence is UTF16 big-endian

A struct describing the collating sequence a function is executing in

The name of the collating sequence

The type of collating sequence

The text encoding of the collation sequence

Context of the function that requested the collating sequence

Calls the base collating sequence to compare two strings

The first string to compare The second string to compare -1 if s1 is less than s2, 0 if s1 is equal to s2, and 1 if s1 is greater than s2

Calls the base collating sequence to compare two character arrays

The first array to compare The second array to compare -1 if c1 is less than c2, 0 if c1 is equal to c2, and 1 if c1 is greater than c2

A simple custom attribute to enable us to easily find user-defined functions in the loaded assemblies and initialize them in SQLite as connections are made.

Default constructor, initializes the internal variables for the function.

Constructs an instance of this class.

The name of the function, as seen by the SQLite core library. The number of arguments that the function will accept. The type of function being declared. This will either be Scalar, Aggregate, or Collation.

The function's name as it will be used in SQLite command text.

The number of arguments this function expects. -1 if the number of arguments is variable.

The type of function this implementation will be.

The object instance that describes the class containing the implementation for the associated function.

This class provides key info for a given SQLite statement. Providing key information for a given statement is non-trivial :(

This function does all the nasty work at determining what keys need to be returned for a given statement.

Make sure all the subqueries are open and ready and sync'd with the current rowid of the table they're supporting

Release any readers on any subqueries

Append all the columns we've added to the original query to the schema

How many additional columns of keyinfo we're holding

Used to support CommandBehavior.KeyInfo

A single sub-query for a given table/database.

Event data for logging event handlers.

The error code. The type of this object value should be or .

SQL statement text as the statement first begins executing

Extra data associated with this event, if any.

Constructs the object.

Should be null. The error code. The type of this object value should be or . The error message, if any. The extra data, if any.

Raised when a log event occurs.

The current connection Event arguments of the trace

Manages the SQLite custom logging functionality and the associated callback for the whole process.

Object used to synchronize access to the static instance data for this class.

Member variable to store the AppDomain.DomainUnload event handler.

The default log event handler.

The log callback passed to native SQLite engine. This must live as long as the SQLite library has a pointer to it.

The base SQLite object to interop with.

This will be non-zero if logging is currently enabled.

Initializes the SQLite logging facilities.

Handles the AppDomain being unloaded.

Should be null. The data associated with this event.

Log a message to all the registered log event handlers without going through the SQLite library.

The message to be logged.

Log a message to all the registered log event handlers without going through the SQLite library.

The SQLite error code. The message to be logged.

Log a message to all the registered log event handlers without going through the SQLite library.

The integer error code. The message to be logged.

Log a message to all the registered log event handlers without going through the SQLite library.

The error code. The type of this object value should be System.Int32 or SQLiteErrorCode. The message to be logged.

Creates and initializes the default log event handler.

Adds the default log event handler to the list of handlers.

Removes the default log event handler from the list of handlers.

Internal proxy function that calls any registered application log event handlers. WARNING: This method is used more-or-less directly by native code, do not modify its type signature.

The extra data associated with this message, if any. The error code associated with this message. The message string to be logged.

Default logger. Currently, uses the Trace class (i.e. sends events to the current trace listeners, if any).

Should be null. The data associated with this event.

Member variable to store the application log handler to call.

This event is raised whenever SQLite raises a logging event. Note that this should be set as one of the first things in the application.

If this property is true, logging is enabled; otherwise, logging is disabled. When logging is disabled, no logging events will fire.

MetaDataCollections specific to SQLite

Returns a list of databases attached to the connection

Returns column information for the specified table

Returns index information for the optionally-specified table

Returns base columns for the given index

Returns the tables in the given catalog

Returns user-defined views in the given catalog

Returns underlying column information on the given view

Returns foreign key information for the given catalog

Returns the triggers on the database

SQLite implementation of DbParameter.

The data type of the parameter

The version information for mapping the parameter

The value of the data in the parameter

The source column for the parameter

The column name

The data size, unused by SQLite

Default constructor

Constructs a named parameter given the specified parameter name

The parameter name

Constructs a named parameter given the specified parameter name and initial value

The parameter name The initial value of the parameter

Constructs a named parameter of the specified type

The parameter name The datatype of the parameter

Constructs a named parameter of the specified type and source column reference

The parameter name The data type The source column

Constructs a named parameter of the specified type, source column and row version

The parameter name The data type The source column The row version information

Constructs an unnamed parameter of the specified data type

The datatype of the parameter

Constructs an unnamed parameter of the specified data type and sets the initial value

The datatype of the parameter The initial value of the parameter

Constructs an unnamed parameter of the specified data type and source column

The datatype of the parameter The source column

Constructs an unnamed parameter of the specified data type, source column and row version

The data type The source column The row version information

Constructs a named parameter of the specified type and size

The parameter name The data type The size of the parameter

Constructs a named parameter of the specified type, size and source column

The name of the parameter The data type The size of the parameter The source column

Constructs a named parameter of the specified type, size, source column and row version

The name of the parameter The data type The size of the parameter The source column The row version information

Constructs a named parameter of the specified type, size, source column and row version

The name of the parameter The data type The size of the parameter Only input parameters are supported in SQLite Ignored Ignored Ignored The source column The row version information The initial value to assign the parameter

Constructs a named parameter, yet another flavor

The name of the parameter The data type The size of the parameter Only input parameters are supported in SQLite Ignored Ignored The source column The row version information Whether or not this parameter is for comparing NULL's The intial value to assign the parameter

Constructs an unnamed parameter of the specified type and size

The data type The size of the parameter

Constructs an unnamed parameter of the specified type, size, and source column

The data type The size of the parameter The source column

Constructs an unnamed parameter of the specified type, size, source column and row version

The data type The size of the parameter The source column The row version information

Resets the DbType of the parameter so it can be inferred from the value

Clones a parameter

A new, unassociated SQLiteParameter

Whether or not the parameter can contain a null value

Returns the datatype of the parameter

Supports only input parameters

Returns the parameter name

Returns the size of the parameter

Gets/sets the source column

Used by DbCommandBuilder to determine the mapping for nullable fields

Gets and sets the row version

Gets and sets the parameter value. If no datatype was specified, the datatype will assume the type from the value given.

SQLite implementation of DbParameterCollection.

The underlying command to which this collection belongs

The internal array of parameters in this collection

Determines whether or not all parameters have been bound to their statement(s)

Initializes the collection

The command to which the collection belongs

Retrieves an enumerator for the collection

An enumerator for the underlying array

Adds a parameter to the collection

The parameter name The data type The size of the value The source column A SQLiteParameter object

Adds a parameter to the collection

The parameter name The data type The size of the value A SQLiteParameter object

Adds a parameter to the collection

The parameter name The data type A SQLiteParameter object

Adds a parameter to the collection

The parameter to add A zero-based index of where the parameter is located in the array

Adds a parameter to the collection

The parameter to add A zero-based index of where the parameter is located in the array

Adds a named/unnamed parameter and its value to the parameter collection.

Name of the parameter, or null to indicate an unnamed parameter The initial value of the parameter Returns the SQLiteParameter object created during the call.

Adds an array of parameters to the collection

The array of parameters to add

Adds an array of parameters to the collection

The array of parameters to add

Clears the array and resets the collection

Determines if the named parameter exists in the collection

The name of the parameter to check True if the parameter is in the collection

Determines if the parameter exists in the collection

The SQLiteParameter to check True if the parameter is in the collection

Not implemented

Retrieve a parameter by name from the collection

The name of the parameter to fetch A DbParameter object

Retrieves a parameter by its index in the collection

The index of the parameter to retrieve A DbParameter object

Returns the index of a parameter given its name

The name of the parameter to find -1 if not found, otherwise a zero-based index of the parameter

Returns the index of a parameter

The parameter to find -1 if not found, otherwise a zero-based index of the parameter

Inserts a parameter into the array at the specified location

The zero-based index to insert the parameter at The parameter to insert

Removes a parameter from the collection

The parameter to remove

Removes a parameter from the collection given its name

The name of the parameter to remove

Removes a parameter from the collection given its index

The zero-based parameter index to remove

Re-assign the named parameter to a new parameter object

The name of the parameter to replace The new parameter

Re-assign a parameter at the specified index

The zero-based index of the parameter to replace The new parameter

Un-binds all parameters from their statements

This function attempts to map all parameters in the collection to all statements in a Command. Since named parameters may span multiple statements, this function makes sure all statements are bound to the same named parameter. Unnamed parameters are bound in sequence.

Returns false

Returns null

Returns a count of parameters in the collection

Overloaded to specialize the return value of the default indexer

Name of the parameter to get/set The specified named SQLite parameter

Overloaded to specialize the return value of the default indexer

The index of the parameter to get/set The specified SQLite parameter

Represents a single SQL statement in SQLite.

The underlying SQLite object this statement is bound to

The command text of this SQL statement

The actual statement pointer

An index from which unnamed parameters begin

Names of the parameters as SQLite understands them to be

Parameters for this statement

Command this statement belongs to (if any)

The flags associated with the parent connection object.

Initializes the statement and attempts to get all information about parameters in the statement

The base SQLite object The flags associated with the parent connection object The statement The command text for this statement The previous command in a multi-statement command

Disposes and finalizes the statement

If the underlying database connection is open, fetches the number of changed rows resulting from the most recent query; otherwise, does nothing.

The number of changes when true is returned. Undefined if false is returned. Non-zero if the number of changed rows was fetched.

Called by SQLiteParameterCollection, this function determines if the specified parameter name belongs to this statement, and if so, keeps a reference to the parameter so it can be bound later.

The parameter name to map The parameter to assign it

Bind all parameters, making sure the caller didn't miss any

Perform the bind operation for an individual parameter

The index of the parameter to bind The parameter we're binding

SQLite implementation of DbTransaction.

The connection to which this transaction is bound

Constructs the transaction object, binding it to the supplied connection

The connection to open a transaction on TRUE to defer the writelock, or FALSE to lock immediately

Disposes the transaction. If it is currently active, any changes are rolled back.

Commits the current transaction.

Rolls back the active transaction.

Returns the underlying connection to which this transaction applies.

Forwards to the local Connection property

Gets the isolation level of the transaction. SQLite only supports Serializable transactions.

The file extension used for dynamic link libraries.

The file extension used for the XML configuration file.

This is the name of the XML configuration file specific to the System.Data.SQLite assembly.

This lock is used to protect the static _SQLiteNativeModuleFileName, _SQLiteNativeModuleHandle, and processorArchitecturePlatforms fields.

This dictionary stores the mappings between processor architecture names and platform names. These mappings are now used for two purposes. First, they are used to determine if the assembly code base should be used instead of the location, based upon whether one or more of the named sub-directories exist within the assembly code base. Second, they are used to assist in loading the appropriate SQLite interop assembly into the current process.

For now, this method simply calls the Initialize method.

Attempts to initialize this class by pre-loading the native SQLite library for the processor architecture of the current process.

Queries and returns the XML configuration file name for the assembly containing the managed System.Data.SQLite components.

The XML configuration file name -OR- null if it cannot be determined or does not exist.

Queries and returns the value of the specified setting, using the XML configuration file and/or the environment variables for the current process and/or the current system, when available.

The name of the setting. The value to be returned if the setting has not been set explicitly or cannot be determined. The value of the setting -OR- the default value specified by if it has not been set explicitly or cannot be determined. By default, all references to existing environment variables will be expanded to their corresponding values within the value to be returned unless either the "No_Expand" or "No_Expand_" environment variable is set [to anything].

Queries and returns the directory for the assembly currently being executed.

The directory for the assembly currently being executed -OR- null if it cannot be determined.

The name of the environment variable containing the processor architecture of the current process.

This is the P/Invoke method that wraps the native Win32 LoadLibrary function. See the MSDN documentation for full details on what it does.

The name of the executable library. The native module handle upon success -OR- IntPtr.Zero on failure.

The native module file name for the native SQLite library or null.

The native module handle for the native SQLite library or the value IntPtr.Zero.

Searches for the native SQLite library in the directory containing the assembly currently being executed as well as the base directory for the current application domain.

Upon success, this parameter will be modified to refer to the base directory containing the native SQLite library. Upon success, this parameter will be modified to refer to the name of the immediate directory (i.e. the offset from the base directory) containing the native SQLite library. Non-zero (success) if the native SQLite library was found; otherwise, zero (failure).

Queries and returns the base directory of the current application domain.

The base directory for the current application domain -OR- null if it cannot be determined.

Determines if the dynamic link library file name requires a suffix and adds it if necessary.

The original dynamic link library file name to inspect. The dynamic link library file name, possibly modified to include an extension.

Queries and returns the processor architecture of the current process.

The processor architecture of the current process -OR- null if it cannot be determined.

Given the processor architecture, returns the name of the platform.

The processor architecture to be translated to a platform name. The platform name for the specified processor architecture -OR- null if it cannot be determined.

Attempts to load the native SQLite library based on the specified directory and processor architecture.

The base directory to use, null for default (the base directory of the current application domain). This directory should contain the processor architecture specific sub-directories. The requested processor architecture, null for default (the processor architecture of the current process). This caller should almost always specify null for this parameter. The candidate native module file name to load will be stored here, if necessary. The native module handle as returned by LoadLibrary will be stored here, if necessary. This value will be IntPtr.Zero if the call to LoadLibrary fails. Non-zero if the native module was loaded successfully; otherwise, zero.

A strongly-typed resource class, for looking up localized strings, etc.

Returns the cached ResourceManager instance used by this class.

Overrides the current thread's CurrentUICulture property for all resource lookups using this strongly typed resource class.

Looks up a localized string similar to <?xml version="1.0" standalone="yes"?> <DocumentElement> <DataTypes> <TypeName>smallint</TypeName> <ProviderDbType>10</ProviderDbType> <ColumnSize>5</ColumnSize> <DataType>System.Int16</DataType> <CreateFormat>smallint</CreateFormat> <IsAutoIncrementable>false</IsAutoIncrementable> <IsCaseSensitive>false</IsCaseSensitive> <IsFixedLength>true</IsFixedLength> <IsFixedPrecisionScale>true</IsFixedPrecisionScale> <IsLong>false</IsLong> <IsNullable>true</ [rest of string was truncated]";.

Looks up a localized string similar to ALL,ALTER,AND,AS,AUTOINCREMENT,BETWEEN,BY,CASE,CHECK,COLLATE,COMMIT,CONSTRAINT,CREATE,CROSS,DEFAULT,DEFERRABLE,DELETE,DISTINCT,DROP,ELSE,ESCAPE,EXCEPT,FOREIGN,FROM,FULL,GROUP,HAVING,IN,INDEX,INNER,INSERT,INTERSECT,INTO,IS,ISNULL,JOIN,LEFT,LIMIT,NATURAL,NOT,NOTNULL,NULL,ON,OR,ORDER,OUTER,PRIMARY,REFERENCES,RIGHT,ROLLBACK,SELECT,SET,TABLE,THEN,TO,TRANSACTION,UNION,UNIQUE,UPDATE,USING,VALUES,WHEN,WHERE.

Looks up a localized string similar to <?xml version="1.0" encoding="utf-8" ?> <DocumentElement> <MetaDataCollections> <CollectionName>MetaDataCollections</CollectionName> <NumberOfRestrictions>0</NumberOfRestrictions> <NumberOfIdentifierParts>0</NumberOfIdentifierParts> </MetaDataCollections> <MetaDataCollections> <CollectionName>DataSourceInformation</CollectionName> <NumberOfRestrictions>0</NumberOfRestrictions> <NumberOfIdentifierParts>0</NumberOfIdentifierParts> </MetaDataCollections> <MetaDataC [rest of string was truncated]";.

This class represents a context from the SQLite core library that can be passed to the sqlite3_result_*() and associated functions.

This interface represents a native handle provided by the SQLite core library.

The native handle value.

The native context handle.

Constructs an instance of this class using the specified native context handle.

The native context handle to use.

Sets the context result to NULL.

Sets the context result to the specified value.

The value to use.

Sets the context result to the specified value.

The value to use.

Sets the context result to the specified value.

The value to use.

Sets the context result to the specified value.

The value to use. This value will be converted to the UTF-8 encoding prior to being used.

Sets the context result to the specified value containing an error message.

The value containing the error message text. This value will be converted to the UTF-8 encoding prior to being used.

Sets the context result to the specified value.

The value to use.

Sets the context result to contain the error code SQLITE_TOOBIG.

Sets the context result to contain the error code SQLITE_NOMEM.

Sets the context result to the specified array value.

The array value to use.

Sets the context result to a BLOB of zeros of the specified size.

The number of zero bytes to use for the BLOB context result.

Sets the context result to the specified .

The to use.

Returns the underlying SQLite native handle associated with this object instance.

This class represents a value from the SQLite core library that can be passed to the sqlite3_value_*() and associated functions.

The native value handle.

Constructs an instance of this class using the specified native value handle.

The native value handle to use.

Invalidates the native value handle, thereby preventing further access to it from this object instance.

Converts a logical array of native pointers to native sqlite3_value structures into a managed array of object instances.

The number of elements in the logical array of native sqlite3_value structures. The native pointer to the logical array of native sqlite3_value structures to convert. The managed array of object instances or null upon failure.

Gets and returns the type affinity associated with this value.

The type affinity associated with this value.

Gets and returns the number of bytes associated with this value, if it refers to a UTF-8 encoded string.

The number of bytes associated with this value. The returned value may be zero.

Gets and returns the associated with this value.

The associated with this value.

Gets and returns the associated with this value.

The associated with this value.

Gets and returns the associated with this value.

The associated with this value.

Gets and returns the associated with this value.

The associated with this value. The value is converted from the UTF-8 encoding prior to being returned.

Gets and returns the array associated with this value.

The array associated with this value.

Uses the native value handle to obtain and store the managed value for this object instance, thus saving it for later use. The type of the managed value is determined by the type affinity of the native value. If the type affinity is not recognized by this method, no work is done and false is returned.

Non-zero if the native value was persisted successfully.

Returns the underlying SQLite native handle associated with this object instance.

Returns non-zero if the native SQLite value has been successfully persisted as a managed value within this object instance (i.e. the property may then be read successfully).

If the managed value for this object instance is available (i.e. it has been previously persisted via the ) method, that value is returned; otherwise, an exception is thrown. The returned value may be null.

These are the allowed values for the operators that are part of a constraint term in the WHERE clause of a query that uses a virtual table.

This value represents the equality operator.

This value represents the greater than operator.

This value represents the less than or equal to operator.

This value represents the less than operator.

This value represents the greater than or equal to operator.

This value represents the MATCH operator.

This class represents the native sqlite3_index_constraint structure from the SQLite core library.

Constructs an instance of this class using the specified native sqlite3_index_constraint structure.

The native sqlite3_index_constraint structure to use.

Constructs an instance of this class using the specified field values.

Column on left-hand side of constraint. Constraint operator (). True if this constraint is usable. Used internally - should ignore.

Column on left-hand side of constraint.

Constraint operator ().

True if this constraint is usable.

Used internally - should ignore.

This class represents the native sqlite3_index_orderby structure from the SQLite core library.

Constructs an instance of this class using the specified native sqlite3_index_orderby structure.

The native sqlite3_index_orderby structure to use.

Constructs an instance of this class using the specified field values.

Column number. True for DESC. False for ASC.

Column number.

True for DESC. False for ASC.

This class represents the native sqlite3_index_constraint_usage structure from the SQLite core library.

Constructs an instance of this class using the specified native sqlite3_index_constraint_usage structure.

The native sqlite3_index_constraint_usage structure to use.

Constructs an instance of this class using the specified field values.

If greater than 0, constraint is part of argv to xFilter. Do not code a test for this constraint.

If greater than 0, constraint is part of argv to xFilter.

Do not code a test for this constraint.

This class represents the various inputs provided by the SQLite core library to the method.

Constructs an instance of this class.

The number of instances to pre-allocate space for. The number of instances to pre-allocate space for.

An array of object instances, each containing information supplied by the SQLite core library.

This class represents the various outputs provided to the SQLite core library by the method.

Constructs an instance of this class.

The number of instances to pre-allocate space for.

Determines if the native estimatedRows field can be used, based on the available version of the SQLite core library.

Non-zero if the property is supported by the SQLite core library.

An array of object instances, each containing information to be supplied to the SQLite core library.

Number used to help identify the selected index. This value will later be provided to the method.

String used to help identify the selected index. This value will later be provided to the method.

Non-zero if the index string must be freed by the SQLite core library.

True if output is already ordered.

Estimated cost of using this index. Using a null value here indicates that a default estimated cost value should be used.

Estimated number of rows returned. Using a null value here indicates that a default estimated rows value should be used.

This class represents the various inputs and outputs used with the method.

Constructs an instance of this class.

The number of (and ) instances to pre-allocate space for. The number of instances to pre-allocate space for.

Converts a native pointer to a native sqlite3_index_info structure into a new object instance.

The native pointer to the native sqlite3_index_info structure to convert. Upon success, this parameter will be modified to contain the newly created object instance.

Populates the outputs of a pre-allocated native sqlite3_index_info structure using an existing object instance.

The existing object instance containing the output data to use. The native pointer to the pre-allocated native sqlite3_index_info structure.

The object instance containing the inputs to the method.

The object instance containing the outputs from the method.

This class represents a managed virtual table implementation. It is not sealed and should be used as the base class for any user-defined virtual table classes implemented in managed code.

The index within the array of strings provided to the and methods containing the name of the module implementing this virtual table.

The index within the array of strings provided to the and methods containing the name of the database containing this virtual table.

The index within the array of strings provided to the and methods containing the name of the virtual table.

Constructs an instance of this class.

The original array of strings provided to the and methods.

This method should normally be used by the method in order to perform index selection based on the constraints provided by the SQLite core library.

The object instance containing all the data for the inputs and outputs relating to index selection. Non-zero upon success.

Attempts to record the renaming of the virtual table associated with this object instance.

The new name for the virtual table. Non-zero upon success.

Disposes of this object instance.

Throws an if this object instance has been disposed.

Disposes of this object instance.

Non-zero if this method is being called from the method. Zero if this method is being called from the finalizer.

Finalizes this object instance.

The original array of strings provided to the and methods.

The name of the module implementing this virtual table.

The name of the database containing this virtual table.

The name of the virtual table.

The object instance containing all the data for the inputs and outputs relating to the most recent index selection.

Returns the underlying SQLite native handle associated with this object instance.

This class represents a managed virtual table cursor implementation. It is not sealed and should be used as the base class for any user-defined virtual table cursor classes implemented in managed code.

This value represents an invalid integer row sequence number.

The field holds the integer row sequence number for the current row pointed to by this cursor object instance.

Constructs an instance of this class.

The object instance associated with this object instance.

Constructs an instance of this class.

Attempts to persist the specified object instances in order to make them available after the method returns.

The array of object instances to be persisted. The number of object instances that were successfully persisted.

This method should normally be used by the method in order to perform filtering of the result rows and/or to record the filtering criteria provided by the SQLite core library.

Number used to help identify the selected index. String used to help identify the selected index. The values corresponding to each column in the selected index.

Determines the integer row sequence number for the current row.

The integer row sequence number for the current row -OR- zero if it cannot be determined.

Adjusts the integer row sequence number so that it refers to the next row.

Disposes of this object instance.

Throws an if this object instance has been disposed.

Disposes of this object instance.

Non-zero if this method is being called from the method. Zero if this method is being called from the finalizer.

Finalizes this object instance.

The object instance associated with this object instance.

Number used to help identify the selected index. This value will be set via the method.

String used to help identify the selected index. This value will be set via the method.

The values used to filter the rows returned via this cursor object instance. This value will be set via the method.

Returns the underlying SQLite native handle associated with this object instance.

This interface represents a virtual table implementation written in native code.

This method is called to create a new instance of a virtual table in response to a CREATE VIRTUAL TABLE statement. The db parameter is a pointer to the SQLite database connection that is executing the CREATE VIRTUAL TABLE statement. The pAux argument is the copy of the client data pointer that was the fourth argument to the sqlite3_create_module() or sqlite3_create_module_v2() call that registered the virtual table module. The argv parameter is an array of argc pointers to null terminated strings. The first string, argv[0], is the name of the module being invoked. The module name is the name provided as the second argument to sqlite3_create_module() and as the argument to the USING clause of the CREATE VIRTUAL TABLE statement that is running. The second, argv[1], is the name of the database in which the new virtual table is being created. The database name is "main" for the primary database, or "temp" for TEMP database, or the name given at the end of the ATTACH statement for attached databases. The third element of the array, argv[2], is the name of the new virtual table, as specified following the TABLE keyword in the CREATE VIRTUAL TABLE statement. If present, the fourth and subsequent strings in the argv[] array report the arguments to the module name in the CREATE VIRTUAL TABLE statement. The job of this method is to construct the new virtual table object (an sqlite3_vtab object) and return a pointer to it in *ppVTab. As part of the task of creating a new sqlite3_vtab structure, this method must invoke sqlite3_declare_vtab() to tell the SQLite core about the columns and datatypes in the virtual table. The sqlite3_declare_vtab() API has the following prototype:


            int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable)

The first argument to sqlite3_declare_vtab() must be the same database connection pointer as the first parameter to this method. The second argument to sqlite3_declare_vtab() must a zero-terminated UTF-8 string that contains a well-formed CREATE TABLE statement that defines the columns in the virtual table and their data types. The name of the table in this CREATE TABLE statement is ignored, as are all constraints. Only the column names and datatypes matter. The CREATE TABLE statement string need not to be held in persistent memory. The string can be deallocated and/or reused as soon as the sqlite3_declare_vtab() routine returns.

The native database connection handle. The original native pointer value that was provided to the sqlite3_create_module(), sqlite3_create_module_v2() or sqlite3_create_disposable_module() functions. The number of arguments from the CREATE VIRTUAL TABLE statement. The array of string arguments from the CREATE VIRTUAL TABLE statement. Upon success, this parameter must be modified to point to the newly created native sqlite3_vtab derived structure. Upon failure, this parameter must be modified to point to the error message, with the underlying memory having been obtained from the sqlite3_malloc() function. A standard SQLite return code.

The xConnect method is very similar to xCreate. It has the same parameters and constructs a new sqlite3_vtab structure just like xCreate. And it must also call sqlite3_declare_vtab() like xCreate. The difference is that xConnect is called to establish a new connection to an existing virtual table whereas xCreate is called to create a new virtual table from scratch. The xCreate and xConnect methods are only different when the virtual table has some kind of backing store that must be initialized the first time the virtual table is created. The xCreate method creates and initializes the backing store. The xConnect method just connects to an existing backing store. As an example, consider a virtual table implementation that provides read-only access to existing comma-separated-value (CSV) files on disk. There is no backing store that needs to be created or initialized for such a virtual table (since the CSV files already exist on disk) so the xCreate and xConnect methods will be identical for that module. Another example is a virtual table that implements a full-text index. The xCreate method must create and initialize data structures to hold the dictionary and posting lists for that index. The xConnect method, on the other hand, only has to locate and use an existing dictionary and posting lists that were created by a prior xCreate call. The xConnect method must return SQLITE_OK if it is successful in creating the new virtual table, or SQLITE_ERROR if it is not successful. If not successful, the sqlite3_vtab structure must not be allocated. An error message may optionally be returned in *pzErr if unsuccessful. Space to hold the error message string must be allocated using an SQLite memory allocation function like sqlite3_malloc() or sqlite3_mprintf() as the SQLite core will attempt to free the space using sqlite3_free() after the error has been reported up to the application. The xConnect method is required for every virtual table implementation, though the xCreate and xConnect pointers of the sqlite3_module object may point to the same function the virtual table does not need to initialize backing store.

SQLite uses the xBestIndex method of a virtual table module to determine the best way to access the virtual table. The xBestIndex method has a prototype like this:


            int (*xBestIndex)(sqlite3_vtab *pVTab, sqlite3_index_info*);

The SQLite core communicates with the xBestIndex method by filling in certain fields of the sqlite3_index_info structure and passing a pointer to that structure into xBestIndex as the second parameter. The xBestIndex method fills out other fields of this structure which forms the reply. The sqlite3_index_info structure looks like this:


             struct sqlite3_index_info {
               /* Inputs */
               const int nConstraint;   /* Number of entries in aConstraint */
               const struct sqlite3_index_constraint {
                  int iColumn;          /* Column on left-hand side of
                                         * constraint */
                  unsigned char op;     /* Constraint operator */
                  unsigned char usable; /* True if this constraint is usable */
                  int iTermOffset;      /* Used internally - xBestIndex should
                                         * ignore */
               } *const aConstraint;    /* Table of WHERE clause constraints */
               const int nOrderBy;      /* Number of terms in the ORDER BY
                                         * clause */
               const struct sqlite3_index_orderby {
                  int iColumn;          /* Column number */
                  unsigned char desc;   /* True for DESC.  False for ASC. */
               } *const aOrderBy;       /* The ORDER BY clause */
               /* Outputs */
               struct sqlite3_index_constraint_usage {
                 int argvIndex;         /* if greater than zero, constraint is
                                         * part of argv to xFilter */
                 unsigned char omit;    /* Do not code a test for this
                                         * constraint */
               } *const aConstraintUsage;
               int idxNum;              /* Number used to identify the index */
               char *idxStr;            /* String, possibly obtained from
                                         * sqlite3_malloc() */
               int needToFreeIdxStr;    /* Free idxStr using sqlite3_free() if
                                         * true */
               int orderByConsumed;     /* True if output is already ordered */
               double estimatedCost;    /* Estimated cost of using this index */
             };

In addition, there are some defined constants:


             #define SQLITE_INDEX_CONSTRAINT_EQ    2
             #define SQLITE_INDEX_CONSTRAINT_GT    4
             #define SQLITE_INDEX_CONSTRAINT_LE    8
             #define SQLITE_INDEX_CONSTRAINT_LT    16
             #define SQLITE_INDEX_CONSTRAINT_GE    32
             #define SQLITE_INDEX_CONSTRAINT_MATCH 64

The SQLite core calls the xBestIndex method when it is compiling a query that involves a virtual table. In other words, SQLite calls this method when it is running sqlite3_prepare() or the equivalent. By calling this method, the SQLite core is saying to the virtual table that it needs to access some subset of the rows in the virtual table and it wants to know the most efficient way to do that access. The xBestIndex method replies with information that the SQLite core can then use to conduct an efficient search of the virtual table. While compiling a single SQL query, the SQLite core might call xBestIndex multiple times with different settings in sqlite3_index_info. The SQLite core will then select the combination that appears to give the best performance. Before calling this method, the SQLite core initializes an instance of the sqlite3_index_info structure with information about the query that it is currently trying to process. This information derives mainly from the WHERE clause and ORDER BY or GROUP BY clauses of the query, but also from any ON or USING clauses if the query is a join. The information that the SQLite core provides to the xBestIndex method is held in the part of the structure that is marked as "Inputs". The "Outputs" section is initialized to zero. The information in the sqlite3_index_info structure is ephemeral and may be overwritten or deallocated as soon as the xBestIndex method returns. If the xBestIndex method needs to remember any part of the sqlite3_index_info structure, it should make a copy. Care must be take to store the copy in a place where it will be deallocated, such as in the idxStr field with needToFreeIdxStr set to 1. Note that xBestIndex will always be called before xFilter, since the idxNum and idxStr outputs from xBestIndex are required inputs to xFilter. However, there is no guarantee that xFilter will be called following a successful xBestIndex. The xBestIndex method is required for every virtual table implementation. 2.3.1 Inputs The main thing that the SQLite core is trying to communicate to the virtual table is the constraints that are available to limit the number of rows that need to be searched. The aConstraint[] array contains one entry for each constraint. There will be exactly nConstraint entries in that array. Each constraint will correspond to a term in the WHERE clause or in a USING or ON clause that is of the form


                column OP EXPR

Where "column" is a column in the virtual table, OP is an operator like "=" or "<", and EXPR is an arbitrary expression. So, for example, if the WHERE clause contained a term like this:


                     a = 5

Then one of the constraints would be on the "a" column with operator "=" and an expression of "5". Constraints need not have a literal representation of the WHERE clause. The query optimizer might make transformations to the WHERE clause in order to extract as many constraints as it can. So, for example, if the WHERE clause contained something like this:


                     x BETWEEN 10 AND 100 AND 999>y

The query optimizer might translate this into three separate constraints:


                     x >= 10
                     x <= 100
                     y < 999

For each constraint, the aConstraint[].iColumn field indicates which column appears on the left-hand side of the constraint. The first column of the virtual table is column 0. The rowid of the virtual table is column -1. The aConstraint[].op field indicates which operator is used. The SQLITE_INDEX_CONSTRAINT_* constants map integer constants into operator values. Columns occur in the order they were defined by the call to sqlite3_declare_vtab() in the xCreate or xConnect method. Hidden columns are counted when determining the column index. The aConstraint[] array contains information about all constraints that apply to the virtual table. But some of the constraints might not be usable because of the way tables are ordered in a join. The xBestIndex method must therefore only consider constraints that have an aConstraint[].usable flag which is true. In addition to WHERE clause constraints, the SQLite core also tells the xBestIndex method about the ORDER BY clause. (In an aggregate query, the SQLite core might put in GROUP BY clause information in place of the ORDER BY clause information, but this fact should not make any difference to the xBestIndex method.) If all terms of the ORDER BY clause are columns in the virtual table, then nOrderBy will be the number of terms in the ORDER BY clause and the aOrderBy[] array will identify the column for each term in the order by clause and whether or not that column is ASC or DESC. 2.3.2 Outputs Given all of the information above, the job of the xBestIndex method it to figure out the best way to search the virtual table. The xBestIndex method fills the idxNum and idxStr fields with information that communicates an indexing strategy to the xFilter method. The information in idxNum and idxStr is arbitrary as far as the SQLite core is concerned. The SQLite core just copies the information through to the xFilter method. Any desired meaning can be assigned to idxNum and idxStr as long as xBestIndex and xFilter agree on what that meaning is. The idxStr value may be a string obtained from an SQLite memory allocation function such as sqlite3_mprintf(). If this is the case, then the needToFreeIdxStr flag must be set to true so that the SQLite core will know to call sqlite3_free() on that string when it has finished with it, and thus avoid a memory leak. If the virtual table will output rows in the order specified by the ORDER BY clause, then the orderByConsumed flag may be set to true. If the output is not automatically in the correct order then orderByConsumed must be left in its default false setting. This will indicate to the SQLite core that it will need to do a separate sorting pass over the data after it comes out of the virtual table. The estimatedCost field should be set to the estimated number of disk access operations required to execute this query against the virtual table. The SQLite core will often call xBestIndex multiple times with different constraints, obtain multiple cost estimates, then choose the query plan that gives the lowest estimate. The aConstraintUsage[] array contains one element for each of the nConstraint constraints in the inputs section of the sqlite3_index_info structure. The aConstraintUsage[] array is used by xBestIndex to tell the core how it is using the constraints. The xBestIndex method may set aConstraintUsage[].argvIndex entries to values greater than one. Exactly one entry should be set to 1, another to 2, another to 3, and so forth up to as many or as few as the xBestIndex method wants. The EXPR of the corresponding constraints will then be passed in as the argv[] parameters to xFilter. For example, if the aConstraint[3].argvIndex is set to 1, then when xFilter is called, the argv[0] passed to xFilter will have the EXPR value of the aConstraint[3] constraint. By default, the SQLite core double checks all constraints on each row of the virtual table that it receives. If such a check is redundant, the xBestFilter method can suppress that double-check by setting aConstraintUsage[].omit.

The native pointer to the sqlite3_vtab derived structure. The native pointer to the sqlite3_index_info structure. A standard SQLite return code.

This method releases a connection to a virtual table. Only the sqlite3_vtab object is destroyed. The virtual table is not destroyed and any backing store associated with the virtual table persists. This method undoes the work of xConnect. This method is a destructor for a connection to the virtual table. Contrast this method with xDestroy. The xDestroy is a destructor for the entire virtual table. The xDisconnect method is required for every virtual table implementation, though it is acceptable for the xDisconnect and xDestroy methods to be the same function if that makes sense for the particular virtual table.

The native pointer to the sqlite3_vtab derived structure. A standard SQLite return code.

This method releases a connection to a virtual table, just like the xDisconnect method, and it also destroys the underlying table implementation. This method undoes the work of xCreate. The xDisconnect method is called whenever a database connection that uses a virtual table is closed. The xDestroy method is only called when a DROP TABLE statement is executed against the virtual table. The xDestroy method is required for every virtual table implementation, though it is acceptable for the xDisconnect and xDestroy methods to be the same function if that makes sense for the particular virtual table.

The native pointer to the sqlite3_vtab derived structure. A standard SQLite return code.

The xOpen method creates a new cursor used for accessing (read and/or writing) a virtual table. A successful invocation of this method will allocate the memory for the sqlite3_vtab_cursor (or a subclass), initialize the new object, and make *ppCursor point to the new object. The successful call then returns SQLITE_OK. For every successful call to this method, the SQLite core will later invoke the xClose method to destroy the allocated cursor. The xOpen method need not initialize the pVtab field of the sqlite3_vtab_cursor structure. The SQLite core will take care of that chore automatically. A virtual table implementation must be able to support an arbitrary number of simultaneously open cursors. When initially opened, the cursor is in an undefined state. The SQLite core will invoke the xFilter method on the cursor prior to any attempt to position or read from the cursor. The xOpen method is required for every virtual table implementation.

The native pointer to the sqlite3_vtab derived structure. Upon success, this parameter must be modified to point to the newly created native sqlite3_vtab_cursor derived structure. A standard SQLite return code.

The xClose method closes a cursor previously opened by xOpen. The SQLite core will always call xClose once for each cursor opened using xOpen. This method must release all resources allocated by the corresponding xOpen call. The routine will not be called again even if it returns an error. The SQLite core will not use the sqlite3_vtab_cursor again after it has been closed. The xClose method is required for every virtual table implementation.

The native pointer to the sqlite3_vtab_cursor derived structure. A standard SQLite return code.

This method begins a search of a virtual table. The first argument is a cursor opened by xOpen. The next two argument define a particular search index previously chosen by xBestIndex. The specific meanings of idxNum and idxStr are unimportant as long as xFilter and xBestIndex agree on what that meaning is. The xBestIndex function may have requested the values of certain expressions using the aConstraintUsage[].argvIndex values of the sqlite3_index_info structure. Those values are passed to xFilter using the argc and argv parameters. If the virtual table contains one or more rows that match the search criteria, then the cursor must be left point at the first row. Subsequent calls to xEof must return false (zero). If there are no rows match, then the cursor must be left in a state that will cause the xEof to return true (non-zero). The SQLite engine will use the xColumn and xRowid methods to access that row content. The xNext method will be used to advance to the next row. This method must return SQLITE_OK if successful, or an sqlite error code if an error occurs. The xFilter method is required for every virtual table implementation.

The native pointer to the sqlite3_vtab_cursor derived structure. Number used to help identify the selected index. The native pointer to the UTF-8 encoded string containing the string used to help identify the selected index. The number of native pointers to sqlite3_value structures specified in . An array of native pointers to sqlite3_value structures containing filtering criteria for the selected index. A standard SQLite return code.

The xNext method advances a virtual table cursor to the next row of a result set initiated by xFilter. If the cursor is already pointing at the last row when this routine is called, then the cursor no longer points to valid data and a subsequent call to the xEof method must return true (non-zero). If the cursor is successfully advanced to another row of content, then subsequent calls to xEof must return false (zero). This method must return SQLITE_OK if successful, or an sqlite error code if an error occurs. The xNext method is required for every virtual table implementation.

The native pointer to the sqlite3_vtab_cursor derived structure. A standard SQLite return code.

The xEof method must return false (zero) if the specified cursor currently points to a valid row of data, or true (non-zero) otherwise. This method is called by the SQL engine immediately after each xFilter and xNext invocation. The xEof method is required for every virtual table implementation.

The native pointer to the sqlite3_vtab_cursor derived structure. Non-zero if no more rows are available; zero otherwise.

The SQLite core invokes this method in order to find the value for the N-th column of the current row. N is zero-based so the first column is numbered 0. The xColumn method may return its result back to SQLite using one of the following interface:


                sqlite3_result_blob()
                sqlite3_result_double()
                sqlite3_result_int()
                sqlite3_result_int64()
                sqlite3_result_null()
                sqlite3_result_text()
                sqlite3_result_text16()
                sqlite3_result_text16le()
                sqlite3_result_text16be()
                sqlite3_result_zeroblob()

If the xColumn method implementation calls none of the functions above, then the value of the column defaults to an SQL NULL. To raise an error, the xColumn method should use one of the result_text() methods to set the error message text, then return an appropriate error code. The xColumn method must return SQLITE_OK on success. The xColumn method is required for every virtual table implementation.

The native pointer to the sqlite3_vtab_cursor derived structure. The native pointer to the sqlite3_context structure to be used for returning the specified column value to the SQLite core library. The zero-based index corresponding to the column containing the value to be returned. A standard SQLite return code.

A successful invocation of this method will cause *pRowid to be filled with the rowid of row that the virtual table cursor pCur is currently pointing at. This method returns SQLITE_OK on success. It returns an appropriate error code on failure. The xRowid method is required for every virtual table implementation.

The native pointer to the sqlite3_vtab_cursor derived structure. Upon success, this parameter must be modified to contain the unique integer row identifier for the current row for the specified cursor. A standard SQLite return code.

All changes to a virtual table are made using the xUpdate method. This one method can be used to insert, delete, or update. The argc parameter specifies the number of entries in the argv array. The value of argc will be 1 for a pure delete operation or N+2 for an insert or replace or update where N is the number of columns in the table. In the previous sentence, N includes any hidden columns. Every argv entry will have a non-NULL value in C but may contain the SQL value NULL. In other words, it is always true that argv[i]!=0 for i between 0 and argc-1. However, it might be the case that sqlite3_value_type(argv[i])==SQLITE_NULL. The argv[0] parameter is the rowid of a row in the virtual table to be deleted. If argv[0] is an SQL NULL, then no deletion occurs. The argv[1] parameter is the rowid of a new row to be inserted into the virtual table. If argv[1] is an SQL NULL, then the implementation must choose a rowid for the newly inserted row. Subsequent argv[] entries contain values of the columns of the virtual table, in the order that the columns were declared. The number of columns will match the table declaration that the xConnect or xCreate method made using the sqlite3_declare_vtab() call. All hidden columns are included. When doing an insert without a rowid (argc>1, argv[1] is an SQL NULL), the implementation must set *pRowid to the rowid of the newly inserted row; this will become the value returned by the sqlite3_last_insert_rowid() function. Setting this value in all the other cases is a harmless no-op; the SQLite engine ignores the *pRowid return value if argc==1 or argv[1] is not an SQL NULL. Each call to xUpdate will fall into one of cases shown below. Note that references to argv[i] mean the SQL value held within the argv[i] object, not the argv[i] object itself.


                argc = 1

The single row with rowid equal to argv[0] is deleted. No insert occurs.


                argc > 1
                argv[0] = NULL

A new row is inserted with a rowid argv[1] and column values in argv[2] and following. If argv[1] is an SQL NULL, the a new unique rowid is generated automatically.


                argc > 1
                argv[0] ? NULL
                argv[0] = argv[1]

The row with rowid argv[0] is updated with new values in argv[2] and following parameters.


                argc > 1
                argv[0] ? NULL
                argv[0] ? argv[1]

The row with rowid argv[0] is updated with rowid argv[1] and new values in argv[2] and following parameters. This will occur when an SQL statement updates a rowid, as in the statement:


                        UPDATE table SET rowid=rowid+1 WHERE ...;

The xUpdate method must return SQLITE_OK if and only if it is successful. If a failure occurs, the xUpdate must return an appropriate error code. On a failure, the pVTab->zErrMsg element may optionally be replaced with error message text stored in memory allocated from SQLite using functions such as sqlite3_mprintf() or sqlite3_malloc(). If the xUpdate method violates some constraint of the virtual table (including, but not limited to, attempting to store a value of the wrong datatype, attempting to store a value that is too large or too small, or attempting to change a read-only value) then the xUpdate must fail with an appropriate error code. There might be one or more sqlite3_vtab_cursor objects open and in use on the virtual table instance and perhaps even on the row of the virtual table when the xUpdate method is invoked. The implementation of xUpdate must be prepared for attempts to delete or modify rows of the table out from other existing cursors. If the virtual table cannot accommodate such changes, the xUpdate method must return an error code. The xUpdate method is optional. If the xUpdate pointer in the sqlite3_module for a virtual table is a NULL pointer, then the virtual table is read-only.

The native pointer to the sqlite3_vtab derived structure. The number of new or modified column values contained in . The array of native pointers to sqlite3_value structures containing the new or modified column values, if any. Upon success, this parameter must be modified to contain the unique integer row identifier for the row that was inserted, if any. A standard SQLite return code.

This method begins a transaction on a virtual table. This is method is optional. The xBegin pointer of sqlite3_module may be NULL. This method is always followed by one call to either the xCommit or xRollback method. Virtual table transactions do not nest, so the xBegin method will not be invoked more than once on a single virtual table without an intervening call to either xCommit or xRollback. Multiple calls to other methods can and likely will occur in between the xBegin and the corresponding xCommit or xRollback.

The native pointer to the sqlite3_vtab derived structure. A standard SQLite return code.

This method signals the start of a two-phase commit on a virtual table. This is method is optional. The xSync pointer of sqlite3_module may be NULL. This method is only invoked after call to the xBegin method and prior to an xCommit or xRollback. In order to implement two-phase commit, the xSync method on all virtual tables is invoked prior to invoking the xCommit method on any virtual table. If any of the xSync methods fail, the entire transaction is rolled back.

The native pointer to the sqlite3_vtab derived structure. A standard SQLite return code.

This method causes a virtual table transaction to commit. This is method is optional. The xCommit pointer of sqlite3_module may be NULL. A call to this method always follows a prior call to xBegin and xSync.

The native pointer to the sqlite3_vtab derived structure. A standard SQLite return code.

This method causes a virtual table transaction to rollback. This is method is optional. The xRollback pointer of sqlite3_module may be NULL. A call to this method always follows a prior call to xBegin.

The native pointer to the sqlite3_vtab derived structure. A standard SQLite return code.

This method provides notification that the virtual table implementation that the virtual table will be given a new name. If this method returns SQLITE_OK then SQLite renames the table. If this method returns an error code then the renaming is prevented. The xRename method is required for every virtual table implementation.

The native pointer to the sqlite3_vtab derived structure. The number of arguments to the function being sought. The name of the function being sought. Upon success, this parameter must be modified to contain the delegate responsible for implementing the specified function. Upon success, this parameter must be modified to contain the native user-data pointer associated with . Non-zero if the specified function was found; zero otherwise.

The native pointer to the sqlite3_vtab derived structure. The native pointer to the UTF-8 encoded string containing the new name for the virtual table. A standard SQLite return code.

These methods provide the virtual table implementation an opportunity to implement nested transactions. They are always optional and will only be called in SQLite version 3.7.7 and later. When xSavepoint(X,N) is invoked, that is a signal to the virtual table X that it should save its current state as savepoint N. A subsequent call to xRollbackTo(X,R) means that the state of the virtual table should return to what it was when xSavepoint(X,R) was last called. The call to xRollbackTo(X,R) will invalidate all savepoints with N>R; none of the invalided savepoints will be rolled back or released without first being reinitialized by a call to xSavepoint(). A call to xRelease(X,M) invalidates all savepoints where N>=M. None of the xSavepoint(), xRelease(), or xRollbackTo() methods will ever be called except in between calls to xBegin() and either xCommit() or xRollback().

The native pointer to the sqlite3_vtab derived structure. This is an integer identifier under which the the current state of the virtual table should be saved. A standard SQLite return code.

The native pointer to the sqlite3_vtab derived structure. This is an integer used to indicate that any saved states with an identifier greater than or equal to this should be deleted by the virtual table. A standard SQLite return code.

The native pointer to the sqlite3_vtab derived structure. This is an integer identifier used to specify a specific saved state for the virtual table for it to restore itself back to, which should also have the effect of deleting all saved states with an integer identifier greater than this one. A standard SQLite return code.

This interface represents a virtual table implementation written in managed code.

This method is called in response to the method.

The object instance associated with the virtual table. The native user-data pointer associated with this module, as it was provided to the SQLite core library when the native module instance was created. The module name, database name, virtual table name, and all other arguments passed to the CREATE VIRTUAL TABLE statement. Upon success, this parameter must be modified to contain the object instance associated with the virtual table. Upon failure, this parameter must be modified to contain an error message. A standard SQLite return code.

This method is called in response to the method.

The object instance associated with this virtual table. The object instance containing all the data for the inputs and outputs relating to index selection. A standard SQLite return code.

This method is called in response to the method.

The object instance associated with this virtual table. A standard SQLite return code.

This method is called in response to the method.

The object instance associated with this virtual table. A standard SQLite return code.

This method is called in response to the method.

The object instance associated with this virtual table. Upon success, this parameter must be modified to contain the object instance associated with the newly opened virtual table cursor. A standard SQLite return code.

This method is called in response to the method.

The object instance associated with the previously opened virtual table cursor to be used. A standard SQLite return code.

This method is called in response to the method.

The object instance associated with the previously opened virtual table cursor to be used. Number used to help identify the selected index. String used to help identify the selected index. The values corresponding to each column in the selected index. A standard SQLite return code.

This method is called in response to the method.

The object instance associated with the previously opened virtual table cursor to be used. A standard SQLite return code.

This method is called in response to the method.

The object instance associated with the previously opened virtual table cursor to be used. Non-zero if no more rows are available; zero otherwise.

This method is called in response to the method.

The object instance associated with the previously opened virtual table cursor to be used. The object instance to be used for returning the specified column value to the SQLite core library. The zero-based index corresponding to the column containing the value to be returned. A standard SQLite return code.

This method is called in response to the method.

The object instance associated with the previously opened virtual table cursor to be used. Upon success, this parameter must be modified to contain the unique integer row identifier for the current row for the specified cursor. A standard SQLite return code.

This method is called in response to the method.

The object instance associated with this virtual table. The array of object instances containing the new or modified column values, if any. Upon success, this parameter must be modified to contain the unique integer row identifier for the row that was inserted, if any. A standard SQLite return code.

This method is called in response to the method.

The object instance associated with this virtual table. A standard SQLite return code.

This method is called in response to the method.

The object instance associated with this virtual table. A standard SQLite return code.

This method is called in response to the method.

The object instance associated with this virtual table. A standard SQLite return code.

This method is called in response to the method.

The object instance associated with this virtual table. A standard SQLite return code.

This method is called in response to the method.

The object instance associated with this virtual table. The number of arguments to the function being sought. The name of the function being sought. Upon success, this parameter must be modified to contain the object instance responsible for implementing the specified function. Upon success, this parameter must be modified to contain the native user-data pointer associated with . Non-zero if the specified function was found; zero otherwise.

This method is called in response to the method.

The object instance associated with this virtual table. The new name for the virtual table. A standard SQLite return code.

This method is called in response to the method.

The object instance associated with this virtual table. This is an integer identifier under which the the current state of the virtual table should be saved. A standard SQLite return code.

This method is called in response to the method.

The object instance associated with this virtual table. This is an integer used to indicate that any saved states with an identifier greater than or equal to this should be deleted by the virtual table. A standard SQLite return code.

This method is called in response to the method.

The object instance associated with this virtual table. This is an integer identifier used to specify a specific saved state for the virtual table for it to restore itself back to, which should also have the effect of deleting all saved states with an integer identifier greater than this one. A standard SQLite return code.

Returns non-zero if the schema for the virtual table has been declared.

Returns the name of the module as it was registered with the SQLite core library.

This class contains static methods that are used to allocate, manipulate, and free native memory provided by the SQLite core library.

Allocates at least the specified number of bytes of native memory via the SQLite core library sqlite3_malloc() function and returns the resulting native pointer.

The number of bytes to allocate. The native pointer that points to a block of memory of at least the specified size -OR- if the memory could not be allocated.

Gets and returns the actual size of the specified memory block that was previously obtained from the method.

The native pointer to the memory block previously obtained from the method. The actual size, in bytes, of the memory block specified via the native pointer.

Frees a memory block previously obtained from the method.

The native pointer to the memory block previously obtained from the method.

This class contains static methods that are used to deal with native UTF-8 string pointers to be used with the SQLite core library.

This is the maximum possible length for the native UTF-8 encoded strings used with the SQLite core library.

This is the object instance used to handle conversions from/to UTF-8.

Converts the specified managed string into the UTF-8 encoding and returns the array of bytes containing its representation in that encoding.

The managed string to convert. The array of bytes containing the representation of the managed string in the UTF-8 encoding or null upon failure.

Converts the specified array of bytes representing a string in the UTF-8 encoding and returns a managed string.

The array of bytes to convert. The managed string or null upon failure.

Probes a native pointer to a string in the UTF-8 encoding for its terminating NUL character, within the specified length limit.

The native NUL-terminated string pointer. The maximum length of the native string, in bytes. The length of the native string, in bytes -OR- zero if the length could not be determined.

Converts the specified native NUL-terminated UTF-8 string pointer into a managed string.

The native NUL-terminated UTF-8 string pointer. The managed string or null upon failure.

Converts the specified native UTF-8 string pointer of the specified length into a managed string.

The native UTF-8 string pointer. The length of the native string, in bytes. The managed string or null upon failure.

Converts the specified managed string into a native NUL-terminated UTF-8 string pointer using memory obtained from the SQLite core library.

The managed string to convert. The native NUL-terminated UTF-8 string pointer or upon failure.

Converts a logical array of native NUL-terminated UTF-8 string pointers into an array of managed strings.

The number of elements in the logical array of native NUL-terminated UTF-8 string pointers. The native pointer to the logical array of native NUL-terminated UTF-8 string pointers to convert. The array of managed strings or null upon failure.

Converts an array of managed strings into an array of native NUL-terminated UTF-8 string pointers.

The array of managed strings to convert. The array of native NUL-terminated UTF-8 string pointers or null upon failure.

This class contains static methods that are used to deal with native pointers to memory blocks that logically contain arrays of bytes to be used with the SQLite core library.

Converts a native pointer to a logical array of bytes of the specified length into a managed byte array.

The native pointer to the logical array of bytes to convert. The length, in bytes, of the logical array of bytes to convert. The managed byte array or null upon failure.

Converts a managed byte array into a native pointer to a logical array of bytes.

The managed byte array to convert. The native pointer to a logical byte array or null upon failure.

This class contains static methods that are used to perform several low-level data marshalling tasks between native and managed code.

Returns a new object instance based on the specified object instance and an integer offset.

The object instance representing the base memory location. The integer offset from the base memory location that the new object instance should point to. The new object instance.

Rounds up an integer size to the next multiple of the alignment.

The size, in bytes, to be rounded up. The required alignment for the return value. The size, in bytes, rounded up to the next multiple of the alignment. This value may end up being the same as the original size.

Determines the offset, in bytes, of the next structure member.

The offset, in bytes, of the current structure member. The size, in bytes, of the current structure member. The alignment, in bytes, of the next structure member. The offset, in bytes, of the next structure member.

Reads a value from the specified memory location.

The object instance representing the base memory location. The integer offset from the base memory location where the value to be read is located. The value at the specified memory location.

Reads a value from the specified memory location.

The object instance representing the base memory location. The integer offset from the base memory location where the to be read is located. The value at the specified memory location.

Reads an value from the specified memory location.

The object instance representing the base memory location. The integer offset from the base memory location where the value to be read is located. The value at the specified memory location.

Writes an value to the specified memory location.

The object instance representing the base memory location. The integer offset from the base memory location where the value to be written is located. The value to write.

Writes an value to the specified memory location.

The object instance representing the base memory location. The integer offset from the base memory location where the value to be written is located. The value to write.

Writes a value to the specified memory location.

The object instance representing the base memory location. The integer offset from the base memory location where the value to be written is located. The value to write.

Writes a value to the specified memory location.

The object instance representing the base memory location. The integer offset from the base memory location where the value to be written is located. The value to write.

Generates a hash code value for the object.

The object instance used to calculate the hash code. Non-zero if different object instances with the same value should generate different hash codes, where applicable. This parameter has no effect on the .NET Compact Framework. The hash code value -OR- zero if the object is null.

This class represents a managed virtual table module implementation. It is not sealed and must be used as the base class for any user-defined virtual table module classes implemented in managed code.

The default version of the native sqlite3_module structure in use.

This field is used to store the native sqlite3_module structure associated with this object instance.

This field is used to store the destructor delegate to be passed to the SQLite core library via the sqlite3_create_disposable_module() function.

This field is used to store a pointer to the native sqlite3_module structure returned by the sqlite3_create_disposable_module function.

This field is used to store the virtual table instances associated with this module. The native pointer to the sqlite3_vtab derived structure is used to key into this collection.

This field is used to store the virtual table cursor instances associated with this module. The native pointer to the sqlite3_vtab_cursor derived structure is used to key into this collection.

This field is used to store the virtual table function instances associated with this module. The case-insensitive function name and the number of arguments (with -1 meaning "any") are used to construct the string that is used to key into this collection.

Constructs an instance of this class.

The name of the module. This parameter cannot be null.

Calls the native SQLite core library in order to create a new disposable module containing the implementation of a virtual table.

The native database connection pointer to use. Non-zero upon success.

This method is called by the SQLite core library when the native module associated with this object instance is being destroyed due to its parent connection being closed. It may also be called by the "vtshim" module if/when the sqlite3_dispose_module() function is called.

The native user-data pointer associated with this module, as it was provided to the SQLite core library when the native module instance was created.

Creates and returns the native sqlite_module structure using the configured (or default) interface implementation.

The native sqlite_module structure using the configured (or default) interface implementation.

Creates and returns the native sqlite_module structure using the specified interface implementation.

The interface implementation to use. The native sqlite_module structure using the specified interface implementation.

Creates a copy of the specified object instance, using default implementations for the contained delegates when necessary.

The object instance to copy. The new object instance.

Calls one of the virtual table initialization methods.

Non-zero to call the method; otherwise, the method will be called. The native database connection handle. The original native pointer value that was provided to the sqlite3_create_module(), sqlite3_create_module_v2() or sqlite3_create_disposable_module() functions. The number of arguments from the CREATE VIRTUAL TABLE statement. The array of string arguments from the CREATE VIRTUAL TABLE statement. Upon success, this parameter must be modified to point to the newly created native sqlite3_vtab derived structure. Upon failure, this parameter must be modified to point to the error message, with the underlying memory having been obtained from the sqlite3_malloc() function. A standard SQLite return code.

Calls one of the virtual table finalization methods.

Non-zero to call the method; otherwise, the method will be called. The native pointer to the sqlite3_vtab derived structure. A standard SQLite return code.

Arranges for the specified error message to be placed into the zErrMsg field of a sqlite3_vtab derived structure, freeing the existing error message, if any.

The object instance to be used. The native pointer to the sqlite3_vtab derived structure. Non-zero if this error message should also be logged using the class. Non-zero if caught exceptions should be logged using the class. The error message. Non-zero upon success.

Arranges for the specified error message to be placed into the zErrMsg field of a sqlite3_vtab derived structure, freeing the existing error message, if any.

The object instance to be used. The object instance used to lookup the native pointer to the sqlite3_vtab derived structure. Non-zero if this error message should also be logged using the class. Non-zero if caught exceptions should be logged using the class. The error message. Non-zero upon success.

Arranges for the specified error message to be placed into the zErrMsg field of a sqlite3_vtab derived structure, freeing the existing error message, if any.

The object instance to be used. The native pointer to the sqlite3_vtab_cursor derived structure used to get the native pointer to the sqlite3_vtab derived structure. Non-zero if this error message should also be logged using the class. Non-zero if caught exceptions should be logged using the class. The error message. Non-zero upon success.

Arranges for the specified error message to be placed into the zErrMsg field of a sqlite3_vtab derived structure, freeing the existing error message, if any.

Gets and returns the interface implementation to be used when creating the native sqlite3_module structure. Derived classes may override this method to supply an alternate implementation for the interface.

The interface implementation to be used when populating the native sqlite3_module structure. If the returned value is null, the private methods provided by the class and relating to the interface will be used to create the necessary delegates.

Creates and returns the interface implementation corresponding to the current object instance.

The interface implementation corresponding to the current object instance.

Allocates a native sqlite3_vtab derived structure and returns a native pointer to it.

A native pointer to a native sqlite3_vtab derived structure.

Zeros out the fields of a native sqlite3_vtab derived structure.

The native pointer to the native sqlite3_vtab derived structure to zero.

Frees a native sqlite3_vtab structure using the provided native pointer to it.

A native pointer to a native sqlite3_vtab derived structure.

Allocates a native sqlite3_vtab_cursor derived structure and returns a native pointer to it.

A native pointer to a native sqlite3_vtab_cursor derived structure.

Frees a native sqlite3_vtab_cursor structure using the provided native pointer to it.

A native pointer to a native sqlite3_vtab_cursor derived structure.

Reads and returns the native pointer to the sqlite3_vtab derived structure based on the native pointer to the sqlite3_vtab_cursor derived structure.

The object instance to be used. The native pointer to the sqlite3_vtab_cursor derived structure from which to read the native pointer to the sqlite3_vtab derived structure. The native pointer to the sqlite3_vtab derived structure -OR- if it cannot be determined.

Reads and returns the native pointer to the sqlite3_vtab derived structure based on the native pointer to the sqlite3_vtab_cursor derived structure.

The native pointer to the sqlite3_vtab_cursor derived structure from which to read the native pointer to the sqlite3_vtab derived structure. The native pointer to the sqlite3_vtab derived structure -OR- if it cannot be determined.

Looks up and returns the object instance based on the native pointer to the sqlite3_vtab derived structure.

The native pointer to the sqlite3_vtab derived structure. The object instance or null if the corresponding one cannot be found.

Allocates and returns a native pointer to a sqlite3_vtab derived structure and creates an association between it and the specified object instance.

The object instance to be used when creating the association. The native pointer to a sqlite3_vtab derived structure or if the method fails for any reason.

Looks up and returns the object instance based on the native pointer to the sqlite3_vtab_cursor derived structure.

The native pointer to the sqlite3_vtab derived structure. The native pointer to the sqlite3_vtab_cursor derived structure. The object instance or null if the corresponding one cannot be found.

Allocates and returns a native pointer to a sqlite3_vtab_cursor derived structure and creates an association between it and the specified object instance.

The object instance to be used when creating the association. The native pointer to a sqlite3_vtab_cursor derived structure or if the method fails for any reason.

Deterimines the key that should be used to identify and store the object instance for the virtual table (i.e. to be returned via the method).

The number of arguments to the virtual table function. The name of the virtual table function. The object instance associated with this virtual table function. The string that should be used to identify and store the virtual table function instance. This method cannot return null. If null is returned from this method, the behavior is undefined.

Attempts to declare the schema for the virtual table using the specified database connection.

The object instance to use when declaring the schema of the virtual table. This parameter may not be null. The string containing the CREATE TABLE statement that completely describes the schema for the virtual table. This parameter may not be null. Upon failure, this parameter must be modified to contain an error message. A standard SQLite return code.

Calls the native SQLite core library in order to declare a virtual table function in response to a call into the or virtual table methods.

The object instance to use when declaring the schema of the virtual table. The number of arguments to the function being declared. The name of the function being declared. Upon success, the contents of this parameter are undefined. Upon failure, it should contain an appropriate error message. A standard SQLite return code.

Arranges for the specified error message to be placed into the zErrMsg field of a sqlite3_vtab derived structure, freeing the existing error message, if any.

The native pointer to the sqlite3_vtab derived structure. The error message. Non-zero upon success.

Arranges for the specified error message to be placed into the zErrMsg field of a sqlite3_vtab derived structure, freeing the existing error message, if any.

The object instance used to lookup the native pointer to the sqlite3_vtab derived structure. The error message. Non-zero upon success.

Arranges for the specified error message to be placed into the zErrMsg field of a sqlite3_vtab derived structure, freeing the existing error message, if any.

The object instance used to lookup the native pointer to the sqlite3_vtab derived structure. The error message. Non-zero upon success.

Modifies the specified object instance to contain the specified estimated cost.

The object instance to modify. The estimated cost value to use. Using a null value means that the default value provided by the SQLite core library should be used. Non-zero upon success.

Modifies the specified object instance to contain the default estimated cost.

The object instance to modify. Non-zero upon success.

Modifies the specified object instance to contain the specified estimated rows.

The object instance to modify. The estimated rows value to use. Using a null value means that the default value provided by the SQLite core library should be used. Non-zero upon success.

Modifies the specified object instance to contain the default estimated rows.

The object instance to modify. Non-zero upon success.

See the method.

See the method. See the method. See the method. See the method. See the method. See the method. See the method.

See the method.

See the method. See the method. See the method. See the method. See the method. See the method. See the method.

See the method.

See the method. See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method. See the method. See the method. See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method. See the method. See the method.

See the method.

See the method. See the method. See the method.

See the method.

See the method. See the method. See the method. See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method. See the method. See the method. See the method. See the method.

See the method.

See the method. See the method. See the method.

See the method.

See the method. See the method. See the method.

See the method.

See the method. See the method. See the method.

See the method.

See the method. See the method. See the method.

This method is called in response to the method.

The object instance associated with this virtual table. The object instance containing all the data for the inputs and outputs relating to index selection. A standard SQLite return code.

This method is called in response to the method.

The object instance associated with this virtual table. A standard SQLite return code.

This method is called in response to the method.

The object instance associated with this virtual table. A standard SQLite return code.

This method is called in response to the method.

The object instance associated with the previously opened virtual table cursor to be used. A standard SQLite return code.

This method is called in response to the method.

The object instance associated with the previously opened virtual table cursor to be used. A standard SQLite return code.

This method is called in response to the method.

The object instance associated with the previously opened virtual table cursor to be used. Non-zero if no more rows are available; zero otherwise.

This method is called in response to the method.

The object instance associated with this virtual table. A standard SQLite return code.

This method is called in response to the method.

The object instance associated with this virtual table. A standard SQLite return code.

This method is called in response to the method.

The object instance associated with this virtual table. A standard SQLite return code.

This method is called in response to the method.

The object instance associated with this virtual table. A standard SQLite return code.

This method is called in response to the method.

The object instance associated with this virtual table. The new name for the virtual table. A standard SQLite return code.

This method is called in response to the method.

The object instance associated with this virtual table. This is an integer identifier under which the the current state of the virtual table should be saved. A standard SQLite return code.

This method is called in response to the method.

Disposes of this object instance.

Throws an if this object instance has been disposed.

Disposes of this object instance.

Non-zero if this method is being called from the method. Zero if this method is being called from the finalizer.

Finalizes this object instance.

Returns or sets a boolean value indicating whether virtual table errors should be logged using the class.

Returns or sets a boolean value indicating whether exceptions caught in the method, the method, the method, the method, and the method should be logged using the class.

Returns or sets a boolean value indicating whether virtual table errors should be logged using the class.

Returns or sets a boolean value indicating whether exceptions caught in the method, method, and the method should be logged using the class.

Returns non-zero if the schema for the virtual table has been declared.

Returns the name of the module as it was registered with the SQLite core library.

This class implements the interface by forwarding those method calls to the object instance it contains. If the contained object instance is null, all the methods simply generate an error.

This is the value that is always used for the "logErrors" parameter to the various static error handling methods provided by the class.

This is the value that is always used for the "logExceptions" parameter to the various static error handling methods provided by the class.

This is the error message text used when the contained object instance is not available for any reason.

The object instance used to provide an implementation of the interface.

Constructs an instance of this class.

The object instance used to provide an implementation of the interface.

Sets the table error message to one that indicates the native module implementation is not available.

The native pointer to the sqlite3_vtab derived structure. The value of .

Sets the table error message to one that indicates the native module implementation is not available.

The native pointer to the sqlite3_vtab_cursor derived structure. The value of .

See the method.

See the method. See the method. See the method. See the method. See the method. See the method. See the method.

See the method.

See the method. See the method. See the method. See the method. See the method. See the method. See the method.

See the method.

See the method. See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method. See the method. See the method. See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method. See the method. See the method.

See the method.

See the method. See the method. See the method.

See the method.

See the method. See the method. See the method. See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method. See the method. See the method. See the method. See the method.

See the method.

See the method. See the method. See the method.

See the method.

See the method. See the method. See the method.

See the method.

See the method. See the method. See the method.

See the method.

See the method. See the method. See the method.

Disposes of this object instance.

Throws an if this object instance has been disposed.

Disposes of this object instance.

Non-zero if this method is being called from the method. Zero if this method is being called from the finalizer.

Finalizes this object instance.

This class represents a virtual table cursor to be used with the class. It is not sealed and may be used as the base class for any user-defined virtual table cursor class that wraps an object instance.

The instance provided when this cursor was created.

This value will be non-zero if false has been returned from the method.

Constructs an instance of this class.

The object instance associated with this object instance. The instance to expose as a virtual table cursor.

Advances to the next row of the virtual table cursor using the method of the object instance.

Non-zero if the current row is valid; zero otherwise. If zero is returned, no further rows are available.

Resets the virtual table cursor position, also invalidating the current row, using the method of the object instance.

Closes the virtual table cursor. This method must not throw any exceptions.

Throws an if the virtual table cursor has been closed.

Throws an if this object instance has been disposed.

Disposes of this object instance.

Non-zero if this method is being called from the method. Zero if this method is being called from the finalizer.

Returns the value for the current row of the virtual table cursor using the property of the object instance.

Returns non-zero if the end of the virtual table cursor has been seen (i.e. no more rows are available, including the current one).

Returns non-zero if the virtual table cursor is open.

This class implements a virtual table module that exposes an object instance as a read-only virtual table. It is not sealed and may be used as the base class for any user-defined virtual table class that wraps an object instance. The following short example shows it being used to treat an array of strings as a table data source:


               public static class Sample
               {
                 public static void Main()
                 {
                   using (SQLiteConnection connection = new SQLiteConnection(
                       "Data Source=:memory:;"))
                   {
                     connection.Open();
            
                     connection.CreateModule(new SQLiteModuleEnumerable(
                       "sampleModule", new string[] { "one", "two", "three" }));
            
                     using (SQLiteCommand command = connection.CreateCommand())
                     {
                       command.CommandText =
                           "CREATE VIRTUAL TABLE t1 USING sampleModule;";
            
                       command.ExecuteNonQuery();
                     }
            
                     using (SQLiteCommand command = connection.CreateCommand())
                     {
                       command.CommandText = "SELECT * FROM t1;";
            
                       using (SQLiteDataReader dataReader = command.ExecuteReader())
                       {
                         while (dataReader.Read())
                           Console.WriteLine(dataReader[0].ToString());
                       }
                     }
            
                     connection.Close();
                   }
                 }
               }

This class implements a virtual table module that does nothing by providing "empty" implementations for all of the interface methods. The result codes returned by these "empty" method implementations may be controlled on a per-method basis by using and/or overriding the , , , , and methods from within derived classes.

This field is used to store the values to return, on a per-method basis, for all methods that are part of the interface.

Constructs an instance of this class.

The name of the module. This parameter cannot be null.

Determines the default value to be returned by methods of the interface that lack an overridden implementation in all classes derived from the class.

The value that should be returned by all interface methods unless a more specific result code has been set for that interface method.

Converts a value into a boolean return value for use with the method.

The value to convert. The value.

Converts a value into a boolean return value for use with the method.

The value to convert. The value.

Determines the value that should be returned by the specified interface method if it lack an overridden implementation. If no specific value is available (or set) for the specified method, the value returned by the method will be returned instead.

The name of the method. Currently, this method must be part of the interface. The value that should be returned by the interface method.

Sets the value that should be returned by the specified interface method if it lack an overridden implementation.

The name of the method. Currently, this method must be part of the interface. The value that should be returned by the interface method. Non-zero upon success.

See the method.

See the method. See the method. See the method. See the method. See the method. See the method.

See the method.

See the method. See the method. See the method. See the method. See the method. See the method.

See the method.

See the method. See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method. See the method. See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method. See the method. See the method.

See the method.

See the method. See the method. See the method.

See the method.

See the method. See the method. See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method. See the method. See the method. See the method. See the method.

See the method.

See the method. See the method. See the method.

See the method.

See the method. See the method. See the method.

See the method.

See the method. See the method. See the method.

See the method.

See the method. See the method. See the method.

Throws an if this object instance has been disposed.

Disposes of this object instance.

Non-zero if this method is being called from the method. Zero if this method is being called from the finalizer.

The CREATE TABLE statement used to declare the schema for the virtual table.

The instance containing the backing data for the virtual table.

Non-zero if different object instances with the same value should generate different row identifiers, where applicable. This has no effect on the .NET Compact Framework.

Constructs an instance of this class.

The name of the module. This parameter cannot be null. The instance to expose as a virtual table. This parameter cannot be null.

Constructs an instance of this class.

The name of the module. This parameter cannot be null. The instance to expose as a virtual table. This parameter cannot be null. Non-zero if different object instances with the same value should generate different row identifiers, where applicable. This parameter has no effect on the .NET Compact Framework.

Determines the SQL statement used to declare the virtual table. This method should be overridden in derived classes if they require a custom virtual table schema.

The SQL statement used to declare the virtual table -OR- null if it cannot be determined.

Sets the table error message to one that indicates the virtual table cursor is of the wrong type.

The object instance. The value of .

Sets the table error message to one that indicates the virtual table cursor has no current row.

The object instance. The value of .

Determines the string to return as the column value for the object instance value.

The object instance associated with the previously opened virtual table cursor to be used. The object instance to return a string representation for. The string representation of the specified object instance or null upon failure.

Constructs an unique row identifier from two values. The first value must contain the row sequence number for the current row and the second value must contain the hash code of the enumerator value for the current row.

The integer row sequence number for the current row. The hash code of the enumerator value for the current row. The unique row identifier or zero upon failure.

Determines the unique row identifier for the current row.

The object instance associated with the previously opened virtual table cursor to be used. The object instance to return a unique row identifier for. The unique row identifier or zero upon failure.

See the method.

See the method. See the method. See the method. See the method. See the method. See the method.

See the method.

See the method. See the method. See the method. See the method. See the method. See the method.

See the method.

See the method. See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method. See the method. See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method.

See the method.

See the method. See the method. See the method. See the method.

See the method.

See the method. See the method. See the method.

See the method.

See the method. See the method. See the method. See the method.

See the method.

See the method. See the method. See the method.

Throws an if this object instance has been disposed.

Disposes of this object instance.

Non-zero if this method is being called from the method. Zero if this method is being called from the finalizer.

The instance provided when this cursor was created.

Constructs an instance of this class.

The object instance associated with this object instance. The instance to expose as a virtual table cursor.

Closes the virtual table cursor. This method must not throw any exceptions.

Throws an if this object instance has been disposed.

Disposes of this object instance.

Non-zero if this method is being called from the method. Zero if this method is being called from the finalizer.

Returns the value for the current row of the virtual table cursor using the property of the object instance.

The instance containing the backing data for the virtual table.

Constructs an instance of this class.

The name of the module. This parameter cannot be null. The instance to expose as a virtual table. This parameter cannot be null.

See the method.

See the method. See the method. See the method.

See the method.

See the method. See the method. See the method. See the method.

Throws an if this object instance has been disposed.

Disposes of this object instance.

Non-zero if this method is being called from the method. Zero if this method is being called from the finalizer.