web server - Borland Technical Publications

Container-Managed Persistence in Borland Enterprise Server
This section illustrates some of the information that needs to be provided for containermanaged
finder methods, particularly if you are constructing container-managed finder
methods at the command line level. Because it is not an exhaustive reference, you
should refer to the DTD of the deployment descriptor for the detailed syntax. Look for
the syntax for the finder methods and Object-Relation (OR) mapping metadata.
Constructing finder methods
When you construct a finder method, you are actually constructing an SQL select
statement with a where clause. The select statement includes a clause that states what
records or data are to be found and returned. For example, you might want to find and
return checking accounts in a bank. The where clause of the select statement sets
limits on the selection process; that is, you might want to find only those checking
accounts with a balance greater than some specified amount, or accounts with a
certain level of activity per month. When the Container uses container-managed
persistence, you must specify the terms of the where clause in the deployment
descriptor.
For example, suppose you have a finder method called findAccountsLargerThan(int
balance) and you are using container-managed persistence. This finder method
attempts to find all bank accounts with a balance greater than the specified value.
When the Container executes this finder method, it actually executes a select
statement whose where clause tests the account balances against the int value
passed as a parameter to the method. Because we're using container-managed
persistence, the deployment descriptor needs to specify the conditions of the where
clause; otherwise, the Container does not know how to construct the complete select
statement.
The value of the where clause for the findAccountsLargerThan(int balance)method is
“balance > :balance“. In English, this translates to: “the value of the balance column is
greater than the value of the parameter named balance.” (Note that there is only one
argument to the finder method, an int value.)
The default container-managed persistence implementation supports this finder
method by constructing the complete SQL select statement, as follows:
select * from Accounts where ? > balance
The CMP engine then substitutes “?” with the int parameter. Lastly, the engine
converts the result set into either an Enumeration or Collection of primary keys, as
required by the EJB Specification.
It is possible to inspect the various SQL statements that the CMP implementation
constructs. To do this, enable the EJBDebug flag on the container. When that flag is
enabled, it prints the exact statements constructed by the Container.
While other EJB Container products use code generation to support CMP, the Borland
Container does not use code generation because it has serious limitations. For
example, code generation makes it difficult to support a “tuned update” feature,
because of the great number of different update statements to container-managed
fields that are required.
Constructing the where clause
The where clause is a necessary part of select statements when you want to delimit the
extent of the returned records. Because the where clause syntax can be fairly complex,
you must follow certain rules in the XML deployment descriptor file so that the EJB
Container can correctly construct this clause.
To begin with, you are not obligated to use the literal “where” in your .
You can construct a where clause without this literal and rely on the Container to
supply it. However, the Container only does this if the is not an empty
string; it leaves empty strings empty. For example, you could define a where clause as
either:
116 BES Developer’s Guide