Using unixODBC in a multithreaded, concurrent setting

Question

I'm going to ask and answer this question because it took me forever to figure out and I wish the answer had been here to begin with.

The problem: One long-running unixODBC query blocks all others from the same application.

The question: How does one stop this from happening.

Answer 1

The answer, in the form of a cut-and-paste comment from __handles.c -- I know, why doesn't everyone think to look there for documentation to begin with, right?

/*
 * use just one mutex for all the lists, this avoids any issues
 * with deadlocks, the performance issue should be minimal, if it
 * turns out to be a problem, we can readdress this
 *
 * We also have a mutex to protect the connection pooling code
 *
 * If compiled with thread support the DM allows four different
 * thread strategies
 *
 * Level 0 - Only the DM internal structures are protected
 * the driver is assumed to take care of it's self
 *
 * Level 1 - The driver is protected down to the statement level
 * each statement will be protected, and the same for the connect
 * level for connect functions, note that descriptors are considered
 * equal to statements when it comes to thread protection.
 *
 * Level 2 - The driver is protected at the connection level. only
 * one thread can be in a particular driver at one time
 *
 * Level 3 - The driver is protected at the env level, only one thing
 * at a time.
 *
 * By default the driver open connections with a lock level of 3,
 * this can be changed by adding the line
 *
 * Threading = N
 *
 * to the driver entry in odbcinst.ini, where N is the locking level
 * (0-3)
 *
 */

Answer 2

Just an addition to that answer. The current release of unixODBC 2.3.0 defaults to Threading = 0, so the default now is to assume that driver are thread safe. This was a risky assumption in years past, not so much now.

Answer 3

If your driver supports asynchronous functions, you can enabled it and execute time consuming functions in async mode.

No threads required at application side.