Setting this property to true bypasses Kodo's attempt, when
executing a transaction with the pessimistic lock manager, to lock
records in the database upon load. Because some databases do not
support pessimistic locking, attempting a pessimistic transaction
within Kodo will result in an exception with these databases unless
this property is set to true. At the same time, setting this property
to true means that the semantics of a pessimistic transaction with the
database are not obtained.

The SQL function call or operation to concatenate two strings. Use
the tokens {0} and {1} to represent the two arguments. The result of
the function or operation is to concatenate the {1} string to the end
of the {0} string.

The SQL function call to trim any number of a particular character
from the start of a string. Note: some databases do not support
specifying the character in which case only spaces or whitespace can
be trimmed. Use the token {1} when possible to represent the
character, and the token {0} to represent the string.

Some dictionaries must alter their behavior depending on the
driver's vendor. When used, the dictionary often sets this property
using its own logic. To override this logic, see the VENDOR_XXX
constants, if any, defined in the dictionary's Javadoc.

The database is able to store time values to this degree of
precision, which is expressed in nanoseconds. This value is usually
one million, meaning that the database is able to store time values
with a precision of one millisecond. Particular databases may have
more or less precision. Kodo and OpenJPA will round all time values to
this degree of precision before storing them in the database.

When true, the dictionary prefers to store large numbers (Java
fields of type BigInteger and BigDecimal) as string values in the
database. Likewise, the dictionary will instruct the mapping tool to
map the BigInteger or BigDecimal fields to character columns. Because
many databases have limitations on the number of digits that can be
stored in a numeric column (for example, Oracle can only store 38
digits), this option may be necessary for some applications. Note that
this option may prevent Kodo from executing meaningful numeric queries
against the columns.

The string the database uses to delimit between column expressions
in a SELECT COUNT(DISTINCT column-list) clause. Defaults to null for
most databases, meaning that they do not support multiple columns in a
distinct COUNT clause.

Indicates where to specify in the SQL select statement the range,
if any, of the result rows to be returned. When limiting the number of
returned result rows to a subset of all those that satisfy the query's
conditions, the position of the range clause varies by database.
Examine the source code of the
org.apache.openjpa.jdbc.sql.DBDictionary class to view the possible
values and their effects.

The magic word(s) to append to the column definition of a SQL
statement that creates an auto-assignment column. For example,
"AUTO_INCREMENT" for MySQL. Used only when the mapping tool generates
a schema.

Comma-separated list of table types to use when looking for tables
during schema reflection, as defined in the JDBC method
java.sql.DatabaseMetaData.getTableInfo. Examples are "TABLE" and
"TABLE,VIEW,ALIAS".

A comma separated list of additional database types that have a
size defined by the database. In other words, when a column of a fixed
size type is declared, its size cannot be defined by the user. Common
examples would be DATE, FLOAT, and INTEGER. Each database dictionary
has its own internal set of fixed size type names
(fixedSizeTypeNameSet) that include the names mentioned above and many
others. Names added to this property are added to the dictionary's
internal set.

When true, the database supports correlated subselects. Correlated
subselects are select statements nested within select statements that
refer to a column in the outer select statement. For performance
reasons, correlated subselects are generally a last resort.

When true, the database supports deferred constraints. The database
supports deferred constraints by checking for constraint violations
when the transaction commits, rather than checking for violations
immediately after receiving each SQL statement within the
transaction.

The SQL function call to trim any number of a particular character
from the end of a string. Note: some databases do not support
specifying the character in which case only spaces or whitespace can
be trimmed. Use the token {1} when possible to represent the
character, and the token {0} to represent the string.

When true, then any data truncation or rounding that is performed
by the dictionary in order to store a value in the database will be
treated as a fatal error. Otherwise, the dictionary issues a
warning.

A special command to issue to the database when shutting down the
pool. Usually the pool of connections to the database is closed when
the application is ending. For embedded databases, whose lifecycle is
coterminous with the application, there may be a special command,
usually "SHUTDOWN", that will cause the database to close cleanly.

The style of SQL join syntax to use in select statements:
sql92 - ANSI SQL92 join syntax where joins are expressed
in the SQL FROM clause. Outer joins are supported. Not all databases
support this syntax. traditional - Traditional SQL join
syntax where joins are expressed in the SQL WHERE clause. Outer joins
are not supported. database - Join syntax is encoded to
some extent within the dictionary class for the database. Outer joins
may be supported.

When greater than -1, the maximum size of a BLOB value that can be
sent directly to the database within an insert or update statement.
Values whose size is greater than MaxEmbeddedBlobSize force OpenJPA to
work around this limitation. A value of -1 means that there is no
limitation.

The SQL function call to trim any number of a particular character
from both the start and end of a string. Note: some databases do not
support specifying the character in which case only spaces or
whitespace can be trimmed. Use the token {1} when possible to
represent the character, and the token {0} to represent the
string.