net.java.ao

Class DatabaseProvider

java.lang.Object

net.java.ao.DatabaseProvider

All Implemented Interfaces:

Disposable

Direct Known Subclasses:

ClientDerbyDatabaseProvider, EmbeddedDerbyDatabaseProvider, HSQLDatabaseProvider, MySQLDatabaseProvider, OracleDatabaseProvider, PostgreSQLDatabaseProvider, SQLServerDatabaseProvider

public abstract class DatabaseProvider
extends Object
implements Disposable

The superclass parent of all DatabaseProvider implementations. Various implementations allow for an abstraction around database-specific functionality (such as DDL). DatabaseProvider(s) also handle the creation of new Connection instances and fully encapsulate the raw JDBC driver. Any database-specific code should be placed in the database provider, rather than embedded within the API logic.

This superclass contains a base-line, default implementation of most database-specific methods, thus requiring a minimum of work to implement a new database provider. For the sake of sanity (read: mine), this base-line implementation is basically specific to MySQL. Thus any DatabaseProvider implementations are really specifying the differences between the database in question and MySQL. To fully utilize the default implementations provided in this class, this fact should be kept in mind.

This class also handles the implementation details required to ensure that only one active Connection instance is available per thread. This is in fact a very basic (and naive) form of connection pooling. It should not be relied upon for performance reasons. Instead one should enable connection pooling via the DataSource passed to instances. You can also use the net.java.ao.builder.EntityManagerBuilder builder to make it easier to configure the pooling. The purpose of the thread-locked connection pooling in this class is to satisfy transactions with external SQL statements.

Author:

Daniel Spiewak

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected static class	DatabaseProvider.RenderFieldOptions
static interface	DatabaseProvider.SqlListener

Field Summary

Fields

Modifier and Type	Field and Description
protected org.slf4j.Logger	logger
protected org.slf4j.Logger	sqlLogger
protected TypeManager	typeManager

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	DatabaseProvider(DisposableDataSource dataSource, String schema)
protected	DatabaseProvider(DisposableDataSource dataSource, String schema, TypeManager typeManager)

Method Summary

Methods

Modifier and Type	Method and Description
protected String	_getFunctionNameForField(TriggerNameConverter triggerNameConverter, DDLTable table, DDLField field) Retrieves the name of the function which corresponds to the field in question (if any).
protected String	_getTriggerNameForField(TriggerNameConverter triggerNameConverter, DDLTable table, DDLField field) Retrieves the name of the trigger which corresponds to the field in question (if any).
protected SQLAction	_renderDropFunctionForField(NameConverters nameConverters, DDLTable table, DDLField field) Renders SQL statement(s) to drop the function which corresponds to the specified field, if applicable, or null otherwise.
protected SQLAction	_renderDropSequenceForField(NameConverters nameConverters, DDLTable table, DDLField field) Renders SQL statement(s) to drop the sequence which corresponds to the specified field, or null if none.
protected SQLAction	_renderDropTriggerForField(NameConverters nameConverters, DDLTable table, DDLField field) Renders SQL statement(s) to drop the trigger which corresponds to the specified field, or null if none.
protected SQLAction	_renderFunctionForField(NameConverters nameConverters, DDLTable table, DDLField field) Renders the function which corresponds to the specified field, or null if none.
protected SQLAction	_renderSequenceForField(NameConverters nameConverters, DDLTable table, DDLField field) Renders the SQL for creating a sequence for the specified field, or null if none.
protected SQLAction	_renderTriggerForField(NameConverters nameConverters, DDLTable table, DDLField field) Renders the trigger which corresponds to the specified field, or null if none.
void	addSqlListener(DatabaseProvider.SqlListener l)
Connection	commitTransaction(Connection c)
protected String	convertTypeToString(TypeInfo<?> type) Converts the specified type into the database-specific DDL String value.
void	dispose() Frees any resources held by the database provider or delegate libraries (such as connection pools).
protected <T extends RawEntity<K>,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.
void	executeUpdate(Statement stmt, CharSequence sql)
Iterable<String>	executeUpdateForAction(Statement stmt, SQLAction action, Set<String> completedStatements)
Iterable<String>	executeUpdatesForActions(Statement stmt, Iterable<SQLAction> actions, Set<String> completedStatements) Attempt to execute a list of actions that make up a logical unit (e.g.
protected Iterable<DDLForeignKey>	findForeignKeysForField(DDLTable table, DDLField field)
Connection	getConnection() Retrieves a JDBC Connection instance which corresponds to the database represented by the provider instance.
protected String	getDateFormat() Returns the database-specific TIMESTAMP text format as defined by the SimpleDateFormat syntax.
protected String	getExistingIndexName(IndexNameConverter indexNameConverter, DDLIndex index)
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 abstract Set<String>	getReservedWords() Retrieves the set of all reserved words for the underlying database.
String	getSchema()
ResultSet	getSequences(Connection conn)
ResultSet	getTables(Connection conn) Returns a result set of all of the tables (and associated meta) in the database.
TypeManager	getTypeManager()
Object	handleBlob(ResultSet res, Class<?> type, String field)
void	handleUpdateError(String sql, SQLException e) Tells whether this exception should be ignored when running an updated statement.
protected boolean	hasIndex(IndexNameConverter indexNameConverter, DDLIndex index)
protected boolean	hasIndex(String tableName, String indexName)
<T extends RawEntity<K>,K> K	insertReturningKey(EntityManager manager, Connection conn, Class<T> entityType, Class<K> pkType, String pkField, boolean pkIdentity, String table, DBParam... params) Generates an INSERT statement to be used to create a new row in the database, returning the primary key value.
boolean	isCaseSensitive() Flag indicating whether or not the underlying database uses case-sensitive identifiers.
protected boolean	isNumericType(int type) Simple helper function used to determine of the specified JDBC type is representitive of a numeric type.
protected boolean	isSchemaNotEmpty()
protected void	onSql(String sql)
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.
PreparedStatement	preparedStatement(Connection c, CharSequence sql)
PreparedStatement	preparedStatement(Connection c, CharSequence sql, int autoGeneratedKeys)
PreparedStatement	preparedStatement(Connection c, CharSequence sql, int resultSetType, int resultSetConcurrency)
String	processID(String id) Performs any database specific post-processing on the specified identifier.
protected String	processOnClause(String on)
String	processOrderClause(String order)
String	processWhereClause(String where) Processes the where clause to make it compatible with the given database.
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 String	querySelectFields(Query query)
protected String	queryTableName(Query query, TableNameConverter converter)
String	quote(String id)
void	removeSqlListener(DatabaseProvider.SqlListener l)
protected Iterable<SQLAction>	renderAccessories(NameConverters nameConverters, DDLTable table) Generates the database-specific DDL statements required to create all of the functions, sequences, and triggers necessary for the given table, by calling renderAccessoriesForField(NameConverters, DDLTable, DDLField) for each of the table's fields.
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.
Iterable<SQLAction>	renderAction(NameConverters nameConverters, DDLAction action) Top level delegating method for the process of rendering a database-agnostic DDLAction into the database-specific SQL actions.
protected Iterable<SQLAction>	renderAlterTableAddColumn(NameConverters nameConverters, DDLTable table, DDLField field) Generates the database-specific DDL statements required to add a column to an existing table.
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 SQLAction	renderAlterTableAddKey(DDLForeignKey key) Generates the database-specific DDL statement required to add a foreign key to a table.
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	renderAlterTableChangeColumnStatement(NameConverters nameConverters, DDLTable table, DDLField oldField, DDLField field, DatabaseProvider.RenderFieldOptions options) Generates the database-specific DDL statement only for altering a table and changing a column.
protected Iterable<SQLAction>	renderAlterTableDropColumn(NameConverters nameConverters, DDLTable table, DDLField field) Generates the database-specific DDL statements required to remove the specified column from the given table.
protected SQLAction	renderAlterTableDropColumnStatement(DDLTable table, DDLField field)
protected SQLAction	renderAlterTableDropKey(DDLForeignKey key) Generates the database-specific DDL statement required to remove a foreign key from a table.
protected String	renderAppend() Generates any database-specific options which must be appended to the end of a table definition.
protected String	renderAutoIncrement() Generates the DDL fragment required to specify an INTEGER field as auto-incremented.
protected String	renderConstraintsForTable(UniqueNameConverter uniqueNameConverter, DDLTable table) Renders the foreign key constraints in database-specific DDL for the table in question.
protected SQLAction	renderCreateIndex(IndexNameConverter indexNameConverter, DDLIndex index) Generates the database-specific DDL statement required to create a new index.
protected String	renderDate(Date date) Renders the provided Date instance as a DATETIME literal in the database-specific format.
protected Iterable<SQLAction>	renderDropAccessories(NameConverters nameConverters, DDLTable table) Generates the database-specific DDL statements required to drop all of the functions, sequences, and triggers associated with the given table, by calling renderDropAccessoriesForField(NameConverters, DDLTable, DDLField) for each of the table's fields.
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.
protected String	renderField(NameConverters nameConverters, DDLTable table, DDLField field, DatabaseProvider.RenderFieldOptions options) Generates the database-specific DDL fragment required to render the field and its associated type.
protected String	renderFieldDefault(DDLTable table, DDLField field)
protected DatabaseProvider.RenderFieldOptions	renderFieldOptionsInAlterColumn()
protected Iterable<SQLAction>	renderFields(DDLTable table, com.google.common.base.Predicate<DDLField> filter, com.google.common.base.Function<DDLField,Iterable<SQLAction>> render)
protected String	renderFieldType(DDLField field) Renders the database-specific DDL type for the field in question.
protected String	renderForeignKey(DDLForeignKey key) Renders the specified foreign key representation into the database-specific DDL.
protected SQLAction	renderInsert(DDLTable ddlTable, DDLValue[] ddlValues)
protected String	renderPrimaryKey(String tableName, String pkFieldName)
String	renderQuery(Query query, TableNameConverter converter, boolean count) Top level delegating method for rendering a database-agnostic Query object into its (potentially) database-specific query statement.
protected String	renderQueryGroupBy(Query query) Renders the GROUP BY portion of the query in the database-specific SQL dialect.
protected String	renderQueryJoins(Query query, TableNameConverter converter) Renders the JOIN portion of the query in the database-specific SQL dialect.
protected String	renderQueryLimit(Query query) Renders the LIMIT portion of the query in the database-specific SQL dialect.
protected String	renderQueryOrderBy(Query query) Renders the ORDER BY 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	renderQueryWhere(Query query) Renders the WHERE portion of the query in the database-specific SQL dialect.
protected SQLAction	renderTable(NameConverters nameConverters, DDLTable table) Renders the specified table representation into the corresponding database-specific DDL statement.
protected String	renderUnique(UniqueNameConverter uniqueNameConverter, DDLTable table, DDLField field) Renders the UNIQUE constraint as defined by the database-specific DDL syntax.
protected String	renderValue(Object value) Renders the given Java instance in a database-specific way.
void	rollbackTransaction(Connection c)
protected void	setPostConnectionProperties(Connection conn) Called to make any post-creation modifications to a new Connection instance.
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.
String	shorten(String id)
protected boolean	shouldQuoteID(String id) Determines whether or not the specified identifier should be quoted before transmission to the underlying database.
Connection	startTransaction()
String	withSchema(String tableName)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

logger

protected final org.slf4j.Logger logger

sqlLogger

protected final org.slf4j.Logger sqlLogger

typeManager

protected final TypeManager typeManager

Constructor Detail

DatabaseProvider

protected DatabaseProvider(DisposableDataSource dataSource,
                String schema,
                TypeManager typeManager)

DatabaseProvider

protected DatabaseProvider(DisposableDataSource dataSource,
                String schema)

Method Detail

getTypeManager

public TypeManager getTypeManager()

getSchema

public String getSchema()

renderAutoIncrement

protected String renderAutoIncrement()

Generates 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.

renderAction

public final Iterable<SQLAction> renderAction(NameConverters nameConverters,
                               DDLAction action)

Top level delegating method for the process of rendering a database-agnostic DDLAction into the database-specific SQL actions. If the action is to create an entity, then each of the SQL actions may have a corresponding undo action to roll back creation of the entity if necessary.

Parameters:

nameConverters -

action - The database-agnostic action to render.

Returns:

An array of DDL statements specific to the database in question.

See Also:

renderTable(net.java.ao.schema.NameConverters, net.java.ao.schema.ddl.DDLTable), #renderFunctions(net.java.ao.schema.TriggerNameConverter, net.java.ao.schema.ddl.DDLTable), #renderTriggers(net.java.ao.schema.TriggerNameConverter, net.java.ao.schema.SequenceNameConverter, net.java.ao.schema.ddl.DDLTable), #renderSequences(net.java.ao.schema.SequenceNameConverter, net.java.ao.schema.ddl.DDLTable), #renderDropTriggers(net.java.ao.schema.TriggerNameConverter, net.java.ao.schema.ddl.DDLTable), #renderDropFunctions(net.java.ao.schema.TriggerNameConverter, net.java.ao.schema.ddl.DDLTable), #renderDropSequences(net.java.ao.schema.SequenceNameConverter, net.java.ao.schema.ddl.DDLTable), renderDropTableActions(net.java.ao.schema.NameConverters, net.java.ao.schema.ddl.DDLTable), renderAlterTableAddColumn(net.java.ao.schema.NameConverters, net.java.ao.schema.ddl.DDLTable, net.java.ao.schema.ddl.DDLField), renderAlterTableChangeColumn(net.java.ao.schema.NameConverters, net.java.ao.schema.ddl.DDLTable, net.java.ao.schema.ddl.DDLField, net.java.ao.schema.ddl.DDLField), renderDropColumnActions(net.java.ao.schema.NameConverters, net.java.ao.schema.ddl.DDLTable, net.java.ao.schema.ddl.DDLField), renderAlterTableAddKey(DDLForeignKey), renderAlterTableDropKey(DDLForeignKey)

renderQuery

public String renderQuery(Query query,
                 TableNameConverter converter,
                 boolean count)

Top level delegating method for rendering a database-agnostic Query object into its (potentially) database-specific query statement. This method invokes the various renderQuery* methods to construct its output, thus it is doubtful that any subclasses will have to override it. Rather, one of the delegate methods should be considered.

An example of a database-specific query rendering would be the following Query:

Query.select().from(Person.class).limit(10)

On MySQL, this would render to SELECT id FROM people LIMIT 10 However, on SQL Server, this same Query would render as SELECT TOP 10 id FROM people

Parameters:

query - The database-agnostic Query object to be rendered in a potentially database-specific way.

converter - Used to convert Entity classes into table names.

count - If true, render the Query as a SELECT COUNT(*) rather than a standard field-data query.

Returns:

A syntactically complete SQL statement potentially specific to the database.

See Also:

renderQuerySelect(Query, TableNameConverter, boolean), renderQueryJoins(Query, TableNameConverter), renderQueryWhere(Query), renderQueryGroupBy(Query), renderQueryOrderBy(Query), renderQueryLimit(Query)

parseValue

public 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. 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)

Parameters:

type - 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.

Returns:

A Java value which corresponds to the specified String.

setQueryStatementProperties

public void setQueryStatementProperties(Statement stmt,
                               Query query)
                                 throws SQLException

Allows 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.

Parameters:

stmt - The instance against which the properties should be set.

query - The query which is being executed against the statement instance.

Throws:

SQLException

setQueryResultSetProperties

public void setQueryResultSetProperties(ResultSet res,
                               Query query)
                                 throws SQLException

Allows the provider to set database-specific options on a ResultSet 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).

Parameters:

res - The ResultSet to modify.

query - The query instance which was run to produce the result set.

Throws:

SQLException

getTables

public ResultSet getTables(Connection conn)
                    throws SQLException

Returns 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.

Parameters:

conn - The connection to use in retrieving the database tables.

Returns:

A result set of tables (and meta) corresponding in fields to the JDBC specification.

Throws:

SQLException

See Also:

DatabaseMetaData.getTables(String, String, String, String[])

getSequences

public ResultSet getSequences(Connection conn)
                       throws SQLException

Throws:

SQLException

getIndexes

public ResultSet getIndexes(Connection conn,
                   String tableName)
                     throws SQLException

Throws:

SQLException

getImportedKeys

public ResultSet getImportedKeys(Connection connection,
                        String tableName)
                          throws SQLException

Throws:

SQLException

renderQuerySelect

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. 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 renderQuery(Query, TableNameConverter, boolean).

Parameters:

query - 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(*).

Returns:

The database-specific SQL rendering of the SELECT portion of the query.

queryTableName

protected final String queryTableName(Query query,
                    TableNameConverter converter)

querySelectFields

protected final String querySelectFields(Query query)

renderQueryJoins

protected String renderQueryJoins(Query query,
                      TableNameConverter converter)

Renders the JOIN portion of the query in the database-specific SQL dialect. Very few databases deviate from the standard in this matter, thus the default implementation is usually sufficient.

An example return value: " JOIN table1 ON table.id = table1.value"

There is usually no need to call this method directly. Under normal operations it functions as a delegate for renderQuery(Query, TableNameConverter, boolean).

Parameters:

query - The Query instance from which to determine the JOIN properties.

converter - The name converter to allow conversion of the query entity interface into a proper table name.

Returns:

The database-specific SQL rendering of the JOIN portion of the query.

renderQueryWhere

protected String renderQueryWhere(Query query)

Renders the WHERE portion of the query in the database-specific SQL dialect. Very few databases deviate from the standard in this matter, thus the default implementation is usually sufficient.

An example return value: " WHERE name = ? OR age < 20"

There is usually no need to call this method directly. Under normal operations it functions as a delegate for renderQuery(Query, TableNameConverter, boolean).

Parameters:

query - The Query instance from which to determine the WHERE properties.

Returns:

The database-specific SQL rendering of the WHERE portion of the query.

renderQueryGroupBy

protected String renderQueryGroupBy(Query query)

Renders the GROUP BY portion of the query in the database-specific SQL dialect. Very few databases deviate from the standard in this matter, thus the default implementation is usually sufficient.

An example return value: " GROUP BY name"

There is usually no need to call this method directly. Under normal operations it functions as a delegate for renderQuery(Query, TableNameConverter, boolean).

Parameters:

query - The Query instance from which to determine the GROUP BY properties.

Returns:

The database-specific SQL rendering of the GROUP BY portion of the query.

renderQueryOrderBy

protected String renderQueryOrderBy(Query query)

Renders the ORDER BY portion of the query in the database-specific SQL dialect. Very few databases deviate from the standard in this matter, thus the default implementation is usually sufficient.

An example return value: " ORDER BY name ASC"

There is usually no need to call this method directly. Under normal operations it functions as a delegate for renderQuery(Query, TableNameConverter, boolean).

Parameters:

query - The Query instance from which to determine the ORDER BY properties.

Returns:

The database-specific SQL rendering of the ORDER BY portion of the query.

processOrderClause

public final String processOrderClause(String order)

renderQueryLimit

protected String renderQueryLimit(Query query)

Renders 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 setQueryResultSetProperties(ResultSet, Query) and 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 renderQuery(Query, TableNameConverter, boolean).

Parameters:

query - The Query instance from which to determine the LIMIT properties.

Returns:

The database-specific SQL rendering of the LIMIT portion of the query.

getConnection

public final Connection getConnection()
                               throws SQLException

Retrieves a JDBC Connection instance which corresponds to the database represented by the provider instance. This Connection can be used to execute arbitrary JDBC operations against the database. Also, this is the method used by the whole of ActiveObjects itself to get database connections when required.

All Connection instances are pooled internally by thread. Thus, there is never more than one connection per thread. This is necessary to allow arbitrary JDBC operations within a transaction without breaking transaction integrity. Developers using this method should bear this fact in mind and consider the Connection instance immutable. The only exception is if one is absolutely certain that the JDBC code in question is not being executed within a transaction.

Despite the fact that there is only a single connection per thread, the Connection instances returned from this method should still be treated as bona fide JDBC connections. They can and should be closed when their usage is complete. This is especially important when actual connection pooling is in use and non-disposal of connections can lead to a crash as the connection pool runs out of resources. The developer need not concern themselves with the single-connection-per-thread issue when closing the connection as the call to close() will be intercepted and ignored if necessary.

Returns:

A new connection to the database

Throws:

SQLException

startTransaction

public final Connection startTransaction()
                                  throws SQLException

Throws:

SQLException

commitTransaction

public final Connection commitTransaction(Connection c)
                                   throws SQLException

Throws:

SQLException

rollbackTransaction

public final void rollbackTransaction(Connection c)
                               throws SQLException

Throws:

SQLException

dispose

public void dispose()

Frees any resources held by the database provider or delegate libraries (such as connection pools). This method should be once usage of the provider is complete to ensure that all connections are committed and closed.

Specified by:

dispose in interface Disposable

setPostConnectionProperties

protected void setPostConnectionProperties(Connection conn)
                                    throws SQLException

Called to make any post-creation modifications to a new Connection instance. This is used for databases such as Derby which require the schema to be set after the connection is created.

Parameters:

conn - The connection to modify according to the database requirements.

Throws:

SQLException

renderConstraintsForTable

protected String renderConstraintsForTable(UniqueNameConverter uniqueNameConverter,
                               DDLTable table)

Renders the foreign key constraints in database-specific DDL for the table in question. Actually, this method only loops through the foreign keys and renders indentation and line-breaks. The actual rendering is done in a second delegate method.

Parameters:

uniqueNameConverter -

table - The database-agnostic DDL representation of the table in question.

Returns:

The String rendering of all of the foreign keys for the table.

See Also:

renderForeignKey(DDLForeignKey)

renderForeignKey

protected String renderForeignKey(DDLForeignKey key)

Renders the specified foreign key representation into the database-specific DDL. The implementation must name the foreign key according to the DDLForeignKey#getFKName() value otherwise migrations will no longer function appropriately.

Parameters:

key - The database-agnostic foreign key representation.

Returns:

The database-pecific DDL fragment corresponding to the foreign key in question.

convertTypeToString

protected String convertTypeToString(TypeInfo<?> type)

Converts the specified type into the database-specific DDL String value. By default, this delegates to the DatabaseType#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.

Parameters:

type - The type instance to convert to a DDL string.

Returns:

The database-specific DDL representation of the type (e.g. "VARCHAR").

renderTable

protected final SQLAction renderTable(NameConverters nameConverters,
                    DDLTable table)

Renders the specified table representation into the corresponding database-specific DDL statement. For legacy reasons, this only allows single-statement table creation. Additional statements (triggers, functions, etc) must be created in one of the other delegate methods for DDL creation. This method does a great deal of delegation to other DatabaseProvider methods for functions such as field rendering, foreign key rendering, etc.

Parameters:

nameConverters -

table - The database-agnostic table representation.

Returns:

The database-specific DDL statements which correspond to the specified table creation.

renderPrimaryKey

protected String renderPrimaryKey(String tableName,
                      String pkFieldName)

renderInsert

protected SQLAction renderInsert(DDLTable ddlTable,
                     DDLValue[] ddlValues)

renderDropTableStatement

protected SQLAction renderDropTableStatement(DDLTable table)

Generates the appropriate database-specific DDL statement to drop the specified table representation. The default implementation is merely "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)).

Parameters:

table - The table representation which is to be dropped.

Returns:

A database-specific DDL statement which drops the specified table.

renderAccessories

protected final Iterable<SQLAction> renderAccessories(NameConverters nameConverters,
                                    DDLTable table)

Generates the database-specific DDL statements required to create all of the functions, sequences, and triggers necessary for the given table, by calling renderAccessoriesForField(NameConverters, DDLTable, DDLField) for each of the table's fields. Each returned SQLAction has a correspondingundo action that deletes the corresponding function, sequence, or trigger.

Parameters:

nameConverters -

table - The table for which the objects must be generated.

Returns:

An ordered list of SQLActions.

renderDropAccessories

protected final Iterable<SQLAction> renderDropAccessories(NameConverters nameConverters,
                                        DDLTable table)

Generates the database-specific DDL statements required to drop all of the functions, sequences, and triggers associated with the given table, by calling renderDropAccessoriesForField(NameConverters, DDLTable, DDLField) for each of the table's fields.

Parameters:

nameConverters -

table - The table for which the objects must be dropped.

Returns:

An ordered list of SQLActions.

renderAccessoriesForField

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. Each returned SQLAction should have a corresponding undo action that deletes the corresponding function, sequence, or trigger. The default implementation returns an empty list.

Parameters:

nameConverters -

table -

field -

Returns:

an ordered list of SQLActions

renderDropAccessoriesForField

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. The default implementation returns an empty list.

Parameters:

nameConverters -

table -

field -

Returns:

an ordered list of SQLActions

renderFields

protected final Iterable<SQLAction> renderFields(DDLTable table,
                               com.google.common.base.Predicate<DDLField> filter,
                               com.google.common.base.Function<DDLField,Iterable<SQLAction>> render)

renderAlterTableAddColumn

protected Iterable<SQLAction> renderAlterTableAddColumn(NameConverters nameConverters,
                                            DDLTable table,
                                            DDLField field)

Generates the database-specific DDL statements required to add a column to an existing table. Included in the return value should be the statements required to add all necessary functions and triggers to ensure that the column acts appropriately. For example, if the field is tagged with an @OnUpdate annotation, chances are there will be a trigger and possibly a function along with the ALTER statement. These "extra" functions are properly ordered and will only be appended if their values are not null. Because of this, very few database providers will need to override this method.

Each SQLAction should have a corresponding undo action; these will be executed in reverse order if the action needs to be rolled back.

Parameters:

nameConverters -

table - The table which should receive the new column.

field - The column to add to the specified table.

Returns:

An array of DDL statements to execute.

See Also:

#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)

renderAlterTableAddColumnStatement

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.

Parameters:

nameConverters -

table - The table which should receive the new column.

field - The column to add to the specified table.

Returns:

A DDL statements to execute.

renderAlterTableChangeColumn

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. 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 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.

Parameters:

nameConverters -

table - 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.

See Also:

#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)

renderFieldOptionsInAlterColumn

protected DatabaseProvider.RenderFieldOptions renderFieldOptionsInAlterColumn()

renderAlterTableChangeColumnStatement

protected SQLAction renderAlterTableChangeColumnStatement(NameConverters nameConverters,
                                              DDLTable table,
                                              DDLField oldField,
                                              DDLField field,
                                              DatabaseProvider.RenderFieldOptions options)

Generates the database-specific DDL statement only for altering a table and changing a column. This method must only generate a single statement as it does not need to concern itself with functions or triggers associated with the column. This method is only to be called as a delegate for the renderAlterTableChangeColumn(net.java.ao.schema.NameConverters, net.java.ao.schema.ddl.DDLTable, net.java.ao.schema.ddl.DDLField, net.java.ao.schema.ddl.DDLField) method, for which it is a primary delegate. The default implementation of this method functions according to the MySQL specification.

Parameters:

nameConverters -

table - The table containing the column to change.

oldField - The old column definition.

field - The new column definition (defining the resultant DDL).

options -

Returns:

A single DDL statement which is to be executed.

See Also:

renderField(net.java.ao.schema.NameConverters, net.java.ao.schema.ddl.DDLTable, net.java.ao.schema.ddl.DDLField, net.java.ao.DatabaseProvider.RenderFieldOptions)

renderAlterTableDropColumn

protected Iterable<SQLAction> renderAlterTableDropColumn(NameConverters nameConverters,
                                             DDLTable table,
                                             DDLField field)

Generates the database-specific DDL statements required to remove the specified column from the given table. This should also generate the necessary statements to drop all triggers and functions associated with the column in question. If the database being implemented has a non-standard syntax for dropping functions and/or triggers, it may be required to override this method, even if the syntax to drop columns is standard.

Parameters:

nameConverters -

table - The table from which to drop the column.

field - The column definition to remove from the table.

Returns:

An array of DDL statements to be executed.

See Also:

#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)

renderAlterTableDropColumnStatement

protected SQLAction renderAlterTableDropColumnStatement(DDLTable table,
                                            DDLField field)

renderAlterTableAddKey

protected SQLAction renderAlterTableAddKey(DDLForeignKey key)

Generates the database-specific DDL statement required to add a foreign key to a table. For databases which do not support such a statement, a warning should be printed to stderr and a null value returned.

Parameters:

key - The foreign key to be added. As this instance contains all necessary data (such as domestic table, field, etc), no additional parameters are required.

Returns:

A DDL statement to be executed, or null.

See Also:

renderForeignKey(DDLForeignKey)

renderAlterTableDropKey

protected SQLAction renderAlterTableDropKey(DDLForeignKey key)

Generates the database-specific DDL statement required to remove a foreign key from a table. For databases which do not support such a statement, a warning should be printed to stderr and a null value returned. This method assumes that the renderForeignKey(DDLForeignKey) method properly names the foreign key according to the DDLForeignKey.getFKName() method.

Parameters:

key - The foreign key to be removed. As this instance contains all necessary data (such as domestic table, field, etc), no additional parameters are required.

Returns:

A DDL statement to be executed, or null.

renderCreateIndex

protected SQLAction renderCreateIndex(IndexNameConverter indexNameConverter,
                          DDLIndex index)

Generates the database-specific DDL statement required to create a new index. The syntax for this operation is highly standardized and thus it is unlikely this method will be overridden. If the database in question does not support indexes, a warning should be printed to stderr and null returned.

Parameters:

indexNameConverter -

index - The index to create. This single instance contains all of the data necessary to create the index, thus no separate parameters (such as a DDLTable) are required.

Returns:

A DDL statement to be executed.

renderDropIndex

protected SQLAction renderDropIndex(IndexNameConverter indexNameConverter,
                        DDLIndex index)

Generates the database-specific DDL statement required to drop an index. The syntax for this operation is highly standardized and thus it is unlikely this method will be overridden. If the database in question does not support indexes, a warning should be printed to stderr and null returned.

Parameters:

indexNameConverter -

index - 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.

Returns:

A DDL statement to be executed, or null.

hasIndex

protected boolean hasIndex(IndexNameConverter indexNameConverter,
               DDLIndex index)

getExistingIndexName

protected String getExistingIndexName(IndexNameConverter indexNameConverter,
                          DDLIndex index)

hasIndex

protected boolean hasIndex(String tableName,
               String indexName)

renderAppend

protected String renderAppend()

Generates any database-specific options which must be appended to the end of a table definition. The only database I am aware of which requires this is MySQL. For example:

CREATE TABLE test (
     id INTEGER NOT NULL AUTO_INCREMENT,
     name VARCHAR(45),
     PRIMARY KEY(id)
 ) ENGINE=InnoDB;

The "ENGINE=InnoDB" clause is what is returned by this method. The default implementation simply returns null, signifying that no append should be rendered.

Returns:

A DDL clause to be appended to the CREATE TABLE DDL, or null

renderField

protected final String renderField(NameConverters nameConverters,
                 DDLTable table,
                 DDLField field,
                 DatabaseProvider.RenderFieldOptions options)

Generates the database-specific DDL fragment required to render the field and its associated type. This includes all field attributes, such as @NotNull, @AutoIncrement (if supported by the database at the field level) and so on. Sample return value:

name VARCHAR(255) DEFAULT "Skye" NOT NULL

Certain databases don't allow defined precision for certain types (such as Derby and INTEGER). The logic for whether or not to render precision should not be within this method, but delegated to the #considerPrecision(DDLField) method.

Almost all functionality within this method is delegated to other methods within the implementation. As such, it is almost never necessary to override this method directly. An exception to this would be a database like PostgreSQL which requires a different type for auto-incremented fields.

Parameters:

nameConverters -

table -

field - The field to be rendered.

options -

Returns:

A DDL fragment to be embedded in a statement elsewhere.

renderFieldDefault

protected String renderFieldDefault(DDLTable table,
                        DDLField field)

renderValue

protected String renderValue(Object value)

Renders the given Java instance in a database-specific way. This method handles special cases such as Calendar, Boolean (which is always rendered as 0/1), functions, null and numbers. All other values are rendered (by default) as 'value.toString()' (the String value enclosed within single quotes). Implementations are encouraged to override this method as necessary.

Parameters:

value - The Java instance to be rendered as a database literal.

Returns:

The database-specific String rendering of the instance in question.

See Also:

renderDate(Date)

renderDate

protected String renderDate(Date date)

Renders the provided Date instance as a DATETIME literal in the database-specific format. The return value should not be enclosed within quotes, as this is accomplished within other functions when rendering is required. This method is actually a boiler-plate usage of the SimpleDateFormat class, using the date format defined within the getDateFormat() method.

Parameters:

date - The time instance to be rendered.

Returns:

The database-specific String representation of the time.

renderUnique

protected String renderUnique(UniqueNameConverter uniqueNameConverter,
                  DDLTable table,
                  DDLField field)

Renders the UNIQUE constraint as defined by the database-specific DDL syntax. This method is a delegate of other, more complex methods such as 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.

Parameters:

uniqueNameConverter -

table -

field -

Returns:

The database-specific rendering of UNIQUE.

getDateFormat

protected String getDateFormat()

Returns the database-specific TIMESTAMP text format as defined by the SimpleDateFormat 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

Returns:

The database-specific TIMESTAMP text format

renderFieldType

protected String renderFieldType(DDLField field)

Renders the database-specific DDL type for the field in question. This method merely delegates to the convertTypeToString(TypeInfo) method, passing the field type. Thus, it is rarely necessary (if ever) to override this method. It may be deprecated in a future release.

Parameters:

field - The field which contains the type to be rendered.

Returns:

The database-specific type DDL rendering.

handleBlob

public Object handleBlob(ResultSet res,
                Class<?> type,
                String field)
                  throws SQLException

Throws:

SQLException

_getTriggerNameForField

protected String _getTriggerNameForField(TriggerNameConverter triggerNameConverter,
                             DDLTable table,
                             DDLField field)

Retrieves the name of the trigger which corresponds to the field in question (if any). If no trigger will be automatically created for the specified field, null should be returned. This function is to allow for databases which require the use of triggers on a field to allow for certain functionality (like ON UPDATE). The default implementation returns null.

Parameters:

triggerNameConverter -

table - The table which contains the field for which a trigger may or may not exist.

field - The field for which a previous migration may have created a trigger.

Returns:

The unique name of the trigger which was created for the field, or null if none.

See Also:

#renderTriggerForField(net.java.ao.schema.TriggerNameConverter, net.java.ao.schema.SequenceNameConverter, net.java.ao.schema.ddl.DDLTable, net.java.ao.schema.ddl.DDLField)

_renderTriggerForField

protected SQLAction _renderTriggerForField(NameConverters nameConverters,
                               DDLTable table,
                               DDLField field)

Renders the trigger which corresponds to the specified field, or null 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.

Parameters:

nameConverters -

table - 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. @return A database-specific DDL statement creating a trigger for the field in question, or null.

See Also:

#getTriggerNameForField(net.java.ao.schema.TriggerNameConverter, net.java.ao.schema.ddl.DDLTable, net.java.ao.schema.ddl.DDLField)

_renderDropTriggerForField

protected SQLAction _renderDropTriggerForField(NameConverters nameConverters,
                                   DDLTable table,
                                   DDLField field)

Renders SQL statement(s) to drop the trigger which corresponds to the specified field, or null if none.

Parameters:

nameConverters -

table - 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. @return A database-specific DDL statement to drop a trigger for the field in question, or null.

_getFunctionNameForField

protected String _getFunctionNameForField(TriggerNameConverter triggerNameConverter,
                              DDLTable table,
                              DDLField field)

Retrieves the name of the function which corresponds to the field in question (if any). If no function will be automatically created for the specified field, null should be returned. This method is to allow for databases which require the use of explicitly created functions which correspond to triggers (e.g. PostgreSQL). Few providers will need to override the default implementation of this method, which returns null.

Parameters:

triggerNameConverter -

table - The table which contains the field for which a function may or may not exist.

field - The field for which a previous migration may have created a function.

Returns:

The unique name of the function which was created for the field, or null if none.

_renderFunctionForField

protected SQLAction _renderFunctionForField(NameConverters nameConverters,
                                DDLTable table,
                                DDLField field)

Renders the function which corresponds to the specified field, or null if none. This is to allow for databases which require the use of triggers and explicitly created functions to provide functionality such as ON UPDATE (e.g. PostgreSQL). The default implementation returns null.

Parameters:

nameConverters -

table - The table containing the field for which a function may need to be rendered.

field - The field for which the function should be rendered, if any.

Returns:

A database-specific DDL statement creating a function for the field in question, or null.

See Also:

#getFunctionNameForField(net.java.ao.schema.TriggerNameConverter, net.java.ao.schema.ddl.DDLTable, net.java.ao.schema.ddl.DDLField)

_renderDropFunctionForField

protected SQLAction _renderDropFunctionForField(NameConverters nameConverters,
                                    DDLTable table,
                                    DDLField field)

Renders SQL statement(s) to drop the function which corresponds to the specified field, if applicable, or null otherwise.

Parameters:

nameConverters -

table - The table containing the field for which a function may need to be rendered.

field - The field for which the function should be rendered, if any.

Returns:

A database-specific DDL statement to drop a function for the field in question, or null.

_renderSequenceForField

protected SQLAction _renderSequenceForField(NameConverters nameConverters,
                                DDLTable table,
                                DDLField field)

Renders the SQL for creating a sequence for the specified field, or null if none. The default implementation returns null.

Parameters:

nameConverters -

table - The table containing the field for which a sequence may need to be rendered.

field - The field for which the sequence should be rendered, if any.

Returns:

A database-specific DDL statement creating a sequence for the field in question, or null.

_renderDropSequenceForField

protected SQLAction _renderDropSequenceForField(NameConverters nameConverters,
                                    DDLTable table,
                                    DDLField field)

Renders SQL statement(s) to drop the sequence which corresponds to the specified field, or null if none.

insertReturningKey

public <T extends RawEntity<K>,K> K insertReturningKey(EntityManager manager,
                                              Connection conn,
                                              Class<T> entityType,
                                              Class<K> pkType,
                                              String pkField,
                                              boolean pkIdentity,
                                              String table,
                                              DBParam... params)
                     throws SQLException

Generates an INSERT statement to be used to create a new row in the database, returning the primary key value. This method also invokes the delegate method, #executeInsertReturningKey(EntityManager, java.sql.Connection, Class, String, String, DBParam...) passing the appropriate parameters and query. This method is required because some databases do not support the JDBC parameter RETURN_GENERATED_KEYS (such as HSQLDB and PostgreSQL). Also, some databases (such as MS SQL Server) require odd tricks to support explicit value passing to auto-generated fields. This method should take care of any extra queries or odd SQL generation required to implement both auto-generated primary key returning, as well as explicit primary key value definition.

Overriding implementations of this method should be sure to use the Connection instance passed to the method, not a new instance generated using the getConnection() method. This is because this method is in fact a delegate invoked by EntityManager as part of the entity creation process and may be part of a transaction, a bulk creation or some more complicated operation. Both optimization and usage patterns on the API dictate that the specified connection instance be used. Implementations may assume that the given connection instance is never null.

The default implementation of this method should be sufficient for any fully compliant ANSI SQL database with a properly implemented JDBC driver. Note that this method should not not actually execute the SQL it generates, but pass it on to the #executeInsertReturningKey(EntityManager, java.sql.Connection, Class, String, String, DBParam...) method, allowing for functional delegation and better extensibility. However, this method may execute any additional statements required to prepare for the INSERTion (as in the case of MS SQL Server which requires some config parameters to be set on the database itself prior to INSERT).

Parameters:

manager - The EntityManager which was used to dispatch the INSERT in question.

conn - The connection to be used in the eventual execution of the generated SQL statement.

entityType - The Java class of the entity.

pkType - The Java type of the primary key value. Can be used to perform a linear search for a specified primary key value in the params list. The return value of the method must be of the same type.

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.

pkIdentity - Flag indicating whether or not the primary key field is auto-incremented by the database (IDENTITY field).

table - The name of the table into which the row is to be INSERTed.

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.

See Also:

#executeInsertReturningKey(EntityManager, java.sql.Connection, Class, String, String, DBParam...)

executeInsertReturningKey

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

Delegate 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 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.

Parameters:

manager - 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.

Throws:

SQLException

See Also:

#insertReturningKey(EntityManager, Connection, Class, String, boolean, String, DBParam...)

putNull

public void putNull(PreparedStatement stmt,
           int index)
             throws SQLException

Stores an SQL NULL 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.

Parameters:

stmt - The statement in which to store the NULL value.

index - The index of the parameter which should be assigned NULL.

Throws:

SQLException

putBoolean

public void putBoolean(PreparedStatement stmt,
              int index,
              boolean value)
                throws SQLException

Stors an SQL BOOLEAN 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.

Parameters:

stmt - 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.

Throws:

SQLException

isNumericType

protected boolean isNumericType(int type)

Simple helper function used to determine of the specified JDBC type is representitive of a numeric type. The definition of numeric type in this case may be assumed to be any type which has a corresponding (or coercibly corresponding) Java class which is a subclass of Number. The default implementation should be suitable for every conceivable use-case.

Parameters:

type - The JDBC type which is to be tested.

Returns:

true if the specified type represents a numeric type, otherwise false.

processOnClause

protected String processOnClause(String on)

processWhereClause

public final String processWhereClause(String where)

Processes the where clause to make it compatible with the given database. By default it simply escapes IDs that need to be.

Parameters:

where - the raw where clause,

Returns:

the processed where clause compatible with the database in use.

See Also:

processID(String)

processID

public final String processID(String id)

Performs any database specific post-processing on the specified identifier. This usually means quoting reserved words, though it could potentially encompass other tasks. This method is called with unbelievable frequency and thus must return extremely quickly.

The default implementation checks two factors: max identifier length and whether or not it represents a reserved word in the underlying database. If the identifier excedes the maximum ID length for the database in question, the excess text will be hashed against the hash code for the whole and concatenated with the leading remainder. The shouldQuoteID(String) method is utilitized to determine whether or not the identifier in question should be quoted. For most databases, this involves checking a set of reserved words, but the method is flexible enough to allow more complex "reservations rules" (such as those required by Oracle). If the identifier is reserved in any way, the database-specific quoting string will be retrieved from DatabaseMetaData and used to enclose the identifier. This method cannot simply quote all identifiers by default due to the way that some databases (such as HSQLDB and PostgreSQL) attach extra significance to quoted fields.

The general assurance of this method is that for any input identfier, this method will return a correspondingly-unique identifier which is guarenteed to be valid within the underlying database.

Parameters:

id - The identifier to process.

Returns:

A unique identifier corresponding with the input which is guaranteed to function within the underlying database.

See Also:

getMaxIDLength(), shouldQuoteID(String)

withSchema

public final String withSchema(String tableName)

isSchemaNotEmpty

protected final boolean isSchemaNotEmpty()

shorten

public final String shorten(String id)

quote

public final String quote(String id)

shouldQuoteID

protected boolean shouldQuoteID(String id)

Determines whether or not the specified identifier should be quoted before transmission to the underlying database. The default implementation transforms the identifier into all-upper-case and checks the result against getReservedWords(). Databases with more complicated rules regarding quoting should provide a custom implementation of this method.

Parameters:

id - The identifier to check against the quoting rules.

Returns:

true if the specified identifier is invalid under the relevant quoting rules, otherwise false.

getMaxIDLength

protected int getMaxIDLength()

Returns the maximum length for any identifier in the underlying database. If the database defines different maximum lengths for different identifier types, the minimum value should be returned by this method. By default, this just returns Integer.MAX_VALUE.

Returns:

The maximum identifier length for the database.

getReservedWords

protected abstract Set<String> getReservedWords()

Retrieves the set of all reserved words for the underlying database. The set returns should be speculative, meaning that it should include any possible reserved words, not just those for a particular version. As an implementation guideline, the Set instance returned from this method should guarentee O(1) lookup times, otherwise ORM performance will suffer greatly.

Returns:

A set of upper case reserved words specific to the database.

isCaseSensitive

public boolean isCaseSensitive()

Flag indicating whether or not the underlying database uses case-sensitive identifiers. This specifically affects comparisons in the SchemaReader utility. The default value is true. Note that databases which support both case-sensetive and case-insensetive identifiers (like MySQL) should return true for better all-around compatibility.

Returns:

boolean true if identifiers are case-sensetive, false otherwise.

handleUpdateError

public void handleUpdateError(String sql,
                     SQLException e)
                       throws SQLException

Tells whether this exception should be ignored when running an updated statement. Typically, errors on dropping non-existing objects should be ignored.

Parameters:

sql -

e - the SQLException that occured.

Throws:

SQLException - throws the SQLException if it should not be ignored.

preparedStatement

public final PreparedStatement preparedStatement(Connection c,
                                  CharSequence sql)
                                          throws SQLException

Throws:

SQLException

preparedStatement

public final PreparedStatement preparedStatement(Connection c,
                                  CharSequence sql,
                                  int autoGeneratedKeys)
                                          throws SQLException

Throws:

SQLException

preparedStatement

public final PreparedStatement preparedStatement(Connection c,
                                  CharSequence sql,
                                  int resultSetType,
                                  int resultSetConcurrency)
                                          throws SQLException

Throws:

SQLException

executeUpdate

public final void executeUpdate(Statement stmt,
                 CharSequence sql)
                         throws SQLException

Throws:

SQLException

executeUpdatesForActions

public final Iterable<String> executeUpdatesForActions(Statement stmt,
                                        Iterable<SQLAction> actions,
                                        Set<String> completedStatements)
                                                throws SQLException

Attempt to execute a list of actions that make up a logical unit (e.g. adding an entire table, or adding a new column to an existing table). If any action fails, throw an SQLException, but first go backward through all successfully completed actions in this list and execute their corresponding undo action, if any. For instance, if we successfully executed a CREATE TABLE and a CREATE SEQUENCE, but the next statement fails, we will execute DROP SEQUENCE and then DROP TABLE before rethrowing the exception.

Parameters:

provider -

stmt - A JDBC Statement that will be reused for all updates

actions - A list of SQLActions to execute

completedStatements - A set of SQL statements that should not be executed if we encounter the same one again. This is necessary because our schema diff logic is not as smart as it could be, so it may tell us, for instance, to create an index for a new column even though the statements for creating the column also included creation of the index.

Returns:

all SQL statements that were executed

Throws:

SQLException

executeUpdateForAction

public final Iterable<String> executeUpdateForAction(Statement stmt,
                                      SQLAction action,
                                      Set<String> completedStatements)
                                              throws SQLException

Throws:

SQLException

addSqlListener

public final void addSqlListener(DatabaseProvider.SqlListener l)

removeSqlListener

public final void removeSqlListener(DatabaseProvider.SqlListener l)

onSql

protected final void onSql(String sql)

findForeignKeysForField

protected Iterable<DDLForeignKey> findForeignKeysForField(DDLTable table,
                                              DDLField field)