Dialect (hibernate-core JavaDocs)

java.lang.Object
- org.hibernate.dialect.Dialect

All Implemented Interfaces:

ConversionContext

Direct Known Subclasses:

AbstractHANADialect, AbstractTransactSQLDialect, CockroachDialect, DB2Dialect, DerbyDialect, H2Dialect, HSQLDialect, MySQLDialect, OracleDialect, PostgreSQLDialect, SpannerDialect
```
public abstract class Dialect
extends Object
implements ConversionContext
```
Represents a dialect of SQL implemented by a particular RDBMS. Subclasses implement Hibernate compatibility with different database platforms. Subclasses must provide a public constructor that registers a set of type mappings from JDBC type codes to database native type names, along with default Hibernate properties. This constructor may have no parameters, or it may have a single parameter of type DialectResolutionInfo. Subclasses should be immutable.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static interface`	`Dialect.SizeStrategy` Pluggable strategy for determining the Size to use for columns of a given SQL type.
`class`	`Dialect.SizeStrategyImpl`

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`CLOSED_QUOTE` Characters used as closing for quoting SQL identifiers
`static String`	`DEFAULT_BATCH_SIZE` Defines a default batch size constant
`protected static LobMergeStrategy`	`LEGACY_LOB_MERGE_STRATEGY` The legacy behavior of Hibernate.
`protected static LobMergeStrategy`	`NEW_LOCATOR_LOB_MERGE_STRATEGY` Merge strategy based on creating a new LOB locator.
`protected static String`	`NO_BATCH` Defines a "no batching" batch size constant
`static String`	`QUOTE` Characters used as opening for quoting SQL identifiers
`protected BatchLoadSizingStrategy`	`STANDARD_DEFAULT_BATCH_LOAD_SIZING_STRATEGY`
`protected static LobMergeStrategy`	`STREAM_XFER_LOB_MERGE_STRATEGY` Merge strategy based on transferring contents based on streams.
`static String`	`TWO_SINGLE_QUOTES_REPLACEMENT`

Constructor Summary

Constructors
Modifier Constructor and Description

protected Dialect()

Constructors
Modifier	Constructor and Description
`protected`	`Dialect()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`String`	`addSqlHintOrComment(String sql, QueryOptions queryOptions, boolean commentsEnabled)` Modify the SQL, adding hints or comments, if necessary
`String`	`appendLockHint(LockMode mode, String tableName)` Deprecated. use `appendLockHint(LockOptions,String)` instead
`String`	`appendLockHint(LockOptions lockOptions, String tableName)` Deprecated. This was moved to `AbstractSqlAstTranslator`
`String`	`applyLocksToSql(String sql, LockOptions aliasedLockOptions, Map<String,String[]> keyColumnNames)` Modifies the given SQL by applying the appropriate updates for the specified lock modes and key columns.
`boolean`	`areStringComparisonsCaseInsensitive()` Are string comparisons implicitly case insensitive.
`void`	`augmentRecognizedTableTypes(List<String> tableTypesList)`
`protected static Size`	`binaryToDecimalPrecision(int code, Size size)` Useful conversion for databases which represent the precision of a float(p) using p expressed in decimal digits instead of the usual (standard) binary digits.
`boolean`	`bindLimitParametersFirst()` Deprecated. `getLimitHandler()` should be overridden instead.
`boolean`	`bindLimitParametersInReverseOrder()` Deprecated. `getLimitHandler()` should be overridden instead.
`IdentifierHelper`	`buildIdentifierHelper(IdentifierHelperBuilder builder, DatabaseMetaData dbMetaData)` Build the IdentifierHelper indicated by this Dialect for handling identifier conversions.
`SQLExceptionConversionDelegate`	`buildSQLExceptionConversionDelegate()` Build an instance of a `SQLExceptionConversionDelegate` for interpreting dialect-specific error or SQLState codes.
`SQLExceptionConverter`	`buildSQLExceptionConverter()` Deprecated. `buildSQLExceptionConversionDelegate()` should be overridden instead.
`boolean`	`canCreateCatalog()` Does this dialect support catalog creation?
`boolean`	`canCreateSchema()` Does this dialect support schema creation?
`String`	`castPattern(CastType from, CastType to)` Obtain a pattern for the SQL equivalent to a `cast()` function call.
`char`	`closeQuote()` The character specific to this dialect used to close a quoted identifier.
`void`	`contributeTypes(TypeContributions typeContributions, ServiceRegistry serviceRegistry)` Allows the Dialect to contribute additional types
`int`	`convertToFirstRowValue(int zeroBasedFirstResult)` Deprecated. `getLimitHandler()` should be overridden instead.
`CaseFragment`	`createCaseFragment()` Deprecated. migrating away from deprecated `CaseFragment`
`JoinFragment`	`createOuterJoinFragment()` Deprecated. migrating away from deprecated `JoinFragment`
`String`	`currentDate()` Translation of the HQL/JPQL `current_date` function, which maps to the Java type `java.sql.Date`, and of the HQL `local_date` function which maps to the Java type `java.sql.LocalDate`.
`String`	`currentLocalTime()` Translation of the HQL `local_time` function, which maps to the Java type `java.time.LocalTime` which is a time with no time zone.
`String`	`currentLocalTimestamp()` Translation of the HQL `local_datetime` function, which maps to the Java type `java.time.LocalDateTime` which is a datetime with no time zone.
`String`	`currentTime()` Translation of the HQL/JPQL `current_time` function, which maps to the Java type `java.sql.Time` which is a time with no time zone.
`String`	`currentTimestamp()` Translation of the HQL/JPQL `current_timestamp` function, which maps to the Java type `java.sql.Timestamp` which is a datetime with no time zone.
`String`	`currentTimestampWithTimeZone()` Translation of the HQL `offset_datetime` function, which maps to the Java type `java.time.OffsetDateTime` which is a datetime with a time zone.
`ScrollMode`	`defaultScrollMode()` Certain dialects support a subset of ScrollModes.
`boolean`	`doesReadCommittedCauseWritersToBlockReaders()` For the underlying database, is READ_COMMITTED isolation implemented by forcing readers to wait for write locks to be released?
`boolean`	`doesRepeatableReadCauseReadersToBlockWriters()` For the underlying database, is REPEATABLE_READ isolation implemented by forcing writers to wait for read locks to be released?
`boolean`	`dropConstraints()` Do we need to drop constraints before dropping tables in this dialect?
`boolean`	`equivalentTypes(int typeCode1, int typeCode2)` Do the given JDBC type codes, as defined in `Types` represent essentially the same type in this dialect of SQL? The default implementation treats `NUMERIC` and `DECIMAL` as the same type, and `FLOAT`, `REAL`, and `DOUBLE` as essentially the same type, since the ANSI SQL specification fails to meaningfully distinguish them.
`static String`	`escapeComment(String comment)`
`protected String`	`escapeLiteral(String literal)` Escape String literal.
`String`	`extractPattern(TemporalUnit unit)` Obtain a pattern for the SQL equivalent to an `extract()` function call.
`boolean`	`forceLimitUsage()` Deprecated. `getLimitHandler()` should be overridden instead.
`boolean`	`forceLobAsLastValue()` HHH-4635 Oracle expects all Lob values to be last in inserts and updates.
`protected String`	`formatAsTimestamp(Calendar calendar, TimeZone jdbcTimeZone)`
`protected String`	`formatAsTimestamp(Date date, TimeZone jdbcTimeZone)`
`protected String`	`formatAsTimestamp(TemporalAccessor temporalAccessor, TimeZone jdbcTimeZone)`
`String`	`formatBinaryLiteral(byte[] bytes)`
`String`	`formatDateTimeLiteral(Calendar calendar, TemporalType precision, TimeZone jdbcTimeZone)`
`String`	`formatDateTimeLiteral(Date date, TemporalType precision, TimeZone jdbcTimeZone)`
`String`	`formatDateTimeLiteral(TemporalAccessor temporalAccessor, TemporalType precision, TimeZone jdbcTimeZone)`
`boolean`	`forUpdateOfColumns()` Deprecated. Use `getWriteRowLockStrategy()` instead
`String`	`getAddColumnString()` The syntax used to add a column to a table (optional).
`String`	`getAddColumnSuffixString()` The syntax for the suffix used to add a column to a table (optional).
`String`	`getAddForeignKeyConstraintString(String constraintName, String foreignKeyDefinition)`
`String`	`getAddForeignKeyConstraintString(String constraintName, String[] foreignKey, String referencedTable, String[] primaryKey, boolean referencesPrimaryKey)` The syntax used to add a foreign key constraint to a table.
`String`	`getAddPrimaryKeyConstraintString(String constraintName)` The syntax used to add a primary key constraint to a table.
`String`	`getAddUniqueConstraintString(String constraintName)` Deprecated. `getUniqueDelegate()` should be overridden instead.
`String`	`getAlterTableString(String tableName)` Command used to alter a table.
`Exporter<AuxiliaryDatabaseObject>`	`getAuxiliaryDatabaseObjectExporter()`
`String`	`getBooleanCheckCondition(String columnName, int sqlType, char falseChar, char trueChar)` Render a SQL check condition for a column that represents a boolean value.
`CallableStatementSupport`	`getCallableStatementSupport()`
`String`	`getCascadeConstraintsString()` The keyword that specifies that a `drop table` operation should be cascaded to its constraints, typically `" cascade"` where the leading space is required, or the empty string if there is no such keyword in this dialect.
`String`	`getCaseInsensitiveLike()` The name of the SQL function that can do case insensitive like comparison.
`String`	`getCastTypeName(SqlExpressable type, Long length, Integer precision, Integer scale)` Get the name of the database type appropriate for casting operations (via the CAST() SQL function) for the given `SqlExpressable` SQL type.
`ColumnAliasExtractor`	`getColumnAliasExtractor()`
`String`	`getColumnComment(String comment)` Get the comment into a form supported for column definition.
`String[]`	`getCreateCatalogCommand(String catalogName)` Get the SQL command used to create the named catalog
`String`	`getCreateMultisetTableString()` Slight variation on `getCreateTableString()`.
`String[]`	`getCreateSchemaCommand(String schemaName)` Get the SQL command used to create the named schema
`protected String`	`getCreateSequenceString(String sequenceName)` Deprecated. implement `SequenceSupport` and override `getSequenceSupport()`
`protected String`	`getCreateSequenceString(String sequenceName, int initialValue, int incrementSize)` Deprecated. implement `SequenceSupport` and override `getSequenceSupport()`
`String[]`	`getCreateSequenceStrings(String sequenceName, int initialValue, int incrementSize)` Deprecated. implement `SequenceSupport` and override `getSequenceSupport()`
`String`	`getCreateTableString()` Command used to create a table.
`String`	`getCreateTemporaryTableColumnAnnotation(int sqlTypeCode)` Annotation to be appended to the end of each COLUMN clause for temporary tables.
`String`	`getCrossJoinSeparator()` The separator to use for declaring cross joins in a SQL query, typically either `" cross join "` or a comma `", "`, where the spaces are required.
`String`	`getCurrentSchemaCommand()` Get the SQL command used to retrieve the current schema name.
`String`	`getCurrentTimestampSelectString()` Deprecated. no longer called, use `currentTimestamp()`
`String`	`getCurrentTimestampSQLFunctionName()` Deprecated. use `currentTimestamp()`, `currentLocalTimestamp()`, or `currentTimestampWithTimeZone()`.
`BatchLoadSizingStrategy`	`getDefaultBatchLoadSizingStrategy()`
`int`	`getDefaultDecimalPrecision()` This is the default precision for a generated column mapped to a `BigInteger` or `BigDecimal`.
`long`	`getDefaultLobLength()`
`Properties`	`getDefaultProperties()` Retrieve a set of default Hibernate properties for this database.
`int`	`getDefaultTimestampPrecision()` This is the default precision for a generated column mapped to a `Timestamp` or `LocalDateTime`.
`static Dialect`	`getDialect()` Deprecated. this just calls the default constructor and does not pass in the `DialectResolutionInfo`.
`static Dialect`	`getDialect(Properties props)` Deprecated. this just calls the default constructor and does not pass in the `DialectResolutionInfo`.
`int`	`getDoublePrecision()` This is the default precision for a generated column mapped to a Java `Double` or `double`.
`String[]`	`getDropCatalogCommand(String catalogName)` Get the SQL command used to drop the named catalog
`String`	`getDropForeignKeyString()`
`String[]`	`getDropSchemaCommand(String schemaName)` Get the SQL command used to drop the named schema
`protected String`	`getDropSequenceString(String sequenceName)` Deprecated. implement `SequenceSupport` and override `getSequenceSupport()`
`String[]`	`getDropSequenceStrings(String sequenceName)` Deprecated. implement `SequenceSupport` and override `getSequenceSupport()`
`String`	`getDropTableString(String tableName)` Generate a DROP TABLE statement
`String`	`getEnumCheckCondition(String columnName, int sqlType, Class<? extends Enum<?>> enumClass)` Render a SQL check condition for a column that represents an enumerated value.
`SqmMultiTableMutationStrategy`	`getFallbackSqmMutationStrategy(EntityMappingType entityDescriptor, RuntimeModelCreationContext runtimeModelCreationContext)`
`int`	`getFloatPrecision()` This is the default precision for a generated column mapped to a Java `Float` or `float`.
`Exporter<ForeignKey>`	`getForeignKeyExporter()`
`String`	`getForUpdateNowaitString()` Retrieves the `FOR UPDATE NOWAIT` syntax specific to this dialect.
`String`	`getForUpdateNowaitString(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.
`String`	`getForUpdateSkipLockedString()` Retrieves the `FOR UPDATE SKIP LOCKED` syntax specific to this dialect.
`String`	`getForUpdateSkipLockedString(String aliases)` Get the `FOR UPDATE OF column_list SKIP LOCKED` fragment appropriate for this dialect given the aliases of the columns to be write locked.
`String`	`getForUpdateString()` Get the string to append to SELECT statements to acquire locks for this dialect.
`String`	`getForUpdateString(LockMode lockMode)` Given a lock mode, determine the appropriate for update fragment to use.
`String`	`getForUpdateString(LockOptions lockOptions)` Given LockOptions (lockMode, timeout), determine the appropriate for update fragment to use.
`String`	`getForUpdateString(String aliases)` Get the `FOR UPDATE OF column_list` fragment appropriate for this dialect given the aliases of the columns to be write locked.
`String`	`getForUpdateString(String aliases, LockOptions lockOptions)` Get the `FOR UPDATE OF column_list` fragment appropriate for this dialect given the aliases of the columns to be write locked.
`long`	`getFractionalSecondPrecisionInNanos()` The "native" precision for arithmetic with datetimes and day-to-second durations.
`String`	`getFromDual()` Deprecated. Moved to `AbstractSqlAstTranslator`
`GroupByConstantRenderingStrategy`	`getGroupByConstantRenderingStrategy()` Deprecated. Moved to `AbstractSqlAstTranslator`
`GroupBySummarizationRenderingStrategy`	`getGroupBySummarizationRenderingStrategy()` Deprecated. Moved to `AbstractSqlAstTranslator`
`String`	`getHibernateTypeName(int code)` Get the name of the Hibernate `Type` associated with the given `Types` type code.
`String`	`getHibernateTypeName(int code, Integer length, Integer precision, Integer scale)` Get the name of the Hibernate `Type` associated with the given `Types` typecode with the given storage specification parameters.
`HqlTranslator`	`getHqlTranslator()` Return an HqlTranslator specific for the Dialect.
`IdentityColumnSupport`	`getIdentityColumnSupport()` Get the appropriate `IdentityColumnSupport`
`Exporter<Index>`	`getIndexExporter()`
`int`	`getInExpressionCountLimit()` Return the limit that the underlying database places on the number of elements in an `IN` predicate.
`Set<String>`	`getKeywords()` Deprecated. These are only ever used (if at all) from the code that handles identifier quoting. So see `buildIdentifierHelper(org.hibernate.engine.jdbc.env.spi.IdentifierHelperBuilder, java.sql.DatabaseMetaData)` instead
`LimitHandler`	`getLimitHandler()` Returns a `LimitHandler` that implements support for `Query.setMaxResults(int)` and `Query.setFirstResult(int)` for this dialect.
`protected String`	`getLimitString(String query, boolean hasOffset)` Deprecated. `getLimitHandler()` should be overridden instead.
`String`	`getLimitString(String query, int offset, int limit)` Deprecated. `getLimitHandler()` should be overridden instead.
`LobMergeStrategy`	`getLobMergeStrategy()`
`LockingStrategy`	`getLockingStrategy(Lockable lockable, LockMode lockMode)` Get a strategy instance which knows how to acquire a database-level lock of the specified mode for this dialect.
`RowLockStrategy`	`getLockRowIdentifier(LockMode lockMode)`
`String`	`getLowercaseFunction()` The name of the SQL function that transforms a string to lowercase
`int`	`getMaxAliasLength()` What is the maximum length Hibernate can use for generated aliases? The maximum here should account for the fact that Hibernate often needs to append "uniqueing" information to the end of generated aliases.
`NameQualifierSupport`	`getNameQualifierSupport()` By default interpret this based on DatabaseMetaData.
`NationalizationSupport`	`getNationalizationSupport()`
`Class`	`getNativeIdentifierGeneratorClass()` Deprecated. use `getNativeIdentifierGeneratorStrategy()` instead
`String`	`getNativeIdentifierGeneratorStrategy()` Resolves the native generation strategy associated to this dialect.
`String`	`getNoColumnsInsertString()` The fragment used to insert a row without specifying any column values.
`String`	`getNotExpression(String expression)` Deprecated. todo (6.0): Remove
`String`	`getNullColumnString()` The keyword used to specify a nullable column.
`String`	`getNullColumnString(String columnType)` The keyword used to specify a nullable column.
`NullOrdering`	`getNullOrdering()` Returns the ordering of null.
`int`	`getPreferredSqlTypeCodeForBoolean()` The JDBC `type code` to use for mapping properties of Java type `boolean`.
`String`	`getQueryHintString(String query, List<String> hintList)` Apply a hint to the query.
`String`	`getQueryHintString(String query, String hints)` Apply a hint to the query.
`String`	`getQuerySequencesString()` Get the select command used retrieve the names of all sequences.
`String`	`getRawTypeName(int code)` Get the name of the database type associated with the given `Types` typecode, with no length, precision, or scale.
`String`	`getRawTypeName(JdbcTypeDescriptor jdbcTypeDescriptor)`
`String`	`getReadLockString(int timeout)` Get the string to append to SELECT statements to acquire READ locks for this dialect.
`String`	`getReadLockString(String aliases, int timeout)` Get the string to append to SELECT statements to acquire READ locks for this dialect given the aliases of the columns to be read locked.
`RowLockStrategy`	`getReadRowLockStrategy()` The row lock strategy to use for read locks.
`ResultSet`	`getResultSet(CallableStatement statement)` Given a callable statement previously processed by `registerResultSetOutParameter(java.sql.CallableStatement, int)`, extract the `ResultSet` from the OUT parameter.
`ResultSet`	`getResultSet(CallableStatement statement, int position)` Given a callable statement previously processed by `registerResultSetOutParameter(java.sql.CallableStatement, int)`, extract the `ResultSet`.
`ResultSet`	`getResultSet(CallableStatement statement, String name)` Given a callable statement previously processed by `registerResultSetOutParameter(java.sql.CallableStatement, int)`, extract the `ResultSet` from the OUT parameter.
`SchemaNameResolver`	`getSchemaNameResolver()` Get the strategy for determining the schema name of a Connection
`String`	`getSelectClauseNullString(int sqlType)` Given a `Types` type code, determine an appropriate null value to use in a select clause.
`String`	`getSelectGUIDString()` Get the command used to select a GUID from the underlying database.
`String`	`getSelectSequenceNextValString(String sequenceName)` Deprecated. implement `SequenceSupport` and override `getSequenceSupport()`
`Exporter<Sequence>`	`getSequenceExporter()`
`SequenceInformationExtractor`	`getSequenceInformationExtractor()` A source of `SequenceInformation`.
`String`	`getSequenceNextValString(String sequenceName)` Deprecated. implement `SequenceSupport` and override `getSequenceSupport()`
`String`	`getSequenceNextValString(String sequenceName, int increment)` Deprecated. implement `SequenceSupport` and override `getSequenceSupport()`
`SequenceSupport`	`getSequenceSupport()`
`Dialect.SizeStrategy`	`getSizeStrategy()`
`SqlAstTranslatorFactory`	`getSqlAstTranslatorFactory()` Return an SqlAstTranslatorFactory specific for the Dialect.
`protected JdbcTypeDescriptor`	`getSqlTypeDescriptorOverride(int sqlCode)` Returns the `JdbcTypeDescriptor` that should be used to handle the given JDBC type code.
`SqmTranslatorFactory`	`getSqmTranslatorFactory()` Return an SqmToSqlAstConverterFactory specific for the Dialect.
`String`	`getTableAliasSeparator()` The separator to use between a table name and its alias in a SQL query, typically either `" as "` where the spaces are required, or a space character `" "`.
`String`	`getTableComment(String comment)` Get the comment into a form supported for table definition.
`Exporter<Table>`	`getTableExporter()`
`String`	`getTableTypeString()`
`String`	`getTypeName(int code)`
`String`	`getTypeName(int code, Size size)` Get the name of the database type associated with the given `java.sql.Types` typecode.
`String`	`getTypeName(JdbcTypeDescriptor jdbcTypeDescriptor)`
`String`	`getTypeName(JdbcTypeDescriptor jdbcTypeDescriptor, Size size)` Get the name of the database type associated with the given `SqlTypeDescriptor`.
`UniqueDelegate`	`getUniqueDelegate()` Get the UniqueDelegate supported by this dialect
`Exporter<Constraint>`	`getUniqueKeyExporter()`
`abstract int`	`getVersion()`
`ViolatedConstraintNameExtractor`	`getViolatedConstraintNameExtractor()`
`String`	`getWriteLockString(int timeout)` Get the string to append to SELECT statements to acquire WRITE locks for this dialect.
`String`	`getWriteLockString(String aliases, int timeout)` Get the string to append to SELECT statements to acquire WRITE locks for this dialect given the aliases of the columns to be write locked.
`RowLockStrategy`	`getWriteRowLockStrategy()` The row lock strategy to use for write locks.
`boolean`	`hasAlterTable()` Does this dialect support the `ALTER TABLE` syntax?
`boolean`	`hasSelfReferentialForeignKeyBug()` Does the database/driver have bug in deleting rows that refer to other rows being deleted in the same query?
`void`	`initializeFunctionRegistry(QueryEngine queryEngine)` Initialize the given registry with any dialect-specific functions.
`String`	`inlineLiteral(String literal)` Inline String literal.
`boolean`	`isCurrentTimestampSelectStringCallable()` Deprecated. no longer called
`boolean`	`isEmptyStringTreatedAsNull()` Return whether the dialect considers an empty-string value as null.
`boolean`	`isJdbcLogWarningsEnabledByDefault()` Does the fetching JDBC statement warning for logging is enabled by default
`boolean`	`isLockTimeoutParameterized()` If this dialect supports specifying lock timeouts, are those timeouts rendered into the `SQL` string as parameters.
`boolean`	`isTypeNameRegistered(String typeName)` Whether or not the given type name has been registered for this dialect (including both hibernate type names and custom-registered type names).
`char`	`openQuote()` The character specific to this dialect used to begin a quoted identifier.
`protected String`	`prependComment(String sql, String comment)`
`boolean`	`qualifyIndexName()` Do we need to qualify index names with the schema name?
`String`	`quote(String name)` Apply dialect-specific quoting.
`protected void`	`registerColumnType(int code, long capacity, String name)` Subclasses register a type name for the given type code and maximum column length.
`protected void`	`registerColumnType(int code, String name)` Subclasses register a type name for the given type code.
`protected void`	`registerHibernateType(int code, long capacity, String name)` Registers a Hibernate `Type` name for the given `Types` type code and maximum column length.
`protected void`	`registerHibernateType(int code, String name)` Registers a Hibernate `Type` name for the given `Types` type code.
`protected void`	`registerKeyword(String word)`
`int`	`registerResultSetOutParameter(CallableStatement statement, int position)` Registers a parameter (either OUT, or the new REF_CURSOR param type available in Java 8) capable of returning `ResultSet` by position.
`int`	`registerResultSetOutParameter(CallableStatement statement, String name)` Registers a parameter (either OUT, or the new REF_CURSOR param type available in Java 8) capable of returning `ResultSet` by name.
`JdbcTypeDescriptor`	`remapSqlTypeDescriptor(JdbcTypeDescriptor jdbcTypeDescriptor)` Allows the dialect to override a `JdbcTypeDescriptor`.
`String`	`renderOrderByElement(String expression, String collation, String order, NullPrecedence nulls)` Deprecated. todo (6.0): remove?
`boolean`	`replaceResultVariableInOrderByClauseWithPosition()` Deprecated. We now use ordinal rendering by default to produce smaller SQL
`boolean`	`requiresCastingOfParametersInSelectClause()` Deprecated. Moved to `AbstractSqlAstTranslator`
`boolean`	`requiresFloatCastingOfIntegerDivision()` Does this dialect require that integer divisions be wrapped in `cast()` calls to tell the db parser the expected type.
`boolean`	`requiresParensForTupleDistinctCounts()` If `supportsTupleDistinctCounts()` is true, does the Dialect require the tuple to be wrapped with parens?
`JdbcTypeDescriptor`	`resolveSqlTypeDescriptor(int jdbcTypeCode, int precision, int scale, JdbcTypeDescriptorRegistry jdbcTypeDescriptorRegistry)`
`boolean`	`supportsBindAsCallableArgument()` Does this dialect support using a JDBC bind parameter as an argument to a function or procedure call?
`boolean`	`supportsBitType()` Does this dialect have a true SQL `BIT` type with just two values (0 and 1) or, even better, a proper SQL `BOOLEAN` type, or does `Types.BIT` get mapped to a numeric type with more than two values?
`boolean`	`supportsCascadeDelete()` Does this dialect support cascaded delete on foreign key definitions?
`boolean`	`supportsCaseInsensitiveLike()` Does this dialect support case insensitive LIKE restrictions?
`boolean`	`supportsCircularCascadeDeleteConstraints()` Does this dialect support definition of cascade delete constraints which can cause circular chains?
`boolean`	`supportsColumnCheck()` Does this dialect support column-level check constraints?
`boolean`	`supportsCommentOn()` Does this dialect/database support commenting on tables, columns, etc?
`boolean`	`supportsCurrentTimestampSelection()` Deprecated. no longer called
`boolean`	`supportsEmptyInList()` Does this dialect support empty IN lists? For example, is [where XYZ in ()] a supported construct?
`boolean`	`supportsExistsInSelect()` Does the dialect support an exists statement in the select clause?
`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...
`boolean`	`supportsFetchClause(FetchClauseType type)` Does this dialect support the given fetch clause type.
`boolean`	`supportsFractionalTimestampArithmetic()` Whether the database supports adding a fractional interval to a timestamp e.g.
`boolean`	`supportsIfExistsAfterAlterTable()` For an "alter table", can the phrase "if exists" be applied?
`boolean`	`supportsIfExistsAfterConstraintName()` For dropping a constraint with an "alter table", can the phrase "if exists" be applied after the constraint name? NOTE : Only one or the other (or neither) of this and `supportsIfExistsBeforeConstraintName()` should return true
`boolean`	`supportsIfExistsAfterTableName()` For dropping a table, can the phrase "if exists" be applied after the table name? NOTE : Only one or the other (or neither) of this and `supportsIfExistsBeforeTableName()` should return true
`boolean`	`supportsIfExistsBeforeConstraintName()` For dropping a constraint with an "alter table", can the phrase "if exists" be applied before the constraint name? NOTE : Only one or the other (or neither) of this and `supportsIfExistsAfterConstraintName()` should return true
`boolean`	`supportsIfExistsBeforeTableName()` For dropping a table, can the phrase "if exists" be applied before the table name? NOTE : Only one or the other (or neither) of this and `supportsIfExistsAfterTableName()` should return true
`boolean`	`supportsJdbcConnectionLobCreation(DatabaseMetaData databaseMetaData)` Check whether the JDBC `Connection` supports creating LOBs via `Connection.createBlob()`, `Connection.createNClob()` or `Connection.createClob()`.
`boolean`	`supportsLimit()` Deprecated. `getLimitHandler()` should be overridden instead.
`boolean`	`supportsLimitOffset()` Deprecated. `getLimitHandler()` should be overridden instead.
`boolean`	`supportsLobValueChangePropagation()` Does the dialect support propagating 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...
`boolean`	`supportsLockTimeouts()` Informational metadata about whether this dialect is known to support specifying timeouts for requested lock acquisitions.
`boolean`	`supportsNamedParameters(DatabaseMetaData databaseMetaData)` Override the DatabaseMetaData#supportsNamedParameters()
`boolean`	`supportsNationalizedTypes()` Deprecated. (since 6.0) Prefer `getNationalizationSupport()` which gives a little better insight into what is supported. This is interpreted as true if the supported strategy is `NationalizationSupport.EXPLICIT`
`boolean`	`supportsNoColumnsInsert()` Check if the INSERT statement is allowed to contain no column.
`boolean`	`supportsNonQueryWithCTE()` Does this dialect/database support non-query statements (e.g.
`boolean`	`supportsNotNullUnique()` Deprecated. `getUniqueDelegate()` should be overridden instead.
`boolean`	`supportsNoWait()` Does this dialect/database support NO_WAIT timeout.
`boolean`	`supportsNullPrecedence()`
`boolean`	`supportsOffsetInSubquery()` Does this dialect support offset in subqueries? Ex: select * from Table1 where col1 in (select col1 from Table2 order by col2 limit 1 offset 1)
`boolean`	`supportsOrderByInSubquery()` Does this dialect support the order by clause in subqueries? Ex: select * from Table1 where col1 in (select col1 from Table2 order by col2 limit 1)
`boolean`	`supportsOrdinalSelectItemReference()` Does this dialect support references to result variables (i.e, select items) by column positions (1-origin) as defined by the select clause?
`boolean`	`supportsOuterJoinForUpdate()` Does this dialect support `FOR UPDATE` in conjunction with outer joined rows?
`boolean`	`supportsParametersInInsertSelect()` Does this dialect support parameters within the `SELECT` clause of `INSERT ...`
`boolean`	`supportsPartitionBy()` Does the underlying database support partition by
`boolean`	`supportsPooledSequences()` Deprecated. implement `SequenceSupport` and override `getSequenceSupport()`
`boolean`	`supportsResultSetPositionQueryMethodsOnForwardOnlyCursor()` Does this dialect support asking the result set its positioning information on forward only cursors.
`boolean`	`supportsRowValueConstructorSyntax()` Deprecated. Moved to `AbstractSqlAstTranslator`
`boolean`	`supportsRowValueConstructorSyntaxInInList()` Deprecated. Moved to `AbstractSqlAstTranslator`
`boolean`	`supportsRowValueConstructorSyntaxInInSubquery()` Deprecated. Moved to `AbstractSqlAstTranslator`
`boolean`	`supportsRowValueConstructorSyntaxInQuantifiedPredicates()` Deprecated. Moved to `AbstractSqlAstTranslator`
`boolean`	`supportsRowValueConstructorSyntaxInSet()` Deprecated. Moved to `AbstractSqlAstTranslator`
`boolean`	`supportsSelectAliasInGroupByClause()`
`boolean`	`supportsSelectQueryWithoutFromClause()` Deprecated. Moved to `AbstractSqlAstTranslator`
`boolean`	`supportsSequences()` Deprecated. implement `SequenceSupport` and override `getSequenceSupport()`
`boolean`	`supportsSkipLocked()` Does this dialect/database support SKIP_LOCKED timeout.
`boolean`	`supportsSubqueryInSelect()` Does this dialect support subqueries in the select clause? Ex: select col1, (select col2 from Table2 where ..) from Table1
`boolean`	`supportsSubqueryOnMutatingTable()` Does this dialect support referencing the table being mutated in a subquery.
`boolean`	`supportsSubselectAsInPredicateLHS()` Are subselects supported as the left-hand-side (LHS) of IN-predicates.
`boolean`	`supportsTableCheck()` Does this dialect support table-level check constraints?
`boolean`	`supportsTemporalLiteralOffset()` Whether the Dialect supports timezone offset in temporal literals.
`boolean`	`supportsTemporaryTables()`
`boolean`	`supportsTimezoneTypes()` Whether the Dialect supports timezone types like `Types.TIMESTAMP_WITH_TIMEZONE`.
`boolean`	`supportsTruncateWithCast()` Does this dialect support truncation of values to a specified length through a cast?
`boolean`	`supportsTupleCounts()` Does this dialect support `count(a,b)`?
`boolean`	`supportsTupleDistinctCounts()` Does this dialect support `count(distinct a,b)`?
`boolean`	`supportsTuplesInSubqueries()` Deprecated. See `supportsRowValueConstructorSyntaxInInSubquery()`
`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.
`boolean`	`supportsUnionAll()` Does this dialect support UNION ALL.
`boolean`	`supportsUnionInSubquery()` Does this dialect support UNION in a subquery.
`boolean`	`supportsUnique()` Deprecated. `getUniqueDelegate()` should be overridden instead.
`boolean`	`supportsUniqueConstraintInCreateAlterTable()` Deprecated. `getUniqueDelegate()` should be overridden instead.
`boolean`	`supportsValuesList()` Does this dialect/database support VALUES list (e.g.
`boolean`	`supportsValuesListForInsert()` Does this dialect/database support VALUES list (e.g.
`boolean`	`supportsVariableLimit()` Deprecated. `getLimitHandler()` should be overridden instead.
`boolean`	`supportsWait()` Does this dialect/database support WAIT timeout.
`boolean`	`supportsWindowFunctions()` Does this dialect support window functions like `row_number() over (..)`
`String`	`timestampaddPattern(TemporalUnit unit, TemporalType temporalType)` Obtain a pattern for the SQL equivalent to a `timestampadd()` function call.
`String`	`timestampdiffPattern(TemporalUnit unit, TemporalType fromTemporalType, TemporalType toTemporalType)` Obtain a pattern for the SQL equivalent to a `timestampdiff()` function call.
`String`	`toBooleanValueString(boolean bool)` The SQL literal value to which this database maps boolean values.
`String`	`toString()`
`String`	`transformSelectString(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.
`String`	`translateDatetimeFormat(String format)` Translate the given datetime format string from the pattern language defined by Java's `DateTimeFormatter` to whatever pattern language is understood by the native datetime formatting function for this database (often the `to_char()` function).
`String`	`translateDurationField(TemporalUnit unit)` Return the name used to identify the given unit of duration as an argument to `#timestampadd()` or `#timestampdiff()`, or of this dialect's `equivalent` `functions`.
`String`	`translateExtractField(TemporalUnit unit)` Return the name used to identify the given field as an argument to the `extract()` function, or of this dialect's `equivalent` function.
`String`	`trimPattern(TrimSpec specification, char character)` Obtain a pattern for the SQL equivalent to a `trim()` function call.
`boolean`	`useFollowOnLocking(String sql, QueryOptions queryOptions)` Some dialects have trouble applying pessimistic locking depending upon what other query options are specified (paging, ordering, etc).
`boolean`	`useInputStreamToInsertBlob()` Should LOBs (both BLOB and CLOB) be bound using stream operations (i.e.
`boolean`	`useMaxForLimit()` Deprecated. `getLimitHandler()` should be overridden instead.
`protected String`	`wrapDateLiteral(String date)`
`protected String`	`wrapTimeLiteral(String time)`
`protected String`	`wrapTimestampLiteral(String timestamp)`

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

- Field Detail
  - DEFAULT_BATCH_SIZE
```
public static final String DEFAULT_BATCH_SIZE
```
    Defines a default batch size constant
    
    See Also:
    
    Constant Field Values
  - NO_BATCH
```
protected static final String NO_BATCH
```
    Defines a "no batching" batch size constant
    
    See Also:
    
    Constant Field Values
  - QUOTE
```
public static final String QUOTE
```
    Characters used as opening for quoting SQL identifiers
    
    See Also:
    
    Constant Field Values
  - CLOSED_QUOTE
```
public static final String CLOSED_QUOTE
```
    Characters used as closing for quoting SQL identifiers
    
    See Also:
    
    Constant Field Values
  - TWO_SINGLE_QUOTES_REPLACEMENT
```
public static final String TWO_SINGLE_QUOTES_REPLACEMENT
```
  - LEGACY_LOB_MERGE_STRATEGY
```
protected static final LobMergeStrategy LEGACY_LOB_MERGE_STRATEGY
```
    The legacy behavior of Hibernate. LOBs are not processed by merge
  - STREAM_XFER_LOB_MERGE_STRATEGY
```
protected static final LobMergeStrategy STREAM_XFER_LOB_MERGE_STRATEGY
```
    Merge strategy based on transferring contents based on streams.
  - NEW_LOCATOR_LOB_MERGE_STRATEGY
```
protected static final LobMergeStrategy NEW_LOCATOR_LOB_MERGE_STRATEGY
```
    Merge strategy based on creating a new LOB locator.
  - STANDARD_DEFAULT_BATCH_LOAD_SIZING_STRATEGY
```
protected final BatchLoadSizingStrategy STANDARD_DEFAULT_BATCH_LOAD_SIZING_STRATEGY
```
- Constructor Detail
  - Dialect
```
protected Dialect()
```
- Method Detail
  - resolveSqlTypeDescriptor
```
public JdbcTypeDescriptor resolveSqlTypeDescriptor(int jdbcTypeCode,
                                                   int precision,
                                                   int scale,
                                                   JdbcTypeDescriptorRegistry jdbcTypeDescriptorRegistry)
```
  - binaryToDecimalPrecision
```
protected static Size binaryToDecimalPrecision(int code,
                                               Size size)
```
    Useful conversion for databases which represent the precision of a float(p) using p expressed in decimal digits instead of the usual (standard) binary digits.
  - getBooleanCheckCondition
```
public String getBooleanCheckCondition(String columnName,
                                       int sqlType,
                                       char falseChar,
                                       char trueChar)
```
    Render a SQL check condition for a column that represents a boolean value.
  - getEnumCheckCondition
```
public String getEnumCheckCondition(String columnName,
                                    int sqlType,
                                    Class<? extends Enum<?>> enumClass)
```
    Render a SQL check condition for a column that represents an enumerated value.
  - getVersion
```
public abstract int getVersion()
```
  - initializeFunctionRegistry
```
public void initializeFunctionRegistry(QueryEngine queryEngine)
```
    Initialize the given registry with any dialect-specific functions. Support for certain SQL functions is required, and if the database does not support a required function, then the dialect must define a way to emulate it. These required functions include the functions defined by the JPA query language specification:
    - avg(arg) - aggregate function
    - count([distinct ]arg) - aggregate function
    - max(arg) - aggregate function
    - min(arg) - aggregate function
    - sum(arg) - aggregate function
    - coalesce(arg0, arg1, ...)
    - nullif(arg0, arg1)
    - lower(arg)
    - upper(arg)
    - length(arg)
    - concat(arg0, arg1, ...)
    - locate(pattern, string[, start])
    - substring(string, start[, length])
    - trim([[spec ][character ]from] string)
    - abs(arg)
    - mod(arg0, arg1)
    - sqrt(arg)
    - current date
    - current time
    - current timestamp
    Along with an additional set of functions defined by ANSI SQL:
    - any(arg) - aggregate function
    - every(arg) - aggregate function
    - cast(arg as Type)
    - extract(field from arg)
    - ln(arg)
    - exp(arg)
    - power(arg0, arg1)
    - floor(arg)
    - ceiling(arg)
    - position(pattern in string)
    - substring(string from start[ for length])
    - overlay(string placing replacement from start[ for length])
    And the following functions for working with java.time types:
    - local date
    - local time
    - local datetime
    - offset datetime
    - instant
    And a number of additional "standard" functions:
    - left(string, length)
    - right(string, length)
    - replace(string, pattern, replacement)
    - pad(string with length spec[ character])
    - sign(arg)
    - sin(arg)
    - cos(arg)
    - tan(arg)
    - asin(arg)
    - acos(arg)
    - atan(arg)
    - atan2(arg0, arg1)
    - round(arg0, arg1)
    - least(arg0, arg1, ...)
    - greatest(arg0, arg1, ...)
    - format(datetime as pattern)
    - str(arg) - synonym of cast(a as String)
    - ifnull(arg0, arg1) - synonym of coalesce(a, b)
    Finally, the following functions are defined as abbreviations for extract(), and desugared by the parser:
    - second(arg) - synonym of extract(second from a)
    - minute(arg) - synonym of extract(minute from a)
    - hour(arg) - synonym of extract(hour from a)
    - day(arg) - synonym of extract(day from a)
    - month(arg) - synonym of extract(month from a)
    - year(arg) - synonym of extract(year from a)
  - currentDate
```
public String currentDate()
```
    Translation of the HQL/JPQL current_date function, which maps to the Java type java.sql.Date, and of the HQL local_date function which maps to the Java type java.sql.LocalDate.
  - currentTime
```
public String currentTime()
```
    Translation of the HQL/JPQL current_time function, which maps to the Java type java.sql.Time which is a time with no time zone. This contradicts ANSI SQL where current_time has the type TIME WITH TIME ZONE.
    It is recommended to override this in dialects for databases which support localtime or time at local.
  - currentTimestamp
```
public String currentTimestamp()
```
    Translation of the HQL/JPQL current_timestamp function, which maps to the Java type java.sql.Timestamp which is a datetime with no time zone. This contradicts ANSI SQL where current_timestamp has the type TIMESTAMP WITH TIME ZONE.
    It is recommended to override this in dialects for databases which support localtimestamp or timestamp at local.
  - currentLocalTime
```
public String currentLocalTime()
```
    Translation of the HQL local_time function, which maps to the Java type java.time.LocalTime which is a time with no time zone. It should usually be the same SQL function as for currentTime().
    It is recommended to override this in dialects for databases which support localtime or current_time at local.
  - currentLocalTimestamp
```
public String currentLocalTimestamp()
```
    Translation of the HQL local_datetime function, which maps to the Java type java.time.LocalDateTime which is a datetime with no time zone. It should usually be the same SQL function as for currentTimestamp().
    It is recommended to override this in dialects for databases which support localtimestamp or current_timestamp at local.
  - currentTimestampWithTimeZone
```
public String currentTimestampWithTimeZone()
```
    Translation of the HQL offset_datetime function, which maps to the Java type java.time.OffsetDateTime which is a datetime with a time zone. This in principle correctly maps to the ANSI SQL current_timestamp which has the type TIMESTAMP WITH TIME ZONE.
  - extractPattern
```
public String extractPattern(TemporalUnit unit)
```
    Obtain a pattern for the SQL equivalent to an extract() function call. The resulting pattern must contain ?1 and ?2 placeholders for the arguments.
    This method does not need to handle TemporalUnit.NANOSECOND, TemporalUnit.NATIVE, TemporalUnit.OFFSET, TemporalUnit.DATE, TemporalUnit.TIME, TemporalUnit.WEEK_OF_YEAR, or TemporalUnit.WEEK_OF_MONTH, which are already desugared by ExtractFunction.
    
    Parameters:
    
    unit - the first argument
  - castPattern
```
public String castPattern(CastType from,
                          CastType to)
```
    Obtain a pattern for the SQL equivalent to a cast() function call. The resulting pattern must contain ?1 and ?2 placeholders for the arguments.
    
    Parameters:
    
    from - a CastType indicating the type of the value argument
    
    to - a CastType indicating the type the value argument is cast to
  - trimPattern
```
public String trimPattern(TrimSpec specification,
                          char character)
```
    Obtain a pattern for the SQL equivalent to a trim() function call. The resulting pattern must contain a ?1 placeholder for the argument of type String.
    
    Parameters:
    
    specification - leading or trailing
    
    character - the character to trim
  - supportsFractionalTimestampArithmetic
```
public boolean supportsFractionalTimestampArithmetic()
```
    Whether the database supports adding a fractional interval to a timestamp e.g. `timestamp + 0.5 second`
  - timestampdiffPattern
```
public String timestampdiffPattern(TemporalUnit unit,
                                   TemporalType fromTemporalType,
                                   TemporalType toTemporalType)
```
    Obtain a pattern for the SQL equivalent to a timestampdiff() function call. The resulting pattern must contain ?1, ?2, and ?3 placeholders for the arguments.
    
    Parameters:
    
    unit - the first argument
    
    fromTemporalType - true if the first argument is a timestamp, false if a date
    
    toTemporalType - true if the second argument is
  - timestampaddPattern
```
public String timestampaddPattern(TemporalUnit unit,
                                  TemporalType temporalType)
```
    Obtain a pattern for the SQL equivalent to a timestampadd() function call. The resulting pattern must contain ?1, ?2, and ?3 placeholders for the arguments.
    
    Parameters:
    
    unit - the first argument
    
    temporalType - true if the third argument is a
  - equivalentTypes
```
public boolean equivalentTypes(int typeCode1,
                               int typeCode2)
```
    Do the given JDBC type codes, as defined in Types represent essentially the same type in this dialect of SQL? The default implementation treats NUMERIC and DECIMAL as the same type, and FLOAT, REAL, and DOUBLE as essentially the same type, since the ANSI SQL specification fails to meaningfully distinguish them.
    
    Parameters:
    
    typeCode1 - the first JDBC type code
    
    typeCode2 - the second JDBC type code
    
    Returns:
    
    true if the two type codes are equivalent
  - getDialect
```
@Deprecated
public static Dialect getDialect()
                                      throws HibernateException
```
    Deprecated. this just calls the default constructor and does not pass in the DialectResolutionInfo.
    
    Get an instance of the dialect specified by the current System properties.
    
    Returns:
    
    The specified Dialect
    
    Throws:
    
    HibernateException - If no dialect was specified, or if it could not be instantiated.
  - getDialect
```
@Deprecated
public static Dialect getDialect(Properties props)
                                      throws HibernateException
```
    Deprecated. this just calls the default constructor and does not pass in the DialectResolutionInfo.
    
    Get an instance of the dialect specified by the given properties or by the current System properties.
    
    Parameters:
    
    props - The properties to use for finding the dialect class to use.
    
    Returns:
    
    The specified Dialect
    
    Throws:
    
    HibernateException - If no dialect was specified, or if it could not be instantiated.
  - getDefaultProperties
```
public final Properties getDefaultProperties()
```
    Retrieve a set of default Hibernate properties for this database.
    
    Returns:
    
    a set of Hibernate properties
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - contributeTypes
```
public void contributeTypes(TypeContributions typeContributions,
                            ServiceRegistry serviceRegistry)
```
    Allows the Dialect to contribute additional types
    
    Parameters:
    
    typeContributions - Callback to contribute the types
    
    serviceRegistry - The service registry
  - getRawTypeName
```
public String getRawTypeName(int code)
                      throws HibernateException
```
    Get the name of the database type associated with the given Types typecode, with no length, precision, or scale.
    
    Parameters:
    
    code - The Types typecode
    
    Returns:
    
    the database type name
    
    Throws:
    
    HibernateException - If no mapping was specified for that type.
  - getRawTypeName
```
public String getRawTypeName(JdbcTypeDescriptor jdbcTypeDescriptor)
                      throws HibernateException
```
    Throws:
    
    HibernateException
  - getTypeName
```
public String getTypeName(JdbcTypeDescriptor jdbcTypeDescriptor)
                   throws HibernateException
```
    Throws:
    
    HibernateException
  - getTypeName
```
public String getTypeName(int code)
                   throws HibernateException
```
    Throws:
    
    HibernateException
  - getTypeName
```
public String getTypeName(int code,
                          Size size)
                   throws HibernateException
```
    Get the name of the database type associated with the given java.sql.Types typecode.
    
    Parameters:
    
    code - java.sql.Types typecode
    
    size - the length, precision, scale of the column
    
    Returns:
    
    the database type name
    
    Throws:
    
    HibernateException
  - getTypeName
```
public String getTypeName(JdbcTypeDescriptor jdbcTypeDescriptor,
                          Size size)
```
    Get the name of the database type associated with the given SqlTypeDescriptor.
    
    Parameters:
    
    jdbcTypeDescriptor - the SQL type
    
    size - the length, precision, scale of the column
    
    Returns:
    
    the database type name
  - getCastTypeName
```
public String getCastTypeName(SqlExpressable type,
                              Long length,
                              Integer precision,
                              Integer scale)
```
    Get the name of the database type appropriate for casting operations (via the CAST() SQL function) for the given SqlExpressable SQL type.
    
    Returns:
    
    The database type name
  - registerColumnType
```
protected void registerColumnType(int code,
                                  long capacity,
                                  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).
    
    Parameters:
    
    code - The Types typecode
    
    capacity - The maximum length of database type
    
    name - The database type name
  - registerColumnType
```
protected void registerColumnType(int code,
                                  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).
    
    Parameters:
    
    code - The Types typecode
    
    name - The database type name
  - remapSqlTypeDescriptor
```
public JdbcTypeDescriptor remapSqlTypeDescriptor(JdbcTypeDescriptor jdbcTypeDescriptor)
```
    Allows the dialect to override a JdbcTypeDescriptor.
    If the passed sqlTypeDescriptor allows itself to be remapped (per JdbcTypeDescriptor.canBeRemapped()), then this method uses getSqlTypeDescriptorOverride(int) to get an optional override based on the SQL code returned by JdbcTypeDescriptor.getJdbcTypeCode().
    If this dialect does not provide an override or if the sqlTypeDescriptor does not allow itself to be remapped, then this method simply returns the original passed sqlTypeDescriptor
    
    Parameters:
    
    jdbcTypeDescriptor - The JdbcTypeDescriptor to override
    
    Returns:
    
    The JdbcTypeDescriptor that should be used for this dialect; if there is no override, then original sqlTypeDescriptor is returned.
    
    Throws:
    
    IllegalArgumentException - if sqlTypeDescriptor is null.
    
    See Also:
    
    getSqlTypeDescriptorOverride(int)
  - getSqlTypeDescriptorOverride
```
protected JdbcTypeDescriptor getSqlTypeDescriptorOverride(int sqlCode)
```
    Returns the JdbcTypeDescriptor that should be used to handle the given JDBC type code. Returns null if there is no override.
    
    Parameters:
    
    sqlCode - A Types constant indicating the SQL column type
    
    Returns:
    
    The JdbcTypeDescriptor to use as an override, or null if there is no override.
  - getLobMergeStrategy
```
public LobMergeStrategy getLobMergeStrategy()
```
  - getHibernateTypeName
```
public String getHibernateTypeName(int code)
                            throws HibernateException
```
    Get the name of the Hibernate Type associated with the given Types type code.
    
    Parameters:
    
    code - The Types type code
    
    Returns:
    
    The Hibernate Type name.
    
    Throws:
    
    HibernateException - If no mapping was specified for that type.
  - isTypeNameRegistered
```
public boolean isTypeNameRegistered(String typeName)
```
    Whether or not the given type name has been registered for this dialect (including both hibernate type names and custom-registered type names).
    
    Parameters:
    
    typeName - the type name.
    
    Returns:
    
    true if the given string has been registered either as a hibernate type or as a custom-registered one
  - getHibernateTypeName
```
public String getHibernateTypeName(int code,
                                   Integer length,
                                   Integer precision,
                                   Integer scale)
                            throws HibernateException
```
    Get the name of the Hibernate Type associated with the given Types typecode with the given storage specification parameters.
    
    Parameters:
    
    code - The Types typecode
    
    length - The datatype length
    
    precision - The datatype precision
    
    scale - The datatype scale
    
    Returns:
    
    The Hibernate Type name.
    
    Throws:
    
    HibernateException - If no mapping was specified for that type.
  - registerHibernateType
```
protected void registerHibernateType(int code,
                                     long capacity,
                                     String name)
```
    Registers a Hibernate Type name for the given Types type code and maximum column length.
    
    Parameters:
    
    code - The Types typecode
    
    capacity - The maximum length of database type
    
    name - The Hibernate Type name
  - registerHibernateType
```
protected void registerHibernateType(int code,
                                     String name)
```
    Registers a Hibernate Type name for the given Types type code.
    
    Parameters:
    
    code - The Types typecode
    
    name - The Hibernate Type name
  - getNativeIdentifierGeneratorClass
```
@Deprecated
public Class getNativeIdentifierGeneratorClass()
```
    Deprecated. use getNativeIdentifierGeneratorStrategy() instead
    
    The class (which implements IdentifierGenerator) which acts as this dialects native generation strategy.
    Comes into play whenever the user specifies the native generator.
    
    Returns:
    
    The native generator class.
  - getNativeIdentifierGeneratorStrategy
```
public String getNativeIdentifierGeneratorStrategy()
```
    Resolves the native generation strategy associated to this dialect.
    Comes into play whenever the user specifies the native generator.
    
    Returns:
    
    The native generator strategy.
  - getIdentityColumnSupport
```
public IdentityColumnSupport getIdentityColumnSupport()
```
    Get the appropriate IdentityColumnSupport
    
    Returns:
    
    the IdentityColumnSupport
    
    Since:
    
    5.1
  - getSequenceSupport
```
public SequenceSupport getSequenceSupport()
```
  - getQuerySequencesString
```
public String getQuerySequencesString()
```
    Get the select command used retrieve the names of all sequences.
    
    Returns:
    
    The select command; or null if sequences are not supported.
    
    See Also:
    
    SchemaUpdate
  - getSequenceInformationExtractor
```
public SequenceInformationExtractor getSequenceInformationExtractor()
```
    A source of SequenceInformation.
  - getSelectGUIDString
```
public String getSelectGUIDString()
```
    Get the command used to select a GUID from the underlying database.
    Optional operation.
    
    Returns:
    
    The appropriate command.
  - getFromDual
```
@Deprecated
public String getFromDual()
```
    Deprecated. Moved to AbstractSqlAstTranslator
    
    Some databases require a bit of syntactic noise when there are no tables in the from clause.
    
    Returns:
    
    the SQL equivalent to Oracle's from dual.
  - supportsSelectQueryWithoutFromClause
```
@Deprecated
public boolean supportsSelectQueryWithoutFromClause()
```
    Deprecated. Moved to AbstractSqlAstTranslator
  - supportsTemporaryTables
```
public boolean supportsTemporaryTables()
```
  - getLimitHandler
```
public LimitHandler getLimitHandler()
```
    Returns a LimitHandler that implements support for Query.setMaxResults(int) and Query.setFirstResult(int) for this dialect.
  - supportsLockTimeouts
```
public boolean supportsLockTimeouts()
```
    Informational metadata about whether this dialect is known to support specifying timeouts for requested lock acquisitions.
    
    Returns:
    
    True is this dialect supports specifying lock timeouts.
  - isLockTimeoutParameterized
```
public boolean isLockTimeoutParameterized()
```
    If this dialect supports specifying lock timeouts, are those timeouts rendered into the SQL string as parameters. The implication is that Hibernate will need to bind the timeout value as a parameter in the PreparedStatement. If true, the param position is always handled as the last parameter; if the dialect specifies the lock timeout elsewhere in the SQL statement then the timeout value should be directly rendered into the statement and this method should return false.
    
    Returns:
    
    True if the lock timeout is rendered into the SQL string as a parameter; false otherwise.
  - getLockingStrategy
```
public LockingStrategy getLockingStrategy(Lockable lockable,
                                          LockMode lockMode)
```
    Get a strategy instance which knows how to acquire a database-level lock of the specified mode for this dialect.
    
    Parameters:
    
    lockable - The persister for the entity to be locked.
    
    lockMode - The type of lock to be acquired.
    
    Returns:
    
    The appropriate locking strategy.
    
    Since:
    
    3.2
  - getForUpdateString
```
public String getForUpdateString(LockOptions lockOptions)
```
    Given LockOptions (lockMode, timeout), determine the appropriate for update fragment to use.
    
    Parameters:
    
    lockOptions - contains the lock mode to apply.
    
    Returns:
    
    The appropriate for update fragment.
  - getForUpdateString
```
public String getForUpdateString(LockMode lockMode)
```
    Given a lock mode, determine the appropriate for update fragment to use.
    
    Parameters:
    
    lockMode - The lock mode to apply.
    
    Returns:
    
    The appropriate for update fragment.
  - getForUpdateString
```
public String getForUpdateString()
```
    Get the string to append to SELECT statements to acquire locks for this dialect.
    
    Returns:
    
    The appropriate FOR UPDATE clause string.
  - getWriteLockString
```
public String getWriteLockString(int timeout)
```
    Get the string to append to SELECT statements to acquire WRITE locks for this dialect. Location of the returned string is treated the same as getForUpdateString.
    
    Parameters:
    
    timeout - in milliseconds, -1 for indefinite wait and 0 for no wait.
    
    Returns:
    
    The appropriate LOCK clause string.
  - getWriteLockString
```
public String getWriteLockString(String aliases,
                                 int timeout)
```
    Get the string to append to SELECT statements to acquire WRITE locks for this dialect given the aliases of the columns to be write locked. Location of the of the returned string is treated the same as getForUpdateString.
    
    Parameters:
    
    aliases - The columns to be read locked.
    
    timeout - in milliseconds, -1 for indefinite wait and 0 for no wait.
    
    Returns:
    
    The appropriate LOCK clause string.
  - getReadLockString
```
public String getReadLockString(int timeout)
```
    Get the string to append to SELECT statements to acquire READ locks for this dialect. Location of the returned string is treated the same as getForUpdateString.
    
    Parameters:
    
    timeout - in milliseconds, -1 for indefinite wait and 0 for no wait.
    
    Returns:
    
    The appropriate LOCK clause string.
  - getReadLockString
```
public String getReadLockString(String aliases,
                                int timeout)
```
    Get the string to append to SELECT statements to acquire READ locks for this dialect given the aliases of the columns to be read locked. Location of the returned string is treated the same as getForUpdateString.
    
    Parameters:
    
    aliases - The columns to be read locked.
    
    timeout - in milliseconds, -1 for indefinite wait and 0 for no wait.
    
    Returns:
    
    The appropriate LOCK clause string.
  - forUpdateOfColumns
```
@Deprecated
public boolean forUpdateOfColumns()
```
    Deprecated. Use getWriteRowLockStrategy() instead
    
    Does the FOR UPDATE OF clause accept a list of columns instead of a list of table aliases?
    
    Returns:
    
    True if the database supports FOR UPDATE OF syntax; false otherwise.
  - getWriteRowLockStrategy
```
public RowLockStrategy getWriteRowLockStrategy()
```
    The row lock strategy to use for write locks.
  - getReadRowLockStrategy
```
public RowLockStrategy getReadRowLockStrategy()
```
    The row lock strategy to use for read locks.
  - supportsOuterJoinForUpdate
```
public boolean supportsOuterJoinForUpdate()
```
    Does this dialect support FOR UPDATE in conjunction with outer joined rows?
    
    Returns:
    
    True if outer joined rows can be locked via FOR UPDATE.
  - getForUpdateString
```
public String getForUpdateString(String aliases)
```
    Get the FOR UPDATE OF column_list fragment appropriate for this dialect given the aliases of the columns to be write locked.
    
    Parameters:
    
    aliases - The columns to be write locked.
    
    Returns:
    
    The appropriate FOR UPDATE OF column_list clause string.
  - getForUpdateString
```
public String getForUpdateString(String aliases,
                                 LockOptions lockOptions)
```
    Get the FOR UPDATE OF column_list fragment appropriate for this dialect given the aliases of the columns to be write locked.
    
    Parameters:
    
    aliases - The columns to be write locked.
    
    lockOptions - the lock options to apply
    
    Returns:
    
    The appropriate FOR UPDATE OF column_list clause string.
  - getForUpdateNowaitString
```
public String getForUpdateNowaitString()
```
    Retrieves the FOR UPDATE NOWAIT syntax specific to this dialect.
    
    Returns:
    
    The appropriate FOR UPDATE NOWAIT clause string.
  - getForUpdateSkipLockedString
```
public String getForUpdateSkipLockedString()
```
    Retrieves the FOR UPDATE SKIP LOCKED syntax specific to this dialect.
    
    Returns:
    
    The appropriate FOR UPDATE SKIP LOCKED clause string.
  - getForUpdateNowaitString
```
public String getForUpdateNowaitString(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.
    
    Parameters:
    
    aliases - The columns to be write locked.
    
    Returns:
    
    The appropriate FOR UPDATE OF colunm_list NOWAIT clause string.
  - getForUpdateSkipLockedString
```
public String getForUpdateSkipLockedString(String aliases)
```
    Get the FOR UPDATE OF column_list SKIP LOCKED fragment appropriate for this dialect given the aliases of the columns to be write locked.
    
    Parameters:
    
    aliases - The columns to be write locked.
    
    Returns:
    
    The appropriate FOR UPDATE colunm_list SKIP LOCKED clause string.
  - appendLockHint
```
@Deprecated
public String appendLockHint(LockMode mode,
                                         String tableName)
```
    Deprecated. use appendLockHint(LockOptions,String) instead
    
    Some dialects support an alternative means to SELECT FOR UPDATE, whereby a "lock hint" is appended to the table name in the from clause.
    contributed by Helge Schulz
    
    Parameters:
    
    mode - The lock mode to apply
    
    tableName - The name of the table to which to apply the lock hint.
    
    Returns:
    
    The table with any required lock hints.
  - appendLockHint
```
@Deprecated
public String appendLockHint(LockOptions lockOptions,
                                         String tableName)
```
    Deprecated. This was moved to AbstractSqlAstTranslator
    
    Some dialects support an alternative means to SELECT FOR UPDATE, whereby a "lock hint" is appended to the table name in the from clause.
    contributed by Helge Schulz
    
    Parameters:
    
    lockOptions - The lock options to apply
    
    tableName - The name of the table to which to apply the lock hint.
    
    Returns:
    
    The table with any required lock hints.
  - applyLocksToSql
```
public String applyLocksToSql(String sql,
                              LockOptions aliasedLockOptions,
                              Map<String,String[]> 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.
    
    Parameters:
    
    sql - the SQL string to modify
    
    aliasedLockOptions - lock options indexed by aliased table names.
    
    keyColumnNames - a map of key columns indexed by aliased table names.
    
    Returns:
    
    the modified SQL string.
  - getCreateTableString
```
public String getCreateTableString()
```
    Command used to create a table.
    
    Returns:
    
    The command used to create a table.
  - getAlterTableString
```
public String getAlterTableString(String tableName)
```
    Command used to alter a table.
    
    Parameters:
    
    tableName - The name of the table to alter
    
    Returns:
    
    The command used to alter a table.
    
    Since:
    
    5.2.11
  - getCreateMultisetTableString
```
public String getCreateMultisetTableString()
```
    Slight variation on 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.
    
    Returns:
    
    The command used to create a multiset table.
  - getFallbackSqmMutationStrategy
```
public SqmMultiTableMutationStrategy getFallbackSqmMutationStrategy(EntityMappingType entityDescriptor,
                                                                    RuntimeModelCreationContext runtimeModelCreationContext)
```
  - registerResultSetOutParameter
```
public int registerResultSetOutParameter(CallableStatement statement,
                                         int position)
                                  throws SQLException
```
    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.
    
    Parameters:
    
    statement - The callable statement.
    
    position - The bind position at which to register the output param.
    
    Returns:
    
    The number of (contiguous) bind positions used.
    
    Throws:
    
    SQLException - Indicates problems registering the param.
  - registerResultSetOutParameter
```
public int registerResultSetOutParameter(CallableStatement statement,
                                         String name)
                                  throws SQLException
```
    Registers a parameter (either OUT, or the new REF_CURSOR param type available in Java 8) capable of returning ResultSet *by name*. Pre-Java 8, registering such ResultSet-returning parameters varied greatly across database and drivers; hence its inclusion as part of the Dialect contract.
    
    Parameters:
    
    statement - The callable statement.
    
    name - The parameter name (for drivers which support named parameters).
    
    Returns:
    
    The number of (contiguous) bind positions used.
    
    Throws:
    
    SQLException - Indicates problems registering the param.
  - getResultSet
```
public ResultSet getResultSet(CallableStatement statement)
                       throws SQLException
```
    Given a callable statement previously processed by registerResultSetOutParameter(java.sql.CallableStatement, int), extract the ResultSet from the OUT parameter.
    
    Parameters:
    
    statement - The callable statement.
    
    Returns:
    
    The extracted result set.
    
    Throws:
    
    SQLException - Indicates problems extracting the result set.
  - getResultSet
```
public ResultSet getResultSet(CallableStatement statement,
                              int position)
                       throws SQLException
```
    Given a callable statement previously processed by registerResultSetOutParameter(java.sql.CallableStatement, int), extract the ResultSet.
    
    Parameters:
    
    statement - The callable statement.
    
    position - The bind position at which to register the output param.
    
    Returns:
    
    The extracted result set.
    
    Throws:
    
    SQLException - Indicates problems extracting the result set.
  - getResultSet
```
public ResultSet getResultSet(CallableStatement statement,
                              String name)
                       throws SQLException
```
    Given a callable statement previously processed by registerResultSetOutParameter(java.sql.CallableStatement, int), extract the ResultSet from the OUT parameter.
    
    Parameters:
    
    statement - The callable statement.
    
    name - The parameter name (for drivers which support named parameters).
    
    Returns:
    
    The extracted result set.
    
    Throws:
    
    SQLException - Indicates problems extracting the result set.
  - supportsCurrentTimestampSelection
```
@Deprecated
public boolean supportsCurrentTimestampSelection()
```
    Deprecated. no longer called
    
    Does this dialect support a way to retrieve the database's current timestamp value?
    
    Returns:
    
    True if the current timestamp can be retrieved; false otherwise.
  - isCurrentTimestampSelectStringCallable
```
@Deprecated
public boolean isCurrentTimestampSelectStringCallable()
```
    Deprecated. no longer called
    
    Should the value returned by getCurrentTimestampSelectString() be treated as callable. Typically this indicates that JDBC escape syntax is being used...
    
    Returns:
    
    True if the getCurrentTimestampSelectString() return is callable; false otherwise.
  - getCurrentTimestampSelectString
```
@Deprecated
public String getCurrentTimestampSelectString()
```
    Deprecated. no longer called, use currentTimestamp()
    
    Retrieve the command used to retrieve the current timestamp from the database.
    
    Returns:
    
    The command.
  - getCurrentTimestampSQLFunctionName
```
@Deprecated
public String getCurrentTimestampSQLFunctionName()
```
    Deprecated. use currentTimestamp(), currentLocalTimestamp(), or currentTimestampWithTimeZone().
    
    The name of the database-specific SQL function for retrieving the current timestamp.
    
    Returns:
    
    The function name.
  - buildSQLExceptionConverter
```
@Deprecated
public SQLExceptionConverter buildSQLExceptionConverter()
```
    Deprecated. buildSQLExceptionConversionDelegate() should be overridden instead.
    Build an instance of the SQLExceptionConverter preferred by this dialect for converting SQLExceptions into Hibernate's JDBCException hierarchy.
    The preferred method is to not override this method; if possible, buildSQLExceptionConversionDelegate() should be overridden instead. If this method is not overridden, the default SQLExceptionConverter implementation executes 3 SQLException converter delegates:
    1. a "static" delegate based on the JDBC 4 defined SQLException hierarchy;
    2. the vendor-specific delegate returned by buildSQLExceptionConversionDelegate(); (it is strongly recommended that specific Dialect implementations override buildSQLExceptionConversionDelegate())
    3. a delegate that interprets SQLState codes for either X/Open or SQL-2003 codes, depending on java.sql.DatabaseMetaData#getSQLStateType
    If this method is overridden, it is strongly recommended that the returned SQLExceptionConverter interpret SQL errors based on vendor-specific error codes rather than the SQLState since the interpretation is more accurate when using vendor-specific ErrorCodes.
    Returns:
    
    The Dialect's preferred SQLExceptionConverter, or null to indicate that the default SQLExceptionConverter should be used.
    
    See Also:
    
    buildSQLExceptionConversionDelegate()
  - buildSQLExceptionConversionDelegate
```
public SQLExceptionConversionDelegate buildSQLExceptionConversionDelegate()
```
    Build an instance of a SQLExceptionConversionDelegate for interpreting dialect-specific error or SQLState codes.
    When 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.
    Returns:
    
    The SQLExceptionConversionDelegate for this dialect
  - getViolatedConstraintNameExtractor
```
public ViolatedConstraintNameExtractor getViolatedConstraintNameExtractor()
```
    Specified by:
    
    getViolatedConstraintNameExtractor in interface ConversionContext
  - getSelectClauseNullString
```
public String getSelectClauseNullString(int sqlType)
```
    Given a 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.
    
    Parameters:
    
    sqlType - The Types type code.
    
    Returns:
    
    The appropriate select clause value fragment.
  - supportsUnionAll
```
public boolean supportsUnionAll()
```
    Does this dialect support UNION ALL.
    
    Returns:
    
    True if UNION ALL is supported; false otherwise.
  - supportsUnionInSubquery
```
public boolean supportsUnionInSubquery()
```
    Does this dialect support UNION in a subquery.
    
    Returns:
    
    True if UNION is supported ina subquery; false otherwise.
  - createOuterJoinFragment
```
@Deprecated
public JoinFragment createOuterJoinFragment()
```
    Deprecated. migrating away from deprecated JoinFragment
    
    Create a JoinFragment strategy responsible for handling this dialect's variations in how joins are handled.
    
    Returns:
    
    This dialect's JoinFragment strategy.
  - createCaseFragment
```
@Deprecated
public CaseFragment createCaseFragment()
```
    Deprecated. migrating away from deprecated CaseFragment
    
    Create a CaseFragment strategy responsible for handling this dialect's variations in how CASE statements are handled.
    
    Returns:
    
    This dialect's CaseFragment strategy.
  - getNoColumnsInsertString
```
public String getNoColumnsInsertString()
```
    The fragment used to insert a row without specifying any column values. This is not possible on some databases.
    
    Returns:
    
    The appropriate empty values clause.
  - supportsNoColumnsInsert
```
public boolean supportsNoColumnsInsert()
```
    Check if the INSERT statement is allowed to contain no column.
    
    Returns:
    
    if the Dialect supports no-column INSERT.
  - getLowercaseFunction
```
public String getLowercaseFunction()
```
    The name of the SQL function that transforms a string to lowercase
    
    Returns:
    
    The dialect-specific lowercase function.
  - getCaseInsensitiveLike
```
public String getCaseInsensitiveLike()
```
    The name of the SQL function that can do case insensitive like comparison.
    
    Returns:
    
    The dialect-specific "case insensitive" like function.
  - supportsCaseInsensitiveLike
```
public boolean supportsCaseInsensitiveLike()
```
    Does this dialect support case insensitive LIKE restrictions?
    
    Returns:
    
    true if the underlying database supports case insensitive like comparison, false otherwise. The default is false.
  - supportsTruncateWithCast
```
public boolean supportsTruncateWithCast()
```
    Does this dialect support truncation of values to a specified length through a cast?
    
    Returns:
    
    true if the underlying database supports truncation through a cast, false otherwise. The default is true.
  - transformSelectString
```
public String transformSelectString(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.
    
    Parameters:
    
    select - The select command
    
    Returns:
    
    The mutated select command, or the same as was passed in.
  - getMaxAliasLength
```
public int getMaxAliasLength()
```
    What is the maximum length Hibernate can use for generated aliases?
    The maximum here should account for the fact that Hibernate often needs to append "uniqueing" information to the end of generated aliases. That "uniqueing" information will be added to the end of a identifier generated to the length specified here; so be sure to leave some room (generally speaking 5 positions will suffice).
    
    Returns:
    
    The maximum length.
  - toBooleanValueString
```
public String toBooleanValueString(boolean bool)
```
    The SQL literal value to which this database maps boolean values.
    
    Parameters:
    
    bool - The boolean value
    
    Returns:
    
    The appropriate SQL literal.
  - registerKeyword
```
protected void registerKeyword(String word)
```
  - getKeywords
```
@Deprecated
public Set<String> getKeywords()
```
    Deprecated. These are only ever used (if at all) from the code that handles identifier quoting. So see buildIdentifierHelper(org.hibernate.engine.jdbc.env.spi.IdentifierHelperBuilder, java.sql.DatabaseMetaData) instead
  - buildIdentifierHelper
```
public IdentifierHelper buildIdentifierHelper(IdentifierHelperBuilder builder,
                                              DatabaseMetaData dbMetaData)
                                       throws SQLException
```
    Build the IdentifierHelper indicated by this Dialect for handling identifier conversions. Returning null is allowed and indicates that Hibernate should fallback to building a "standard" helper. In the fallback path, any changes made to the IdentifierHelperBuilder during this call will still be incorporated into the built IdentifierHelper.
    The incoming builder will have the following set:
    - IdentifierHelperBuilder.isGloballyQuoteIdentifiers()
    - IdentifierHelperBuilder.getUnquotedCaseStrategy() - initialized to UPPER
    - IdentifierHelperBuilder.getQuotedCaseStrategy() - initialized to MIXED
    By default Hibernate will do the following:
    - Call IdentifierHelperBuilder.applyIdentifierCasing(DatabaseMetaData)
    - Call IdentifierHelperBuilder.applyReservedWords(DatabaseMetaData)
    - Applies AnsiSqlKeywords.sql2003() as reserved words
    - Applies the {#link #sqlKeywords} collected here as reserved words
    - Applies the Dialect's NameQualifierSupport, if it defines one
    Parameters:
    
    builder - A semi-configured IdentifierHelper builder.
    
    dbMetaData - Access to the metadata returned from the driver if needed and if available. WARNING: may be null
    
    Returns:
    
    The IdentifierHelper instance to use, or null to indicate Hibernate should use its fallback path
    
    Throws:
    
    SQLException - Accessing the DatabaseMetaData can throw it. Just re-throw and Hibernate will handle.
    
    See Also:
    
    getNameQualifierSupport()
  - openQuote
```
public char openQuote()
```
    The character specific to this dialect used to begin a quoted identifier.
    
    Returns:
    
    The dialect's specific open quote character.
  - closeQuote
```
public char closeQuote()
```
    The character specific to this dialect used to close a quoted identifier.
    
    Returns:
    
    The dialect's specific close quote character.
  - quote
```
public final String quote(String name)
```
    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.
    
    Parameters:
    
    name - The value to be quoted.
    
    Returns:
    
    The quoted (or unmodified, if not starting with back-tick) value.
    
    See Also:
    
    openQuote(), closeQuote()
  - getTableExporter
```
public Exporter<Table> getTableExporter()
```
  - getSequenceExporter
```
public Exporter<Sequence> getSequenceExporter()
```
  - getIndexExporter
```
public Exporter<Index> getIndexExporter()
```
  - getForeignKeyExporter
```
public Exporter<ForeignKey> getForeignKeyExporter()
```
  - getUniqueKeyExporter
```
public Exporter<Constraint> getUniqueKeyExporter()
```
  - getAuxiliaryDatabaseObjectExporter
```
public Exporter<AuxiliaryDatabaseObject> getAuxiliaryDatabaseObjectExporter()
```
  - canCreateCatalog
```
public boolean canCreateCatalog()
```
    Does this dialect support catalog creation?
    
    Returns:
    
    True if the dialect supports catalog creation; false otherwise.
  - getCreateCatalogCommand
```
public String[] getCreateCatalogCommand(String catalogName)
```
    Get the SQL command used to create the named catalog
    
    Parameters:
    
    catalogName - The name of the catalog to be created.
    
    Returns:
    
    The creation commands
  - getDropCatalogCommand
```
public String[] getDropCatalogCommand(String catalogName)
```
    Get the SQL command used to drop the named catalog
    
    Parameters:
    
    catalogName - The name of the catalog to be dropped.
    
    Returns:
    
    The drop commands
  - canCreateSchema
```
public boolean canCreateSchema()
```
    Does this dialect support schema creation?
    
    Returns:
    
    True if the dialect supports schema creation; false otherwise.
  - getCreateSchemaCommand
```
public String[] getCreateSchemaCommand(String schemaName)
```
    Get the SQL command used to create the named schema
    
    Parameters:
    
    schemaName - The name of the schema to be created.
    
    Returns:
    
    The creation commands
  - getDropSchemaCommand
```
public String[] getDropSchemaCommand(String schemaName)
```
    Get the SQL command used to drop the named schema
    
    Parameters:
    
    schemaName - The name of the schema to be dropped.
    
    Returns:
    
    The drop commands
  - getCurrentSchemaCommand
```
public String getCurrentSchemaCommand()
```
    Get the SQL command used to retrieve the current schema name. Works in conjunction with getSchemaNameResolver(), unless the return from there does not need this information. E.g., a custom impl might make use of the Java 1.7 addition of the Connection.getSchema() method
    
    Returns:
    
    The current schema retrieval SQL
  - getSchemaNameResolver
```
public SchemaNameResolver getSchemaNameResolver()
```
    Get the strategy for determining the schema name of a Connection
    
    Returns:
    
    The schema name resolver strategy
  - hasAlterTable
```
public boolean hasAlterTable()
```
    Does this dialect support the ALTER TABLE syntax?
    
    Returns:
    
    True if we support altering of tables; false otherwise.
  - dropConstraints
```
public boolean dropConstraints()
```
    Do we need to drop constraints before dropping tables in this dialect?
    
    Returns:
    
    True if constraints must be dropped prior to dropping the table; false otherwise.
  - qualifyIndexName
```
public boolean qualifyIndexName()
```
    Do we need to qualify index names with the schema name?
    
    Returns:
    
    boolean
  - getAddColumnString
```
public String getAddColumnString()
```
    The syntax used to add a column to a table (optional).
    
    Returns:
    
    The "add column" fragment.
  - getAddColumnSuffixString
```
public String getAddColumnSuffixString()
```
    The syntax for the suffix used to add a column to a table (optional).
    
    Returns:
    
    The suffix "add column" fragment.
  - getDropForeignKeyString
```
public String getDropForeignKeyString()
```
  - getTableTypeString
```
public String getTableTypeString()
```
  - getAddForeignKeyConstraintString
```
public String getAddForeignKeyConstraintString(String constraintName,
                                               String[] foreignKey,
                                               String referencedTable,
                                               String[] primaryKey,
                                               boolean referencesPrimaryKey)
```
    The syntax used to add a foreign key constraint to a table.
    
    Parameters:
    
    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
    
    Returns:
    
    the "add FK" fragment
  - getAddForeignKeyConstraintString
```
public String getAddForeignKeyConstraintString(String constraintName,
                                               String foreignKeyDefinition)
```
  - getAddPrimaryKeyConstraintString
```
public String getAddPrimaryKeyConstraintString(String constraintName)
```
    The syntax used to add a primary key constraint to a table.
    
    Parameters:
    
    constraintName - The name of the PK constraint.
    
    Returns:
    
    The "add PK" fragment
  - hasSelfReferentialForeignKeyBug
```
public boolean hasSelfReferentialForeignKeyBug()
```
    Does the database/driver have bug in deleting rows that refer to other rows being deleted in the same query?
    
    Returns:
    
    true if the database/driver has this bug
  - getNullColumnString
```
public String getNullColumnString()
```
    The keyword used to specify a nullable column.
    
    Returns:
    
    String
  - getNullColumnString
```
public String getNullColumnString(String columnType)
```
    The keyword used to specify a nullable column.
    
    Returns:
    
    String
  - supportsCommentOn
```
public boolean supportsCommentOn()
```
    Does this dialect/database support commenting on tables, columns, etc?
    
    Returns:
    
    true if commenting is supported
  - getTableComment
```
public String getTableComment(String comment)
```
    Get the comment into a form supported for table definition.
    
    Parameters:
    
    comment - The comment to apply
    
    Returns:
    
    The comment fragment
  - getColumnComment
```
public String getColumnComment(String comment)
```
    Get the comment into a form supported for column definition.
    
    Parameters:
    
    comment - The comment to apply
    
    Returns:
    
    The comment fragment
  - supportsIfExistsBeforeTableName
```
public boolean supportsIfExistsBeforeTableName()
```
    For dropping a table, can the phrase "if exists" be applied before the table name?
    NOTE : Only one or the other (or neither) of this and supportsIfExistsAfterTableName() should return true
    
    Returns:
    
    true if the "if exists" can be applied before the table name
  - supportsIfExistsAfterTableName
```
public boolean supportsIfExistsAfterTableName()
```
    For dropping a table, can the phrase "if exists" be applied after the table name?
    NOTE : Only one or the other (or neither) of this and supportsIfExistsBeforeTableName() should return true
    
    Returns:
    
    true if the "if exists" can be applied after the table name
  - supportsIfExistsBeforeConstraintName
```
public boolean supportsIfExistsBeforeConstraintName()
```
    For dropping a constraint with an "alter table", can the phrase "if exists" be applied before the constraint name?
    NOTE : Only one or the other (or neither) of this and supportsIfExistsAfterConstraintName() should return true
    
    Returns:
    
    true if the "if exists" can be applied before the constraint name
  - supportsIfExistsAfterConstraintName
```
public boolean supportsIfExistsAfterConstraintName()
```
    For dropping a constraint with an "alter table", can the phrase "if exists" be applied after the constraint name?
    NOTE : Only one or the other (or neither) of this and supportsIfExistsBeforeConstraintName() should return true
    
    Returns:
    
    true if the "if exists" can be applied after the constraint name
  - supportsIfExistsAfterAlterTable
```
public boolean supportsIfExistsAfterAlterTable()
```
    For an "alter table", can the phrase "if exists" be applied?
    
    Returns:
    
    true if the "if exists" can be applied after ALTER TABLE
    
    Since:
    
    5.2.11
  - getDropTableString
```
public String getDropTableString(String tableName)
```
    Generate a DROP TABLE statement
    
    Parameters:
    
    tableName - The name of the table to drop
    
    Returns:
    
    The DROP TABLE command
  - supportsColumnCheck
```
public boolean supportsColumnCheck()
```
    Does this dialect support column-level check constraints?
    
    Returns:
    
    True if column-level CHECK constraints are supported; false otherwise.
  - supportsTableCheck
```
public boolean supportsTableCheck()
```
    Does this dialect support table-level check constraints?
    
    Returns:
    
    True if table-level CHECK constraints are supported; false otherwise.
  - supportsCascadeDelete
```
public boolean supportsCascadeDelete()
```
    Does this dialect support cascaded delete on foreign key definitions?
    
    Returns:
    
    true indicates that the dialect does support cascaded delete on foreign keys.
  - getCascadeConstraintsString
```
public String getCascadeConstraintsString()
```
    The keyword that specifies that a drop table operation should be cascaded to its constraints, typically " cascade" where the leading space is required, or the empty string if there is no such keyword in this dialect.
    
    Returns:
    
    The cascade drop keyword, if any, with a leading space
  - getCrossJoinSeparator
```
public String getCrossJoinSeparator()
```
    The separator to use for declaring cross joins in a SQL query, typically either " cross join " or a comma ", ", where the spaces are required.
    
    Returns:
    
    The cross join separator, with spaces
  - getTableAliasSeparator
```
public String getTableAliasSeparator()
```
    The separator to use between a table name and its alias in a SQL query, typically either " as " where the spaces are required, or a space character " ".
    
    Returns:
    
    The separator keyword, if any, with spaces
  - getColumnAliasExtractor
```
public ColumnAliasExtractor getColumnAliasExtractor()
```
  - supportsEmptyInList
```
public boolean supportsEmptyInList()
```
    Does this dialect support empty IN lists?
    For example, is [where XYZ in ()] a supported construct?
    
    Returns:
    
    True if empty in lists are supported; false otherwise.
    
    Since:
    
    3.2
  - areStringComparisonsCaseInsensitive
```
public boolean areStringComparisonsCaseInsensitive()
```
    Are string comparisons implicitly case insensitive.
    In other words, does [where 'XYZ' = 'xyz'] resolve to true?
    
    Returns:
    
    True if comparisons are case insensitive.
    
    Since:
    
    3.2
  - supportsRowValueConstructorSyntax
```
@Deprecated
public boolean supportsRowValueConstructorSyntax()
```
    Deprecated. Moved to AbstractSqlAstTranslator
    
    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') ...".
    
    Returns:
    
    True if this SQL dialect is known to support "row value constructor" syntax; false otherwise.
    
    Since:
    
    3.2
  - supportsRowValueConstructorSyntaxInSet
```
@Deprecated
public boolean supportsRowValueConstructorSyntaxInSet()
```
    Deprecated. Moved to AbstractSqlAstTranslator
    
    Is this dialect known to support what ANSI-SQL terms "row value constructor" syntax, sometimes called tuple syntax, in the SET clause;
    Basically, does it support syntax like "... SET (FIRST_NAME, LAST_NAME) = ('Steve', 'Ebersole') ...".
    
    Returns:
    
    True if this SQL dialect is known to support "row value constructor" syntax in the SET clause; false otherwise.
  - supportsRowValueConstructorSyntaxInQuantifiedPredicates
```
@Deprecated
public boolean supportsRowValueConstructorSyntaxInQuantifiedPredicates()
```
    Deprecated. Moved to AbstractSqlAstTranslator
    
    Is this dialect known to support what ANSI-SQL terms "row value constructor" syntax; sometimes called tuple syntax with quantified predicates.
    Basically, does it support syntax like "... where (FIRST_NAME, LAST_NAME) = ALL (select ...) ...".
    
    Returns:
    
    True if this SQL dialect is known to support "row value constructor" syntax with quantified predicates; false otherwise.
    
    Since:
    
    6.0
  - supportsRowValueConstructorSyntaxInInList
```
@Deprecated
public boolean supportsRowValueConstructorSyntaxInInList()
```
    Deprecated. Moved to AbstractSqlAstTranslator
    
    If the dialect supports row values, does it offer such support in IN lists as well?
    For example, "... where (FIRST_NAME, LAST_NAME) IN ( (?, ?), (?, ?) ) ..."
    
    Returns:
    
    True if this SQL dialect is known to support "row value constructor" syntax in the IN list; false otherwise.
    
    Since:
    
    3.2
  - supportsRowValueConstructorSyntaxInInSubquery
```
@Deprecated
public boolean supportsRowValueConstructorSyntaxInInSubquery()
```
    Deprecated. Moved to AbstractSqlAstTranslator
  - getGroupBySummarizationRenderingStrategy
```
@Deprecated
public GroupBySummarizationRenderingStrategy getGroupBySummarizationRenderingStrategy()
```
    Deprecated. Moved to AbstractSqlAstTranslator
    
    The strategy to use for rendering summarizations in the GROUP BY clause.
    
    Since:
    
    6.0
  - getGroupByConstantRenderingStrategy
```
@Deprecated
public GroupByConstantRenderingStrategy getGroupByConstantRenderingStrategy()
```
    Deprecated. Moved to AbstractSqlAstTranslator
    
    The strategy to use for rendering constants in the GROUP BY clause.
    
    Since:
    
    6.0
  - useInputStreamToInsertBlob
```
public boolean useInputStreamToInsertBlob()
```
    Should LOBs (both BLOB and CLOB) be bound using stream operations (i.e. PreparedStatement.setBinaryStream(int, java.io.InputStream, int)).
    
    Returns:
    
    True if BLOBs and CLOBs should be bound using stream operations.
    
    Since:
    
    3.2
  - supportsParametersInInsertSelect
```
public boolean supportsParametersInInsertSelect()
```
    Does this dialect support parameters within the SELECT clause of INSERT ... SELECT ... statements?
    
    Returns:
    
    True if this is supported; false otherwise.
    
    Since:
    
    3.2
  - replaceResultVariableInOrderByClauseWithPosition
```
@Deprecated
public boolean replaceResultVariableInOrderByClauseWithPosition()
```
    Deprecated. We now use ordinal rendering by default to produce smaller SQL
    
    Does this dialect require that references to result variables (i.e, select expression aliases) in an ORDER BY clause be replaced by column positions (1-origin) as defined by the select clause?
    
    Returns:
    
    true if result variable references in the ORDER BY clause should be replaced by column positions; false otherwise.
    
    See Also:
    
    supportsOrdinalSelectItemReference()
  - supportsOrdinalSelectItemReference
```
public boolean supportsOrdinalSelectItemReference()
```
    Does this dialect support references to result variables (i.e, select items) by column positions (1-origin) as defined by the select clause?
    
    Returns:
    
    true if result variable references by column positions are supported; false otherwise.
    
    Since:
    
    6.0.0
  - getNullOrdering
```
public NullOrdering getNullOrdering()
```
    Returns the ordering of null.
    
    Since:
    
    6.0.0
  - supportsNullPrecedence
```
public boolean supportsNullPrecedence()
```
  - renderOrderByElement
```
@Deprecated
public String renderOrderByElement(String expression,
                                               String collation,
                                               String order,
                                               NullPrecedence nulls)
```
    Deprecated. todo (6.0): remove?
    
    Renders an ordering fragment
    
    Parameters:
    
    expression - The SQL order expression. In case of @OrderBy annotation user receives property placeholder (e.g. attribute name enclosed in '{' and '}' signs).
    
    collation - Collation string in format collate IDENTIFIER, or null if expression has not been explicitly specified.
    
    order - Order direction. Possible values: asc, desc, or null if expression has not been explicitly specified.
    
    nulls - Nulls precedence. Default value: NullPrecedence.NONE.
    
    Returns:
    
    Renders single element of ORDER BY clause.
  - requiresCastingOfParametersInSelectClause
```
@Deprecated
public boolean requiresCastingOfParametersInSelectClause()
```
    Deprecated. Moved to AbstractSqlAstTranslator
    
    Does this dialect require that parameters appearing in the SELECT clause be wrapped in cast() calls to tell the db parser the expected type.
    
    Returns:
    
    True if select clause parameter must be cast()ed
    
    Since:
    
    3.2
  - requiresFloatCastingOfIntegerDivision
```
public boolean requiresFloatCastingOfIntegerDivision()
```
    Does this dialect require that integer divisions be wrapped in cast() calls to tell the db parser the expected type.
    
    Returns:
    
    True if integer divisions must be cast()ed to float
  - supportsResultSetPositionQueryMethodsOnForwardOnlyCursor
```
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 ResultSet.isAfterLast() and ResultSet.isBeforeFirst(). Certain drivers do not allow access to these methods for forward only cursors.
    NOTE : this is highly driver dependent!
    
    Returns:
    
    True if methods like ResultSet.isAfterLast() and ResultSet.isBeforeFirst() are supported for forward only cursors; false otherwise.
    
    Since:
    
    3.2
  - supportsCircularCascadeDeleteConstraints
```
public boolean supportsCircularCascadeDeleteConstraints()
```
    Does this dialect support definition of cascade delete constraints which can cause circular chains?
    
    Returns:
    
    True if circular cascade delete constraints are supported; false otherwise.
    
    Since:
    
    3.2
  - supportsSubselectAsInPredicateLHS
```
public boolean supportsSubselectAsInPredicateLHS()
```
    Are subselects supported as the left-hand-side (LHS) of IN-predicates.
    In other words, is syntax like ... <subquery> IN (1, 2, 3) ... supported?
    
    Returns:
    
    True if subselects can appear as the LHS of an in-predicate; false otherwise.
    
    Since:
    
    3.2
  - supportsExpectedLobUsagePattern
```
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...
    
    Returns:
    
    True if normal LOB usage patterns can be used with this driver; false if driver-specific hookiness needs to be applied.
    
    Since:
    
    3.2
  - supportsLobValueChangePropagation
```
public boolean supportsLobValueChangePropagation()
```
    Does the dialect support propagating 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: Blob.setBinaryStream(long), Blob.setBytes(long, byte[]), Blob.setBytes(long, byte[], int, int), or Blob.truncate(long).
    For CLOBs, the internal value might be changed by: Clob.setAsciiStream(long), Clob.setCharacterStream(long), Clob.setString(long, String), Clob.setString(long, String, int, int), or 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 supportsExpectedLobUsagePattern().
    
    Returns:
    
    True if the changes are propagated back to the database; false otherwise.
    
    Since:
    
    3.2
  - supportsUnboundedLobLocatorMaterialization
```
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 supportsExpectedLobUsagePattern() also support the ability to materialize a LOB outside the owning transaction...
    
    Returns:
    
    True if unbounded materialization is supported; false otherwise.
    
    Since:
    
    3.2
  - supportsSubqueryOnMutatingTable
```
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)
    Returns:
    
    True if this dialect allows references the mutating table from a subquery.
  - supportsExistsInSelect
```
public boolean supportsExistsInSelect()
```
    Does the dialect support an exists statement in the select clause?
    
    Returns:
    
    True if exists checks are allowed in the select clause; false otherwise.
  - doesReadCommittedCauseWritersToBlockReaders
```
public boolean doesReadCommittedCauseWritersToBlockReaders()
```
    For the underlying database, is READ_COMMITTED isolation implemented by forcing readers to wait for write locks to be released?
    
    Returns:
    
    True if writers block readers to achieve READ_COMMITTED; false otherwise.
  - doesRepeatableReadCauseReadersToBlockWriters
```
public boolean doesRepeatableReadCauseReadersToBlockWriters()
```
    For the underlying database, is REPEATABLE_READ isolation implemented by forcing writers to wait for read locks to be released?
    
    Returns:
    
    True if readers block writers to achieve REPEATABLE_READ; false otherwise.
  - supportsBindAsCallableArgument
```
public boolean supportsBindAsCallableArgument()
```
    Does this dialect support using a JDBC bind parameter as an argument to a function or procedure call?
    
    Returns:
    
    Returns true if the database supports accepting bind params as args, false otherwise. The default is true.
  - supportsTupleCounts
```
public boolean supportsTupleCounts()
```
    Does this dialect support `count(a,b)`?
    
    Returns:
    
    True if the database supports counting tuples; false otherwise.
  - supportsTupleDistinctCounts
```
public boolean supportsTupleDistinctCounts()
```
    Does this dialect support `count(distinct a,b)`?
    
    Returns:
    
    True if the database supports counting distinct tuples; false otherwise.
  - requiresParensForTupleDistinctCounts
```
public boolean requiresParensForTupleDistinctCounts()
```
    If supportsTupleDistinctCounts() is true, does the Dialect require the tuple to be wrapped with parens?
    
    Returns:
    
    boolean
  - getInExpressionCountLimit
```
public int getInExpressionCountLimit()
```
    Return the limit that the underlying database places on the number of elements in an IN predicate. If the database defines no such limits, simply return zero or less-than-zero.
    
    Returns:
    
    int The limit, or zero-or-less to indicate no limit.
  - forceLobAsLastValue
```
public boolean forceLobAsLastValue()
```
    HHH-4635 Oracle expects all Lob values to be last in inserts and updates.
    
    Returns:
    
    boolean True if Lob values should be last, false if it does not matter.
  - isEmptyStringTreatedAsNull
```
public boolean isEmptyStringTreatedAsNull()
```
    Return whether the dialect considers an empty-string value as null.
    
    Returns:
    
    boolean True if an empty string is treated as null, false othrwise.
  - useFollowOnLocking
```
public boolean useFollowOnLocking(String sql,
                                  QueryOptions queryOptions)
```
    Some dialects have trouble applying pessimistic locking depending upon what other query options are specified (paging, ordering, etc). This method allows these dialects to request that locking be applied by subsequent selects.
    
    Returns:
    
    true indicates that the dialect requests that locking be applied by subsequent select; false (the default) indicates that locking should be applied to the main SQL statement..
    
    Since:
    
    5.2
  - getNotExpression
```
@Deprecated
public String getNotExpression(String expression)
```
    Deprecated. todo (6.0): Remove
    
    Negate an expression
    
    Parameters:
    
    expression - The expression to negate
    
    Returns:
    
    The negated expression
  - getUniqueDelegate
```
public UniqueDelegate getUniqueDelegate()
```
    Get the UniqueDelegate supported by this dialect
    
    Returns:
    
    The UniqueDelegate
  - supportsUnique
```
@Deprecated
public boolean supportsUnique()
```
    Deprecated. getUniqueDelegate() should be overridden instead.
    
    Does this dialect support the UNIQUE column syntax?
    
    Returns:
    
    boolean
  - supportsUniqueConstraintInCreateAlterTable
```
@Deprecated
public boolean supportsUniqueConstraintInCreateAlterTable()
```
    Deprecated. getUniqueDelegate() should be overridden instead.
    
    Does this dialect support adding Unique constraints via create and alter table ?
    
    Returns:
    
    boolean
  - getAddUniqueConstraintString
```
@Deprecated
public String getAddUniqueConstraintString(String constraintName)
```
    Deprecated. getUniqueDelegate() should be overridden instead.
    
    The syntax used to add a unique constraint to a table.
    
    Parameters:
    
    constraintName - The name of the unique constraint.
    
    Returns:
    
    The "add unique" fragment
  - supportsNotNullUnique
```
@Deprecated
public boolean supportsNotNullUnique()
```
    Deprecated. getUniqueDelegate() should be overridden instead.
    
    Is the combination of not-null and unique supported?
    
    Returns:
    
    deprecated
  - getQueryHintString
```
public String getQueryHintString(String query,
                                 List<String> hintList)
```
    Apply a hint to the query. The entire query is provided, allowing the Dialect full control over the placement and syntax of the hint. By default, ignore the hint and simply return the query.
    
    Parameters:
    
    query - The query to which to apply the hint.
    
    hintList - The hints to apply
    
    Returns:
    
    The modified SQL
  - getQueryHintString
```
public String getQueryHintString(String query,
                                 String hints)
```
    Apply a hint to the query. The entire query is provided, allowing the Dialect full control over the placement and syntax of the hint. By default, ignore the hint and simply return the query.
    
    Parameters:
    
    query - The query to which to apply the hint.
    
    hints - The hints to apply
    
    Returns:
    
    The modified SQL
  - defaultScrollMode
```
public ScrollMode defaultScrollMode()
```
    Certain dialects support a subset of ScrollModes. Provide a default to be used by Criteria and Query.
    
    Returns:
    
    ScrollMode
  - supportsTuplesInSubqueries
```
@Deprecated
public boolean supportsTuplesInSubqueries()
```
    Deprecated. See supportsRowValueConstructorSyntaxInInSubquery()
    
    Does this dialect support tuples in subqueries? Ex: delete from Table1 where (col1, col2) in (select col1, col2 from Table2)
    
    Returns:
    
    boolean
  - supportsOffsetInSubquery
```
public boolean supportsOffsetInSubquery()
```
    Does this dialect support offset in subqueries? Ex: select * from Table1 where col1 in (select col1 from Table2 order by col2 limit 1 offset 1)
    
    Returns:
    
    boolean
  - supportsOrderByInSubquery
```
public boolean supportsOrderByInSubquery()
```
    Does this dialect support the order by clause in subqueries? Ex: select * from Table1 where col1 in (select col1 from Table2 order by col2 limit 1)
    
    Returns:
    
    boolean
  - supportsSubqueryInSelect
```
public boolean supportsSubqueryInSelect()
```
    Does this dialect support subqueries in the select clause? Ex: select col1, (select col2 from Table2 where ..) from Table1
    
    Returns:
    
    boolean
  - supportsFetchClause
```
public boolean supportsFetchClause(FetchClauseType type)
```
    Does this dialect support the given fetch clause type.
    
    Parameters:
    
    type - The fetch clause type
    
    Returns:
    
    true if the underlying database supports the given fetch clause type, false otherwise. The default is false.
  - supportsWindowFunctions
```
public boolean supportsWindowFunctions()
```
    Does this dialect support window functions like `row_number() over (..)`
    
    Returns:
    
    true if the underlying database supports window functions, false otherwise. The default is false.
  - getCallableStatementSupport
```
public CallableStatementSupport getCallableStatementSupport()
```
  - getNameQualifierSupport
```
public NameQualifierSupport getNameQualifierSupport()
```
    By default interpret this based on DatabaseMetaData.
    
    Returns:
    
    The NameQualifierSupport.
  - getDefaultBatchLoadSizingStrategy
```
public BatchLoadSizingStrategy getDefaultBatchLoadSizingStrategy()
```
  - isJdbcLogWarningsEnabledByDefault
```
public boolean isJdbcLogWarningsEnabledByDefault()
```
    Does the fetching JDBC statement warning for logging is enabled by default
    
    Returns:
    
    boolean
    
    Since:
    
    5.1
  - augmentRecognizedTableTypes
```
public void augmentRecognizedTableTypes(List<String> tableTypesList)
```
  - supportsPartitionBy
```
public boolean supportsPartitionBy()
```
    Does the underlying database support partition by
    
    Returns:
    
    boolean
    
    Since:
    
    5.2
  - supportsNamedParameters
```
public boolean supportsNamedParameters(DatabaseMetaData databaseMetaData)
                                throws SQLException
```
    Override the DatabaseMetaData#supportsNamedParameters()
    
    Returns:
    
    boolean
    
    Throws:
    
    SQLException - Accessing the DatabaseMetaData can throw it. Just re-throw and Hibernate will handle.
  - supportsNationalizedTypes
```
@Deprecated
public final boolean supportsNationalizedTypes()
```
    Deprecated. (since 6.0) Prefer getNationalizationSupport() which gives a little better insight into what is supported. This is interpreted as true if the supported strategy is NationalizationSupport.EXPLICIT
    
    Does this dialect supports Nationalized Types
    
    Returns:
    
    boolean
  - getNationalizationSupport
```
public NationalizationSupport getNationalizationSupport()
```
  - getPreferredSqlTypeCodeForBoolean
```
public int getPreferredSqlTypeCodeForBoolean()
```
    The JDBC type code to use for mapping properties of Java type boolean.
    Usually Types.BOOLEAN or Types.BIT.
    
    Returns:
    
    one of the type codes defined by Types.
  - supportsNonQueryWithCTE
```
public boolean supportsNonQueryWithCTE()
```
    Does this dialect/database support non-query statements (e.g. INSERT, UPDATE, DELETE) with CTE (Common Table Expressions)?
    
    Returns:
    
    true if non-query statements are supported with CTE
  - supportsValuesList
```
public boolean supportsValuesList()
```
    Does this dialect/database support VALUES list (e.g. VALUES (1), (2), (3) )
    
    Returns:
    
    true if VALUES list are supported
  - supportsValuesListForInsert
```
public boolean supportsValuesListForInsert()
```
    Does this dialect/database support VALUES list (e.g. VALUES (1), (2), (3) ) for insert statements.
    
    Returns:
    
    true if VALUES list are supported for insert statements
  - supportsSkipLocked
```
public boolean supportsSkipLocked()
```
    Does this dialect/database support SKIP_LOCKED timeout.
    
    Returns:
    
    true if SKIP_LOCKED is supported
  - supportsNoWait
```
public boolean supportsNoWait()
```
    Does this dialect/database support NO_WAIT timeout.
    
    Returns:
    
    true if NO_WAIT is supported
  - supportsWait
```
public boolean supportsWait()
```
    Does this dialect/database support WAIT timeout.
    
    Returns:
    
    true if WAIT is supported
  - inlineLiteral
```
public String inlineLiteral(String literal)
```
    Inline String literal.
    
    Returns:
    
    escaped String
  - supportsJdbcConnectionLobCreation
```
public boolean supportsJdbcConnectionLobCreation(DatabaseMetaData databaseMetaData)
```
    Check whether the JDBC Connection supports creating LOBs via Connection.createBlob(), Connection.createNClob() or Connection.createClob().
    
    Parameters:
    
    databaseMetaData - JDBC DatabaseMetaData which can be used if LOB creation is supported only starting from a given Driver version
    
    Returns:
    
    true if LOBs can be created via the JDBC Connection.
  - escapeLiteral
```
protected String escapeLiteral(String literal)
```
    Escape String literal.
    
    Returns:
    
    escaped String
  - addSqlHintOrComment
```
public String addSqlHintOrComment(String sql,
                                  QueryOptions queryOptions,
                                  boolean commentsEnabled)
```
    Modify the SQL, adding hints or comments, if necessary
  - prependComment
```
protected String prependComment(String sql,
                                String comment)
```
  - escapeComment
```
public static String escapeComment(String comment)
```
  - getHqlTranslator
```
public HqlTranslator getHqlTranslator()
```
    Return an HqlTranslator specific for the Dialect. Return null to use Hibernate's standard translator. Note that QueryEngineOptions.getCustomHqlTranslator() has higher precedence
    
    See Also:
    
    StandardHqlTranslator, QueryEngine.getHqlTranslator()
  - getSqmTranslatorFactory
```
public SqmTranslatorFactory getSqmTranslatorFactory()
```
    Return an SqmToSqlAstConverterFactory specific for the Dialect. Return null to use Hibernate's standard translator. Note that QueryEngineOptions.getCustomSqmTranslatorFactory() has higher precedence as it comes directly from the user config
    
    See Also:
    
    StandardSqmTranslator, QueryEngine.getSqmTranslatorFactory()
  - getSqlAstTranslatorFactory
```
public SqlAstTranslatorFactory getSqlAstTranslatorFactory()
```
    Return an SqlAstTranslatorFactory specific for the Dialect. Return null to use Hibernate's standard translator.
    
    See Also:
    
    StandardSqlAstTranslatorFactory, JdbcEnvironment.getSqlAstTranslatorFactory()
  - supportsSelectAliasInGroupByClause
```
public boolean supportsSelectAliasInGroupByClause()
```
  - getSizeStrategy
```
public Dialect.SizeStrategy getSizeStrategy()
```
  - getDefaultLobLength
```
public long getDefaultLobLength()
```
  - getDefaultDecimalPrecision
```
public int getDefaultDecimalPrecision()
```
    This is the default precision for a generated column mapped to a BigInteger or BigDecimal.
    Usually returns the maximum precision of the database, except when there is no such maximum precision, or the maximum precision is very high.
    
    Returns:
    
    the default precision, in decimal digits
  - getDefaultTimestampPrecision
```
public int getDefaultTimestampPrecision()
```
    This is the default precision for a generated column mapped to a Timestamp or LocalDateTime.
    Usually 6 (microseconds) or 3 (milliseconds).
    
    Returns:
    
    the default precision, in decimal digits, of the fractional seconds field
  - getFloatPrecision
```
public int getFloatPrecision()
```
    This is the default precision for a generated column mapped to a Java Float or float. That is, a value representing "single precision".
    Usually 24 binary digits, at least for databases with a conventional interpretation of the ANSI SQL specification.
    
    Returns:
    
    a value representing "single precision", usually in binary digits, but sometimes in decimal digits
  - getDoublePrecision
```
public int getDoublePrecision()
```
    This is the default precision for a generated column mapped to a Java Double or double. That is, a value representing "double precision".
    Usually 53 binary digits, at least for databases with a conventional interpretation of the ANSI SQL specification.
    
    Returns:
    
    a value representing "double precision", usually in binary digits, but sometimes in decimal digits
  - getFractionalSecondPrecisionInNanos
```
public long getFractionalSecondPrecisionInNanos()
```
    The "native" precision for arithmetic with datetimes and day-to-second durations. Datetime differences will be calculated with this precision except when a precision is explicitly specified as a TemporalUnit.
    Usually 1 (nanoseconds), 1_000 (microseconds), or 1_000_000 (milliseconds).
    
    Returns:
    
    the precision, specified as a quantity of nanoseconds
    
    See Also:
    
    TemporalUnit.NATIVE
  - supportsBitType
```
public boolean supportsBitType()
```
    Does this dialect have a true SQL BIT type with just two values (0 and 1) or, even better, a proper SQL BOOLEAN type, or does Types.BIT get mapped to a numeric type with more than two values?
    
    Returns:
    
    true if there is a BIT or BOOLEAN type
  - formatBinaryLiteral
```
public String formatBinaryLiteral(byte[] bytes)
```
  - getLockRowIdentifier
```
public RowLockStrategy getLockRowIdentifier(LockMode lockMode)
```
  - translateDatetimeFormat
```
public String translateDatetimeFormat(String format)
```
    Translate the given datetime format string from the pattern language defined by Java's DateTimeFormatter to whatever pattern language is understood by the native datetime formatting function for this database (often the to_char() function).
    Since it's never possible to translate all of the pattern letter sequences understood by DateTimeFormatter, only the following subset of pattern letters is accepted by Hibernate:
    - G: era
    - y: year of era
    - Y: year of week-based year
    - M: month of year
    - w: week of week-based year (ISO week number)
    - W: week of month
    - E: day of week (name)
    - e: day of week (number)
    - d: day of month
    - D: day of year
    - a: AM/PM
    - H: hour of day (24 hour time)
    - h: hour of AM/PM (12 hour time)
    - m: minutes
    - s: seconds
    - z,Z,x: timezone offset
    In addition, punctuation characters and single-quoted literal strings are accepted.
    Returns:
    
    a pattern accepted by the function that formats dates and times in this dialect
  - translateExtractField
```
public String translateExtractField(TemporalUnit unit)
```
    Return the name used to identify the given field as an argument to the extract() function, or of this dialect's equivalent function.
    This method does not need to handle TemporalUnit.NANOSECOND, TemporalUnit.NATIVE, TemporalUnit.OFFSET, TemporalUnit.DATE, TemporalUnit.TIME, TemporalUnit.WEEK_OF_YEAR, nor TemporalUnit.WEEK_OF_MONTH, which are already desugared by ExtractFunction.
  - translateDurationField
```
public String translateDurationField(TemporalUnit unit)
```
    Return the name used to identify the given unit of duration as an argument to #timestampadd() or #timestampdiff(), or of this dialect's equivalent functions.
    This method does not need to handle TemporalUnit.NANOSECOND, TemporalUnit.NATIVE, TemporalUnit.OFFSET, TemporalUnit.DAY_OF_WEEK, TemporalUnit.DAY_OF_MONTH, TemporalUnit.DAY_OF_YEAR, TemporalUnit.DATE, TemporalUnit.TIME, TemporalUnit.TIMEZONE_HOUR, TemporalUnit.TIMEZONE_MINUTE, TemporalUnit.WEEK_OF_YEAR, nor TemporalUnit.WEEK_OF_MONTH, which are not units of duration.
  - wrapTimestampLiteral
```
protected String wrapTimestampLiteral(String timestamp)
```
  - wrapDateLiteral
```
protected String wrapDateLiteral(String date)
```
  - wrapTimeLiteral
```
protected String wrapTimeLiteral(String time)
```
  - formatDateTimeLiteral
```
public String formatDateTimeLiteral(TemporalAccessor temporalAccessor,
                                    TemporalType precision,
                                    TimeZone jdbcTimeZone)
```
  - formatAsTimestamp
```
protected String formatAsTimestamp(TemporalAccessor temporalAccessor,
                                   TimeZone jdbcTimeZone)
```
  - formatDateTimeLiteral
```
public String formatDateTimeLiteral(Date date,
                                    TemporalType precision,
                                    TimeZone jdbcTimeZone)
```
  - formatAsTimestamp
```
protected String formatAsTimestamp(Date date,
                                   TimeZone jdbcTimeZone)
```
  - formatDateTimeLiteral
```
public String formatDateTimeLiteral(Calendar calendar,
                                    TemporalType precision,
                                    TimeZone jdbcTimeZone)
```
  - formatAsTimestamp
```
protected String formatAsTimestamp(Calendar calendar,
                                   TimeZone jdbcTimeZone)
```
  - supportsTemporalLiteralOffset
```
public boolean supportsTemporalLiteralOffset()
```
    Whether the Dialect supports timezone offset in temporal literals.
  - supportsTimezoneTypes
```
public boolean supportsTimezoneTypes()
```
    Whether the Dialect supports timezone types like Types.TIMESTAMP_WITH_TIMEZONE.
  - supportsLimit
```
@Deprecated
public boolean supportsLimit()
```
    Deprecated. getLimitHandler() should be overridden instead.
  - supportsLimitOffset
```
@Deprecated
public boolean supportsLimitOffset()
```
    Deprecated. getLimitHandler() should be overridden instead.
  - supportsVariableLimit
```
@Deprecated
public boolean supportsVariableLimit()
```
    Deprecated. getLimitHandler() should be overridden instead.
  - bindLimitParametersInReverseOrder
```
@Deprecated
public boolean bindLimitParametersInReverseOrder()
```
    Deprecated. getLimitHandler() should be overridden instead.
  - bindLimitParametersFirst
```
@Deprecated
public boolean bindLimitParametersFirst()
```
    Deprecated. getLimitHandler() should be overridden instead.
  - useMaxForLimit
```
@Deprecated
public boolean useMaxForLimit()
```
    Deprecated. getLimitHandler() should be overridden instead.
  - forceLimitUsage
```
@Deprecated
public boolean forceLimitUsage()
```
    Deprecated. getLimitHandler() should be overridden instead.
  - getLimitString
```
@Deprecated
public String getLimitString(String query,
                                         int offset,
                                         int limit)
```
    Deprecated. getLimitHandler() should be overridden instead.
  - getLimitString
```
@Deprecated
protected String getLimitString(String query,
                                            boolean hasOffset)
```
    Deprecated. getLimitHandler() should be overridden instead.
  - convertToFirstRowValue
```
@Deprecated
public int convertToFirstRowValue(int zeroBasedFirstResult)
```
    Deprecated. getLimitHandler() should be overridden instead.
  - supportsSequences
```
@Deprecated
public boolean supportsSequences()
```
    Deprecated. implement SequenceSupport and override getSequenceSupport()
  - supportsPooledSequences
```
@Deprecated
public boolean supportsPooledSequences()
```
    Deprecated. implement SequenceSupport and override getSequenceSupport()
  - getSequenceNextValString
```
@Deprecated
public String getSequenceNextValString(String sequenceName)
                                            throws MappingException
```
    Deprecated. implement SequenceSupport and override getSequenceSupport()
    
    Throws:
    
    MappingException
  - getSelectSequenceNextValString
```
@Deprecated
public String getSelectSequenceNextValString(String sequenceName)
                                                  throws MappingException
```
    Deprecated. implement SequenceSupport and override getSequenceSupport()
    
    Throws:
    
    MappingException
  - getSequenceNextValString
```
@Deprecated
public String getSequenceNextValString(String sequenceName,
                                                   int increment)
                                            throws MappingException
```
    Deprecated. implement SequenceSupport and override getSequenceSupport()
    
    Throws:
    
    MappingException
  - getCreateSequenceStrings
```
@Deprecated
public String[] getCreateSequenceStrings(String sequenceName,
                                                     int initialValue,
                                                     int incrementSize)
                                              throws MappingException
```
    Deprecated. implement SequenceSupport and override getSequenceSupport()
    
    Throws:
    
    MappingException
  - getCreateSequenceString
```
@Deprecated
protected String getCreateSequenceString(String sequenceName)
                                              throws MappingException
```
    Deprecated. implement SequenceSupport and override getSequenceSupport()
    
    Throws:
    
    MappingException
  - getCreateSequenceString
```
@Deprecated
protected String getCreateSequenceString(String sequenceName,
                                                     int initialValue,
                                                     int incrementSize)
                                              throws MappingException
```
    Deprecated. implement SequenceSupport and override getSequenceSupport()
    
    Throws:
    
    MappingException
  - getDropSequenceStrings
```
@Deprecated
public String[] getDropSequenceStrings(String sequenceName)
                                            throws MappingException
```
    Deprecated. implement SequenceSupport and override getSequenceSupport()
    
    Throws:
    
    MappingException
  - getDropSequenceString
```
@Deprecated
protected String getDropSequenceString(String sequenceName)
                                            throws MappingException
```
    Deprecated. implement SequenceSupport and override getSequenceSupport()
    
    Throws:
    
    MappingException
  - getCreateTemporaryTableColumnAnnotation
```
public String getCreateTemporaryTableColumnAnnotation(int sqlTypeCode)
```
    Annotation to be appended to the end of each COLUMN clause for temporary tables.
    
    Parameters:
    
    sqlTypeCode - The SQL type code
    
    Returns:
    
    The annotation to be appended (e.g. "COLLATE DATABASE_DEFAULT" in SQLServer SQL)

Class Dialect

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_BATCH_SIZE

NO_BATCH

QUOTE

CLOSED_QUOTE

TWO_SINGLE_QUOTES_REPLACEMENT

LEGACY_LOB_MERGE_STRATEGY

STREAM_XFER_LOB_MERGE_STRATEGY

NEW_LOCATOR_LOB_MERGE_STRATEGY

STANDARD_DEFAULT_BATCH_LOAD_SIZING_STRATEGY

Constructor Detail

Dialect

Method Detail

resolveSqlTypeDescriptor

binaryToDecimalPrecision

getBooleanCheckCondition

getEnumCheckCondition

getVersion

initializeFunctionRegistry

currentDate

currentTime

currentTimestamp

currentLocalTime

currentLocalTimestamp

currentTimestampWithTimeZone

extractPattern

castPattern

trimPattern

supportsFractionalTimestampArithmetic

timestampdiffPattern

timestampaddPattern

equivalentTypes

getDialect

getDialect

getDefaultProperties

toString

contributeTypes

getRawTypeName

getRawTypeName

getTypeName

getTypeName

getTypeName

getTypeName

getCastTypeName

registerColumnType

registerColumnType

remapSqlTypeDescriptor

getSqlTypeDescriptorOverride

getLobMergeStrategy

getHibernateTypeName

isTypeNameRegistered

getHibernateTypeName

registerHibernateType

registerHibernateType

getNativeIdentifierGeneratorClass

getNativeIdentifierGeneratorStrategy

getIdentityColumnSupport

getSequenceSupport

getQuerySequencesString

getSequenceInformationExtractor

getSelectGUIDString

getFromDual

supportsSelectQueryWithoutFromClause

supportsTemporaryTables

getLimitHandler

supportsLockTimeouts

isLockTimeoutParameterized

getLockingStrategy

getForUpdateString

getForUpdateString

getForUpdateString

getWriteLockString

getWriteLockString

getReadLockString