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 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

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 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.

Determines how SQLite handles the transaction journal file.

Sets the default isolation level for transactions on the connection.

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

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]";.

The connection pool object

The default version number new pools will get

Attempt to pull a pooled connection out of the queue for active duty

The filename for a desired connection The maximum size the connection pool for the filename can be The pool version the returned connection will belong to Returns NULL if no connections were available. Even if none are, the poolversion will still be a valid pool version

Clears out all pooled connections and rev's up the default pool version to force all old active objects not in the pool to get discarded rather than returned to their pools.

Clear a given pool for a given filename. Discards anything in the pool for the given file, and revs the pool version so current active objects on the old version of the pool will get discarded rather than be returned to the pool.

The filename of the pool to clear

Return a connection to the pool for someone else to use.

The filename of the pool to use The connection handle to pool The pool version the handle was created under If the version numbers don't match between the connection and the pool, then the handle is discarded.

We don't have to thread-lock anything in this function, because it's only called by other functions above which already have a thread-safe lock.

The 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.

SQLite implentation of DbConnection.

The ConnectionString property of the SQLiteConnection class can contain the following parameter(s), delimited with a semi-colon: Parameter Values Required Default Data Source {filename} Y Version 3 N 3 UseUTF16Encoding True
False N False DateTimeFormat Ticks - Use DateTime.Ticks
ISO8601 - Use ISO8601 DateTime format N ISO8601 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 Normal Page Size {size in bytes} N 1024 Password {password} 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 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

State of the current connection

The connection string

Nesting level of the transactions open on the connection

The default isolation level for new transactions

Whether or not the connection is enlisted in a distrubuted transaction

The base SQLite object to interop with

The database filename minus path and extension

Temporary password storage, emptied after the database has been opened

Default command timeout

Constructs a new SQLiteConnection object

Default constructor

Initializes the connection with the specified connection string

The connection string to use on 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.

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.

Disposes of the SQLiteConnection, closing it if it is active.

True if the connection is being explicitly closed.

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 state. If it is different from the previous state, an event is raised.

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 SQLiteTransaction 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 SQLiteTransaction if one isn't already active on the connection.

Returns a SQLiteTransaction object.

Forwards to the local BeginTransaction() function

Supported isolation levels are Unspecified, Serializable, and ReadCommitted

Not implemented

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 SQLiteCommand and associate it with this connection.

Returns an instantiated SQLiteCommand object already assigned to this connection.

Forwards to the local CreateCommand() function

Parses the connection string into component parts

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

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.

Opens the connection using the parameters found in the ConnectionString

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

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

The database filename to expand 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

Returns a SQLiteProviderFactory object.

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

The connection string containing the parameters for the connection

Parameter Values Required Default Data Source {filename} Y Version 3 N 3 UseUTF16Encoding True
False N False DateTimeFormat Ticks - Use DateTime.Ticks
ISO8601 - Use ISO8601 DateTime format
JulianDay - Use JulianDay format N ISO8601 BinaryGUID Yes/On/1 - Store GUID columns in binary form
No/Off/0 - Store GUID columns as text N On 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 Normal Page Size {size in bytes} N 1024 Password {password} 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 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

Returns the filename without extension or path

Returns an empty string

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"

Returns the version of the underlying SQLite database engine

Returns the state of the connection.

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

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 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

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

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

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.

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.

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.

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.

The internal aggregate Step function callback, which wraps the raw context pointer and calls the virtual Step() method.

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.

A raw context pointer

Placeholder for a user-defined disposal routine

True if the object is being disposed explicitly

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.

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 Returns an array of functions which the connection object should retain until the connection is closed.

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 context pointer for the user function Count of arguments to the function A pointer to the array of 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

SQLite implementation of DbProviderFactory.

Static instance member which returns an instanced SQLiteFactory class.

Returns a new SQLiteCommand object.

A SQLiteCommand object.

Returns a new SQLiteCommandBuilder object.

A SQLiteCommandBuilder object.

Creates a new SQLiteConnection.

A SQLiteConnection object.

Creates a new SQLiteConnectionStringBuilder.

A SQLiteConnectionStringBuilder object.

Creates a new SQLiteDataAdapter.

A SQLiteDataAdapter object.

Creates a new SQLiteParameter.

A SQLiteParameter object.

Will provide a DbProviderServices object in .NET 3.5

The class or interface type to query for

SQLite exception class.

Public constructor for generating a SQLite error given the base error code

The SQLite error code to report Extra text to go along with the error message text

Various public constructors that just pass along to the base Exception

Passed verbatim to Exception

Various public constructors that just pass along to the base Exception

Various public constructors that just pass along to the base Exception Passed to Exception Passed to Exception

Initializes the exception class with the SQLite error code.

The SQLite error code A detailed error message An error message string

Retrieves the underlying SQLite error code for this exception

SQLite error codes

Success

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

malloc() failed

Attempt to write a read-only database

Operation terminated by sqlite3_interrupt()

Some kind of disk I/O error occurred

The database disk image is malformed

Table or record not found

Insertion failed because database is full

Unable to open the database file

Database lock protocol error

Database is empty

The database schema changed

Too much data for one row of a table

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

sqlite3_step() has another row ready

sqlite3_step() has finished executing

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.

An array of ISO8601 datetime formats we support conversion from

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

The default DateTime format for this instance

Initializes the conversion class

The default date/time format to use for this instance

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 current DateTimeFormat specified for the connection when it was opened.

Acceptable ISO8601 DateTime formats are: yyyy-MM-dd HH:mm:ss yyyyMMddHHmmss yyyyMMddTHHmmssfffffff yyyy-MM-dd yy-MM-dd yyyyMMdd HH:mm:ss THHmmss The string containing either a Tick value, a JulianDay double, or an ISO8601-format string A DateTime value

Converts a julianday value into a DateTime

The value to convert A .NET DateTime

Converts a DateTime struct to a JulianDay double

The DateTime to convert The JulianDay value the Datetime represents

Converts a DateTime to a string value, using the current DateTimeFormat specified for the connection when it was opened.

The DateTime value to convert Either a string consisting of the tick count for DateTimeFormat.Ticks, a JulianDay double, or a date/time in ISO8601 format.

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

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.

Determines the data type of a column in a statement

The statement to retrieve information for The column to retrieve type information on The SQLiteType to receive the affinity for the given column

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

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.

For a given type name, return a closest-match .NET type

The name of the type to match The .NET DBType the text evaluates to.

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 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.

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

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

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

Returns a string representing the active version of SQLite

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

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

Used internally

This implementation of SQLite for ADO.NET can process date/time fields in databases in only one of three formats. Ticks, ISO8601 and JulianDay.

ISO8601 is more compatible, readable, fully-processable, but less accurate as it doesn't 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. The preferred order of choosing a datetime format is JulianDay, ISO8601, and then Ticks. Ticks is mainly present for legacy code support.

Using ticks is not recommended and is not well supported with LINQ.

The default format for this provider.

JulianDay format, which is what SQLite uses internally

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 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!

Struct 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

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)

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

The base SQLite object The statement The command text for this statement The previous command in a multi-statement command

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

Disposes and finalizes the statement

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 DbDataReader.

Underlying command this reader is attached to

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

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

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

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

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.

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 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.

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

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 visible fielsd 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 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.

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 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

Commits the current transaction.

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

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.

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