Jaybird 2.1 JDBC driver Java Programmer's Manual - Firebird

If, for example, we want to reuse the statement object for another query, it is not
necessary to completely release the allocated structures. Jaybird is required only
to compile a new statement before using it, in other words we can skip the step 1.
This saves us one round-trip to the server over the network, which might improve
the application performance.
If we close the statement completely, the allocated statement handle is no longer
usable. Jaybird could allocate a new statement handle, however the
implementation does not allow to use the Statement object after close() method
has been called to comply with the JDBC specification.
Statement lifetime and DDL
The step 2 in the previous chapter is probably the most important, and usually,
most expensive part of the statement execution life cycle.
As it was already told, when Firebird server receives the “prepare statement” call,
it parses the SQL statement and converts it into the executable form – BLR
representation. BLR, a Binary Language Representation, contains low-level
commands to traverse the database tables, conditions that are used to filter
records, defines the order in which records are accessed, indices that are used to
improve the performance, etc.
When a BLR is prepared, it holds the references to all database object definitions
that are used during that statement execution. This mechanism preserves the
database schema consistency, it saves the statement objects from the “surprises”
like accessing the database table that is been accessed by some application.
However, holding a reference on the database objects has one very unpleasant
effect – it is not possible to upgrade the database schema, if there are active
connections to the database with open statements referencing the objects being
upgraded. In other words, if two application are running and one is trying to
modify the table, view, procedure or trigger definition while another one is
accessing those objects, the first application will receive an error 335544453
“object is in use”.
Therefore it is strongly recommended to close the statement as soon as it is no
longer needed. This invalidates the BLR and release all references to the database
objects, making them available for the modification.
Special care should be taken when the statement pooling is used (check the details
on page 41). In this case statements are not released even if the close() method
is called. The only possibility to close the pooled statements is to close the pooled
connections. Please check the corresponding chapter for more information.
The java.sql.PreparedStatement interface
As we have seen, Jaybird already performs internal optimization when it comes to
multiple statement execution – it can reuse the allocated statement handle in
subsequent calls. However this improvement is very small and sometimes can
even be neglected when compared to the time needed to compile the SQL
statement into the BLR form.
The PreparedStatement interface addresses such inefficiency. An object that
implements this interface represents a precompiled statement that can be executed
multiple times. If we use the execution flow described in the “Statement
Chapter 4. Executing statements 38