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 PostgreSQLDatabaseProvider

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

    public class PostgreSQLDatabaseProvider

extends DatabaseProvider

Author:
  Daniel Spiewak

Field Summary

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

Constructor Summary
`PostgreSQLDatabaseProvider(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
`<T> T`
` | `executeInsertReturningKey(EntityManager manager, Connection conn, Class<T> pkType, String pkField, String sql, DBParam... params)` Delegate method to execute an INSERT statement returning any auto-generated primary key values.
`protected String` | `getFunctionNameForField(DDLTable table, DDLField field)` Retrieves the name of the function which corresponds to the field in question (if any).
`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)`
`void` | `handleUpdateError(SQLException e)` Tells whether this exception should be ignored when running an updated statement.
`
`<T> T`
` | `insertReturningKey(EntityManager manager, Connection conn, Class<T> 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.
`Object` | `parseValue(int type, String value)` Parses the database-agnostic `String` value relevant to the specified SQL type in `int` form (as defined by `Types` and returns the Java value which corresponds.
`void` | `putNull(PreparedStatement stmt, int index)` Stores an SQL `NULL` value in the database.
`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` | `renderAlterTableDropKey(DDLForeignKey key)` Generates the database-specific DDL statement required to remove a foreign key from a table.
`protected String` | `renderAutoIncrement()` Generates the DDL fragment required to specify an INTEGER field as auto-incremented.
`protected String[]` | `renderDropFunctions(DDLTable table)` Generates the database-specific DDL statements required to drop all associated functions for the given table representation.
`protected String` | `renderDropIndex(DDLIndex index)` Generates the database-specific DDL statement required to drop an index.
`protected String` | `renderFieldType(DDLField field)` Renders the database-specific DDL type for the field in question.
`protected String` | `renderFunction(DatabaseFunction func)` Renders the specified `DatabaseFunction` in its database-specific form.
`protected String` | `renderFunctionForField(DDLTable table, DDLField field)` Renders the function which corresponds to the specified field, or `null` if none.
`protected String` | `renderOnUpdate(DDLField field)` Renders the appropriate field suffix to allow for the `OnUpdate` functionality.
`protected String` | `renderTriggerForField(DDLTable table, DDLField field)` Renders the trigger which corresponds to the specified field, or `null` if none.
`protected String` | `renderValue(Object value)` Renders the given Java instance in a database-specific way.
`protected boolean` | `shouldQuoteID(String id)` Determines whether or not the specified identifier should be quoted before transmission to the underlying database.

Methods inherited from class net.java.ao.DatabaseProvider
`dispose, getConnection, getDateFormat, getEventManager, getMaxIDLength, getSequences, isCaseSensetive, isNumericType, processID, processWhereClause, putBoolean, renderAction, renderAlterTableAddColumn, renderAlterTableAddKey, renderAlterTableChangeColumnStatement, renderAlterTableDropColumn, renderAppend, renderCalendar, renderConstraintsForTable, renderCreateIndex, renderDropSequences, renderDropTable, renderDropTriggers, renderField, renderFieldPrecision, renderForeignKey, renderFunctions, renderInsert, renderQuery, renderQueryGroupBy, renderQueryJoins, renderQueryLimit, renderQueryOrderBy, renderQuerySelect, renderQueryWhere, renderSequences, renderTable, renderTriggers, renderUnique, setEventManager, setPostConnectionProperties, setQueryResultSetProperties, setQueryStatementProperties`

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

Constructor Detail

### PostgreSQLDatabaseProvider

    public PostgreSQLDatabaseProvider(DisposableDataSource dataSource)

Method Detail

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

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

### 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[])`

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

### renderFieldType

    protected String renderFieldType(DDLField field)

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

  Overrides:
    `renderFieldType` in class `DatabaseProvider`
  Parameters:
    `field` - The field which contains the type to be rendered.
  Returns:
    The database-specific type DDL rendering.

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

### renderValue

    protected String renderValue(Object value)

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

  Overrides:
    `renderValue` in class `DatabaseProvider`
  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:
    `DatabaseProvider.renderCalendar(Calendar)`, `DatabaseProvider.renderFunction(DatabaseFunction)`

### renderFunction

    protected String renderFunction(DatabaseFunction func)

  Description copied from class: `DatabaseProvider`

  Renders the specified `DatabaseFunction` in its database-specific form. For example, for MySQL the `CURRENT_DATE` enum value would be rendered as "`CURRENT_DATE`" (without the quotes). For functions which do not have a database equivalent, a default literal value of the appropriate type should be returned. For example, if MySQL did not define either a CURRENT_DATE or a CURRENT_TIMESTAMP function, the appropriate return value for both functions would be `'0000-00-00 00:00:00'` (including the quotes). This is to prevent migrations from failing even in cases where non-standard functions are used.

  As of 1.0, no unconventional functions are allowed by the `DatabaseFunction` enum, thus no database should have any problems with any allowed functions.

  Overrides:
    `renderFunction` in class `DatabaseProvider`
  Parameters:
    `func` - The abstract function to be rendered.
  Returns:
    The database-specific DDL representation of the function in question.

### renderFunctionForField

    protected String renderFunctionForField(DDLTable table,
                                            DDLField field)

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

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

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

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

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

### renderAlterTableDropKey

    protected String renderAlterTableDropKey(DDLForeignKey key)

  Description copied from class: `DatabaseProvider`
  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 `DatabaseProvider.renderForeignKey(DDLForeignKey)` method properly names the foreign key according to the `DDLForeignKey.getFKName()` method.

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

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

### renderDropFunctions

    protected String[] renderDropFunctions(DDLTable table)

  Description copied from class: `DatabaseProvider`
  Generates the database-specific DDL statements required to drop all associated functions for the given table representation. The default implementation is to return an empty array. Some databases (such as PostgreSQL) require triggers to fire functions, unlike most databases which allow triggers to function almost like standalone functions themselves. For such databases, dropping a table means not only dropping the table and the associated triggers, but also the functions associated with the triggers themselves.

  Overrides:
    `renderDropFunctions` in class `DatabaseProvider`
  Parameters:
    `table` - The table representation against which all functions which correspond (directly or indirectly) must be dropped.
  Returns:
    An array of database-specific DDL statement(s) which drop the required functions.

### getFunctionNameForField

    protected String getFunctionNameForField(DDLTable table,
                                             DDLField field)

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

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

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

### insertReturningKey

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

  Description copied from class: `DatabaseProvider`

  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, `DatabaseProvider.executeInsertReturningKey(EntityManager, 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 `DatabaseProvider.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 `DatabaseProvider.executeInsertReturningKey(EntityManager, 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).

  Overrides:
    `insertReturningKey` in class `DatabaseProvider`
  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.
    `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:
    `DatabaseProvider.executeInsertReturningKey(EntityManager, Connection, Class, String, String, DBParam...)`

### executeInsertReturningKey

    protected <T> T executeInsertReturningKey(EntityManager manager,
                                              Connection conn,
                                              Class<T> pkType,
                                              String pkField,
                                              String sql,
                                              DBParam... params)
                                   throws SQLException

  Description copied from class: `DatabaseProvider`

  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 `DatabaseProvider.insertReturningKey(EntityManager, Connection, Class, String, boolean, String, DBParam...)` method. The idea behind this method is to allow custom implementations to override this method to potentially execute other statements (such as getting the next value in a sequence) rather than the default implementaiton which uses the JDBC constant, `RETURN_GENERATED_KEYS`. Any database which has a fully-implemented JDBC driver should have no problems with the default implementation of this method.

  Part of the design behind splitting `insertReturningKey` and `executeInsertReturningKey` is so that logic for generating the actual INSERT statement need not be duplicated throughout the code and in custom implementations providing trivial changes to the default algorithm. This method should avoid actually generating SQL if at all possible.

  This method should iterate through the passed `DBParam(s)` to ensure that no primary key value was explicitly specified. If one was, it should be used in leiu of one which is auto-generated by the database. Also, it is this value which should be returned if specified, rather than the value which would have been generated or `null`. As such, this method should always return exactly the value of the primary key field in the row which was just inserted, regardless of what that value may be.

  In cases where the database mechanism for getting the next primary key value is not thread safe, this method should be declared `synchronized`, or some thread synchronization technique employed. Unfortunately, it is not always possible to ensure that no other INSERT could (potentially) "steal" the expected value out from under the algorithm. Such scenarios are to be avoided when possible, but the algorithm need not take extremely escoteric concurrency cases into account. (see the HSQLDB provider for an example of such a less-than-thorough asynchronous algorithm)

  IMPORTANT: The INSERT `Statement` must use the specified connection, rather than a new one retrieved from `DatabaseProvider.getConnection()` or equivalent. This is because the INSERT may be part of a bulk insertion, a transaction, or possibly another such operation. It is also important to note that this method should not close the connection. Doing so could cause the entity creation algorithm to fail at a higher level up the stack.

  Overrides:
    `executeInsertReturningKey` in class `DatabaseProvider`
  Parameters:
    `manager` - The `EntityManager` which was used to dispatch the INSERT in question.
    `conn` - The database connection to use in executing the INSERT statement.
    `pkType` - The Java class type of the primary key field (for use both in searching the `params` as well as performing value conversion of auto-generated DB values into proper Java instances).
    `pkField` - The database field which is the primary key for the table in question. Can be used to perform a linear search for a specified primary key value in the `params` list.
    `params` - A varargs array of parameters to be passed to the INSERT statement. This may include a specified value for the primary key.
  Throws:
    `SQLException` - If the INSERT fails in the delegate method, or if any additional statements fail with an exception.
  See Also:
    `DatabaseProvider.insertReturningKey(EntityManager, Connection, Class, String, boolean, String, DBParam...)`

### putNull

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

  Description copied from class: `DatabaseProvider`
  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.setString(int, String)`, passing `null` as a value. Databases which require a different implementation (e.g. PostgreSQL) should override this method.

  Overrides:
    `putNull` in class `DatabaseProvider`
  Parameters:
    `stmt` - The statement in which to store the `NULL` value.
    `index` - The index of the parameter which should be assigned `NULL`.
  Throws:
    `SQLException`

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

### shouldQuoteID

    protected boolean shouldQuoteID(String id)

  Description copied from class: `DatabaseProvider`
  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 `DatabaseProvider.getReservedWords()`. Databases with more complicated rules regarding quoting should provide a custom implementation of this method.

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

### handleUpdateError

    public void handleUpdateError(SQLException e)
                           throws SQLException

  Description copied from class: `DatabaseProvider`
  Tells whether this exception should be ignored when running an updated statement. Typically, errors on dropping non-existing objects should be ignored.

  Overrides:
    `handleUpdateError` in class `DatabaseProvider`
  Parameters:
    `e` - the `SQLException` that occured.
  Throws:
    `SQLException` - throws the SQLException if it should not be ignored.

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.