| Methods Summary |
|---|
| public java.lang.String | appendIdentitySelectToInsert(java.lang.String insertString)Provided we {@link #supportsInsertSelectIdentity}, then attch the
"select identity" clause to the insert statement.
Note, if {@link #supportsInsertSelectIdentity} == false then
the insert-string should be returned without modification.
return insertString;
|
| public java.lang.String | appendLockHint(org.hibernate.LockMode mode, java.lang.String tableName)Some dialects support an alternative means to SELECT FOR UPDATE,
whereby a "lock hint" is appends to the table name in the from clause.
contributed by Helge Schulz
return tableName;
|
| public java.lang.String | applyLocksToSql(java.lang.String sql, java.util.Map aliasedLockModes, java.util.Map keyColumnNames)Modifies the given SQL by applying the appropriate updates for the specified
lock modes and key columns.
The behavior here is that of an ANSI SQL SELECT FOR UPDATE. This
method is really intended to allow dialects which do not support
SELECT FOR UPDATE to achieve this in their own fashion.
return sql + new ForUpdateFragment( this, aliasedLockModes, keyColumnNames ).toFragmentString();
|
| public boolean | areStringComparisonsCaseInsensitive()Are string comparisons implicitly case insensitive.
In other words, does [where 'XYZ' = 'xyz'] resolve to true?
return false;
|
| public boolean | bindLimitParametersFirst()Does the LIMIT clause come at the start of the
SELECT statement, rather than at the end?
return false;
|
| public boolean | bindLimitParametersInReverseOrder()ANSI SQL defines the LIMIT clause to be in the form LIMIT offset, limit.
Does this dialect require us to bind the parameters in reverse order?
return false;
|
| public org.hibernate.exception.SQLExceptionConverter | buildSQLExceptionConverter()Build an instance of the SQLExceptionConverter preferred by this dialect for
converting SQLExceptions into Hibernate's JDBCException hierarchy. The default
Dialect implementation simply returns a converter based on X/Open SQLState codes.
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 ErrorCode rather than the SQLState. Unfortunately, the ErrorCode is a vendor-
specific approach.
// The default SQLExceptionConverter for all dialects is based on SQLState
// since SQLErrorCode is extremely vendor-specific. Specific Dialects
// may override to return whatever is most appropriate for that vendor.
return new SQLStateConverter( getViolatedConstraintNameExtracter() );
|
| public char | closeQuote()The character specific to this dialect used to close a quoted identifier.
return '"";
|
| public org.hibernate.sql.CaseFragment | createCaseFragment()Create a {@link org.hibernate.sql.CaseFragment} strategy responsible
for handling this dialect's variations in how CASE statements are
handled.
return new ANSICaseFragment();
|
| public org.hibernate.sql.JoinFragment | createOuterJoinFragment()Create a {@link org.hibernate.sql.JoinFragment} strategy responsible
for handling this dialect's variations in how joins are handled.
return new ANSIJoinFragment();
|
| public boolean | doesReadCommittedCauseWritersToBlockReaders()For the underlying database, is READ_COMMITTED isolation implemented by
forcing readers to wait for write locks to be released?
return false;
|
| public boolean | doesRepeatableReadCauseReadersToBlockWriters()For the underlying database, is REPEATABLE_READ isolation implemented by
forcing writers to wait for read locks to be released?
return false;
|
| public boolean | dropConstraints()Do we need to drop constraints before dropping tables in this dialect?
return true;
|
| public boolean | dropTemporaryTableAfterUse()Do we need to drop the temporary table after use?
return true;
|
| public boolean | forUpdateOfColumns()Is FOR UPDATE OF syntax supported?
// by default we report no support
return false;
|
| public java.lang.String | generateTemporaryTableName(java.lang.String baseTableName)Generate a temporary table name given the bas table.
return "HT_" + baseTableName;
|
| public java.lang.String | getAddColumnString()The syntax used to add a column to a table (optional).
throw new UnsupportedOperationException( "No add column syntax supported by Dialect" );
|
| 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.
StringBuffer res = new StringBuffer( 30 );
res.append( " add constraint " )
.append( constraintName )
.append( " foreign key (" )
.append( StringHelper.join( ", ", foreignKey ) )
.append( ") references " )
.append( referencedTable );
if ( !referencesPrimaryKey ) {
res.append( " (" )
.append( StringHelper.join( ", ", primaryKey ) )
.append( ')" );
}
return res.toString();
|
| public java.lang.String | getAddPrimaryKeyConstraintString(java.lang.String constraintName)The syntax used to add a primary key constraint to a table.
return " add constraint " + constraintName + " primary key ";
|
| public java.lang.String | getCascadeConstraintsString()Completely optional cascading drop clause
return "";
|
| public java.lang.String | getCastTypeName(int code)Get the name of the database type appropriate for casting operations
(via the CAST() SQL function) for the given {@link java.sql.Types} typecode.
return getTypeName( code, Column.DEFAULT_LENGTH, Column.DEFAULT_PRECISION, Column.DEFAULT_SCALE );
|
| public java.lang.String | getColumnComment(java.lang.String comment)
return "";
|
| public java.lang.String | getCreateMultisetTableString()Slight variation on {@link #getCreateTableString}. Here, we have the
command used to create a table when there is no primary key and
duplicate rows are expected.
Most databases do not care about the distinction; originally added for
Teradata support which does care.
return getCreateTableString();
|
| protected java.lang.String | getCreateSequenceString(java.lang.String sequenceName)Typically dialects which support sequences can create a sequence
with a single command. This is convenience form of
{@link #getCreateSequenceStrings} to help facilitate that.
Dialects which support sequences and can create a sequence in a
single command need *only* override this method. Dialects
which support sequences but require multiple commands to create
a sequence should instead override {@link #getCreateSequenceStrings}.
throw new MappingException( "Dialect does not support sequences" );
|
| protected java.lang.String | getCreateSequenceString(java.lang.String sequenceName, int initialValue, int incrementSize)Overloaded form of {@link #getCreateSequenceString(String)}, additionally
taking the initial value and increment size to be applied to the sequence
definition.
The default definition is to suffix {@link #getCreateSequenceString(String)}
with the string: " start with {initialValue} increment by {incrementSize}" where
{initialValue} and {incrementSize} are replacement placeholders. Generally
dialects should only need to override this method if different key phrases
are used to apply the allocation information.
if ( supportsPooledSequences() ) {
return getCreateSequenceString( sequenceName ) + " start with " + initialValue + " increment by " + incrementSize;
}
throw new MappingException( "Dialect does not support pooled sequences" );
|
| public java.lang.String[] | getCreateSequenceStrings(java.lang.String sequenceName)The multiline script used to create a sequence.
return new String[] { getCreateSequenceString( sequenceName ) };
|
| public java.lang.String[] | getCreateSequenceStrings(java.lang.String sequenceName, int initialValue, int incrementSize)An optional multi-line form for databases which {@link #supportsPooledSequences()}.
return new String[] { getCreateSequenceString( sequenceName, initialValue, incrementSize ) };
|
| public java.lang.String | getCreateTableString()Command used to create a table.
return "create table";
|
| public java.lang.String | getCreateTemporaryTablePostfix()Get any fragments needing to be postfixed to the command for
temporary table creation.
return "";
|
| public java.lang.String | getCreateTemporaryTableString()Command used to create a temporary table.
return "create table";
|
| public java.lang.String | getCurrentTimestampSQLFunctionName()The name of the database-specific SQL function for retrieving the
current timestamp.
// the standard SQL function name is current_timestamp...
return "current_timestamp";
|
| public java.lang.String | getCurrentTimestampSelectString()Retrieve the command used to retrieve the current timestammp from the
database.
throw new UnsupportedOperationException( "Database not known to define a current timestamp function" );
|
| public final java.util.Properties | getDefaultProperties()Retrieve a set of default Hibernate properties for this database.
return properties;
|
| public static org.hibernate.dialect.Dialect | getDialect()Get an instance of the dialect specified by the current System properties.
String dialectName = Environment.getProperties().getProperty( Environment.DIALECT );
return instantiateDialect( dialectName );
|
| public static org.hibernate.dialect.Dialect | getDialect(java.util.Properties props)Get an instance of the dialect specified by the given properties or by
the current System properties.
String dialectName = props.getProperty( Environment.DIALECT );
if ( dialectName == null ) {
return getDialect();
}
return instantiateDialect( dialectName );
|
| public java.lang.String | getDropForeignKeyString()
return " drop constraint ";
|
| protected java.lang.String | getDropSequenceString(java.lang.String sequenceName)Typically dialects which support sequences can drop a sequence
with a single command. This is convenience form of
{@link #getDropSequenceStrings} to help facilitate that.
Dialects which support sequences and can drop a sequence in a
single command need *only* override this method. Dialects
which support sequences but require multiple commands to drop
a sequence should instead override {@link #getDropSequenceStrings}.
throw new MappingException( "Dialect does not support sequences" );
|
| public java.lang.String[] | getDropSequenceStrings(java.lang.String sequenceName)The multiline script used to drop a sequence.
return new String[]{getDropSequenceString( sequenceName )};
|
| public java.lang.String | getForUpdateNowaitString()Retrieves the FOR UPDATE NOWAIT syntax specific to this dialect.
// by default we report no support for NOWAIT lock semantics
return getForUpdateString();
|
| public java.lang.String | getForUpdateNowaitString(java.lang.String aliases)Get the FOR UPDATE OF column_list NOWAIT fragment appropriate
for this dialect given the aliases of the columns to be write locked.
return getForUpdateString( aliases );
|
| public java.lang.String | getForUpdateString(org.hibernate.LockMode lockMode)Given a lock mode, determine the appropriate for update fragment to use.
if ( lockMode==LockMode.UPGRADE ) {
return getForUpdateString();
}
else if ( lockMode==LockMode.UPGRADE_NOWAIT ) {
return getForUpdateNowaitString();
}
else if ( lockMode==LockMode.FORCE ) {
return getForUpdateNowaitString();
}
else {
return "";
}
|
| public java.lang.String | getForUpdateString()Get the string to append to SELECT statements to acquire locks
for this dialect.
return " for update";
|
| public java.lang.String | getForUpdateString(java.lang.String aliases)Get the FOR UPDATE OF column_list fragment appropriate for this
dialect given the aliases of the columns to be write locked.
// by default we simply return the getForUpdateString() result since
// the default is to say no support for "FOR UPDATE OF ..."
return getForUpdateString();
|
| public final java.util.Map | getFunctions()Retrieves a map of the dialect's registered fucntions
(functionName => {@link org.hibernate.dialect.function.SQLFunction}).
return sqlFunctions;
|
| public java.lang.String | getHibernateTypeName(int code)Get the name of the Hibernate {@link org.hibernate.type.Type} associated with th given
{@link java.sql.Types} typecode.
String result = hibernateTypeNames.get( code );
if ( result == null ) {
throw new HibernateException( "No Hibernate type mapping for java.sql.Types code: " + code );
}
return result;
|
| public java.lang.String | getHibernateTypeName(int code, int length, int precision, int scale)Get the name of the Hibernate {@link org.hibernate.type.Type} associated
with the given {@link java.sql.Types} typecode with the given storage
specification parameters.
String result = hibernateTypeNames.get( code, length, precision, scale );
if ( result == null ) {
throw new HibernateException(
"No Hibernate type mapping for java.sql.Types code: " +
code +
", length: " +
length
);
}
return result;
|
| public java.lang.String | getIdentityColumnString(int type)The syntax used during DDL to define a column as being an IDENTITY of
a particular type.
return getIdentityColumnString();
|
| protected java.lang.String | getIdentityColumnString()The syntax used during DDL to define a column as being an IDENTITY.
throw new MappingException( "Dialect does not support identity key generation" );
|
| public java.lang.String | getIdentityInsertString()The keyword used to insert a generated value into an identity column (or null).
Need if the dialect does not support inserts that specify no column values.
return null;
|
| public java.lang.String | getIdentitySelectString(java.lang.String table, java.lang.String column, int type)Get the select command to use to retrieve the last generated IDENTITY
value for a particuar table
return getIdentitySelectString();
|
| protected java.lang.String | getIdentitySelectString()Get the select command to use to retrieve the last generated IDENTITY
value.
throw new MappingException( "Dialect does not support identity key generation" );
|
| public java.util.Set | getKeywords()
return sqlKeywords;
|
| public java.lang.String | getLimitString(java.lang.String query, int offset, int limit)Given a limit and an offset, apply the limit clause to the query.
return getLimitString( query, offset > 0 );
|
| protected java.lang.String | getLimitString(java.lang.String query, boolean hasOffset)Apply s limit clause to the query.
Typically dialects utilize {@link #supportsVariableLimit() variable}
limit caluses when they support limits. Thus, when building the
select command we do not actually need to know the limit or the offest
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
{@link #getLimitString(String, int, int)}.
throw new UnsupportedOperationException( "paged queries not supported" );
|
| public org.hibernate.dialect.lock.LockingStrategy | getLockingStrategy(org.hibernate.persister.entity.Lockable lockable, org.hibernate.LockMode lockMode)Get a strategy instance which knows how to acquire a database-level lock
of the specified mode for this dialect.
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 int | getMaxAliasLength()What is the maximum length Hibernate can use for generated aliases?
return 10;
|
| public java.lang.Class | getNativeIdentifierGeneratorClass()The class (which implements {@link org.hibernate.id.IdentifierGenerator})
which acts as this dialects native generation strategy.
Comes into play whenever the user specifies the native generator.
if ( supportsIdentityColumns() ) {
return IdentityGenerator.class;
}
else if ( supportsSequences() ) {
return SequenceGenerator.class;
}
else {
return TableHiLoGenerator.class;
}
|
| public java.lang.String | getNoColumnsInsertString()The fragment used to insert a row without specifying any column values.
This is not possible on some databases.
return "values ( )";
|
| public java.lang.String | getNullColumnString()The keyword used to specify a nullable column.
return "";
|
| public java.lang.String | getQuerySequencesString()Get the select command used retrieve the names of all sequences.
return null;
|
| public java.sql.ResultSet | getResultSet(java.sql.CallableStatement statement)Given a callable statement previously processed by {@link #registerResultSetOutParameter},
extract the {@link java.sql.ResultSet} from the OUT parameter.
throw new UnsupportedOperationException(
getClass().getName() +
" does not support resultsets via stored procedures"
);
|
| public java.lang.String | getSelectClauseNullString(int sqlType)Given a {@link java.sql.Types} type code, determine an appropriate
null value to use in a select clause.
One thing to consider here is that certain databases might
require proper casting for the nulls here since the select here
will be part of a UNION/UNION ALL.
return "null";
|
| public java.lang.String | getSelectGUIDString()Get the command used to select a GUID from the underlying database.
Optional operation.
throw new UnsupportedOperationException( "dialect does not support GUIDs" );
|
| public java.lang.String | getSelectSequenceNextValString(java.lang.String sequenceName)Generate the select expression fragment that will retreive the next
value of a sequence as part of another (typically DML) statement.
This differs from {@link #getSequenceNextValString(String)} in that this
should return an expression usable within another statement.
throw new MappingException( "Dialect does not support sequences" );
|
| public java.lang.String | getSequenceNextValString(java.lang.String sequenceName)Generate the appropriate select statement to to retreive the next value
of a sequence.
This should be a "stand alone" select statement.
throw new MappingException( "Dialect does not support sequences" );
|
| public java.lang.String | getTableComment(java.lang.String comment)
return "";
|
| public java.lang.String | getTableTypeString()
// grrr... for differentiation of mysql storage engines
return "";
|
| public java.lang.String | getTypeName(int code)Get the name of the database type associated with the given
{@link java.sql.Types} typecode.
String result = typeNames.get( code );
if ( result == null ) {
throw new HibernateException( "No default type mapping for (java.sql.Types) " + code );
}
return result;
|
| public java.lang.String | getTypeName(int code, int length, int precision, int scale)Get the name of the database type associated with the given
{@link java.sql.Types} typecode with the given storage specification
parameters.
String result = typeNames.get( code, length, precision, scale );
if ( result == null ) {
throw new HibernateException(
"No type mapping for java.sql.Types code: " +
code +
", length: " +
length
);
}
return result;
|
| public org.hibernate.exception.ViolatedConstraintNameExtracter | getViolatedConstraintNameExtracter()
return EXTRACTER;
|
| public boolean | hasAlterTable()Does this dialect support the ALTER TABLE syntax?
return true;
|
| public boolean | hasDataTypeInIdentityColumn()Whether this dialect have an Identity clause added to the data type or a
completely seperate identity data type
return true;
|
| public boolean | hasSelfReferentialForeignKeyBug()
return false;
|
| private static org.hibernate.dialect.Dialect | instantiateDialect(java.lang.String dialectName)
if ( dialectName == null ) {
throw new HibernateException( "The dialect was not set. Set the property hibernate.dialect." );
}
try {
return ( Dialect ) ReflectHelper.classForName( dialectName ).newInstance();
}
catch ( ClassNotFoundException cnfe ) {
throw new HibernateException( "Dialect class not found: " + dialectName );
}
catch ( Exception e ) {
throw new HibernateException( "Could not instantiate dialect class", e );
}
|
| public boolean | isCurrentTimestampSelectStringCallable()Should the value returned by {@link #getCurrentTimestampSelectString}
be treated as callable. Typically this indicates that JDBC escape
sytnax is being used...
throw new UnsupportedOperationException( "Database not known to define a current timestamp function" );
|
| public char | openQuote()The character specific to this dialect used to begin a quoted identifier.
return '"";
|
| public java.lang.Boolean | performTemporaryTableDDLInIsolation()Does the dialect require that temporary table DDL statements occur in
isolation from other statements? This would be the case if the creation
would cause any current transaction to get committed implicitly.
JDBC defines a standard way to query for this information via the
{@link java.sql.DatabaseMetaData#dataDefinitionCausesTransactionCommit()}
method. However, that does not distinguish between temporary table
DDL and other forms of DDL; MySQL, for example, reports DDL causing a
transaction commit via its driver, even though that is not the case for
temporary table DDL.
Possible return values and their meanings:
- {@link Boolean#TRUE} - Unequivocally, perform the temporary table DDL
in isolation.
- {@link Boolean#FALSE} - Unequivocally, do not perform the
temporary table DDL in isolation.
- null - defer to the JDBC driver response in regards to
{@link java.sql.DatabaseMetaData#dataDefinitionCausesTransactionCommit()}
return null;
|
| public boolean | qualifyIndexName()Do we need to qualify index names with the schema name?
return true;
|
| public final java.lang.String | quote(java.lang.String column)Apply dialect-specific quoting.
By default, the incoming value is checked to see if its first character
is the back-tick (`). If so, the dialect specific quoting is applied.
if ( column.charAt( 0 ) == '`" ) {
return openQuote() + column.substring( 1, column.length() - 1 ) + closeQuote();
}
else {
return column;
}
|
| protected void | registerColumnType(int code, int capacity, java.lang.String name)Subclasses register a type name for the given type code and maximum
column length. $l in the type name with be replaced by the
column length (if appropriate).
typeNames.put( code, capacity, name );
|
| protected void | registerColumnType(int code, java.lang.String name)Subclasses register a type name for the given type code. $l in
the type name with be replaced by the column length (if appropriate).
typeNames.put( code, name );
|
| protected void | registerFunction(java.lang.String name, org.hibernate.dialect.function.SQLFunction function)
sqlFunctions.put( name, function );
|
| protected void | registerHibernateType(int code, int capacity, java.lang.String name)Registers a Hibernate {@link org.hibernate.type.Type} name for the given
{@link java.sql.Types} type code and maximum column length.
hibernateTypeNames.put( code, capacity, name);
|
| protected void | registerHibernateType(int code, java.lang.String name)Registers a Hibernate {@link org.hibernate.type.Type} name for the given
{@link java.sql.Types} type code.
hibernateTypeNames.put( code, name);
|
| protected void | registerKeyword(java.lang.String word)
sqlKeywords.add(word);
|
| public int | registerResultSetOutParameter(java.sql.CallableStatement statement, int position)Registers an OUT parameter which will be returing a
{@link java.sql.ResultSet}. How this is accomplished varies greatly
from DB to DB, hence its inclusion (along with {@link #getResultSet}) here.
throw new UnsupportedOperationException(
getClass().getName() +
" does not support resultsets via stored procedures"
);
|
| public boolean | supportsBindAsCallableArgument()Does this dialect support using a JDBC bind parameter as an argument
to a function or procedure call?
return true;
|
| public boolean | supportsCascadeDelete()
return true;
|
| public boolean | supportsCircularCascadeDeleteConstraints()Does this dialect support definition of cascade delete constraints
which can cause circular chains?
return true;
|
| public boolean | supportsColumnCheck()Does this dialect support column-level check constraints?
return true;
|
| public boolean | supportsCommentOn()
return false;
|
| public boolean | supportsCurrentTimestampSelection()Does this dialect support a way to retrieve the database's current
timestamp value?
return false;
|
| public boolean | supportsEmptyInList()Does this dialect support empty IN lists?
For example, is [where XYZ in ()] a supported construct?
return true;
|
| public boolean | supportsExistsInSelect()Does the dialect support an exists statement in the select clause?
return true;
|
| public boolean | supportsExpectedLobUsagePattern()Expected LOB usage pattern is such that I can perform an insert
via prepared statement with a parameter binding for a LOB value
without crazy casting to JDBC driver implementation-specific classes...
Part of the trickiness here is the fact that this is largely
driver dependent. For example, Oracle (which is notoriously bad with
LOB support in their drivers historically) actually does a pretty good
job with LOB support as of the 10.2.x versions of their drivers...
return true;
|
| public boolean | supportsIdentityColumns()Does this dialect support identity column key generation?
return false;
|
| public boolean | supportsIfExistsAfterTableName()
return false;
|
| public boolean | supportsIfExistsBeforeTableName()
return false;
|
| public boolean | supportsInsertSelectIdentity()Does the dialect support some form of inserting and selecting
the generated IDENTITY value all in the same statement.
return false;
|
| public boolean | supportsLimit()Does this dialect support some form of limiting query results
via a SQL clause?
return false;
|
| public boolean | supportsLimitOffset()Does this dialect's LIMIT support (if any) additionally
support specifying an offset?
return supportsLimit();
|
| public boolean | supportsLobValueChangePropogation()Does the dialect support propogating changes to LOB
values back to the database? Talking about mutating the
internal value of the locator as opposed to supplying a new
locator instance...
For BLOBs, the internal value might be changed by:
{@link java.sql.Blob#setBinaryStream},
{@link java.sql.Blob#setBytes(long, byte[])},
{@link java.sql.Blob#setBytes(long, byte[], int, int)},
or {@link java.sql.Blob#truncate(long)}.
For CLOBs, the internal value might be changed by:
{@link java.sql.Clob#setAsciiStream(long)},
{@link java.sql.Clob#setCharacterStream(long)},
{@link java.sql.Clob#setString(long, String)},
{@link java.sql.Clob#setString(long, String, int, int)},
or {@link java.sql.Clob#truncate(long)}.
NOTE : I do not know the correct answer currently for
databases which (1) are not part of the cruise control process
or (2) do not {@link #supportsExpectedLobUsagePattern}.
return true;
|
| public boolean | supportsNotNullUnique()
return true;
|
| public boolean | supportsOuterJoinForUpdate()Does this dialect support FOR UPDATE in conjunction with
outer joined rows?
return true;
|
| public boolean | supportsParametersInInsertSelect()Does this dialect support parameters within the select clause of
INSERT ... SELECT ... statements?
return true;
|
| public boolean | supportsPooledSequences()Does this dialect support "pooled" sequences. Not aware of a better
name for this. Essentially can we specify the initial and increment values?
return false;
|
| public boolean | supportsResultSetPositionQueryMethodsOnForwardOnlyCursor()Does this dialect support asking the result set its positioning
information on forward only cursors. Specifically, in the case of
scrolling fetches, Hibernate needs to use
{@link java.sql.ResultSet#isAfterLast} and
{@link java.sql.ResultSet#isBeforeFirst}. Certain drivers do not
allow access to these methods for forward only cursors.
NOTE : this is highly driver dependent!
return true;
|
| public boolean | supportsRowValueConstructorSyntax()Is this dialect known to support what ANSI-SQL terms "row value
constructor" syntax; sometimes called tuple syntax.
Basically, does it support syntax like
"... where (FIRST_NAME, LAST_NAME) = ('Steve', 'Ebersole') ...".
// return false here, as most databases do not properly support this construct...
return false;
|
| public boolean | supportsRowValueConstructorSyntaxInInList()If the dialect supports {@link #supportsRowValueConstructorSyntax() row values},
does it offer such support in IN lists as well?
For example, "... where (FIRST_NAME, LAST_NAME) IN ( (?, ?), (?, ?) ) ..."
return false;
|
| public boolean | supportsSequences()Does this dialect support sequences?
return false;
|
| public boolean | supportsSubqueryOnMutatingTable()Does this dialect support referencing the table being mutated in
a subquery. The "table being mutated" is the table referenced in
an UPDATE or a DELETE query. And so can that table then be
referenced in a subquery of said UPDATE/DELETE query.
For example, would the following two syntaxes be supported:
- delete from TABLE_A where ID not in ( select ID from TABLE_A )
- update TABLE_A set NON_ID = 'something' where ID in ( select ID from TABLE_A)
return true;
|
| public boolean | supportsSubselectAsInPredicateLHS()Are subselects supported as the left-hand-side (LHS) of
IN-predicates.
In other words, is syntax like "... IN (1, 2, 3) ..." supported?
return true;
|
| public boolean | supportsTableCheck()Does this dialect support table-level check constraints?
return true;
|
| public boolean | supportsTemporaryTables()Does this dialect support temporary tables?
return false;
|
| public boolean | supportsUnboundedLobLocatorMaterialization()Is it supported to materialize a LOB locator outside the transaction in
which it was created?
Again, part of the trickiness here is the fact that this is largely
driver dependent.
NOTE: all database I have tested which {@link #supportsExpectedLobUsagePattern()}
also support the ability to materialize a LOB outside the owning transaction...
return true;
|
| public boolean | supportsUnionAll()Does this dialect support UNION ALL, which is generally a faster
variant of UNION?
return false;
|
| public boolean | supportsUnique()Does this dialect support the UNIQUE column syntax?
return true;
|
| public boolean | supportsUniqueConstraintInCreateAlterTable()Does this dialect support adding Unique constraints via create and alter table ?
return true;
|
| public boolean | supportsVariableLimit()Does this dialect support bind variables (i.e., prepared statememnt
parameters) for its limit/offset?
return supportsLimit();
|
| public java.lang.String | toBooleanValueString(boolean bool)The SQL literal value to which this database maps boolean values.
return bool ? "1" : "0";
|
| public java.lang.String | toString()
return getClass().getName();
|
| public java.lang.String | transformSelectString(java.lang.String select)Meant as a means for end users to affect the select strings being sent
to the database and perhaps manipulate them in some fashion.
The recommend approach is to instead use
{@link org.hibernate.Interceptor#onPrepareStatement(String)}.
return select;
|
| public boolean | useInputStreamToInsertBlob()Should LOBs (both BLOB and CLOB) be bound using stream operations (i.e.
{@link java.sql.PreparedStatement#setBinaryStream}).
return true;
|
| public boolean | useMaxForLimit()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?
return false;
|
