File	Doc	Category	Size	Date	Package
Cache71Dialect.java	API Doc	Hibernate 3.2.5	29472	Mon Apr 02 10:20:56 BST 2007	org.hibernate.dialect

Cache71Dialect

• java.lang.Object
  • Dialect

etc\CacheSequences.xml

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

Fields Summary
public static final org.hibernate.exception.ViolatedConstraintNameExtracter	EXTRACTER

Constructors Summary
public Cache71Dialect() Creates new Caché71Dialect instance. Sets up the JDBC / Caché type mappings. super(); commonRegistration(); register71Functions();

Methods Summary
public boolean	areStringComparisonsCaseInsensitive() return true;
public boolean	bindLimitParametersFirst() // Does the LIMIT clause come at the start of the SELECT statement, rather than at the end? return true;
public org.hibernate.exception.SQLExceptionConverter	buildSQLExceptionConverter() return new CacheSQLStateConverter( EXTRACTER );
protected final void	commonRegistration() // Note: For object <-> SQL datatype mappings see: // Configuration Manager | Advanced | SQL | System DDL Datatype Mappings // // TBD registerColumnType(Types.BINARY, "binary($1)"); // changed 08-11-2005, jsl registerColumnType( Types.BINARY, "varbinary($1)" ); registerColumnType( Types.BIGINT, "BigInt" ); registerColumnType( Types.BIT, "bit" ); registerColumnType( Types.CHAR, "char(1)" ); registerColumnType( Types.DATE, "date" ); registerColumnType( Types.DECIMAL, "decimal" ); registerColumnType( Types.DOUBLE, "double" ); registerColumnType( Types.FLOAT, "float" ); registerColumnType( Types.INTEGER, "integer" ); registerColumnType( Types.LONGVARBINARY, "longvarbinary" ); // binary %Stream registerColumnType( Types.LONGVARCHAR, "longvarchar" ); // character %Stream registerColumnType( Types.NUMERIC, "numeric($p,$s)" ); registerColumnType( Types.REAL, "real" ); registerColumnType( Types.SMALLINT, "smallint" ); registerColumnType( Types.TIMESTAMP, "timestamp" ); registerColumnType( Types.TIME, "time" ); registerColumnType( Types.TINYINT, "tinyint" ); // TBD should this be varbinary($1)? // registerColumnType(Types.VARBINARY, "binary($1)"); registerColumnType( Types.VARBINARY, "longvarbinary" ); registerColumnType( Types.VARCHAR, "varchar($l)" ); registerColumnType( Types.BLOB, "longvarbinary" ); registerColumnType( Types.CLOB, "longvarchar" ); getDefaultProperties().setProperty( Environment.USE_STREAMS_FOR_BINARY, "false" ); getDefaultProperties().setProperty( Environment.STATEMENT_BATCH_SIZE, DEFAULT_BATCH_SIZE ); //getDefaultProperties().setProperty(Environment.STATEMENT_BATCH_SIZE, NO_BATCH); getDefaultProperties().setProperty( Environment.USE_SQL_COMMENTS, "false" ); registerFunction( "abs", new StandardSQLFunction( "abs" ) ); registerFunction( "acos", new StandardJDBCEscapeFunction( "acos", Hibernate.DOUBLE ) ); registerFunction( "%alphaup", new StandardSQLFunction( "%alphaup", Hibernate.STRING ) ); registerFunction( "ascii", new StandardSQLFunction( "ascii", Hibernate.STRING ) ); registerFunction( "asin", new StandardJDBCEscapeFunction( "asin", Hibernate.DOUBLE ) ); registerFunction( "atan", new StandardJDBCEscapeFunction( "atan", Hibernate.DOUBLE ) ); registerFunction( "bit_length", new SQLFunctionTemplate( Hibernate.INTEGER, "($length(?1)*8)" ) ); // hibernate impelemnts cast in Dialect.java registerFunction( "ceiling", new StandardSQLFunction( "ceiling", Hibernate.INTEGER ) ); registerFunction( "char", new StandardJDBCEscapeFunction( "char", Hibernate.CHARACTER ) ); registerFunction( "character_length", new StandardSQLFunction( "character_length", Hibernate.INTEGER ) ); registerFunction( "char_length", new StandardSQLFunction( "char_length", Hibernate.INTEGER ) ); registerFunction( "cos", new StandardJDBCEscapeFunction( "cos", Hibernate.DOUBLE ) ); registerFunction( "cot", new StandardJDBCEscapeFunction( "cot", Hibernate.DOUBLE ) ); registerFunction( "coalesce", new VarArgsSQLFunction( "coalesce(", ",", ")" ) ); registerFunction( "concat", new VarArgsSQLFunction( Hibernate.STRING, "", "||", "" ) ); registerFunction( "convert", new ConvertFunction() ); registerFunction( "curdate", new StandardJDBCEscapeFunction( "curdate", Hibernate.DATE ) ); registerFunction( "current_date", new NoArgSQLFunction( "current_date", Hibernate.DATE, false ) ); registerFunction( "current_time", new NoArgSQLFunction( "current_time", Hibernate.TIME, false ) ); registerFunction( "current_timestamp", new ConditionalParenthesisFunction( "current_timestamp", Hibernate.TIMESTAMP ) ); registerFunction( "curtime", new StandardJDBCEscapeFunction( "curtime", Hibernate.TIME ) ); registerFunction( "database", new StandardJDBCEscapeFunction( "database", Hibernate.STRING ) ); registerFunction( "dateadd", new VarArgsSQLFunction( Hibernate.TIMESTAMP, "dateadd(", ",", ")" ) ); registerFunction( "datediff", new VarArgsSQLFunction( Hibernate.INTEGER, "datediff(", ",", ")" ) ); registerFunction( "datename", new VarArgsSQLFunction( Hibernate.STRING, "datename(", ",", ")" ) ); registerFunction( "datepart", new VarArgsSQLFunction( Hibernate.INTEGER, "datepart(", ",", ")" ) ); registerFunction( "day", new StandardSQLFunction( "day", Hibernate.INTEGER ) ); registerFunction( "dayname", new StandardJDBCEscapeFunction( "dayname", Hibernate.STRING ) ); registerFunction( "dayofmonth", new StandardJDBCEscapeFunction( "dayofmonth", Hibernate.INTEGER ) ); registerFunction( "dayofweek", new StandardJDBCEscapeFunction( "dayofweek", Hibernate.INTEGER ) ); registerFunction( "dayofyear", new StandardJDBCEscapeFunction( "dayofyear", Hibernate.INTEGER ) ); // is it necessary to register %exact since it can only appear in a where clause? registerFunction( "%exact", new StandardSQLFunction( "%exact", Hibernate.STRING ) ); registerFunction( "exp", new StandardJDBCEscapeFunction( "exp", Hibernate.DOUBLE ) ); registerFunction( "%external", new StandardSQLFunction( "%external", Hibernate.STRING ) ); registerFunction( "$extract", new VarArgsSQLFunction( Hibernate.INTEGER, "$extract(", ",", ")" ) ); registerFunction( "$find", new VarArgsSQLFunction( Hibernate.INTEGER, "$find(", ",", ")" ) ); registerFunction( "floor", new StandardSQLFunction( "floor", Hibernate.INTEGER ) ); registerFunction( "getdate", new StandardSQLFunction( "getdate", Hibernate.TIMESTAMP ) ); registerFunction( "hour", new StandardJDBCEscapeFunction( "hour", Hibernate.INTEGER ) ); registerFunction( "ifnull", new VarArgsSQLFunction( "ifnull(", ",", ")" ) ); registerFunction( "%internal", new StandardSQLFunction( "%internal" ) ); registerFunction( "isnull", new VarArgsSQLFunction( "isnull(", ",", ")" ) ); registerFunction( "isnumeric", new StandardSQLFunction( "isnumeric", Hibernate.INTEGER ) ); registerFunction( "lcase", new StandardJDBCEscapeFunction( "lcase", Hibernate.STRING ) ); registerFunction( "left", new StandardJDBCEscapeFunction( "left", Hibernate.STRING ) ); registerFunction( "len", new StandardSQLFunction( "len", Hibernate.INTEGER ) ); registerFunction( "length", new StandardSQLFunction( "length", Hibernate.INTEGER ) ); registerFunction( "$length", new VarArgsSQLFunction( "$length(", ",", ")" ) ); // aggregate functions shouldn't be registered, right? //registerFunction( "list", new StandardSQLFunction("list",Hibernate.STRING) ); // stopped on $list registerFunction( "$list", new VarArgsSQLFunction( "$list(", ",", ")" ) ); registerFunction( "$listdata", new VarArgsSQLFunction( "$listdata(", ",", ")" ) ); registerFunction( "$listfind", new VarArgsSQLFunction( "$listfind(", ",", ")" ) ); registerFunction( "$listget", new VarArgsSQLFunction( "$listget(", ",", ")" ) ); registerFunction( "$listlength", new StandardSQLFunction( "$listlength", Hibernate.INTEGER ) ); registerFunction( "locate", new StandardSQLFunction( "$FIND", Hibernate.INTEGER ) ); registerFunction( "log", new StandardJDBCEscapeFunction( "log", Hibernate.DOUBLE ) ); registerFunction( "log10", new StandardJDBCEscapeFunction( "log", Hibernate.DOUBLE ) ); registerFunction( "lower", new StandardSQLFunction( "lower" ) ); registerFunction( "ltrim", new StandardSQLFunction( "ltrim" ) ); registerFunction( "minute", new StandardJDBCEscapeFunction( "minute", Hibernate.INTEGER ) ); registerFunction( "mod", new StandardJDBCEscapeFunction( "mod", Hibernate.DOUBLE ) ); registerFunction( "month", new StandardJDBCEscapeFunction( "month", Hibernate.INTEGER ) ); registerFunction( "monthname", new StandardJDBCEscapeFunction( "monthname", Hibernate.STRING ) ); registerFunction( "now", new StandardJDBCEscapeFunction( "monthname", Hibernate.TIMESTAMP ) ); registerFunction( "nullif", new VarArgsSQLFunction( "nullif(", ",", ")" ) ); registerFunction( "nvl", new NvlFunction() ); registerFunction( "%odbcin", new StandardSQLFunction( "%odbcin" ) ); registerFunction( "%odbcout", new StandardSQLFunction( "%odbcin" ) ); registerFunction( "%pattern", new VarArgsSQLFunction( Hibernate.STRING, "", "%pattern", "" ) ); registerFunction( "pi", new StandardJDBCEscapeFunction( "pi", Hibernate.DOUBLE ) ); registerFunction( "$piece", new VarArgsSQLFunction( Hibernate.STRING, "$piece(", ",", ")" ) ); registerFunction( "position", new VarArgsSQLFunction( Hibernate.INTEGER, "position(", " in ", ")" ) ); registerFunction( "power", new VarArgsSQLFunction( Hibernate.STRING, "power(", ",", ")" ) ); registerFunction( "quarter", new StandardJDBCEscapeFunction( "quarter", Hibernate.INTEGER ) ); registerFunction( "repeat", new VarArgsSQLFunction( Hibernate.STRING, "repeat(", ",", ")" ) ); registerFunction( "replicate", new VarArgsSQLFunction( Hibernate.STRING, "replicate(", ",", ")" ) ); registerFunction( "right", new StandardJDBCEscapeFunction( "right", Hibernate.STRING ) ); registerFunction( "round", new VarArgsSQLFunction( Hibernate.FLOAT, "round(", ",", ")" ) ); registerFunction( "rtrim", new StandardSQLFunction( "rtrim", Hibernate.STRING ) ); registerFunction( "second", new StandardJDBCEscapeFunction( "second", Hibernate.INTEGER ) ); registerFunction( "sign", new StandardSQLFunction( "sign", Hibernate.INTEGER ) ); registerFunction( "sin", new StandardJDBCEscapeFunction( "sin", Hibernate.DOUBLE ) ); registerFunction( "space", new StandardSQLFunction( "space", Hibernate.STRING ) ); registerFunction( "%sqlstring", new VarArgsSQLFunction( Hibernate.STRING, "%sqlstring(", ",", ")" ) ); registerFunction( "%sqlupper", new VarArgsSQLFunction( Hibernate.STRING, "%sqlupper(", ",", ")" ) ); registerFunction( "sqrt", new StandardJDBCEscapeFunction( "SQRT", Hibernate.DOUBLE ) ); registerFunction( "%startswith", new VarArgsSQLFunction( Hibernate.STRING, "", "%startswith", "" ) ); // below is for Cache' that don't have str in 2007.1 there is str and we register str directly registerFunction( "str", new SQLFunctionTemplate( Hibernate.STRING, "cast(?1 as char varying)" ) ); registerFunction( "string", new VarArgsSQLFunction( Hibernate.STRING, "string(", ",", ")" ) ); // note that %string is deprecated registerFunction( "%string", new VarArgsSQLFunction( Hibernate.STRING, "%string(", ",", ")" ) ); registerFunction( "substr", new VarArgsSQLFunction( Hibernate.STRING, "substr(", ",", ")" ) ); registerFunction( "substring", new VarArgsSQLFunction( Hibernate.STRING, "substring(", ",", ")" ) ); registerFunction( "sysdate", new NoArgSQLFunction( "sysdate", Hibernate.TIMESTAMP, false ) ); registerFunction( "tan", new StandardJDBCEscapeFunction( "tan", Hibernate.DOUBLE ) ); registerFunction( "timestampadd", new StandardJDBCEscapeFunction( "timestampadd", Hibernate.DOUBLE ) ); registerFunction( "timestampdiff", new StandardJDBCEscapeFunction( "timestampdiff", Hibernate.DOUBLE ) ); registerFunction( "tochar", new VarArgsSQLFunction( Hibernate.STRING, "tochar(", ",", ")" ) ); registerFunction( "to_char", new VarArgsSQLFunction( Hibernate.STRING, "to_char(", ",", ")" ) ); registerFunction( "todate", new VarArgsSQLFunction( Hibernate.STRING, "todate(", ",", ")" ) ); registerFunction( "to_date", new VarArgsSQLFunction( Hibernate.STRING, "todate(", ",", ")" ) ); registerFunction( "tonumber", new StandardSQLFunction( "tonumber" ) ); registerFunction( "to_number", new StandardSQLFunction( "tonumber" ) ); // TRIM(end_keyword string-expression-1 FROM string-expression-2) // use Hibernate implementation "From" is one of the parameters they pass in position ?3 //registerFunction( "trim", new SQLFunctionTemplate(Hibernate.STRING, "trim(?1 ?2 from ?3)") ); registerFunction( "truncate", new StandardJDBCEscapeFunction( "truncate", Hibernate.STRING ) ); registerFunction( "ucase", new StandardJDBCEscapeFunction( "ucase", Hibernate.STRING ) ); registerFunction( "upper", new StandardSQLFunction( "upper" ) ); // %upper is deprecated registerFunction( "%upper", new StandardSQLFunction( "%upper" ) ); registerFunction( "user", new StandardJDBCEscapeFunction( "user", Hibernate.STRING ) ); registerFunction( "week", new StandardJDBCEscapeFunction( "user", Hibernate.INTEGER ) ); registerFunction( "xmlconcat", new VarArgsSQLFunction( Hibernate.STRING, "xmlconcat(", ",", ")" ) ); registerFunction( "xmlelement", new VarArgsSQLFunction( Hibernate.STRING, "xmlelement(", ",", ")" ) ); // xmlforest requires a new kind of function constructor registerFunction( "year", new StandardJDBCEscapeFunction( "year", Hibernate.INTEGER ) );
public org.hibernate.sql.JoinFragment	createOuterJoinFragment() // Create an OuterJoinGenerator for this dialect. return new CacheJoinFragment();
public boolean	dropConstraints() // Do we need to drop constraints before dropping tables in this dialect? return true;
public boolean	dropTemporaryTableAfterUse() return true;
public java.lang.String	generateTemporaryTableName(java.lang.String baseTableName) String name = super.generateTemporaryTableName( baseTableName ); return name.length() > 25 ? name.substring( 1, 25 ) : name;
public java.lang.String	getAddColumnString() // The syntax used to add a column to a table return " add column";
public java.lang.String	getAddForeignKeyConstraintString(java.lang.String constraintName, java.lang.String[] foreignKey, java.lang.String referencedTable, java.lang.String[] primaryKey, boolean referencesPrimaryKey) The syntax used to add a foreign key constraint to a table. return String // The syntax used to add a foreign key constraint to a table. return new StringBuffer( 300 ) .append( " ADD CONSTRAINT " ) .append( constraintName ) .append( " FOREIGN KEY " ) .append( constraintName ) .append( " (" ) .append( StringHelper.join( ", ", foreignKey ) ) // identifier-commalist .append( ") REFERENCES " ) .append( referencedTable ) .append( " (" ) .append( StringHelper.join( ", ", primaryKey ) ) // identifier-commalist .append( ") " ) .toString();
public java.lang.String	getCascadeConstraintsString() // Completely optional cascading drop clause. return "";
public java.lang.String	getCreateTemporaryTablePostfix() return "";
public java.lang.String	getCreateTemporaryTableString() return "create global temporary table";
public java.lang.String	getIdentityColumnString() // The keyword used to specify an identity column, if identity column key generation is supported. return "identity";
public java.lang.String	getIdentitySelectString() return "SELECT LAST_IDENTITY() FROM %TSQL_sys.snf";
public java.lang.String	getLimitString(java.lang.String sql, boolean hasOffset) if ( hasOffset ) { throw new UnsupportedOperationException( "An offset may not be specified to <TOP n> in Cache SQL" ); } // This does not support the Cache SQL 'DISTINCT BY (comma-list)' extensions, // but this extension is not supported through Hibernate anyway. int insertionPoint = sql.startsWith( "select distinct" ) ? 15 : 6; return new StringBuffer( sql.length() + 8 ) .append( sql ) .insert( insertionPoint, " TOP ? " ) .toString();
public org.hibernate.dialect.lock.LockingStrategy	getLockingStrategy(org.hibernate.persister.entity.Lockable lockable, org.hibernate.LockMode lockMode) // InterSystems Cache' does not current support "SELECT ... FOR UPDATE" syntax... // Set your transaction mode to READ_COMMITTED before using if ( lockMode.greaterThan( LockMode.READ ) ) { return new UpdateLockingStrategy( lockable, lockMode ); } else { return new SelectLockingStrategy( lockable, lockMode ); }
public java.lang.String	getLowercaseFunction() // The name of the SQL function that transforms a string to lowercase return "lower";
public java.lang.Class	getNativeIdentifierGeneratorClass() return IdentityGenerator.class;
public java.lang.String	getNoColumnsInsertString() // The keyword used to insert a row without specifying // any column values return " default values";
public java.lang.String	getNullColumnString() // The keyword used to specify a nullable column. return " null";
public java.sql.ResultSet	getResultSet(java.sql.CallableStatement ps) ps.execute(); return ( ResultSet ) ps.getObject( 1 );
public boolean	hasAlterTable() // Does this dialect support the ALTER TABLE syntax? return true;
public boolean	hasDataTypeInIdentityColumn() // Whether this dialect has an Identity clause added to the data type or a completely seperate identity // data type return true;
public boolean	hasSelfReferentialForeignKeyBug() return true;
public java.lang.Boolean	performTemporaryTableDDLInIsolation() return Boolean.FALSE;
public boolean	qualifyIndexName() // Do we need to qualify index names with the schema name? return false;
protected final void	register71Functions() this.registerFunction( "str", new VarArgsSQLFunction( Hibernate.STRING, "str(", ",", ")" ) );
public int	registerResultSetOutParameter(java.sql.CallableStatement statement, int col) return col;
public boolean	supportsCascadeDelete() return true;
public boolean	supportsCheck() // Does this dialect support check constraints? return false;
public boolean	supportsEmptyInList() // Overridden informational metadata ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ return false;
public boolean	supportsForUpdate() // Does this dialect support the FOR UPDATE syntax? return false;
public boolean	supportsForUpdateNowait() // Does this dialect support the Oracle-style FOR UPDATE NOWAIT syntax? return false;
public boolean	supportsForUpdateOf() // Does this dialect support FOR UPDATE OF, allowing particular rows to be locked? return false;
public boolean	supportsIdentityColumns() return true;
public boolean	supportsLimit() return true;
public boolean	supportsLimitOffset() return false;
public boolean	supportsOuterJoinForUpdate() return false;
public boolean	supportsResultSetPositionQueryMethodsOnForwardOnlyCursor() return false;
public boolean	supportsSequences() return false;
public boolean	supportsTemporaryTables() return true;
public boolean	supportsUnique() // Does this dialect support the UNIQUE column syntax? return true;
public boolean	supportsVariableLimit() return true;
public boolean	useMaxForLimit() // Does the LIMIT clause take a "maximum" row number instead of a total number of returned rows? return true;