The strategy to merge Vulcan and Firebird 2.0 to form Firebird 3.0 will
probably be gated by a single central question: Will Firebird 3.0 use
the Vulcan provider architecture.

Firebird 2.0 consists of two main pieces: A client library and a server
executable (some platforms have an embedded engine packages as a plug
replacement for the client library). The client library contains a
Y-valve front-ending the remote interface. The server executable
contains the server code, the Y-valve, and an engine.

In the Vulcan provider architecture, the client library (Firebird.dll
or libfirebird.so) contains only the Y-valve. During the database
attach operation, the Y-valve, under control of a configuration files,
tries to load provider modules from an ordered list until one is able to
successfully attach the database. Vulcan currently has providers for
the engine, the remote interface, and a gateway to legacy Firebird and
Interbase. When the ODS is changed, Vulcan gets another engine
provider, retaining the old shared libraries (buildable only from a CVS
tag) for backwards compatibility. Finally, in Vulcan, the server is an
executable linked to the same client library as ordinary client programs.

The provider architecture has a number of advantages. One is the
ability to perform rolling upgrades. In Firebird 2.0, there are two
ways to provide access to databases with different ODSes. One is to
have the single engine support a variety of ODSes. The other is for the
user to balance two (or more) Firebird installs on the same system. For
former is constraining on development, leading to unnecessarily complex
code to straddle versions, while the latter shift the burden to the
user. The Vulcan provider architecture, on the other hand, allows us to
release a new engine version as a new provider, leaving the existing
engine(s) in place, with a tweak of the core configuration file. This
allow a single program to attach simultaneously two databases of
radically different ODS versions, for a single installation to straddle
versions, and for production and development versions to coexist on a
single system.

The Firebird Y-valve, on the other hand, is hard linked to a fix set of
subsystems managed with conditional compilation.

A further complication is that while the Vulcan Y-valve requires that
each provider be thread safe, the Firebird Y-valve assumes its
subsystems are not, initiating THREAD_ENTER/THREAD_EXIT synchronization
before every subsystem calls, leading to tight integration between the
Firebird Y-valve and engine. Imposing the Vulcan provider architecture
on Firebird 2.0 breaks the division of work between the Firebird why.cpp
and jrd.cpp, and forcing the same global reorganization I had to do for
Vulcan.

The provider architecture is, perhaps, the most important aspect of
Vulcan, providing a clear, clean mechanism to manage change. And change
is the one thing we can be certain of.