Module org.tentackle.sql
Package org.tentackle.sql

Class Oracle

  • All Implemented Interfaces:
    Backend
    @Service(Backend.class)
public class Oracle
extends AbstractSql2003Backend
    Backend for Oracle. Contains some Oracle-specific utility methods as well:

    Date-conversion: Oracle does not use an index on a DATE-column if passed as a Timestamp-variable via a prepared statement, even if used in conjunction with an SQL-hint /*+ INDEX(...) In such cases the TO_DATE-function must be explicitly used. 

     Example:

      if (getDb().isOracle()) {
        query.add(" AND m." + CN_ZEITPUNKT + ">=" + OracleHelper.timestampString(par.vonZeitpunkt));
      }
      else  {
        query.add(" AND m." + CN_ZEITPUNKT + ">=?", par.vonZeitpunkt);
      }


 or:
      if (getDb().isOracle()) {
        query.add(" AND m." + CN_ZEITPUNKT + ">=TO_DATE(?,'" + OracleHelper.ORA_TIMESTAMP_FORMAT + "')",
                  OracleHelper.TIMESTAMP_FORMAT.format(par.vonZeitpunkt));
      }
      else  {
        query.add(" AND m." + CN_ZEITPUNKT + ">=?", par.vonZeitpunkt);
      }
    Rule: if possible use TIMESTAMP column type for a Timestamp-java attribute. In such a case at least Oracle 10 uses the correct index and you don't need this workaround.
    Author:
    harald

    • Field Detail

      • SQL_NESTED_SELECT_1

        public static final java.lang.String SQL_NESTED_SELECT_1
        window function part 1.
        See Also:
        Constant Field Values

      • SQL_NESTED_SELECT_2

        public static final java.lang.String SQL_NESTED_SELECT_2
        window function part 2.
        See Also:
        Constant Field Values

      • SQL_NESTED_SELECT_ROWNUM

        public static final java.lang.String SQL_NESTED_SELECT_ROWNUM
        condition for limit and offset.
        See Also:
        Constant Field Values

      • SQL_NESTED_SELECT_LIMIT

        public static final java.lang.String SQL_NESTED_SELECT_LIMIT
        condition for limit and offset.
        See Also:
        Constant Field Values

      • SQL_NESTED_SELECT_OFFSET

        public static final java.lang.String SQL_NESTED_SELECT_OFFSET
        condition for limit and offset.
        See Also:
        Constant Field Values

    • Constructor Detail

      • Oracle

        public Oracle()

    • Method Detail

      • dateString

        public static java.lang.String dateString​(java.sql.Date date)
        Converts a date to a string.
        Parameters:
        date - the date
        Returns:
        a TO_DATE-date-string

      • timeString

        public static java.lang.String timeString​(java.sql.Time time)
        Converts a time to a string.
        Parameters:
        time - the time
        Returns:
        a TO_DATE-time-string

      • timestampString

        public static java.lang.String timestampString​(java.sql.Timestamp timestamp)
        Converts a timestamp to a string.
        Parameters:
        timestamp - the timestamp
        Returns:
        a TO_DATE-timestamp-string

      • getDriverClassName

        public java.lang.String getDriverClassName()
        Description copied from interface: Backend
        Gets the JDBC driver class name.
        Returns:
        the class name

      • createConnection

        public java.sql.Connection createConnection​(java.lang.String url,
                                            java.lang.String username,
                                            char[] password)
                                     throws java.sql.SQLException
        Description copied from interface: Backend
        Creates a jdbc connection.
        Specified by:
        createConnection in interface Backend
        Overrides:
        createConnection in class AbstractBackend
        Parameters:
        url - the jdbc url
        username - the username
        password - the password
        Returns:
        the created connection
        Throws:
        java.sql.SQLException - if connection could not be established

      • isMatchingUrl

        public boolean isMatchingUrl​(java.lang.String url)
        Description copied from interface: Backend
        Checks whether the backend belongs to the given jdbc url.
        If multiple backend implementations are provided for the same database type, only one backend should match the URL. The others must be selected via name.
        Parameters:
        url - the jdbc url
        Returns:
        true if matches

      • getName

        public java.lang.String getName()
        Description copied from interface: Backend
        Gets the name of the backend.
        Returns:
        the name

      • getBackendId

        public java.lang.String getBackendId​(java.sql.Connection connection)
        Description copied from interface: Backend
        Determines the unique id or name used by the backend for a given connection.

        Useful to figure out the corresponding ManagedConnection from the backend's logfiles.

        Parameters:
        connection - the jdbc connection
        Returns:
        the backend id, null if none

      • isTemporaryName

        public boolean isTemporaryName​(java.lang.String name)
        Description copied from interface: Backend
        Checks whether this is a temporary name.
        Returns whether an entity-, attribute- or index-name is temporary and should not be taken into account for migration or even used in the model.
        Depending on the backend, temporary names start with an underscore or some other lead string.
        Specified by:
        isTemporaryName in interface Backend
        Overrides:
        isTemporaryName in class AbstractBackend
        Parameters:
        name - the name
        Returns:
        true temporary (invalid) name

      • isReservedTableName

        public boolean isReservedTableName​(java.lang.String name)
        Description copied from interface: Backend
        Checks whether this a reserved table name for this backend.
        Applies only to tables. Not to be mixed up with Backend.getReservedWords().
        Useful to avoid conflicts with naming conventions for backend specific things, such as snapshots.
        Specified by:
        isReservedTableName in interface Backend
        Overrides:
        isReservedTableName in class AbstractBackend
        Parameters:
        name - the table name
        Returns:
        true if reserved by backend

      • isReservedSchemaName

        public boolean isReservedSchemaName​(java.lang.String name)
        Description copied from interface: Backend
        Checks whether this is a reserved schema name for this backend.
        Specified by:
        isReservedSchemaName in interface Backend
        Overrides:
        isReservedSchemaName in class AbstractBackend
        Parameters:
        name - the schema name
        Returns:
        true if reserved by backend

      • assertValidName

        public void assertValidName​(SqlNameType nameType,
                            java.lang.String name)
        Description copied from interface: Backend
        Asserts that given string is a valid name and usage.
        Specified by:
        assertValidName in interface Backend
        Overrides:
        assertValidName in class AbstractBackend
        Parameters:
        nameType - the type/usage of the name
        name - the name

      • getEmptyString

        public java.lang.String getEmptyString()
        Description copied from interface: Backend
        Gets the empty string.

        Some dbms (most famous: Oracle) handle empty strings as null. In such cases the empty string (e.g. Oracle) may consist of a single blank or whatever.

        Specified by:
        getEmptyString in interface Backend
        Overrides:
        getEmptyString in class AbstractBackend
        Returns:
        the empty string (never null)

      • valueToLiteral

        public java.lang.String valueToLiteral​(SqlType sqlType,
                                       java.lang.Object value)
        Description copied from interface: Backend
        Conberts a type and value to a literal string.
        Specified by:
        valueToLiteral in interface Backend
        Overrides:
        valueToLiteral in class AbstractBackend
        Parameters:
        sqlType - the sql type
        value - the value
        Returns:
        the constant

      • sqlRequiresExtraCommit

        public boolean sqlRequiresExtraCommit()
        Description copied from interface: Backend
        According to the JDBC-specs Connection.setAutoCommit(boolean)(true) should commit, but some backends require an extra Connection.commit().
        Specified by:
        sqlRequiresExtraCommit in interface Backend
        Overrides:
        sqlRequiresExtraCommit in class AbstractBackend
        Returns:
        true if the database needs an extra commit

      • buildSelectSql

        public void buildSelectSql​(java.lang.StringBuilder sqlBuilder,
                           boolean writeLock,
                           int limit,
                           int offset)
        Description copied from interface: Backend
        Creates a select statement string from an inner sql string.

        sqlBuilder is anything as FROM... WHERE... ORDER BY....
        It is decorated with a leading SELECT plus optional clauses like for the given parameters.

        Specified by:
        buildSelectSql in interface Backend
        Overrides:
        buildSelectSql in class AbstractSql2003Backend
        Parameters:
        sqlBuilder - the sql builder, initially containing the inner sql without leading SELECT.
        writeLock - true select should write lock
        limit - the limit value, ≤ 0 if no limit clause
        offset - the offset value, ≤ 0 if no offset clause

      • getMaxSize

        public int getMaxSize​(SqlType sqlType)
        Description copied from interface: Backend
        Returns the maximum size for a given SQL-type.
        Specified by:
        getMaxSize in interface Backend
        Overrides:
        getMaxSize in class AbstractBackend
        Parameters:
        sqlType - the SQL-type
        Returns:
        the maximum size, 0 if unlimited, -1 if type without size

      • sqlTypeToString

        public java.lang.String sqlTypeToString​(SqlType sqlType,
                                        int size)
        Description copied from interface: Backend
        Converts the java SQL-type to the database type name.
        Specified by:
        sqlTypeToString in interface Backend
        Overrides:
        sqlTypeToString in class AbstractBackend
        Parameters:
        sqlType - the java sql type
        size - the column's size
        Returns:
        the corresponding type string

      • jdbcTypeToSqlType

        public SqlType[] jdbcTypeToSqlType​(int jdbcType,
                                   int size,
                                   int scale)
        Description copied from interface: Backend
        Converts the JDBC data type integer to a tentackle backend SqlTypes.

        There may be more than one sqltype returned!

        Specified by:
        jdbcTypeToSqlType in interface Backend
        Overrides:
        jdbcTypeToSqlType in class AbstractBackend
        Parameters:
        jdbcType - the jdbc data type
        size - the column size
        scale - the column's scale
        Returns:
        the SqlTypes, empty array if no mapping available or no exact match (not generated by TT)
        See Also:
        Types

      • sqlNextFromSequene

        public java.lang.String sqlNextFromSequene​(java.lang.String name)
        Description copied from interface: Backend
        Creates the SQL string to retrieve the next id from a sequence.
        Specified by:
        sqlNextFromSequene in interface Backend
        Overrides:
        sqlNextFromSequene in class AbstractSql2003Backend
        Parameters:
        name - the name of the sequence
        Returns:
        the SQL code

      • sqlRenameTable

        public java.lang.String sqlRenameTable​(java.lang.String tableName,
                                       java.lang.String newTableName)
        Description copied from interface: Backend
        Generate sql code to rename a table.
        Specified by:
        sqlRenameTable in interface Backend
        Overrides:
        sqlRenameTable in class AbstractBackend
        Parameters:
        tableName - the old tablename (with leading schema, if any)
        newTableName - the new tablename (without schema)
        Returns:
        the SQL code

      • sqlAddColumn

        public java.lang.String sqlAddColumn​(java.lang.String tableName,
                                     java.lang.String columnName,
                                     java.lang.String comment,
                                     SqlType sqlType,
                                     int size,
                                     int scale,
                                     boolean nullable,
                                     java.lang.Object defaultValue)
        Description copied from interface: Backend
        Generates sql code to add a column.
        Specified by:
        sqlAddColumn in interface Backend
        Overrides:
        sqlAddColumn in class AbstractBackend
        Parameters:
        tableName - the tablename
        columnName - the new column name
        comment - optional comment, null if none
        sqlType - the JDBC sql type
        size - the optional size
        scale - the optional scale
        nullable - true if NULL, else NOT NULL
        defaultValue - the optional default value
        Returns:
        the SQL code

      • sqlAlterColumnType

        public java.lang.String sqlAlterColumnType​(java.lang.String tableName,
                                           java.lang.String columnName,
                                           java.lang.String comment,
                                           SqlType sqlType,
                                           int size,
                                           int scale,
                                           boolean nullable,
                                           java.lang.Object defaultValue)
        Description copied from interface: Backend
        Generates sql code to change the datatype of a column.
        Specified by:
        sqlAlterColumnType in interface Backend
        Overrides:
        sqlAlterColumnType in class AbstractBackend
        Parameters:
        tableName - the tablename
        columnName - the new column name
        comment - optional comment, null if none
        sqlType - the JDBC sql type
        size - the optional size
        scale - the optional scale
        nullable - true if NULL, else NOT NULL
        defaultValue - the optional default value
        Returns:
        the SQL code

      • extractWhereClause

        protected java.lang.String extractWhereClause​(java.lang.String sql,
                                              int whereOffset)
        Description copied from class: AbstractBackend
        Extracts the where clause from a given sql.
        Overrides:
        extractWhereClause in class AbstractBackend
        Parameters:
        sql - the sql statement
        whereOffset - the location of WHERE in sql
        Returns:
        the where clause without the keyword WHERE