Hello Firebird users and developers,

I'm currently working on a library providing asynchronous and
thread-safe database access to the Firebird database.

I've seen so many applications that display data from a database in a
grid-like fashion that just don't do it right. There are a magnitudes
of problems with it. Just to mention a few:
- Some load only the first few datasets and loading the complete
result set blocks the application and may take extremely long.
- Others automatically load datasets when scrolling in the grid, but
the user does still not know how many datasets exist in the result
set.
- The worst implementation loads all datasets when displaying the grid
and hence they can take minutes to open a specific dialog.
- None I have seen so far give an indication of how many datasets
exist in the result set (i.e. by sizing the scroll-bar appropriately).
Even database-managers that should be very sophisticated in this task,
often fail in this regard.

Asynchronous access means that you can tell Firebird to start
executing and fetching datasets and they'll be provided to your
application via a signal or message as soon as the dataset arrives. In
the meantime, your application can continue processing user-input or
some other tasks. I'm doing this by creating one worker-thread per
database-connection that receives and processes tasks from other
threads. This is a huge improvement over traditional, blocking means
of fetching datasets.
It's especially useful for server and GUI applications, as the main
program flow is never interrupted (for too long) and data processing
happens asynchronously.

The library includes a Grid-widget that can be connected to a buffer
and is filled with data "in the background", without ever interrupting
the user experience. It already works remarkably well and extremely
fast (I still have some optimizations to do, like adding a
Small-Object-Allocator to optimize storage for fetched fields) on
arbitrary table-sizes.
A single database-connection (and hence a single thread) can serve
multiple "receivers" at the same time. Of course, with a linear
slowdown.
You can use it for un-threaded web- or application-servers, too.

I'm using C++ with Qt to develop this library. Qt is an awesome
toolkit of very high quality and made the whole thread-synchronisation
and scheduling - which usually is a huge hassle - a non-issue.
However, it's theoretically possible to write bindings to about any
language and toolkit that's out there.

So I am interested in:

a) How many Firebird-users are developing using Qt (either C++ or Jambi)?
b) What other languages and toolkits are popular among Firebird-users?

I'd be greatful for anyone reporting the tools he's working with.

Kind regards,

Daniel Albuschat