net.java.ao.DatabaseProvider
net.java.ao.db.OracleDatabaseProvider
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||
java.lang.Object
public class OracleDatabaseProvider
| Nested Class Summary |
|---|
| Nested classes/interfaces inherited from class net.java.ao.DatabaseProvider |
|---|
DatabaseProvider.SqlListener |
| Field Summary |
|---|
| Fields inherited from class net.java.ao.DatabaseProvider |
|---|
logger, schema, sqlLogger |
| Constructor Summary | |
|---|---|
OracleDatabaseProvider(DisposableDataSource dataSource)
|
|
| Method Summary | ||
|---|---|---|
protected String |
convertTypeToString(DatabaseType<?> type)
Converts the specified type into the database-specific DDL String value. |
|
protected
|
executeInsertReturningKey(EntityManager manager,
Connection conn,
Class<T> pkType,
String pkField,
String sql,
DBParam... params)
Delegate method to execute an INSERT statement returning any auto-generated primary key values. |
|
protected String |
getDateFormat()
Returns the database-specific TIMESTAMP text format as defined by the SimpleDateFormat syntax. |
|
protected int |
getMaxIDLength()
Returns the maximum length for any identifier in the underlying database. |
|
protected Set<String> |
getReservedWords()
Retrieves the set of all reserved words for the underlying database. |
|
ResultSet |
getSequences(Connection conn)
|
|
ResultSet |
getTables(Connection conn)
Returns a result set of all of the tables (and associated meta) in the database. |
|
void |
handleUpdateError(String sql,
SQLException e)
Tells whether this exception should be ignored when running an updated statement. |
|
Object |
parseValue(int type,
String value)
Parses the database-agnostic String value relevant to the specified SQL
type in int form (as defined by Types and returns
the Java value which corresponds. |
|
void |
putBoolean(PreparedStatement stmt,
int index,
boolean value)
Stors an SQL BOOLEAN value in the database. |
|
protected String |
renderAlterTableChangeColumnStatement(DDLTable table,
DDLField oldField,
DDLField field,
boolean renderUnique)
Generates the database-specific DDL statement only for altering a table and changing a column. |
|
protected String |
renderAlterTableDropKey(DDLForeignKey key)
Generates the database-specific DDL statement required to remove a foreign key from a table. |
|
protected String |
renderAutoIncrement()
Generates the DDL fragment required to specify an INTEGER field as auto-incremented. |
|
protected String[] |
renderDropSequences(DDLTable table)
Generates the database-specific DDL statements required to drop all associated sequences for the given table representation. |
|
protected String |
renderDropTable(DDLTable table)
Generates the appropriate database-specific DDL statement to drop the specified table representation. |
|
protected String[] |
renderDropTriggers(DDLTable table)
Generates the database-specific DDL statements required to drop all associated triggers for the given table representation. |
|
protected String |
renderFieldPrecision(DDLField field)
Renders the statement fragment for the given field representative of its precision only. |
|
protected String |
renderFunction(DatabaseFunction func)
Renders the specified DatabaseFunction in its
database-specific form. |
|
protected String |
renderOnUpdate(DDLField field)
Renders the appropriate field suffix to allow for the OnUpdate functionality. |
|
protected String |
renderQueryLimit(Query query)
Renders the LIMIT portion of the query in the database-specific SQL dialect. |
|
protected String[] |
renderSequences(DDLTable table)
Generates the database-specific DDL statements required to create all of the sequences necessary for the given table. |
|
protected String |
renderTriggerForField(DDLTable table,
DDLField field)
Renders the trigger which corresponds to the specified field, or null if none. |
|
protected String[] |
renderTriggers(DDLTable table)
Generates the database-specific DDL statements required to create all of the triggers necessary for the given table. |
|
void |
setQueryResultSetProperties(ResultSet res,
Query query)
Allows the provider to set database-specific options on a ResultSet instance prior to its use by the library. |
|
void |
setQueryStatementProperties(Statement stmt,
Query query)
Allows the provider to set database-specific options on a Statement instance prior to its usage in a SELECT
query. |
|
protected boolean |
shouldQuoteID(String id)
Determines whether or not the specified identifier should be quoted before transmission to the underlying database. |
|
| Methods inherited from class java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Constructor Detail |
|---|
public OracleDatabaseProvider(DisposableDataSource dataSource)
| Method Detail |
|---|
public void setQueryStatementProperties(Statement stmt,
Query query)
throws SQLException
DatabaseProviderAllows the provider to set database-specific options on a
Statement instance prior to its usage in a SELECT
query. This is to allow things like emulation of the
LIMIT feature on databases which don't support it within
the SQL implementation.
This method is only called on SELECTs.
setQueryStatementProperties in class DatabaseProviderstmt - The instance against which the properties
should be set.query - The query which is being executed against
the statement instance.
SQLException
public void setQueryResultSetProperties(ResultSet res,
Query query)
throws SQLException
DatabaseProviderResultSet instance prior to its use by the library.
This allows for features such as row offsetting even on
databases that don't support it (such as Oracle, Derby,
etc).
setQueryResultSetProperties in class DatabaseProviderres - The ResultSet to modify.query - The query instance which was run to produce
the result set.
SQLException
public ResultSet getTables(Connection conn)
throws SQLException
DatabaseProviderReturns a result set of all of the tables (and associated
meta) in the database. The fields of the result set must
correspond with those specified in the
DatabaseMetaData#getTables(String, String, String, String[])
method. In fact, the default implementation merely calls
this method passing (null, null, "", null).
For databases (such as PostgreSQL) where this is unsuitable,
different parameters can be specified to the getTables
method in the override, or an entirely new implementation
written, as long as the result set corresponds in fields to
the JDBC spec.
getTables in class DatabaseProviderconn - The connection to use in retrieving the database tables.
SQLExceptionDatabaseMetaData.getTables(String, String, String, String[])
public ResultSet getSequences(Connection conn)
throws SQLException
getSequences in class DatabaseProviderSQLExceptionprotected String convertTypeToString(DatabaseType<?> type)
DatabaseProviderDatabaseType#getDefaultName()
method. Subclass implementations should be sure to make a super
call in order to ensure that both default naming and future special
cases are handled appropriately.
convertTypeToString in class DatabaseProvidertype - The type instance to convert to a DDL string.
DatabaseType.getDefaultName()protected String renderFieldPrecision(DDLField field)
DatabaseProviderRenders the statement fragment for the given field representative of its precision only. Consider the following statement:
ALTER TABLE ADD COLUMN name VARCHAR(255)
In this statement, the bit which is rendered by this method is the
"(255)" (without quotes). This is intended to allow
maximum flexibility in field type rendering (as required by PostgreSQL
and others which sometimes render types separately from the rest of
the field info). The default implementation should suffice for every
conceivable database. Any sort of odd functionality relating to
type precision rendering should be handled in the DatabaseProvider.considerPrecision(DDLField)
method if possible.
renderFieldPrecision in class DatabaseProviderfield - The field for which the precision must be rendered.
protected String renderQueryLimit(Query query)
DatabaseProviderRenders the LIMIT portion of the query in the database-specific SQL
dialect. There is wide variety in database implementations of this
particular SQL clause. In fact, many database do not support it at all.
If the database in question does not support LIMIT, this method should
be overridden to return an empty String. For such databases, LIMIT
should be implemented by overriding DatabaseProvider.setQueryResultSetProperties(ResultSet, Query)
and DatabaseProvider.setQueryStatementProperties(Statement, Query).
An example return value: " LIMIT 10,2"
There is usually no need to call this method directly. Under normal
operations it functions as a delegate for DatabaseProvider.renderQuery(Query, TableNameConverter, boolean).
renderQueryLimit in class DatabaseProviderquery - The Query instance from which to determine the LIMIT properties.
protected String renderAutoIncrement()
DatabaseProviderGenerates the DDL fragment required to specify an INTEGER field as
auto-incremented. For databases which do not support such flags (which
is just about every database exception MySQL), "" is an
acceptable return value. This method should never return null
as it would cause the field rendering method to throw a NullPointerException.
renderAutoIncrement in class DatabaseProvider
public Object parseValue(int type,
String value)
DatabaseProviderParses the database-agnostic String value relevant to the specified SQL
type in int form (as defined by Types and returns
the Java value which corresponds. This method is completely database-agnostic, as are
all of all of its delegate methods.
WARNING: This method is being considered for removal to another
class (perhaps TypeManager?) as it is not a database-specific function and thus
confuses the purpose of this class. Do not rely upon it heavily. (better yet, don't rely on it
at all from external code. It's not designed to be part of the public API)
parseValue in class DatabaseProvidertype - The JDBC integer type of the database field against which to parse the
value.value - The database-agnostic String value to parse into a proper Java object
with respect to the specified SQL type.
protected String renderOnUpdate(DDLField field)
DatabaseProviderRenders the appropriate field suffix to allow for the
OnUpdate functionality. For most databases (read:
all but MySQL) this will return an empty String. This is
because few databases provide an implicit ON UPDATE syntax for
fields. As such, most databases will be compelled to return
an empty String and implement the functionality using triggers.
renderOnUpdate in class DatabaseProviderfield - The field for which the ON UPDATE clause should
be rendered.
protected String renderFunction(DatabaseFunction func)
DatabaseProviderRenders the specified DatabaseFunction in its
database-specific form. For example, for MySQL the
CURRENT_DATE enum value would be rendered as
"CURRENT_DATE" (without the quotes). For functions
which do not have a database equivalent, a default literal value
of the appropriate type should be returned. For example, if MySQL
did not define either a CURRENT_DATE or a CURRENT_TIMESTAMP
function, the appropriate return value for both functions would
be '0000-00-00 00:00:00' (including the quotes).
This is to prevent migrations from failing even in cases where
non-standard functions are used.
As of 1.0, no unconventional functions are allowed by the
DatabaseFunction enum, thus no database should have any
problems with any allowed functions.
renderFunction in class DatabaseProviderfunc - The abstract function to be rendered.
protected String getDateFormat()
DatabaseProviderSimpleDateFormat syntax. This format should include
the time down to the second (or even more precise, if allowed by
the database). The default implementation returns the format for
MySQL, which is: yyyy-MM-dd HH:mm:ss
getDateFormat in class DatabaseProvider
protected String renderTriggerForField(DDLTable table,
DDLField field)
DatabaseProvidernull if none. This is to allow for databases which
require the use of triggers to provide functionality such as ON
UPDATE. The default implementation returns null.
renderTriggerForField in class DatabaseProvidertable - The table containing the field for which a trigger
may need to be rendered.field - The field for which the trigger should be rendered,
if any.
null.DatabaseProvider.getTriggerNameForField(DDLTable, DDLField)
protected String renderAlterTableChangeColumnStatement(DDLTable table,
DDLField oldField,
DDLField field,
boolean renderUnique)
DatabaseProviderDatabaseProvider.renderAlterTableChangeColumn(DDLTable, DDLField, DDLField) method,
for which it is a primary delegate. The default implementation of this
method functions according to the MySQL specification.
renderAlterTableChangeColumnStatement in class DatabaseProvidertable - The table containing the column to change.oldField - The old column definition.field - The new column definition (defining the resultant DDL).
DatabaseProvider.renderField(net.java.ao.schema.ddl.DDLField, boolean)protected String renderAlterTableDropKey(DDLForeignKey key)
DatabaseProvidernull value returned. This method assumes that the
DatabaseProvider.renderForeignKey(DDLForeignKey) method properly names
the foreign key according to the DDLForeignKey.getFKName()
method.
renderAlterTableDropKey in class DatabaseProviderkey - The foreign key to be removed. As this instance contains
all necessary data (such as domestic table, field, etc), no
additional parameters are required.
null.protected String renderDropTable(DDLTable table)
DatabaseProvider"DROP TABLE tablename". This is suitable
for every database that I am aware of. Any dependant database
objects (such as triggers, functions, etc) must be rendered in
one of the other delegate methods (such as renderDropTriggers(DDLTable)).
renderDropTable in class DatabaseProvidertable - The table representation which is to be dropped.
public void handleUpdateError(String sql,
SQLException e)
throws SQLException
DatabaseProvider
handleUpdateError in class DatabaseProvidere - the SQLException that occured.
SQLException - throws the SQLException if it should not be ignored.
protected <T> T executeInsertReturningKey(EntityManager manager,
Connection conn,
Class<T> pkType,
String pkField,
String sql,
DBParam... params)
throws SQLException
DatabaseProviderDelegate method to execute an INSERT statement returning any auto-generated
primary key values. This method is primarily designed to be called as a delegate
from the DatabaseProvider.insertReturningKey(EntityManager, Connection, Class, String, boolean, String, DBParam...)
method. The idea behind this method is to allow custom implementations to
override this method to potentially execute other statements (such as getting the
next value in a sequence) rather than the default implementaiton which uses the
JDBC constant, RETURN_GENERATED_KEYS. Any database which has a
fully-implemented JDBC driver should have no problems with the default
implementation of this method.
Part of the design behind splitting insertReturningKey and
executeInsertReturningKey is so that logic for generating the actual
INSERT statement need not be duplicated throughout the code and in custom
implementations providing trivial changes to the default algorithm. This method
should avoid actually generating SQL if at all possible.
This method should iterate through the passed DBParam(s) to
ensure that no primary key value was explicitly specified. If one was, it
should be used in leiu of one which is auto-generated by the database. Also,
it is this value which should be returned if specified, rather than the value
which would have been generated or null. As such, this method
should always return exactly the value of the primary key field in the row which
was just inserted, regardless of what that value may be.
In cases where the database mechanism for getting the next primary key value
is not thread safe, this method should be declared synchronized,
or some thread synchronization technique employed. Unfortunately, it is not
always possible to ensure that no other INSERT could (potentially) "steal" the
expected value out from under the algorithm. Such scenarios are to be avoided
when possible, but the algorithm need not take extremely escoteric concurrency
cases into account. (see the HSQLDB provider for an example of such a
less-than-thorough asynchronous algorithm)
IMPORTANT: The INSERT Statement must use the specified
connection, rather than a new one retrieved from DatabaseProvider.getConnection() or
equivalent. This is because the INSERT may be part of a bulk insertion, a
transaction, or possibly another such operation. It is also important to note
that this method should not close the connection. Doing so could cause the
entity creation algorithm to fail at a higher level up the stack.
executeInsertReturningKey in class DatabaseProvidermanager - The EntityManager which was used to dispatch
the INSERT in question.conn - The database connection to use in executing the INSERT statement.pkType - The Java class type of the primary key field (for use both in
searching the params as well as performing value conversion
of auto-generated DB values into proper Java instances).pkField - The database field which is the primary key for the
table in question. Can be used to perform a linear search for a
specified primary key value in the params list.params - A varargs array of parameters to be passed to the
INSERT statement. This may include a specified value for the
primary key. @throws SQLException If the INSERT fails in the delegate method, or
if any additional statements fail with an exception.
SQLExceptionDatabaseProvider.insertReturningKey(EntityManager, Connection, Class, String, boolean, String, DBParam...)protected String[] renderTriggers(DDLTable table)
DatabaseProviderGenerates the database-specific DDL statements required to create
all of the triggers necessary for the given table. For MySQL, this
will likely return an empty array. The functionality is required
for databases which do not provide an implicit syntax for the
@OnUpdate functionality. In MySQL, it is possible to
provide this functionality with the
field TIMESTAMP ON UPDATE CURRENT_DATE style syntax.
This syntax is not common to all databases, hence triggers must be
used to provide the functionality.
Most of the work for this functionality is delegated to the
DatabaseProvider.renderTriggerForField(DDLTable, DDLField) method.
renderTriggers in class DatabaseProvidertable - The table for which the triggers must be generated.
protected String[] renderDropTriggers(DDLTable table)
DatabaseProvider@OnUpdate function to be implemented using triggers
explicitly (rather than the implicit MySQL syntax). For such
databases, some tables will thus have triggers which are associated
directly with the table. It is these triggers which must be
dropped prior to the dropping of the table itself. For databases
which associate functions with triggers (such as PostgreSQL), these
functions will be dropped using another delegate method and need
not be dealt with in this method's implementation.
renderDropTriggers in class DatabaseProvidertable - The table representation against which all triggers which
correspond (directly or indirectly) must be dropped.
protected String[] renderDropSequences(DDLTable table)
DatabaseProvider
renderDropSequences in class DatabaseProvidertable - The table representation against which all triggers which
correspond (directly or indirectly) must be dropped.
protected String[] renderSequences(DDLTable table)
DatabaseProviderGenerates the database-specific DDL statements required to create all of the sequences necessary for the given table. This is an Oracle specific method used for primary key management
renderSequences in class DatabaseProvidertable - The table for which the triggers must be generated.
protected boolean shouldQuoteID(String id)
DatabaseProviderDatabaseProvider.getReservedWords(). Databases with more complicated
rules regarding quoting should provide a custom implementation of this
method.
shouldQuoteID in class DatabaseProviderid - The identifier to check against the quoting rules.
true if the specified identifier is invalid under
the relevant quoting rules, otherwise false.protected int getMaxIDLength()
DatabaseProviderInteger.MAX_VALUE.
getMaxIDLength in class DatabaseProviderprotected Set<String> getReservedWords()
DatabaseProviderSet instance returned from this
method should guarentee O(1) lookup times, otherwise ORM performance
will suffer greatly.
getReservedWords in class DatabaseProvider
public void putBoolean(PreparedStatement stmt,
int index,
boolean value)
throws SQLException
DatabaseProviderBOOLEAN value in the database. Most databases
handle differences in BOOLEAN semantics within their JDBC
driver(s). However, some do not implement the PreparedStatement.setBoolean(int, boolean)
method correctly. To work around this defect, any database providers
for such databases should override this method to store boolean values in
the relevant fashion.
putBoolean in class DatabaseProviderstmt - The statement in which to store the BOOLEAN value.index - The index of the parameter which should be assigned.value - The value to be stored in the relevant field.
SQLException
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||