System.Data.SQLite
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.
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.
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
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 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
This event is raised whenever SQLite is committing a transaction.
Return non-zero to trigger a rollback
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
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.
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
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.
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.
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
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 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 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 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.
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 DbCommand.
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
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
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.
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
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.
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.
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 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.
This class implements SQLiteBase completely, and is the guts of the code that interop's SQLite with .NET
The opaque pointer returned to us by the sqlite provider
The user-defined functions registered on this connection
Helper function to retrieve a column of data from an active statement.
The statement being step()'d through
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
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 true
Returns false
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
Alternate SQLite3 object, overriding many text behaviors to support UTF-16 (Unicode)
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
SQLite implementation of DbProviderFactory.
SQLite implementation of DbProviderFactory.
Will provide a DbProviderServices object in .NET 3.5
The class or interface type to query for
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.
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]";.
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
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
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
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.
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.
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 delete rows from the database
Returns the automatically-generated SQLite command to update rows in 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
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
Overridden to hide its property from the designer
Overridden to hide its property from the designer
Overridden to hide its property from the designer
Overridden to hide its property from the designer