Having had little luck in getting any concrete information about effective ways to manage ODBC data, and after days of long
trials and errors, I thought at least I could write up a summary of what I've found to work well for ODBC sources and
hopefully others may be able to contribute to this.
Disclaimer: This is a far cry from being an authoritative and is woefully very subjective, being written by me and myself,
using a MySQL server and Access 2003. I do hope that others who are able, can contribute more information to make this
somehow more useful for those who would like to use Access as a front-end client.
There are three principal issues that must be considered when you are using a ODBC data sources:
1. Numbers of connections and different flavor of connections.
2. Size of recordsets and network traffic.
3. Binding forms to ODBC data sources.
As a starting point, one should read the whitepaper on Jet and ODBC Connectivity. This was for Jet 3.0, but should be valid
for 4.0 as well.
ODBC Driver and Connections
The next thing is to understand what your ODBC driver is capable of. In a connection string, there is a parameter for
"Options", which is usually a long integer. You should look at the ODBC driver's manual to ensure you have all options you
need turned on. A good example would be to ensure that a certain data type is correctly mapped to Access's data type. In my
case, I ensured that Big Integer (64-bit) were turned off because Access does not support this (and thankfully, I don't need
By far most important thing you want to look for is to ensure that the driver supports two things- Multiple statements and
Active statements. Jet does try to pool all queries to the server into one connection whenever possible, but if the driver
cannot support multiple statements over single connection, Jet will open another connection to submit a statement. Therefore,
if you have a form that has a combobox, Jet will send two queries, one for form's recordsource and another for combobox's
rowsource. In case of lack of support for multiple statement, Jet will need two connections.
Even if your driver supports multiple statements, Jet may find it necessary to open a second connection if the driver cannot
have more than one active statement. Active statement is when you fetch a big recordset and need to wait a bit for the full
set to come over the wire. So back to that form with a combobox, if Jet find that the form's recordsource will take a while
to be fetched, it will go ahead and open second connection to populate the combobox in order to allow for 'instantaneous'
loading of a form from a user's POV.
Wherever possible, keep numbers of connection to a minimum. As mentioned before, Jet will try to pool all statements into one
connection wherever possible, but Jet cannot help you out if you issue a query using a new ADO connection, DAO ODBCDirect
workspace, or create a recordset within VBA. If you want to avoid the additional overhead of another connection, you should
use a stored query instead, and make sure it has a Connection string in its query property window set, so Jet knows that it
uses ODBC data and pools it with its open connection to the ODBC server. The stored query can then be called within VBA
without incurring another connection.
DSN and DSN-less/ODBC and OLE DB connections
There are two ways to create connections, by using Data Source Name (DSN) or direct connection. To find right connection
string, look at Carl Prothman's excellent website listing all possible connection strings.
Some people say connecting to DSN is better than without. Others say it's faster without DSN. One thing for sure is if you
use DSN, you will need to distribute the DSN file to your users along with the finished database. I would recommend
experimenting with both connection flavors before deciding which is better suited for your needs.
To make a DSN connection DSN-less, look at Doug J Steele's example or perhaps this Add-in by Paul Litwin.
Also, make sure you know whether you have different drivers available. I know for an example, some people prefer third-party
drivers for Oracle over one supplied by Oracle themselves. Furthermore, some drivers are OLE DB which is supposedly better
than ODBC (I say supposedly only because I am skeptical of Microsoft's promises of new and latest technology superseding a
older technology, then dropping their claims and going back to older technology).
To Jet's credit, it is quite intelligent in retrieving just enough rows to populate the bound form, and will continue to fill
up the recordset periodically while a user is working on a row. However, Jet has some quirks where it can do something very
stupid, such as asking for multiple full table scans.
If you bind a form to ODBC table, Jet will do a full table scan. The simplest solution would be to add a WHERE clause to make
the recordset smaller. But by far the better solution would be to set the recordsource's connection string to use ODBC
instead of "(current database)". Jet will then query for keys, which it must have locally in order to manage a recordset,
then afterward query a few rows at a time. If you can manage to keep keys smaller, all the better.
Furthermore, if you want to use subform, do not use Master/Child linking fields. This makes Jet go ape-shit, issuing several
queries to show tables and index which is quite unnecessary. Rather, leave the link blank, and set subform's recordsource
with a WHERE clause to match the parent form's key, so Jet will only ask for rows that match the key only without asking for
indexes and table status every time you move around.
An additional benefit of making all queries for forms' recordsource an ODBC query is that you now have more control over how
you handle those forms *with* Jet's intelligence. For example, you now can start transaction across multiple forms with
subforms and commiting/rollbacking as you see fit, which would have not been possible using Access itself. I have been able
to rollback the changes in two parent records and their related child records by issuing a SQL Pass-through query which
simply says "Rollback;" and nothing was changed for any one of records, just as expected.
If you have a combobox or listbox on a form, this will mean another query in order to fill in the rowsource. Ideally, you
want to keep some tables local to front-end clients, especially for tables that will never change (e.g. a list of states or
provinces for example). For tables that may be updated peridocially but is otherwise select-only, you need to decide whether
you want to make it a dynaset or a snapshot. For a small set, snapshot is faster, but for a larger set, dynaset is faster.
You will need to experiment with the rowsoource to ensure that the network traffic and time to load the rowsource is
One problem is that Access won't accept an variable (at least I have been unable to do so) for a stored query's connection
string, so if you need to change a connection string (e.g. you want to use different set of options, perhaps?), you would
need to do this by hand, or at least write a function to loop through queries and updating the connection strings. Haven't
tried that yet, but would imagine this is very possible.
Keep an eye on SQL log when developing
You definitely will want to have the server write a log of what queries it has received from Jet to give you feedback in
ensuring that Jet doesn't do anything stupid. This has told me far much more about Jet than working within Access
There is only one thing I haven't yet worked on- Sharing a recordset for different controls. Suppose we have a form with a
combobox and a subform, both which use same table as a rowsource and recordsource, respectively. In this case, Jet will issue
two separate query to the server, even if they may use same recordset. If anyone has been able to show how to get such
controls to share recordset, that would be cool.
Also, I'm a bit worried about scattering connection strings all over the place, especially that it will contain a password.
As I see no point in asking users to authenicate themselves every time they use a query with a ODBC connection string, given
that variables can't be used in query's connection string. Would MDE make this less of a problem (I do not know if password
still can be plucked out from a hex editor?). A possible solution is to synchronize Access's security with the server's
security, because Jet will try to use Access's user & password for initial connection, and if a call to retrieve password was
made along with a module at startup to 'fix connections' along with updating the connection string with the entered password,
this may help somehow with keeping the password secret? Does anyone have more information on that?
A useful FAQ for linking Access with Postgresql which may be useful in giving you some ideas of how you can work with Access.
If anyone wants to contribute to this, please do feel free to do so. If anyone finds anything that is dead-on wrong, please
give me a good can of whoop-ass- I hate to lead blind into ditch, so to speak.