Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## net.java.ao.db
Class ClientDerbyDatabaseProvider

    java.lang.Object
      net.java.ao.DatabaseProvider
          net.java.ao.db.ClientDerbyDatabaseProvider

    public class ClientDerbyDatabaseProvider

extends DatabaseProvider

Author:
  Daniel Spiewak

Field Summary

Fields inherited from class net.java.ao.DatabaseProvider
`eventManager`

Constructor Summary
`ClientDerbyDatabaseProvider(DisposableDataSource dataSource)`

Method Summary
`protected boolean` | `considerPrecision(DDLField field)` Determines whether or not the database allows explicit precisions for the field in question.
`protected String` | `convertTypeToString(DatabaseType<?> type)` Converts the specified type into the database-specific DDL String value.
`protected Set<String>` | `getReservedWords()` Retrieves the set of all reserved words for the underlying database.
`ResultSet` | `getTables(Connection conn)` Returns a result set of all of the tables (and associated meta) in the database.
`protected String` | `getTriggerNameForField(DDLTable table, DDLField field)` Retrieves the name of the trigger which corresponds to the field in question (if any).
`Object` | `handleBlob(ResultSet res, Class<?> type, String field)`
`boolean` | `isCaseSensetive()` Flag indicating whether or not the underlying database uses case-sensetive identifiers.
`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.
`protected String[]` | `renderAlterTableChangeColumn(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 String[]` | `renderAlterTableDropColumn(DDLTable table, DDLField field)` Generates the database-specific DDL statements required to remove the specified column from the given table.
`protected String` | `renderAutoIncrement()` Generates the DDL fragment required to specify an INTEGER field as auto-incremented.
`protected String` | `renderDropIndex(DDLIndex index)` Generates the database-specific DDL statement required to drop an index.
`protected String` | `renderOnUpdate(DDLField field)` Renders the appropriate field suffix to allow for the `OnUpdate` functionality.
`protected String` | `renderQueryLimit(Query query)` Renders the LIMIT portion of the query in the database-specific SQL dialect.
`protected String` | `renderTriggerForField(DDLTable table, DDLField field)` Renders the trigger which corresponds to the specified field, or `null` if none.
`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.

Methods inherited from class net.java.ao.DatabaseProvider
`dispose, executeInsertReturningKey, getConnection, getDateFormat, getEventManager, getFunctionNameForField, getMaxIDLength, getSequences, handleUpdateError, insertReturningKey, isNumericType, processID, processWhereClause, putBoolean, putNull, renderAction, renderAlterTableAddColumn, renderAlterTableAddKey, renderAlterTableChangeColumnStatement, renderAlterTableDropKey, renderAppend, renderCalendar, renderConstraintsForTable, renderCreateIndex, renderDropFunctions, renderDropSequences, renderDropTable, renderDropTriggers, renderField, renderFieldPrecision, renderFieldType, renderForeignKey, renderFunction, renderFunctionForField, renderFunctions, renderInsert, renderQuery, renderQueryGroupBy, renderQueryJoins, renderQueryOrderBy, renderQuerySelect, renderQueryWhere, renderSequences, renderTable, renderTriggers, renderUnique, renderValue, setEventManager, shouldQuoteID`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### ClientDerbyDatabaseProvider

    public ClientDerbyDatabaseProvider(DisposableDataSource dataSource)

Method Detail

### setPostConnectionProperties

    protected void setPostConnectionProperties(Connection conn)
                                        throws SQLException

  Description copied from class: `DatabaseProvider`
  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`

### setQueryStatementProperties

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

  Description copied from class: `DatabaseProvider`

  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.

  Overrides:
    `setQueryStatementProperties` in class `DatabaseProvider`
  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

  Description copied from class: `DatabaseProvider`
  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).

  Overrides:
    `setQueryResultSetProperties` in class `DatabaseProvider`
  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

  Description copied from class: `DatabaseProvider`

  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.

  Overrides:
    `getTables` in class `DatabaseProvider`
  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[])`

### parseValue

    public Object parseValue(int type,
                             String value)

  Description copied from class: `DatabaseProvider`

  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)

  Overrides:
    `parseValue` in class `DatabaseProvider`
  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.

### renderQueryLimit

    protected String renderQueryLimit(Query query)

  Description copied from class: `DatabaseProvider`

  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 `DatabaseProvider.setQueryResultSetProperties(ResultSet, Query)` and `DatabaseProvider.setQueryStatementProperties(Statement, Query)`.

  An example return value: `" LIMIT 10,2"`

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

  Overrides:
    `renderQueryLimit` in class `DatabaseProvider`
  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.

### convertTypeToString

    protected String convertTypeToString(DatabaseType<?> type)

  Description copied from class: `DatabaseProvider`
  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.

  Overrides:
    `convertTypeToString` in class `DatabaseProvider`
  Parameters:
    `type` - The type instance to convert to a DDL string.
  Returns:
    The database-specific DDL representation of the type (e.g. "VARCHAR").
  See Also:
    `DatabaseType.getDefaultName()`

### renderAutoIncrement

    protected String renderAutoIncrement()

  Description copied from class: `DatabaseProvider`

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

  Overrides:
    `renderAutoIncrement` in class `DatabaseProvider`

### renderOnUpdate

    protected String renderOnUpdate(DDLField field)

  Description copied from class: `DatabaseProvider`

  Renders the appropriate field suffix to allow for the `OnUpdate` functionality. For most databases (read: all but MySQL) this will return an empty String. This is because few databases provide an implicit ON UPDATE syntax for fields. As such, most databases will be compelled to return an empty String and implement the functionality using triggers.

  Overrides:
    `renderOnUpdate` in class `DatabaseProvider`
  Parameters:
    `field` - The field for which the ON UPDATE clause should be rendered.
  Returns:
    The database-specific ON UPDATE field clause.

### handleBlob

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

  Overrides:
    `handleBlob` in class `DatabaseProvider`
  Throws:
    `SQLException`

### renderTriggerForField

    protected String renderTriggerForField(DDLTable table,
                                           DDLField field)

  Description copied from class: `DatabaseProvider`
  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`.

  Overrides:
    `renderTriggerForField` in class `DatabaseProvider`
  Parameters:
    `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.
  Returns:
    A database-specific DDL statement creating a trigger for the field in question, or `null`.
  See Also:
    `DatabaseProvider.getTriggerNameForField(DDLTable, DDLField)`

### getTriggerNameForField

    protected String getTriggerNameForField(DDLTable table,
                                            DDLField field)

  Description copied from class: `DatabaseProvider`
  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`.

  Overrides:
    `getTriggerNameForField` in class `DatabaseProvider`
  Parameters:
    `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:
    `DatabaseProvider.renderTriggerForField(DDLTable, DDLField)`

### considerPrecision

    protected boolean considerPrecision(DDLField field)

  Description copied from class: `DatabaseProvider`

  Determines whether or not the database allows explicit precisions for the field in question. This is to support databases such as Derby which do not support precisions for certain types. By default, this method returns `true`.

  More often than not, all that is required for this determination is the type. As such, the method signature may change in a future release.

  Overrides:
    `considerPrecision` in class `DatabaseProvider`
  Parameters:
    `field` - The field for which precision should/shouldn't be rendered.
  Returns:
    `true` if precision should be rendered, otherwise `false`.

### renderAlterTableChangeColumn

    protected String[] renderAlterTableChangeColumn(DDLTable table,
                                                    DDLField oldField,
                                                    DDLField field)

  Description copied from class: `DatabaseProvider`

  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 `DatabaseProvider.renderAlterTableChangeColumnStatement(DDLTable, DDLField, DDLField)` method.

  Overrides:
    `renderAlterTableChangeColumn` in class `DatabaseProvider`
  Parameters:
    `table` - The table containing the column to change.
    `oldField` - The old column definition.
    `field` - The new column definition (defining the resultant DDL).
  Returns:
    An array of DDL statements to be executed.
  See Also:
    `DatabaseProvider.getTriggerNameForField(DDLTable, DDLField)`, `DatabaseProvider.getFunctionNameForField(DDLTable, DDLField)`, `DatabaseProvider.renderFunctionForField(DDLTable, DDLField)`, `DatabaseProvider.renderTriggerForField(DDLTable, DDLField)`

### renderAlterTableDropColumn

    protected String[] renderAlterTableDropColumn(DDLTable table,
                                                  DDLField field)

  Description copied from class: `DatabaseProvider`
  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.

  Overrides:
    `renderAlterTableDropColumn` in class `DatabaseProvider`
  Parameters:
    `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:
    `DatabaseProvider.getTriggerNameForField(DDLTable, DDLField)`, `DatabaseProvider.getFunctionNameForField(DDLTable, DDLField)`

### renderDropIndex

    protected String renderDropIndex(DDLIndex index)

  Description copied from class: `DatabaseProvider`
  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.

  Overrides:
    `renderDropIndex` in class `DatabaseProvider`
  Parameters:
    `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`.

### getReservedWords

    protected Set<String> getReservedWords()

  Description copied from class: `DatabaseProvider`
  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.

  Specified by:
    `getReservedWords` in class `DatabaseProvider`
  Returns:
    A set of upper case reserved words specific to the database.

### isCaseSensetive

    public boolean isCaseSensetive()

  Description copied from class: `DatabaseProvider`
  Flag indicating whether or not the underlying database uses case-sensetive 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.

  Overrides:
    `isCaseSensetive` in class `DatabaseProvider`
  Returns:
    boolean `true` if identifiers are case-sensetive, `false` otherwise.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2007-2011. All Rights Reserved.