程序包 org.hibernate.dialect

类 Cache71Dialect

  • 所有已实现的接口:
    ConversionContext
    public class Cache71Dialect
extends Dialect
    Caché 2007.1 dialect. This class is required in order to use Hibernate with InterSystems Caché SQL. Compatible with Caché 2007.1.

    PREREQUISITES

    These setup instructions assume that both Caché and Hibernate are installed and operational.

    HIBERNATE DIRECTORIES AND FILES

    JBoss distributes the InterSystems Cache' dialect for Hibernate 3.2.1 For earlier versions of Hibernate please contact InterSystems Worldwide Response Center (WRC) for the appropriate source files.

    CACHÉ DOCUMENTATION

    Documentation for Caché is available online when Caché is running. It can also be obtained from the InterSystems website. The book, "Object-oriented Application Development Using the Caché Post-relational Database: is also available from Springer-Verlag.

    HIBERNATE DOCUMENTATION

    Hibernate comes with extensive electronic documentation. In addition, several books on Hibernate are available from Manning Publications Co. Three available titles are "Hibernate Quickly", "Hibernate in Action", and "Java Persistence with Hibernate".

    TO SET UP HIBERNATE FOR USE WITH CACHÉ

    The following steps assume that the directory where Caché was installed is C:\CacheSys. This is the default installation directory for Caché. The default installation directory for Hibernate is assumed to be C:\Hibernate.

    If either product is installed in a different location, the pathnames that follow should be modified appropriately.

    Caché version 2007.1 and above is recommended for use with Hibernate. The next step depends on the location of your CacheDB.jar depending on your version of Caché.

    1. Copy C:\CacheSys\dev\java\lib\JDK15\CacheDB.jar to C:\Hibernate\lib\CacheDB.jar.

    2. Insert the following files into your Java classpath:

      • All jar files in the directory C:\Hibernate\lib
      • The directory (or directories) where hibernate.properties and/or hibernate.cfg.xml are kept.

    3. In the file, hibernate.properties (or hibernate.cfg.xml), specify the Caché dialect and the Caché version URL settings.

    For example, in Hibernate 3.2, typical entries in hibernate.properties would have the following "name=value" pairs:

    Property Name Property Value
    hibernate.dialect org.hibernate.dialect.Cache71Dialect
    hibernate.connection.driver_class com.intersys.jdbc.CacheDriver
    hibernate.connection.username (see note 1)
    hibernate.connection.password (see note 1)
    hibernate.connection.url jdbc:Cache://127.0.0.1:1972/USER

    NOTE: Please contact your administrator for the userid and password you should use when attempting access via JDBC. By default, these are chosen to be "_SYSTEM" and "SYS" respectively as noted in the SQL standard.

    CACHÉ VERSION URL

    This is the standard URL for the JDBC driver. For a JDBC driver on the machine hosting Caché, use the IP "loopback" address, 127.0.0.1. For 1972, the default port, specify the super server port of your Caché instance. For USER, substitute the NAMESPACE which contains your Caché database data.

    CACHÉ DIALECTS

    Choices for Dialect are:

    1. org.hibernate.dialect.Cache71Dialect (requires Caché 2007.1 or above)


    SUPPORT FOR IDENTITY COLUMNS

    Caché 2007.1 or later supports identity columns. For Hibernate to use identity columns, specify "native" as the generator.

    SEQUENCE DIALECTS SUPPORT SEQUENCES

    To use Hibernate sequence support with Caché in a namespace, you must FIRST load the following file into that namespace: 

         etc\CacheSequences.xml
    For example, at the COS terminal prompt in the namespace, run the following command:

    d LoadFile^%apiOBJ("c:\hibernate\etc\CacheSequences.xml","ck")

    In your Hibernate mapping you can specify sequence use.

    For example, the following shows the use of a sequence generator in a Hibernate mapping: 

         <id name="id" column="uid" type="long" unsaved-value="null">
         <generator class="sequence"/>
     </id>

    Some versions of Hibernate under some circumstances call getSelectSequenceNextValString() in the dialect. If this happens you will receive the error message: new MappingException( "Dialect does not support sequences" ).

    HIBERNATE FILES ASSOCIATED WITH CACHÉ DIALECT

    The following files are associated with Caché dialect:

    1. src\org\hibernate\dialect\Cache71Dialect.java
    2. src\org\hibernate\dialect\function\ConditionalParenthesisFunction.java
    3. src\org\hibernate\dialect\function\ConvertFunction.java
    4. src\org\hibernate\exception\CacheSQLStateConverter.java
    5. src\org\hibernate\sql\CacheJoinFragment.java
    Cache71Dialect ships with Hibernate 3.2. All other dialects are distributed by InterSystems and subclass Cache71Dialect.
    作者:
    Jonathan Levinson

    • 构造器详细资料

      • Cache71Dialect

        public Cache71Dialect()
        Creates new Cache71Dialect instance. Sets up the JDBC / Caché type mappings.

    • 方法详细资料

      • commonRegistration

        protected final void commonRegistration()

      • register71Functions

        protected final void register71Functions()

      • hasAlterTable

        public boolean hasAlterTable()
        从类复制的说明: Dialect
        Does this dialect support the ALTER TABLE syntax?
        覆盖:
        hasAlterTable 在类中 Dialect
        返回:
        True if we support altering of tables; false otherwise.

      • qualifyIndexName

        public boolean qualifyIndexName()
        从类复制的说明: Dialect
        Do we need to qualify index names with the schema name?
        覆盖:
        qualifyIndexName 在类中 Dialect
        返回:
        boolean

      • getAddForeignKeyConstraintString

        public String getAddForeignKeyConstraintString​(String constraintName,
                                               String[] foreignKey,
                                               String referencedTable,
                                               String[] primaryKey,
                                               boolean referencesPrimaryKey)
        从类复制的说明: Dialect
        The syntax used to add a foreign key constraint to a table.
        覆盖:
        getAddForeignKeyConstraintString 在类中 Dialect
        参数:
        constraintName - The FK constraint name.
        foreignKey - The names of the columns comprising the FK
        referencedTable - The table referenced by the FK
        primaryKey - The explicit columns in the referencedTable referenced by this FK.
        referencesPrimaryKey - if false, constraint should be explicit about which column names the constraint refers to
        返回:
        the "add FK" fragment

      • supportsCheck

        public boolean supportsCheck()
        Does this dialect support check constraints?
        返回:
        false (Cache does not support check constraints)

      • getAddColumnString

        public String getAddColumnString()
        从类复制的说明: Dialect
        The syntax used to add a column to a table (optional).
        覆盖:
        getAddColumnString 在类中 Dialect
        返回:
        The "add column" fragment.

      • dropConstraints

        public boolean dropConstraints()
        从类复制的说明: Dialect
        Do we need to drop constraints before dropping tables in this dialect?
        覆盖:
        dropConstraints 在类中 Dialect
        返回:
        True if constraints must be dropped prior to dropping the table; false otherwise.

      • supportsCascadeDelete

        public boolean supportsCascadeDelete()
        从类复制的说明: Dialect
        Does this dialect support cascaded delete on foreign key definitions?
        覆盖:
        supportsCascadeDelete 在类中 Dialect
        返回:
        true indicates that the dialect does support cascaded delete on foreign keys.

      • hasSelfReferentialForeignKeyBug

        public boolean hasSelfReferentialForeignKeyBug()
        从类复制的说明: Dialect
        Does the database/driver have bug in deleting rows that refer to other rows being deleted in the same query?
        覆盖:
        hasSelfReferentialForeignKeyBug 在类中 Dialect
        返回:
        true if the database/driver has this bug

      • getNativeIdentifierGeneratorStrategy

        public String getNativeIdentifierGeneratorStrategy()
        从类复制的说明: Dialect
        Resolves the native generation strategy associated to this dialect.

        Comes into play whenever the user specifies the native generator.

        覆盖:
        getNativeIdentifierGeneratorStrategy 在类中 Dialect
        返回:
        The native generator strategy.

      • supportsSequences

        public boolean supportsSequences()
        从类复制的说明: Dialect
        Does this dialect support sequences?
        覆盖:
        supportsSequences 在类中 Dialect
        返回:
        True if sequences supported; false otherwise.

      • supportsOuterJoinForUpdate

        public boolean supportsOuterJoinForUpdate()
        从类复制的说明: Dialect
        Does this dialect support FOR UPDATE in conjunction with outer joined rows?
        覆盖:
        supportsOuterJoinForUpdate 在类中 Dialect
        返回:
        True if outer joined rows can be locked via FOR UPDATE.

      • getLockingStrategy

        public LockingStrategy getLockingStrategy​(Lockable lockable,
                                          LockMode lockMode)
        从类复制的说明: Dialect
        Get a strategy instance which knows how to acquire a database-level lock of the specified mode for this dialect.
        覆盖:
        getLockingStrategy 在类中 Dialect
        参数:
        lockable - The persister for the entity to be locked.
        lockMode - The type of lock to be acquired.
        返回:
        The appropriate locking strategy.

      • getLimitHandler

        public LimitHandler getLimitHandler()
        从类复制的说明: Dialect
        Returns the delegate managing LIMIT clause.
        覆盖:
        getLimitHandler 在类中 Dialect
        返回:
        LIMIT clause delegate.

      • supportsLimit

        public boolean supportsLimit()
        从类复制的说明: Dialect
        Does this dialect support some form of limiting query results via a SQL clause?
        覆盖:
        supportsLimit 在类中 Dialect
        返回:
        True if this dialect supports some form of LIMIT.

      • supportsLimitOffset

        public boolean supportsLimitOffset()
        从类复制的说明: Dialect
        Does this dialect's LIMIT support (if any) additionally support specifying an offset?
        覆盖:
        supportsLimitOffset 在类中 Dialect
        返回:
        True if the dialect supports an offset within the limit support.

      • supportsVariableLimit

        public boolean supportsVariableLimit()
        从类复制的说明: Dialect
        Does this dialect support bind variables (i.e., prepared statement parameters) for its limit/offset?
        覆盖:
        supportsVariableLimit 在类中 Dialect
        返回:
        True if bind variables can be used; false otherwise.

      • bindLimitParametersFirst

        public boolean bindLimitParametersFirst()
        从类复制的说明: Dialect
        Does the LIMIT clause come at the start of the SELECT statement, rather than at the end?
        覆盖:
        bindLimitParametersFirst 在类中 Dialect
        返回:
        true if limit parameters should come before other parameters

      • useMaxForLimit

        public boolean useMaxForLimit()
        从类复制的说明: Dialect
        Does the LIMIT clause take a "maximum" row number instead of a total number of returned rows?

        This is easiest understood via an example. Consider you have a table with 20 rows, but you only want to retrieve rows number 11 through 20. Generally, a limit with offset would say that the offset = 11 and the limit = 10 (we only want 10 rows at a time); this is specifying the total number of returned rows. Some dialects require that we instead specify offset = 11 and limit = 20, where 20 is the "last" row we want relative to offset (i.e. total number of rows = 20 - 11 = 9)

        So essentially, is limit relative from offset? Or is limit absolute?

        覆盖:
        useMaxForLimit 在类中 Dialect
        返回:
        True if limit is relative from offset; false otherwise.

      • getLimitString

        public String getLimitString​(String sql,
                             boolean hasOffset)
        从类复制的说明: Dialect
        Apply a limit clause to the query.

        Typically dialects utilize variable limit clauses when they support limits. Thus, when building the select command we do not actually need to know the limit or the offset since we will just be using placeholders.

        Here we do still pass along whether or not an offset was specified so that dialects not supporting offsets can generate proper exceptions. In general, dialects will override one or the other of this method and Dialect.getLimitString(String, int, int).

        覆盖:
        getLimitString 在类中 Dialect
        参数:
        sql - The query to which to apply the limit.
        hasOffset - Is the query requesting an offset?
        返回:
        the modified SQL

      • registerResultSetOutParameter

        public int registerResultSetOutParameter​(CallableStatement statement,
                                         int col)
                                  throws SQLException
        从类复制的说明: Dialect
        Registers a parameter (either OUT, or the new REF_CURSOR param type available in Java 8) capable of returning ResultSet *by position*. Pre-Java 8, registering such ResultSet-returning parameters varied greatly across database and drivers; hence its inclusion as part of the Dialect contract.
        覆盖:
        registerResultSetOutParameter 在类中 Dialect
        参数:
        statement - The callable statement.
        col - The bind position at which to register the output param.
        返回:
        The number of (contiguous) bind positions used.
        抛出:
        SQLException - Indicates problems registering the param.

      • getLowercaseFunction

        public String getLowercaseFunction()
        从类复制的说明: Dialect
        The name of the SQL function that transforms a string to lowercase
        覆盖:
        getLowercaseFunction 在类中 Dialect
        返回:
        The dialect-specific lowercase function.

      • getNullColumnString

        public String getNullColumnString()
        从类复制的说明: Dialect
        The keyword used to specify a nullable column.
        覆盖:
        getNullColumnString 在类中 Dialect
        返回:
        String

      • getNoColumnsInsertString

        public String getNoColumnsInsertString()
        从类复制的说明: Dialect
        The fragment used to insert a row without specifying any column values. This is not possible on some databases.
        覆盖:
        getNoColumnsInsertString 在类中 Dialect
        返回:
        The appropriate empty values clause.

      • buildSQLExceptionConversionDelegate

        public SQLExceptionConversionDelegate buildSQLExceptionConversionDelegate()
        从类复制的说明: Dialect
        Build an instance of a SQLExceptionConversionDelegate for interpreting dialect-specific error or SQLState codes.

        When Dialect.buildSQLExceptionConverter() returns null, the default SQLExceptionConverter is used to interpret SQLState and error codes. If this method is overridden to return a non-null value, the default SQLExceptionConverter will use the returned SQLExceptionConversionDelegate in addition to the following standard delegates:

        1. a "static" delegate based on the JDBC 4 defined SQLException hierarchy;
        2. a delegate that interprets SQLState codes for either X/Open or SQL-2003 codes, depending on java.sql.DatabaseMetaData#getSQLStateType

        It is strongly recommended that specific Dialect implementations override this method, since interpretation of a SQL error is much more accurate when based on the vendor-specific ErrorCode rather than the SQLState.

        Specific Dialects may override to return whatever is most appropriate for that vendor.

        覆盖:
        buildSQLExceptionConversionDelegate 在类中 Dialect
        返回:
        The SQLExceptionConversionDelegate for this dialect

      • supportsEmptyInList

        public boolean supportsEmptyInList()
        从类复制的说明: Dialect
        Does this dialect support empty IN lists?

        For example, is [where XYZ in ()] a supported construct?

        覆盖:
        supportsEmptyInList 在类中 Dialect
        返回:
        True if empty in lists are supported; false otherwise.

      • areStringComparisonsCaseInsensitive

        public boolean areStringComparisonsCaseInsensitive()
        从类复制的说明: Dialect
        Are string comparisons implicitly case insensitive.

        In other words, does [where 'XYZ' = 'xyz'] resolve to true?

        覆盖:
        areStringComparisonsCaseInsensitive 在类中 Dialect
        返回:
        True if comparisons are case insensitive.