Class

ODBCDatabase


Description

Used to open an ODBC database using an ODBC drivers. You use the constants in the ODBCConstant module with the methods and properties of the ODBCDatabase class.

Methods

Name

Parameters

Returns

Shared

AddRow

tableName As String, row As DatabaseRow

BeginTransaction

Close

ColumnPrivileges

TableName As String, ColumnName As String

CommitTransaction

Connect

ConnectionAttribute

Attribute As Integer

Variant

ConnectionInfo

Attribute As Integer

Variant

DataSources

RowSet

DataTypeInfo

DataType As Integer

RowSet

Drivers

RowSet

ExecuteSQL

SQL As String, Optional ParamArray values() As Variant

ForeignKeys

PrimaryTable As String, ForeignTable As String

RowSet

NextRowSet

Boolean

Prepare

statement As String

ODBCPreparedSQLStatement

PrimaryKeys

TableName As String

RowSet

ProcedureColumns

ProcedureName As String

RowSet

Procedures

RowSet

RollbackTransaction

SelectSQL

SQL As String, Optional Paramarray values() As Variant

RowSet

SpecialColumns

IdentifierType As Integer, TableName As String, Scope As Integer, Nullable As Integer

RowSet

TableColumns

TableName As String

RowSet

TableIndexes

TableName As String

RowSet

TablePrivileges

TableName As String

RowSet

Tables

RowSet

Property descriptions


ODBCDatabase.Attribute

Attribute As Integer

Optional attribute. This property is used in conjunction with the AttributeString property to set a string property using the SQLSetConnectAttr ODBC API function.

Using the Attribute property, the attribute is only set before the connection is made to the database. Although the Attribute / AttributeString properties are readable, they are not updated with information from the database.

The AttributeString property is not passed to the database if the Attribute property is set to zero (the default).

For more information, see the documentation for the SQLSetConnectAttr function at msdn.microsoft.com.

If you don't want to use Attribute, pass zero.

The following code sets the SQL_CURRENT_QUALIFIER property:

db.Attribute = :doc:`ODBCConstant</api/databases/odbcconstant>`.SQL_CURRENT_QUALIFIER

db.AttributeString = "NorthWind"

ODBCDatabase.AttributeString

AttributeString As String

Optional attribute. This property is used in conjunction with the Attribute property to set a string property using the SQLSetConnectAttr ODBC API function.

Using the Attribute property, the attribute is only set before the connection is made to the database. Although the Attribute / AttributeString properties are readable, they are not updated with information from the database.

The AttributeString property is not passed to the database if the Attribute property is set to zero (the default).

For more information, see the documentation for the SQLSetConnectAttr function at msdn.microsoft.com.

If you don't want to pass AttributeString, pass the empty string.

The following code sets the SQL_CURRENT_QUALIFIER property:

db.Attribute = :doc:`ODBCConstant</api/databases/odbcconstant>`.SQL_CURRENT_QUALIFIER

db.AttributeString = "NorthWind"

ODBCDatabase.DatabaseName

DatabaseName As String

The name of the database to open.

The DatabaseName is typically used to identify the specific database to use on the server.

This code connects to a database called "BaseballLeague":

Var db As New ODBCDatabase
db.Host = "192.168.1.172"
db.Port = 5432
db.DatabaseName = "BaseballLeague"
db.UserName = "broberts"
db.Password = "streborb"
Try
  db.Connect
  // Use the database
Catch error As DatabaseException
  // DB Connection error
  MessageBox(error.Message)
End Try

ODBCDatabase.DataSource

DataSource As String

The connection string to be used to establish a connection to an ODBC database. The connection string can either contain only the DSN name, or a string containing one or more keywords defined for the driver.

If only the DSN is passed, then the UserName and Password properties are used for the connection. If the connection string contains keywords, then the UserName and Password properties are ignored. See your driver documentation for information about which keywords are supported.

Pass an empty string ("") to the DataSource property to get an open-file dialog box. It will prompt you to choose a list of defined DSNs. The DataSource property may be updated by the ODBC driver with additional parameters used after a connection is made.

For examples of connection strings for various databases, visit http://www.connectionstrings.com.

This example prompts the user to select a Data Source:

Var db As New ODBCDatabase
db.DataSource = ""
Try
  db.Connect
  // proceed with database operations
Catch error As DatabaseException
  MessageBox("Error: " + error.Message)
End Try

This example specifies the DSN information to connect to a Microsoft Access database:

Var db As New ODBCDatabase
db.DataSource = "Driver={Microsoft Access Driver (*.mdb)};Dbq=C:\TestAccessDB.mdb;Uid=Admin;Pwd=;"
Try
  db.Connect
  // proceed with database operations
Catch error As DatabaseException
  MessageBox("Error: " + error.Message)
End Try

ODBCDatabase.DBMS

DBMS As String

This property returns the type of the connected database, such as MySQL or Oracle. The property only contains a value after a successful connection has been made to the database. Writing to the property has no effect.

This property is read-only.

This property is equivalent to calling the GetInfo method with the ODBCConstant.SQL_DBMS_NAME.

After connecting to a database with ODBC, you can display its type:

MessageBox("DB Type: " + db.DBMS)

ODBCDatabase.ExtendedSchema

ExtendedSchema As Boolean

When set to True, additional columns are returned for FieldSchema and TableSchema.

Additional columns are described below

For FieldSchema:

  • TableName

  • NonUnique

  • IndexQualifier

  • Type

  • OrdinalPosition

  • ColumnName

  • TableCatalog

  • TableSchema

  • AscOrDesc

  • Cardinality

  • Pages

  • FilterCondition

For TableSchema:

  • TableType

  • Remarks

  • TableCatalog

  • TableSchema


ODBCDatabase.Host

Host As String

The database host name or IP address of the database server.

This examples connects to a database called "BaseballLeague":

Var db As New ODBCDatabase
db.Host = "192.168.1.172"
db.Port = 5432
db.DatabaseName = "BaseballLeague"
db.UserName = "broberts"
db.Password = "streborb"
Try
  db.Connect
  // Use the database
Catch error As DatabaseException
  // DB Connection error
  MessageBox(error.Message)
End Try

ODBCDatabase.Password

Password As String

The password that is required for access to the database. Typically used in conjunction with UserName.

This examples connects to a database called "BaseballLeague":

Var db As New ODBCDatabase
db.Host = "192.168.1.172"
db.Port = 5432
db.DatabaseName = "BaseballLeague"
db.UserName = "broberts"
db.Password = "streborb"
Try
  db.Connect
  // Use the database
Catch error As DatabaseException
  // DB Connection error
  MessageBox(error.Message)
End Try

ODBCDatabase.ScrollableCursor

ScrollableCursor As Boolean

This property can be set to True in order to cause cursors opened using SQLSelect to be “scrollable.” A RowSet with a scrollable cursor can be navigated in both the forward and backward directions (i.e., using MovePrevious in addition to MoveNext). The default behavior is for a cursor to be non-scrollable (forward only). This property only has an effect if supported by the underlying ODBC driver.


ODBCDatabase.Timeout

Timeout As Integer

The timeout value (in seconds) to be used when connecting to the database. The default is 0, which will use the ODBC driver value.

The timeout value is set before actually connecting to the database. The property can be read, but the value that was previously set will be returned. The value is not returned from the driver. To get the actual value from the driver, use the ConnectionAttribute method with the ODBCConstant.SQL_LOGIN_TIMEOUT parameter.

Set the timeout to 60 seconds:

// db is an existing ODBCDatabase connection
db.Timeout = 60

ODBCDatabase.UserName

UserName As String

The username that is required for access to the database.

This code connects to a database called "BaseballLeague":

Var db As New ODBCDatabase
db.Host = "192.168.1.172"
db.Port = 5432
db.DatabaseName = "BaseballLeague"
db.UserName = "broberts"
db.Password = "streborb"
Try
  db.Connect
  // Use the database
Catch error As DatabaseException
  // DB Connection error
  MessageBox(error.Message)
End Try

Method descriptions


ODBCDatabase.AddRow

AddRow(tableName As String, row As DatabaseRow)

Inserts Data (a populated DatabaseRow) 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:

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

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

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

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

DB.Close // DB is a property on App

ODBCDatabase.ColumnPrivileges

ColumnPrivileges(TableName As String, ColumnName As String)

Returns a RowSet with a list of columns and associated privileges for the specified table.

If the database supports multiple catalogs and schemas, then the RowSet will contain records for all catalogs and schemas that can be accessed by the logged in user that match the given table name.

The ColumnName is a search pattern for a column name of the given table. Use an empty string to match all columns in the table.

Microsoft provides additional information regarding ODBC column privileges.


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

DB.BeginTransaction

You typically want to commit changes after ensuring there were no database errors:

// Prior DB code has run

Try
  DB.CommitTransaction
Catch error As DatabaseException
  MessageBox("Error: " + error.Message)
  DB.RollbackTransaction
End Try

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

This example connects to the database object in the variable db:

Try
  db.Connect
  MessageBox("Connected!")
Catch error As DatabaseException
  MessageBox("Error connecting to the database: " + error.Message)
End Try

ODBCDatabase.ConnectionAttribute

ConnectionAttribute(Attribute As Integer) As Variant

Gets and sets the current setting of a connection attribute. Returns a Variant that contains either a String or an Integer, based on the attribute.

The attribute can be specified using the ODBCConstant constants. The value is only set after the connection is made. Only Integer attributes may be set with this method. To set a String attribute before the connection is made, see the Attribute property.

Microsoft provides additional information about the SQLGetConnectAttr ODBC function.

Obtaining an attribute:

Var currentCatalog As Variant
currentCatalog = db.ConnectionAttribute(ODBCConstant.SQL_CURRENT_QUALIFIER)

Setting an attribute to disable AutoCommit:

db.ConnectionAttribute(ODBCConstant.SQL_AUTOCOMMIT) = ODBCConstant.SQL_AUTOCOMMIT_OFF

ODBCDatabase.ConnectionInfo

ConnectionInfo(Attribute As Integer) As Variant

Returns general information about the driver and data source associated with a connection. Returns a Variant that contains either a String or an Integer, based on the attribute.

ODBCConstant contains integer values that you can use with this function.

Microsoft provides additional information about the SQLGetInfo ODBC function.

Check if the connected ODBC database supports stored procedures:

'db is a valid database connection
Try
 db.Connect
 MessageBox(db.ConnectionInfo(ODBCConstant.SQL_PROCEDURES))
Catch error As DatabaseException
 MessageBox("Error: " + error.ErrorMessage)
End Try

ODBCDatabase.DataSources

DataSources As RowSet

Returns a RowSet with a list of configured Data Source Names (DSN). Returns both User and System DSNs in a single RowSet.

The instance of the ODBCDatabase does not have to be connected to a database in order to use this method.

The RowSet returned by DataSources has two columns. They are:

  • Name: The data source name

  • Description: The Name of the ODBC driver.

Microsoft provides additional information about the SQLDataSources ODBC function.

This code gets all the ODBC data source names and adds them to a ListBox:

DataSourceList.DeleteAllRows

Var rs As RowSet
rs = db.DataSources

If rs <> Nil Then
  While Not rs.AfterLastRow
    DataSourceList.AddRow(rs.Column("Name").StringValue, rs.Column("Description").StringValue)
    rs.MoveToNextRow
  Wend
  rs.Close
End If

ODBCDatabase.DataTypeInfo

DataTypeInfo(DataType As Integer) As RowSet

Returns a RowSet containing information about data types supported by the data source.

The DataType specifies the type for which the information should be returned.

Use ODBCConstant values for the data types.

To return a RowSet containing all defined types, specify ODBCConstant.SQL_ALL_TYPES.

The returned RowSet typically contains these columns, but they could vary depending on the driver being used:

  • Data Type Name

  • Data Type integer value

  • Column size

Microsoft provides additional information about the SQLGetTypeInfo ODBC function.

Displays all the supported data types for the current ODBC connection in a ListBox:

'Var db is a valid database connection
db.DataSource = "TeamExample"

Try
 db.Connect

 Var rs As RowSet
 rs = db.DataTypeInfo(ODBCConstant.SQL_ALL_TYPES)

 If rs <> Nil Then
  For Each row As DatabaseRow In rs
   ListBox1.AddRow(rs.ColumnAt(0).StringValue)
  Next
 End If
Catch error As DatabaseException
 MessageBox("Connection failed. Error:" + error.ErrorMessage)
End Try

ODBCDatabase.Drivers

Drivers As RowSet

Returns a RowSet with a list of configured ODBC drivers.

The instance of the ODBCDatabase does not have to be connected to a database in order to use this method.

The RowSet returned by DataSourceNames has two columns. They are:

  • Name: The driver name

  • Description: A description indicating if the driver is installed

  • Type: The type (for example, System).

Microsoft provides additional information about the SQLDrivers ODBC function.


ODBCDatabase.ExecuteSQL

ExecuteSQL(SQL As String, Optional 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. SQL 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.

Passing values as parameters protects your database by automatically creating a ODBCPreparedStatement.

In this example, the database is being updated without the use of parameters and thus leaves the database vulnerable to a SQL injection attack:

// Updates a table in a database (db)
Var sql As String
sql = "UPDATE Customer SET City='" + CityField.Text + "' WHERE PostalCode='" + PostalCodeField.Text + "'"
Try
 db.ExecuteSQL(sql)
Catch error As DatabaseException
  MessageBox("DB Error: " + error.Message)
End Try

Here's the same example but using parameters which protects you against a SQL injection attack:

// Updates a table in a database (db)
Var sql As String
sql = "UPDATE Customer SET City=? WHERE PostalCode=?"
Try
 db.ExecuteSQL(sql, CityField.Text, PostalCode.Text)
Catch error As DatabaseException
  MessageBox("DB Error: " + error.Message)
End Try

The parameter values can also be passed in as a variant array:

Var sql As String
sql = "UPDATE Customer SET City=? WHERE PostalCode=?"
Var values(1) As Variant
values(0) = CityField.Text
values(1) = PostalCode.Text
Try
 db.ExecuteSQL(sql, values)
Catch error As DatabaseException
  MessageBox("DB Error: " + error.Message)
End Try

This code creates the Team table:

// db is a database
Var sql As String
sql = "CREATE TABLE Team (ID INTEGER NOT NULL, Name TEXT, Coach TEXT, City TEXT, PRIMARY KEY(ID));"
Try
  db.ExecuteSQL(sql)
  MessageBox("Team table created successfully.")
Catch error As DatabaseException
  MessageBox("DB Error: " + error.Message)
End Try

ODBCDatabase.ForeignKeys

ForeignKeys(PrimaryTable As String, ForeignTable As String) As RowSet

Returns a RowSet containing either a list of foreign keys in the specified table (columns in the specified table that refer to primary keys in other tables), or a list of foreign keys in other tables that refer to the primary key in the specified table.

Not all ODBC drivers support this feature. If it is not supported, it will return Nil.

Microsoft provides additional information about the SQLForeignKeys ODBC function.


ODBCDatabase.NextRowSet

NextRowSet As Boolean

Determines whether more results are available on a statement containing SELECT, UPDATE, INSERT, or DELETE statements and, if so, initializes processing for those results. This method only affects the most recently opened RowSet. Not all drivers support multiple RecordSets. Returns True if another RowSet is available. You must execute MoveNext on the previous RowSet to advance to the start of the next RowSet after calling NextRowSet.

For a command that can return multiple record sets from the ODBC database and driver, you iterate though each of them using the RowSet class. When you reach the end of a record set, use NextRecordSet to initialize the next ODBC record set for processing by the RowSet class.

// db is a connected database
// rs contains multiple RowSets from the ODBC database

// First RowSet
While Not rs.AfterLastRow
  // Process data in 1st record set
  rs.MoveToNextRow
Wend

If db.NextRowSet Then // Initialize next ODBC record set (if one is available)
  While Not rs.AfterLastRow
    // Process data in 2nd record set
    rs.MoveToNextRow
  Wend
End If

ODBCDatabase.Prepare

Prepare(statement As String) As PreparedSQLStatement

Creates a PreparedSQLStatement using the SQL statement for use with the ODBCPreparedStatement 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 is a way to attack database-driven applications.

To create a prepared statement, you use the appropriate class for the database you are using. For example, to create a prepared statement for an ODBC database:

// db is a previously connected ODBCDatabase object

Var ps As ODBCPreparedStatement
ps = db.Prepare("SELECT * FROM Country WHERE code = $1")

ODBCDatabase.PrimaryKeys

PrimaryKeys(TableName As String) As RowSet

Returns a RowSet containing the column names that make up the primary key for a table.

Displays the primary keys for a table:

Var db As New ODBCDatabase

db.DataSource = "TeamExample"

If Not db.Connect Then
  MessageBox("Error: " + db.ErrorMessage)
End If

Var rs As RecordSet
rs = db.PrimaryKeys("Team")

If rs <> Nil Then
  While Not rs.EOF
    ListBox1.AddRow(rs.IdxField(1).StringValue)
    rs.MoveNext
  Wend
  rs.Close
End If

ODBCDatabase.ProcedureColumns

ProcedureColumns(ProcedureName As String) As RowSet

Returns a RowSet containing a list of columns associated with a given procedure stored in the database.

Not supported by all ODBC drivers.

Microsoft provides additional information about the SQLProcedureColumns ODBC function.


ODBCDatabase.Procedures

Procedures As RowSet

Returns a RowSet containing the names of the stored procedures in the database.


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

You have to have an open transaction to be able to use Rollback. Call BeginTransaction to begin a transaction:

DB.BeginTransaction

This code uses rollback to revert database changes in a transaction when an error occurs:

// Prior DB code has run

Try
  db.CommitTransaction
Catch error As DatabaseException
  MessageBox("Error: " + error.Message)
  db.RollbackTransaction
End If

ODBCDatabase.SelectSQL

SelectSQL(SQL As String, Optional ParamArray values() As Variant) As RowSet

Executes a SQL SELECT statement and returns the results in a RowSet. The SQL 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.

Passing values as parameters protects your database by automatically creating a ODBCPreparedStatement.

This sample adds the names of all customers in a particular postal code to a ListBox. It passes the entire SQL select as a single statement and appends the value from a TextField called PostalCode, leaving the database vulnerable to a SQL injection attack:

// db is a valid connection to a database
Var rowsFound As RowSet
Try
  rowsFound = db.SelectSQL("SELECT * FROM Customer WHERE PostalCode=" + PostalCode.Text)
  For Each row As DatabaseRow In rowsFound
    ListBox1.AddRow(row.Column("Name").StringValue)
  Next
  rowsFound.Close
Catch error As DatabaseException
  MessageBox("Error: " + error.Message)
End Try

This is the same code as above but instead it uses a value identifier (?) and then passes the value in separately to avoid a SQL injection attack:

// db is a valid connection to a database
Var rowsFound As RowSet
Try
  rowsFound = db.SelectSQL("SELECT * FROM Customer WHERE PostalCode=?", PostalCode.Text)
  For Each row As DatabaseRow In rowsFound
    ListBox1.AddRow(row.Column("Name").StringValue)
  Next
  rowsFound.Close
Catch error As DatabaseException
  MessageBox("Error: " + error.Message)
End Try

Multiple values can be passed to SelectSQL. In this example, Age and PostalCode are both DesktopTextField controls:

// db is a valid connection to a database
Var rowsFound As RowSet
Try
  rowsFound = db.SelectSQL("SELECT * FROM Customer WHERE Age=? AND PostalCode=?", Age.Value, PostalCode.Text)
  For Each row As DatabaseRow In rowsFound
    ListBox1.AddRow(row.Column("Name").StringValue)
  Next
  rowsFound.Close
Catch error As DatabaseException
  MessageBox("Error: " + error.Message)
End Try

ODBCDatabase.SpecialColumns

SpecialColumns(IdentifierType As Integer, TableName As String, Scope As Integer, Nullable As Integer) As RowSet

Retrieves the optimal set of columns that uniquely identifies a row in the table and columns that are automatically updated when any value in the row is updated by a transaction. Returns a RowSet.

The IdentifierType must be either ODBCConstant.SQL_BEST_ROWID or ODBCConstant.SQL_ROWVER, indicating whether to return the optimal list of columns to uniquely identify a row or to return the columns that are automatically updated by a transaction.

Scope is the minimum required scope of the row ID, which must be either ODBCConstant.SQL_SCOPE_CURROW, ODBCConstant.SQL_SCOPE_TRANSACTION, or ODBCConstant.SQL_SCOPE_SESSION.

Nullable indicates whether to return columns that can have a NULL value, which must be either ODBCConstant.SQL_NO_NULLS or ODBCConstant.SQL_SQL_NULLABLE.

Microsoft provides additional information about the SQLSpecialColumns ODBC function.


ODBCDatabase.TableColumns

TableColumns(TableName As String) As RowSet

Returns a RowSet with information about all the columns (fields) in the specified TableName.

The following code creates a table and then display each column name one at a time:

'db is a valid database connection'
Try
  db.ExecuteSQL("CREATE TABLE Invoices (ID INTEGER, CustID INTEGER, Amount Double, Note TEXT)")

   Var columns As RowSet = db.TableColumns("Invoices")

   For Each c As DatabaseRow In columns
     MessageBox("Column: " + c.Column("ColumnName").StringValue)
  Next
Catch error As IOException
   MessageBox("The database could not be created: " + error.Message)
Catch error As DatabaseException
   MessageBox("Database error: " + error.Message)
End Try

ODBCDatabase.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 database:

'db is a valid database connection
Try
  db.Connect
  Var indexRS As RowSet
  indexRS = db.TableIndexes("Invoices") // A table with indexes in the 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

ODBCDatabase.TablePrivileges

TablePrivileges(TableName As String) As RowSet

Returns a RowSet with a list of privileges for the specified table. If the database supports multiple catalogs and schemas, then the RowSet will contain records for all catalogs and schemas that can be accessed by the logged in user that match the given table name.


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

// App.db is a connected database
Var tables As RowSet
tables = 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

In order to use this class, you must have the ODBCDatabase plug-in in your plugins folder.

The ODBCDatabase class also requires a driver manager and driver. On the Windows platform, the driver manager is supplied by Microsoft as part of Windows or as part of the MDAC package. For non-Windows platforms, the iODBC driver manager is required, which is available from http://www.iodbc.org or is installed with most commercial drivers.

ODBC drivers may be included with the OS, or may be obtained from the database vendor or a commercial developer of ODBC drivers. Non-Windows drivers must be compatible with the iODBC standard. For macOS, Actual Technologies supplies iODBC compliant drivers that work well with Xojo apps. There are other vendors as well.

The driver must match the architecture of the app. So a 64-bit app must use a 64-bit ODBC driver and a 32-bit app must use a 32-bit ODBC driver.

The ODBCDatabase engine supports all four RowSet navigation methods: MoveToFirstRow, MoveToNextRow, MoveToPreviousRow, and MoveToLastRow.


PostgreSQL notes

On macOS, when connecting to PostgreSQL using ODBC you must specify a username and password. If you do not, the ODBC driver will crash your app.


Threading

SelectSQL and ExecuteSQL statements do not block when called from within Threads.

Sample code

This code prompts the user to select a Data Source from either the User or System data sources:

Var db As New ODBCDatabase
db.DataSource = ""
Try
 db.Connect
 // proceed with database operations
Catch error As DatabaseExcecption
  MessageBox("Error: " + error.ErrorMessage)
End Try

This code specifies a specific data source to use:

Var db As New ODBCDatabase
db.DataSource = "TestAccessDB"
Try
 db.Connect
 // proceed with database operations
Catch error As DatabaseExcecption
  MessageBox("Error: " + error.ErrorMessage)
End Try

This code specifies the DSN information to connect to a Microsoft Access database:

Var db As New ODBCDatabase
db.DataSource = "Driver={Microsoft Access Driver (*.mdb)};Dbq=C:\TestAccessDB.mdb;Uid=Admin;Pwd=;"
Try
 db.Connect
 // proceed with database operations
Catch error As DatabaseExcecption
  MessageBox("Error: " + error.ErrorMessage)
End Try

Compatibility

All project types on all supported operating systems.

See also

Database parent class; DatabaseColumn, DatabaseRow, ODBCPreparedStatement, RowSet classes.