public final class OracleDatabaseProvider extends DatabaseProvider
DatabaseProvider.RenderFieldOptions, DatabaseProvider.SqlListener| Modifier and Type | Field and Description |
|---|---|
static Set<String> |
RESERVED_WORDS |
logger, quoteRef, sqlLogger, typeManager| Constructor and Description |
|---|
OracleDatabaseProvider(DisposableDataSource dataSource) |
OracleDatabaseProvider(DisposableDataSource dataSource,
String schema) |
| Modifier and Type | Method and Description |
|---|---|
protected <T extends RawEntity<K>,K> |
executeInsertReturningKey(EntityManager manager,
Connection conn,
Class<T> entityType,
Class<K> 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. |
ResultSet |
getImportedKeys(Connection connection,
String tableName) |
ResultSet |
getIndexes(Connection conn,
String tableName) |
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.
|
String |
getSchema() |
ResultSet |
getSequences(Connection conn)
Statement can't be closed locally as this would also close the result set.
|
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. |
void |
putNull(PreparedStatement stmt,
int index)
Stores an SQL
NULL value in the database. |
protected Iterable<SQLAction> |
renderAccessoriesForField(NameConverters nameConverters,
DDLTable table,
DDLField field)
Generates database-specific DDL statements required to create any functions,
sequences, or triggers required for the given field.
|
protected SQLAction |
renderAlterTableAddColumnStatement(NameConverters nameConverters,
DDLTable table,
DDLField field)
Generates the database-specific DDL statement for adding a column,
but not including any corresponding sequences, triggers, etc.
|
protected Iterable<SQLAction> |
renderAlterTableChangeColumn(NameConverters nameConverters,
DDLTable table,
DDLField oldField,
DDLField field)
Generates the database-specific DDL statements required to change
the given column from its old specification to the given DDL value.
|
protected SQLAction |
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 Iterable<SQLAction> |
renderDropAccessoriesForField(NameConverters nameConverters,
DDLTable table,
DDLField field)
Generates database-specific DDL statements required to drop any functions,
sequences, or triggers associated with the given field.
|
protected SQLAction |
renderDropIndex(IndexNameConverter indexNameConverter,
DDLIndex index)
Generates the database-specific DDL statement required to drop
an index.
|
protected SQLAction |
renderDropTableStatement(DDLTable table)
Generates the appropriate database-specific DDL statement to
drop the specified table representation.
|
String |
renderMetadataQuery(String tableName)
Render "SELECT * FROM
|
protected String |
renderQueryLimit(Query query)
Renders the LIMIT portion of the query in the database-specific SQL
dialect.
|
protected String |
renderQuerySelect(Query query,
TableNameConverter converter,
boolean count)
Renders the SELECT portion of a given
Query instance in the
manner required by the database-specific SQL implementation. |
protected String |
renderUnique(UniqueNameConverter uniqueNameConverter,
DDLTable table,
DDLField field)
Renders the
UNIQUE constraint as defined by the
database-specific DDL syntax. |
protected boolean |
shouldQuoteID(String id)
Determines whether or not the specified identifier should be quoted
before transmission to the underlying database.
|
_getFunctionNameForField, _getTriggerNameForField, _renderDropFunctionForField, _renderDropSequenceForField, _renderDropTriggerForField, _renderFunctionForField, _renderSequenceForField, _renderTriggerForField, addSqlListener, commitTransaction, convertTypeToString, dispose, executeUpdate, executeUpdateForAction, executeUpdatesForActions, findForeignKeysForField, getConnection, getTypeManager, handleBlob, hasIndex, hasIndex, insertBatch, insertReturningKey, isCaseSensitive, isNumericType, isSchemaNotEmpty, loadQuoteString, onSql, preparedStatement, preparedStatement, preparedStatement, processID, processID, processOnClause, processOrderClause, processTableName, processWhereClause, querySelectFields, queryTableName, quote, quoteTableName, removeSqlListener, renderAccessories, renderAction, renderAlterTableAddColumn, renderAlterTableAddKey, renderAlterTableChangeColumnStatement, renderAlterTableDropColumn, renderAlterTableDropColumnStatement, renderAppend, renderConstraintsForTable, renderCreateCompositeIndex, renderCreateIndex, renderDate, renderDropAccessories, renderDropColumnActions, renderField, renderFieldDefault, renderFieldOptionsInAlterColumn, renderFields, renderFields, renderFieldType, renderForeignKey, renderInsert, renderPrimaryKey, renderQuery, renderQueryGroupBy, renderQueryHaving, renderQueryJoins, renderQueryOrderBy, renderQueryWhere, renderTable, renderValue, rollbackTransaction, setPostConnectionProperties, setQueryResultSetProperties, setQueryStatementProperties, shorten, shouldQuoteTableName, startTransaction, withSchemapublic OracleDatabaseProvider(DisposableDataSource dataSource)
public OracleDatabaseProvider(DisposableDataSource dataSource, String schema)
public String renderMetadataQuery(String tableName)
DatabaseProviderrenderMetadataQuery in class DatabaseProviderpublic String getSchema()
getSchema in class DatabaseProviderpublic 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 DatabaseProviderSQLExceptionpublic ResultSet getIndexes(Connection conn, String tableName) throws SQLException
getIndexes in class DatabaseProviderSQLExceptionpublic ResultSet getImportedKeys(Connection connection, String tableName) throws SQLException
getImportedKeys in class DatabaseProviderSQLExceptionprotected String renderQuerySelect(Query query, TableNameConverter converter, boolean count)
DatabaseProviderRenders the SELECT portion of a given Query instance in the
manner required by the database-specific SQL implementation. Usually,
this is as simple as "SELECT id FROM table" or "SELECT DISTINCT
* FROM table". However, some databases require the limit and offset
parameters to be specified as part of the SELECT clause. For example,
on HSQLDB, a Query for the "id" field limited to 10 rows would render
SELECT like this: SELECT TOP 10 id FROM table.
There is usually no need to call this method directly. Under normal
operations it functions as a delegate for DatabaseProvider.renderQuery(Query, TableNameConverter, boolean).
renderQuerySelect in class DatabaseProviderquery - The Query instance from which to determine the SELECT properties.converter - The name converter to allow conversion of the query entity
interface into a proper table name.count - Whether or not the query should be rendered as a SELECT COUNT(*).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.
Unfortunately, we live in the real world of proprietary database implementations that requires us to use database specific keywords or semantics to achieve these outcomes. Appropriate methods should be overridden in such cases.
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 DatabaseProviderpublic 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 renderUnique(UniqueNameConverter uniqueNameConverter, DDLTable table, DDLField field)
DatabaseProviderUNIQUE constraint as defined by the
database-specific DDL syntax. This method is a delegate of other, more
complex methods such as DatabaseProvider.renderField(net.java.ao.schema.NameConverters, net.java.ao.schema.ddl.DDLTable, net.java.ao.schema.ddl.DDLField, net.java.ao.DatabaseProvider.RenderFieldOptions). The default
implementation just returns UNIQUE. Implementations may
override this method to return an empty String if the database
in question does not support the constraint.renderUnique in class DatabaseProviderUNIQUE.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:ssgetDateFormat in class DatabaseProviderprotected SQLAction renderAlterTableAddColumnStatement(NameConverters nameConverters, DDLTable table, DDLField field)
DatabaseProviderrenderAlterTableAddColumnStatement in class DatabaseProvidertable - The table which should receive the new column.field - The column to add to the specified table.protected Iterable<SQLAction> renderAlterTableChangeColumn(NameConverters nameConverters, DDLTable table, DDLField oldField, DDLField field)
DatabaseProviderGenerates the database-specific DDL statements required to change the given column from its old specification to the given DDL value. This method will also generate the appropriate statements to remove old triggers and functions, as well as add new ones according to the requirements of the new field definition.
The default implementation of this method functions in the manner specified by the MySQL database. Some databases will have to perform more complicated actions (such as dropping and re-adding the field) in order to satesfy the same use-case. Such databases should print a warning to stderr to ensure that the end-developer is aware of such restrictions.
Thus, the specification for this method allows for data loss. Nevertheless, if the database supplies a mechanism to accomplish the task without data loss, it should be applied.
For maximum flexibility, the default implementation of this method
only deals with the dropping and addition of functions and triggers.
The actual generation of the ALTER TABLE statement is done in the
DatabaseProvider.renderAlterTableChangeColumnStatement(net.java.ao.schema.NameConverters, net.java.ao.schema.ddl.DDLTable, net.java.ao.schema.ddl.DDLField, net.java.ao.schema.ddl.DDLField, net.java.ao.DatabaseProvider.RenderFieldOptions)
method.
renderAlterTableChangeColumn in class DatabaseProvidertable - The table containing the column to change.oldField - The old column definition.field - The new column definition (defining the resultant DDL). @return An array of DDL statements to be executed.#getTriggerNameForField(net.java.ao.schema.TriggerNameConverter, net.java.ao.schema.ddl.DDLTable, net.java.ao.schema.ddl.DDLField),
#getFunctionNameForField(net.java.ao.schema.TriggerNameConverter, net.java.ao.schema.ddl.DDLTable, net.java.ao.schema.ddl.DDLField),
#renderFunctionForField(net.java.ao.schema.TriggerNameConverter, net.java.ao.schema.ddl.DDLTable, net.java.ao.schema.ddl.DDLField),
#renderTriggerForField(net.java.ao.schema.TriggerNameConverter, net.java.ao.schema.SequenceNameConverter, net.java.ao.schema.ddl.DDLTable, net.java.ao.schema.ddl.DDLField)protected SQLAction 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 SQLAction renderDropIndex(IndexNameConverter indexNameConverter, DDLIndex index)
DatabaseProvidernull returned.renderDropIndex in class DatabaseProviderindex - The index to drop. This single instance contains all
of the data necessary to drop the index, thus no separate
parameters (such as a DDLTable) are required.null.protected SQLAction renderDropTableStatement(DDLTable table)
DatabaseProvider"DROP TABLE tablename". This is suitable
for every database that I am aware of. Any dependent database
objects (such as triggers, functions, etc) must be rendered in
one of the other delegate methods (such as renderDropTriggers(DDLTable)).renderDropTableStatement in class DatabaseProvidertable - The table representation which is to be dropped.public void handleUpdateError(String sql, SQLException e) throws SQLException
DatabaseProviderhandleUpdateError in class DatabaseProvidere - the SQLException that occured.SQLException - throws the SQLException if it should not be ignored.protected <T extends RawEntity<K>,K> K executeInsertReturningKey(EntityManager manager, Connection conn, Class<T> entityType, Class<K> 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 #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.entityType - The Java class of the entity.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.SQLException#insertReturningKey(EntityManager, Connection, Class, String, boolean, String, DBParam...)protected Iterable<SQLAction> renderAccessoriesForField(NameConverters nameConverters, DDLTable table, DDLField field)
DatabaseProviderSQLAction
should have a corresponding undo action that deletes
the corresponding function, sequence, or trigger. The default implementation returns
an empty list.renderAccessoriesForField in class DatabaseProviderSQLActionsprotected Iterable<SQLAction> renderDropAccessoriesForField(NameConverters nameConverters, DDLTable table, DDLField field)
DatabaseProviderrenderDropAccessoriesForField in class DatabaseProviderSQLActionsprotected 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 DatabaseProviderpublic void putNull(PreparedStatement stmt, int index) throws SQLException
DatabaseProviderNULL value in the database. This method
is required due to the fact that not all JDBC drivers handle NULLs
in the same fashion. The default implementation calls PreparedStatement.setNull(int, int),
retrieving parameter type from metadata. Databases which require a
different implementation (e.g. PostgreSQL) should override this method.putNull in class DatabaseProviderstmt - The statement in which to store the NULL value.index - The index of the parameter which should be assigned NULL.SQLExceptionpublic 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.SQLExceptionCopyright © 2007–2022 Atlassian. All rights reserved.