` method.
>
> 2017r3 and prior: AES-128 encryption is always used.
>
> 2018r1 and later defaults to AES-128, but AES-256 can also be used by including the prefix "aes256:" before the rest of the encryption key.
>
> This code supplies EncryptionKey before attempting to connect to an encrypted database:
>
> ``` xojo
> Var dbFile As New FolderItem("MyDB.sqlite", FolderItem.PathModes.Native)
> Var db As New SQLiteDatabase
>
> db.DatabaseFile = dbFile
> db.EncryptionKey = "horse+20$"
>
> Try
> db.Connect
> ' Key was correct; DB is connected
> MessageBox("Connected to database.")
> Catch error As DatabaseException
> ' Connection error. This could be because the key is wrong or other reasons
> MessageBox("Connection error: " + error.Message)
> End Try
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SQLiteDatabase.LibraryVersion
**LibraryVersion** As `String`
> Returns a `String` containing the version of SQLite used by Xojo.
>
> This property is read-only.
>
> Displays the SQLite version in use:
>
> ``` xojo
> Var db As New SQLiteDatabase
> MessageBox("SQLite version = " + db.LibraryVersion)
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SQLiteDatabase.LoadExtensions
**LoadExtensions** As `Boolean`
> The default is `False`. Set this to `True` before loading an SQLite extension. After loading the extension, this property gets reset to `False`.
>
>
>
>
>
> Important
>
>
>
> This method is not currently supported for Android.
>
>
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SQLiteDatabase.MetaData
**MetaData** As `String`
> Used to store custom data that doesn't belong in the other properties.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SQLiteDatabase.Tag
**Tag** As `Variant`
> Used to store any value you wish to associated with this instance of the database.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SQLiteDatabase.ThreadYieldInterval
**ThreadYieldInterval** As `Integer`
> Yields time back to your application every *N* virtual machine instructions. The unit is *virtual machine instructions.*
>
>
>
>
>
> Important
>
>
>
> This method is not currently supported for Android.
>
>
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SQLiteDatabase.Timeout
**Timeout** As `Double`
> The maximum number of **seconds** that an operation may wait before a lock is cleared (if any). The default is 10.
>
> If an operation has to wait longer than this amount of seconds then the operation will fail (with a suitable SQL error).
>
> If the value is less than or equal to 0 then all busy handlers will be disabled and the operation will wait indefinitely.
>
> This value can be changed at any time.
>
> This example sets the Timeout to 30 seconds.
>
> ``` xojo
> Var dbFile As New FolderItem("MyDB.sqlite", FolderItem.PathModes.Native)
> Var db As New SQLiteDatabase
>
> db.DatabaseFile = dbFile
> db.Timeout = 30
>
> Try
> db.Connect
> ' Key was correct; DB is connected
> MessageBox("Connected to database.")
> Catch error As DatabaseException
> MessageBox("Connection error: " + error.Message)
> End Try
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SQLiteDatabase.WriteAheadLogging
**WriteAheadLogging** As `Boolean`
> Enables the SQLite Write-Ahead Logging (WAL) mode which can improve performance of database writes. This is especially useful when multiple users are writing to the database, as can be the case with web applications.
>
> The [SQLite organization does not recommend](https://www.sqlite.org/whentouse.html) using SQLite on a network drive, even with WAL enabled. There is a high risk of database corruption. If your desktop app needs a multi-user database, it should use a database server.
>
> If you want to use WAL, you need to set this property to `True` after connecting to the database by calling Connect.
>
> WAL is faster than normal mode (called Journaled) because there is less disk writing. With WAL, a database change writes once to the write-ahead log. With Journaling, a database change writes to a rollback file and to the original database file.
>
> Although faster, WAL does have some limitations:
>
> - WAL database cannot be opened in read-only mode
> - Rolling back large transaction (over 100MB) can be slow
> - Two extra files are created (\*.sqlite-wal and \*.sqlite-shm) alongside the main database file
> - The processes using the database must be on the same host computer
> - WAL does not work over a network filesystem
>
> For more information about WAL, refer to the SQLite documentation: .
>
> This example sets WriteAheadLogging to `True` for a SQLite database:
>
> ``` xojo
> Var dbFile As New FolderItem("MyDB.sqlite", FolderItem.PathModes.Native)
> Var db As New SQLiteDatabase
>
> db.DatabaseFile = dbFile
>
> Try
> db.Connect
> db.WriteAheadLogging = True
> MessageBox("Connected to database.")
> Catch error As DatabaseException
> MessageBox("Connection error: " + error.Message)
> End Try
> ```
## Method descriptions
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SQLiteDatabase.AddDatabase
**AddDatabase**(file As `FolderItem`, databaseName As `String`, \[password As `String`\])
> Adds the SQLite database referred to by *file* to the database object and names it *databaseName*.
>
>
>
>
>
> Note
>
>
>
> This cannot be used to attach an in-memory database.
>
>
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SQLiteDatabase.AddRow
**AddRow**(tableName As `String`, row As `DatabaseRow`)
> Inserts *row* as a new row in *tableName*.
>
> Always look for a `DatabaseException` to verify whether or not the data was added.
>
> This code adds a row to an existing Team table with the columns "Name", "Coach" and "City". It's assumed that the variable db contains an active Database connection:
>
> ``` xojo
> Var row As New DatabaseRow
>
> ' ID will be updated automatically
> row.Column("Name") = "Penguins"
> row.Column("Coach") = "Bob Roberts"
> row.Column("City") = "Boston"
>
> Try
> db.AddRow("Team", row)
> Catch error As DatabaseException
> MessageBox("DB Error: " + error.Message)
> End Try
> ```
**AddRow**(tableName As `String`, row As `DatabaseRow`, idColumnName As `String` = "") As `Integer`
> Inserts *row* as a new row in *tableName* returning the newly assigned ID in the *idColumnName* column.
>
> Always look for a `DatabaseException` to verify whether or not the data was added.
>
> This code adds a row to an existing Team table with the columns "Name", "Coach" and "City" and returns the primary key created by and assigned to the primary key column (id in this case). It's assumed that the variable db contains an active Database connection:
>
> ``` xojo
> Var row As New DatabaseRow
>
> ' ID will be updated automatically
> row.Column("Name") = "Penguins"
> row.Column("Coach") = "Bob Roberts"
> row.Column("City") = "Boston"
>
> Var primaryKey As Integer
>
> Try
> primaryKey = db.AddRow("Team", row, "id")
> Catch error As DatabaseException
> MessageBox("DB Error: " + error.Message)
> End Try
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SQLiteDatabase.BackUp
**BackUp**(destination As SQLiteDatabase, callbackHandler As `SQLiteBackupInterface` = `Nil`, sleepTimeInMilliseconds As `Integer` = 10)
> Backs up the database asynchronously or synchronously. You must be connected to the *destination* database and its original contents (if any) will be overwritten by the backup.
>
>
>
>
>
> Important
>
>
>
> This method is not currently supported for Android.
>
>
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SQLiteDatabase.BeginTransaction
**BeginTransaction**
> Creates a new transaction. Changes to the database made after this call can be saved with `CommitTransaction` or undone with `RollbackTransaction`.
>
> A `DatabaseException` will be raised if the transaction could not begin or another transaction is already in progress.
>
> You typically want to Commit changes after ensuring there were no database errors:
>
> ``` xojo
> ' Prior DB code has run
>
> Try
> DB.BeginTransaction
> DB.ExecuteSQL("CREATE TABLE AddressBook name VARCHAR, email VARCHAR")
> DB.CommitTransaction
> Catch error As DatabaseException
> MessageBox("Error: " + error.Message)
> DB.RollbackTransaction
> End Try
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SQLiteDatabase.Close
**Close**
> Closes or disconnects the database.
>
> Calling Close does not issue a Commit, but some databases will automatically Commit changes in a transaction when you Close the connection and some database will automatically Rollback changes in a transaction when the connection is closed. Refer to the documentation for your database to check what its behavior is.
>
> For desktop apps, you will often Connect to the database when the app starts and Close it when the app quits.
>
> For web apps, you usually Connect to the database when the Session starts and Close it when the Session quits.
>
> This code in the App.Closing event handler closes a previously connected database:
>
> ``` xojo
> DB.Close ' DB is a property on App
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SQLiteDatabase.CommitTransaction
**CommitTransaction**
> Commits an open transaction. This permanently saves changes to the database.
>
> A `DatabaseException` will be raised if the transaction could not be committed.
>
> You have to have an open transaction to be able to use CommitTransation. Use `BeginTransaction` to begin a transaction:
>
> ``` xojo
> DB.BeginTransaction
> ```
>
> You typically want to commit changes after ensuring there were no database errors:
>
> ``` xojo
> ' Prior DB code has run
>
> Try
> DB.CommitTransaction
> Catch error As DatabaseException
> MessageBox("Error: " + error.Message)
> DB.RollbackTransaction
> End Try
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SQLiteDatabase.Connect
**Connect**
> Connects to the database so that you can begin using it.
>
>
>
>
>
> Warning
>
>
>
> A `DatabaseException` will be raised if the connection could not be made.
>
>
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SQLiteDatabase.Constructor
**Constructor**
Note
`Constructors` are special methods called when you create an object with the `New` keyword and pass in the parameters above.
Creates an in-memory
SQLiteDatabase.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SQLiteDatabase.Constructor
**Constructor**(dbFile As `FolderItem`)
> Creates a SQLiteDatabase using the provided database file.
>
> You can use this Constructor instead of manually assigning the data file using the `DatabaseFile` property.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SQLiteDatabase.CreateBlob
**CreateBlob**(tableName As `String`, columnName As `String`, row As `UInt64`, length As `Integer`, databaseName As `String` = "") As `SQLiteBLOB`
> Creates a new BLOB column for the specified table (*tableName*) and column (*columnName*) at the specified row id (*row*).
>
> - The row parameter is the rowid value, and not the actual row number, for example if you only have one record in your database, with a rowid of 100 then you would pass in a row of 100 and not 1 for example.
> - The blob cannot be resized
> - Creating a new blob automatically zeros the entire blob
> - The row must exist when calling CreateBlob, it does not create a new record for you
>
> You can use the Database constants: `MainDatabase ("main")` and `TempDatabase ("temp")` as necessary.
>
> This example stores a picture in a BLOB (db is a preexisting database):
>
> ``` xojo
> Var file As FolderItem
> file = FolderItem.ShowOpenFileDialog("")
>
> Var blob As SQLiteBlob
> Var dbRowID As Integer = 1
> blob = db.CreateBlob("Team", "Logo", dbRowID, file.Length)
>
> If blob <> Nil Then
> Var bd As BinaryStream
> bd = BinaryStream.Open(file, False)
>
> Var data As String
> While Not bd.EndOfFile
> data = bd.Read(1000)
>
> blob.Write(data)
> If blob.WriteError Then
> MessageBox("Error writing to BLOB.")
> Exit While
> End If
> Wend
> bd.Close
> blob.Close
>
> ' Do something with the data
> End If
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SQLiteDatabase.CreateDatabase
**CreateDatabase**
> Creates then opens a new SQLiteDatabase using the FolderItem in the `DatabaseFile` property.
>
> If the database already exists, this function works like `Database.Connect`. If CreateDatabase succeeds, the `DatabaseFile` property will bet set to the `DatabaseFile`. If CreateDatabase does not succeed, an `IOException` is raised.
>
> This code creates a database file and catches the exception if the operation fails:
>
> ``` xojo
> Var db As New SQLiteDatabase
> db.DatabaseFile = SpecialFolder.Desktop.Child("MyDatabase.sqlite")
> Try
> db.CreateDatabase
> Catch error As IOException
> MessageBox("The database file could not be created: " + error.Message)
> End Try
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SQLiteDatabase.Decrypt
**Decrypt**
> Decrypts an encrypted database. You must be connected to the database in order to decrypt it.
>
> This example decrypts an encrypted database:
>
> ``` xojo
> Var db As New SQLiteDatabase
> db.DatabaseFile = FolderItem.ShowOpenFileDialog("db.sqlite")
> db.EncryptionKey = "howdy+doody"
> Try
> db.Connect
> db.Decrypt
> Catch error As DatabaseException
> ' handle error here
> End Try
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SQLiteDatabase.Encrypt
**Encrypt**(password As `String`)
> Encrypts the database using *password* as the encryption key. If you are already connected to an encrypted database and call Encrypt with an empty string, the database is decrypted.
>
>
>
>
>
> Note
>
>
>
> You cannot encrypt a database from within a transaction. You must encrypt it outside of any transactions.
>
>
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SQLiteDatabase.ExecuteSQL
**ExecuteSQL**(command As `String`, `ParamArray` values() As `Variant`)
> Used to execute an SQL *command*. Use this for commands that do not return any data, such as `CREATE TABLE` or `INSERT`. The *command* parameter contains the SQL statement.
>
>
>
>
>
> Tip
>
>
>
> You can also pass an `array` of values as the first and only parameter instead of a `ParamArray`.
>
>
>
>
>
> Warning
>
>
>
> A `DatabaseException` will be raised if the SQL passed is invalid or if an error occurs.
>
>
>
>
>
> Important
>
>
>
> On Android, SQLiteDatabase.ExecuteSQL does not support multiple commands separated by semicolons. If you send multiple commands in this way, only the first command is run.
>
>
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SQLiteDatabase.IsConnected
**IsConnected** As `Boolean`
> Returns `True` if the connection to the database is still active.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SQLiteDatabase.OpenBlob
**OpenBlob**(tableName As `String`, columnName As `String`, row As `UInt64`, readWrite As `Boolean`, databaseName As `String` = "") As `SQLiteBLOB`
> Opens a BLOB column for the specified table (*tableName*) and column (*columnName*) at the specified row id (*row*).
>
> - The row parameter is the rowid value, and not the actual row number, for example if you only have one record in your database, with a rowid of 100 then you would pass in a row of 100 and not 1 for example.
> - Pass in `False` as the readWrite parameter to open the blob for reading only.
> - The blob cannot be resized
> - Creating a new blob automatically zeros the entire blob
> - The row must exist when calling CreateBlob, it does not create a new record for you
>
>
>
>
>
> Important
>
>
>
> This method is not currently supported for Android.
>
>
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SQLiteDatabase.Prepare
**Prepare**(statement As `String`) As `PreparedSQLStatement`
> Creates a PreparedSQLStatement using the SQL *statement* for use with the `SQLitePreparedStatement` class. A prepared statement is an SQL statement with parameters that has been pre-processed by the database so that it can be executed more quickly if it is re-used with different parameters. Prepared statements also mitigate the risk of SQL injection in web apps.
>
> If the provided SQL statement has an error, a `DatabaseException` will occur when you call `SelectSQL` or `ExecuteSQL`.
>
> [SQL Injection](http://en.wikipedia.org/wiki/SQL_injection) is a way to attack database-driven applications.
>
>
>
>
>
> Important
>
>
>
> This method is not currently supported for Android.
>
> `Database.SelectSQL
` and `Database.ExecuteSQL` both support prepared statements without the need to use any of the prepared statement classes. These cover most cases.
>
>
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SQLiteDatabase.RemoveDatabase
**RemoveDatabase**(databaseName As `String`)
> Removes the passed database that was previously added with AddDatabase.
>
> This example removes as previously added database:
>
> ``` xojo
> Var DBFile As New FolderItem("MyDB.sqlite", FolderItem.PathModes.Native)
>
> Try
> currentDB.AddDatabase(attachDBFile, "locations")
> MessageBox("Database attached.")
> ' Queries against the attached database would be prefixed with "locations", such as
> ' SELECT City FROM locations.Addresses WHERE ST = 'TX'
> ' When you are finished, you can detach the database
> currentDB.RemoveDatabase("locations")
> Catch error As IOException
> MessageBox("The database could not be added.")
>
> Catch error As DatabaseException
> MessageBox("The database could not be removed."
> End Try
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SQLiteDatabase.RollbackTransaction
**RollbackTransaction**
> Cancels an open transaction restoring the database to the state it was in before the transaction began.
>
> A `DatabaseException` will be raised if the rollback could not be completed.
>
> You will generally want to rollback database changes if a `DatabaseException` occurs within the transaction.
>
>
>
>
>
> Important
>
>
>
> While rolling back a transaction restores the database to its previous state, it has no impact on the data you access in a `RowSet`. To update the `RowSet` so that its data matches the database, you will need to re-query the database to recreate the `RowSet`.
>
>
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SQLiteDatabase.SelectSQL
**SelectSQL**(query As `String`, `ParamArray` values() As `Variant`) As `RowSet`
> Executes a SQL `SELECT` statement and returns the results in a `RowSet`. The *query* parameter contains the SQL statement.
>
>
>
>
>
> Tip
>
>
>
> You can also pass an `array` of values as the first and only parameter instead of a `ParamArray`.
>
>
>
>
>
> Warning
>
>
>
> A `DatabaseException` will be raised if the SQL passed is invalid or if an error occurs.
>
>
>
>
>
> Note
>
>
>
> SQLite supports other value identifiers as well. See the [SQLite documentation](https://www.sqlite.org/lang_expr.html#varparam) for details.
>
>
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SQLiteDatabase.TableColumns
**TableColumns**(tableName As `String`) As `RowSet`
> Returns a `RowSet` with information about all the columns (fields) in the specified *tableName*.
>
>
>
>
>
> Note
>
>
>
> If an error occurs, a `DatabaseException` will be raised.
>
>
>
>
>
> Note
>
>
>
> Depending upon the version you are using, only a subset of these types may be supported.
>
>
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SQLiteDatabase.TableIndexes
**TableIndexes**(tableName As `String`) As `RowSet`
> Returns a `RowSet` containing the list of indexes for the passed *tableName*. Returns `Nil` if the table has no indexes or the database source does not support indexes.
>
> A `DatabaseException` will be raised if an error occurs.
>
> The `RowSet` returns one row for each index on the table and it has one field: IndexName As `String`.
>
> This code displays the indexes for the "Invoices" table (if it exists) in the specified SQLite database:
>
> ``` xojo
> Var dbFile As FolderItem
> dbFile = FolderItem.ShowOpenFileDialog("")
>
> If dbFile <> Nil Then
> Var db As New SQLiteDatabase
>
> Try
> db.Connect
> Var indexRS As RowSet
>
> indexRS = db.TableIndexes("Invoices") ' A table with indexes in the SQLite DB
>
> For Each row As DatabaseRow In indexRS
> MessageBox("Index: " + row.ColumnAt(0).StringValue)
> Next
>
> indexRS.Close
> Catch error As NilObjectException
> MessageBox("This database has no indexes.")
> Catch error As DatabaseException
> MessageBox("Could not connect to database. Error: " + error.Message)
> End Try
> End If
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SQLiteDatabase.Tables
**Tables** As `RowSet`
> Returns a `RowSet` with a list of all tables in the database.
>
> A `DatabaseException` will be raised if an error occurs.
>
> Tables returns a `RowSet` with one field: TableName As `String`.
>
> The following code gets and displays the table names for the connected database:
>
> ``` xojo
> ' App.db is a connected database
> Var tables As RowSet = App.db.Tables
>
> Try
> For Each row As DatabaseRow In tables
> MessageBox(row.ColumnAt(0).StringValue)
> Next
> tables.Close
> Catch error As NilObjectException
> MessageBox("This database has no tables.")
> End Try
> ```
## Notes
SQLite supports a subset of SQL/92 and SQL/99, including queries that involve self-joins, aggregate functions and more.
For complete documentation of SQLite, refer to the official SQLite documentation:
More specific topics:
- [SQL Syntax](http://sqlite.org/lang.html)
- [Pragma Commands](http://sqlite.org/pragma.html)
- [Unsupported SQL](http://sqlite.org/omitted.html)
A call to SelectSQL returns a dynamic `RowSet`; you can move forward, backward, or jump to the beginning or end as much as you like.
SQLite supports transactions, both for schema changes and for data changes. A transaction is started automatically when you make any change to the database and is ended by calling either the CommitTransaction or RollbackTransaction methods of the `database` class.
All four `RowSet` navigation methods are supported for SQLite: `MoveToFirstRow`, `MoveToNextRow`, `MoveToPreviousRow`, and `MoveToLastRow`.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
### Network access
SQLite is not a server database. There are [appropriate uses for SQLite](https://www.sqlite.org/whentouse.html). According the SQLite developers should not be placed on a shared network drive for access by multiple client apps as this can lead to database corruption.
If you require a database that is shared with multiple client apps you can switch to a server database such as `PostgreSQL` or `MySQL`. There are also products that wrap a server around a SQLite database, such as CubeSQL. Another common solution is to create a `web service` that handles all requests to the SQLite database. Your clients communicate with the web service, which is the only app that then communicates with the SQLite database.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
### Threading
`SelectSQL` and `ExecuteSQL` statements do not block when called from within a `Thread`.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
### Transactions
By default, SQLite does a Commit after each SQL command that changes the database or its data.
To ensure data integrity and to improve performance, you should create a transaction and do your database changes in the transaction. To start a transaction use this command:
``` xojo
db.ExecuteSQL("BEGIN TRANSACTION") ' db is an instance of SQLiteDatabase
```
When you are finished with the database changes, you can close the transaction by calling Commit to make the changes permanent:
``` xojo
db.CommitTransaction
```
If you want to cancel the changes, you can use Rollback:
``` xojo
db.RollbackTransaction
```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
### Encrypted databases
Note
You cannot encrypt a database within a transaction. The encryption must be done outside a transaction.
2017r3 and prior: AES-128 encryption is always used.
2018r1 and later defaults to AES-128, but AES-256 can also be used by including the prefix "aes256:" before the rest of the encryption key.
For more information about the encryption, refer to the [SQLite Encryption](https://www.sqlite.org/see/doc/release/www/readme.wiki) documentation.
To create an encrypted database, specify a value for the EncryptionKey property. The EncryptionKey property must be set before calling either `Connect` or `CreateDatabase`. In other words, write something like this to create a new database:
``` xojo
Var db As New SQLiteDatabase
db.DatabaseFile = New FolderItem("db.sqlite", FolderItem.PathModes.Native)
db.EncryptionKey = "howdy+doody"
Try
db.CreateDatabase
Catch error As IOException
' handle error here
MessageBox(error.Message)
End Try
```
When you open an encrypted database file, you need to supply the key:
``` xojo
Var db As New SQLiteDatabase
db.DatabaseFile = New FolderItem("db.sqlite", FolderItem.PathModes.Native)
db.EncryptionKey = "howdy+doody"
Try
db.Connect
Catch error As IOException
' handle error here
MessageBox(error.Message)
End Try
```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
### Result codes
Operations that don't involve files and cause an error will result in SQLiteDatabase raising a `DatabaseException`. Error information is then available in the `DatabaseException.ErrorNumber` and `DatabaseException.Message` properties. Operations that involve the database file (such as it cannot be found or opened) will raise an `IOException`.
SQLite error codes:
| Error code | Error Message |
|------------|----------------------------------------|
| 0 | Not an error |
| 1 | SQL logic error or missing database |
| 2 | Internal SQLite implementation flaw |
| 3 | Access permission denied |
| 4 | Callback requested query abort |
| 5 | Database is locked |
| 6 | Database table is locked |
| 7 | Out of memory |
| 8 | Attempt to write a read/only database |
| 9 | Interrupted |
| 10 | Disk I/O error |
| 11 | Database disk image is malformed |
| 12 | Table or record not found |
| 13 | Database is full |
| 14 | Unable to open database file |
| 15 | Database locking protocol failure |
| 16 | Table contains no data |
| 17 | Database schema has changed |
| 18 | Too much data for one table row |
| 19 | Constraint failed |
| 20 | Datatype mismatch |
| 21 | Library routine called out of sequence |
| 22 | Kernel lacks large file support |
| 23 | Authorization denied |
| 24 | Auxiliary database format error |
| 25 | Bind or column index out of range |
| 26 | File is encrypted or is not a database |
| 200 | Not connected |
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
### Primary keys
All SQLite tables have an Integer Primary Key column. If you don't explicitly create such a column, one will be created for you with the name "rowid". If you create your own INTEGER PRIMARY KEY column, then rowid acts as an alias to that column. This means that a query that includes rowid will instead return the column that is the primary key.
This SQL will create an Employees table with "EmployeeID" as the primary key:
``` sql
CREATE TABLE Employees (EmployeeID INTEGER PRIMARY KEY, FirstName TEXT, LastName TEXT)
```
You can also use this SQL:
``` sql
CREATE TABLE Employees (EmployeeID INTEGER, FirstName TEXT, LastName TEXT, PRIMARY KEY (EmployeeID))
```
The above syntax is used when creating a table with a multi-part primary key.
Now consider the following queries:
``` sql
SELECT * FROM Employees
SELECT rowid,* FROM Employees
SELECT rowid, FirstName, LastName FROM Employees
```
In all of these cases, you will get the *EmployeeID* column in place of the *rowid* column.
If you have your own primary key column but still wish to get the rowid, you can do so using the SQL AS keyword. The following example returns the columns rowid, EmployeeID, FirstName, LastName:
``` sql
SELECT rowid AS rowid, * FROM tablename
```
If you don't explicitly define your own INTEGER PRIMARY KEY column, you won't get the 'rowid' column unless you specifically include it in the list of columns to include in your query:
``` sql
SELECT rowid, * FROM TableName
```
Note
You should always specifically define a primary key for your tables and not rely on the rowid column. When there is no specific primary key, the values for rowid are not guaranteed to remain the same which could cause problems if you use the rowid values in your apps or in foreign keys. In particular, the rowid values could be renumbered when data is deleted from a table and when the database is cleaned up using the `VACUUM` command.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
### Foreign keys
SQLite supports foreign keys, but they are not enabled by default. To enable them, you use the SQLite `PRAGMA` command each time you connect to the database:
``` sql
PRAGMA foreign_keys = ON;
```
You can send this `PRAGMA` command to SQLite from Xojo using ExecuteSQL:
``` xojo
Var db As New SQLiteDatabase
Try
db.Connect
' Enable foreign keys
db.ExecuteSQL("PRAGMA foreign_keys = ON;")
Catch error As DatabaseException
MessageBox("Database error: " + error.Message)
End Try
```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
### Data types
SQLite handles data types differently than most other database.
In particular, it does not use strong data typing. Although a column and be defined using a data type (called a storage class or affinity with SQLite), you can still put any type of data in any column.
To start, SQLite only supports these data types:
- NULL
- INTEGER
- REAL
- TEXT
- BLOB
Refer to the official SQLite Data Type page here:
The following table describes how to use the SQLite data types to store data from built-in data types with `DatabaseRow` or `DatabaseColumn`:
| FieldType | Description |
|-----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Blob | BLOB stands for Binary Large OBject. It is a column that contains large string data. This data is not altered in any way (no encodings are applied), so you can use a BLOB to store pictures, files or any other binary data. Use `DatabaseColumn.Value` to read or save BLOB data. Alternatively you can use the `SQLiteBLOB` class to handle BLOB data incrementally. |
| Boolean | SQLite does not have a BOOLEAN data type. `` Boolean`s are stored using 0 or 1 in an INTEGER column or as "true" or "false" in a TEXT column. :ref:`DatabaseColumn.BooleanValue `` will correctly convert the above values to a boolean. Other values in a column are undefined when attempting to convert to a boolean. |
| Currency | Use the REAL data type to store `Currency` values with `DatabaseColumn.CurrencyValue`. |
| Date / DateTime | SQLite does not have a DATE or DATETIME data type. `` DateTime`s are stored as text using the format YYYY-MM-DD when using :ref:`DatabaseColumn.DateTimeValue ``. To store a DateTime value, you should manually save `DateTime.SQLDateTime` as a string. |
| Double | Use the REAL data type to store `Double` values using `DatabaseColumn.DoubleValue`. |
| Integer | Use the INTEGER data type to store `Integer` values with `DatabaseColumn.IntegerValue`. SQLite always stored 64-bit integer values. |
| Int64 | Use the INTEGER data type to store `Int64` values with `DatabaseColumn.Int64Value`. SQLite always stored 64-bit integer values. |
| Picture | Use the BLOB data type to store `Pictures` with `DatabaseColumn.PictureValue`. |
| String | Use the TEXT data type to store `String` values with `DatabaseColumn.StringValue`. SQLite converts all text in TEXT columns to UTF-8 encoding. If you want to preserve the original encoding, use a BLOB column type instead. |
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
### In-memory database
An "in-memory database" is a SQLite database that exists only in memory; there is no related file on disk. It works exactly as a SQLite database except it is very fast and completely temporary.
To create an in-memory database, create a new SQLiteDatabase instance and connect to it:
``` xojo
Var inMemoryDB As New SQLiteDatabase
Try
inMemoryDB.Connect
' Can now use inMemoryDB
Catch error As DatabaseException
MessageBox("Connection failed: " + error.Message)
End Try
```
You can use the `Backup` method to save an in-memory database to a file on disk.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
### Modified rows
To find out the number of rows that were modified by an `UPDATE` or `INSERT` command, you can call the SQLite changes function:
``` sql
SELECT changes();
```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
### Extensions
Extentions are not loaded by default. Use the `LoadExtensions` property to enable them as necessary.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
### Performance tips
To improve the performance of SQLite DB access, you can turn on Write-Ahead Logging by setting the `WriteAheadLogging` property to `True`. Additionally, to increase the user's perception of performance, you may want to place long-running queries within a `Thread`.
You can also increase the page size that SQLite uses by changing the page_size setting using the `PRAGMA` command. The default page_size is 4096, but a larger size can help reduce I/O. To change the setting, give it a new value after you create or connect to the database but before you send any other commands that would cause database I/O. The page_size is permanently retained for the database after it is set:
``` xojo
Var db As New SQLiteDatabase
Try
db.Connect
' Set page_size before any other commands are sent
db.ExecuteSQL("PRAGMA page_size = 8192;")
db.ExecuteSQL("CREATE TABLE Foo (c1, c2);")
Catch error As DatabaseException
MessageBox("A database error occurred: " + error.Message)
End Try
```
For more information about PRAGMA commands, visit the official SQLite documentation:
- [PRAGMA statements](http://www.sqlite.org/pragma.html)
Periodically use the `ANALYZE` command to update the internal information that SQLite uses to make better query planning choices. You'll probably want to do this any time you add or remove large amounts of data from a table or when the SQLite database version is updated.
``` xojo
db.ExecuteSQL("ANALYZE")
```
## Sample code
The following example creates a new SQLite database:
``` xojo
Var db As New SQLiteDatabase
db.DatabaseFile = New FolderItem("MyDB.sqlite", FolderItem.PathModes.Native)
Try
db.CreateDatabase
' proceed with database operations...
Catch error As DatabaseException
MessageBox("Database not created. Error: " + error.Message)
Return
End Try
```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
The following example opens an existing SQLite database.
``` xojo
Var db As New SQLiteDatabase
db.DatabaseFile = New FolderItem("MyDB.sqlite", FolderItem.PathModes.Native)
Try
db.Connect
' proceed with database operations here..
Catch error As DatabaseException
MessageBox("The database couldn't be opened. Error: " + error.Message)
Return
End Try
```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
The following example adds a record to a table.
``` xojo
Var db As New SQLiteDatabase
db.DatabaseFile = New FolderItem("Employees.sqlite", FolderItem.PathModes.Native)
Try
db.Connect
db.ExecuteSQL("BEGIN TRANSACTION")
db.ExecuteSQL("INSERT INTO Employees (Name,Job,YearJoined) VALUES " _
+ "('Dr.Strangelove','Advisor',1962)")
db.CommitTransaction
Catch error As DatabaseException
MessageBox("Error: " + error.Message)
db.RollbackTransaction
End Try
```
## Compatibility
| | |
|-----------------------|-----|
| **Project Types** | All |
| **Operating Systems** | All |
`Database` parent class; `DatabaseRow`, `SQLitePreparedStatement`, `RowSet` classes.