Hibernate
/
hibernate-orm
mirror of https://github.com/hibernate/hibernate-orm
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

HHH-13724 Add CockroachDB dialects and configs for testing

This commit is contained in:
Rafi Shamim 2019-11-11 14:29:30 -05:00 committed by Andrea Boriero
parent 4df7986108
commit 4655bdbe12
73 changed files with 1034 additions and 227 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
documentation/documentation.gradle
View File

@ -63,6 +63,7 @@ dependencies {
testRuntime( libraries.mariadb )
testRuntime( libraries.mssql )
testRuntime( libraries.hana )
testRuntime( libraries.cockroachdb )
testCompile( project( ':hibernate-jcache' ) )
testRuntime( libraries.ehcache3 )

2
documentation/src/test/java/org/hibernate/userguide/hql/HQLTest.java
View File

@ -24,6 +24,7 @@ import javax.persistence.TypedQuery;
import org.hibernate.CacheMode;
import org.hibernate.ScrollableResults;
import org.hibernate.Session;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.dialect.H2Dialect;
import org.hibernate.dialect.MySQL5Dialect;
import org.hibernate.dialect.Oracle8iDialect;
@ -1296,6 +1297,7 @@ public class HQLTest extends BaseEntityManagerFunctionalTestCase {
}
@Test
@SkipForDialect(value = CockroachDB192Dialect.class, comment = "https://github.com/cockroachdb/cockroach/issues/26710")
public void test_hql_sqrt_function_example() {
doInJPA( this::entityManagerFactory, entityManager -> {
//tag::hql-sqrt-function-example[]

8
documentation/src/test/java/org/hibernate/userguide/locking/OptimisticLockTest.java
View File

@ -9,16 +9,13 @@ package org.hibernate.userguide.locking;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.Version;
import org.hibernate.annotations.OptimisticLock;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
import org.hibernate.testing.SkipForDialect;
import org.junit.Test;
import org.jboss.logging.Logger;
import static org.hibernate.testing.transaction.TransactionUtil.doInJPA;
/**
@ -34,6 +31,7 @@ public class OptimisticLockTest extends BaseEntityManagerFunctionalTestCase {
}
@Test
@SkipForDialect(value = CockroachDB192Dialect.class, comment = "Fails at SERIALIZABLE isolation")
public void test() {
doInJPA( this::entityManagerFactory, entityManager -> {
Phone phone = new Phone();

4
documentation/src/test/java/org/hibernate/userguide/locking/OptimisticLockingTest.java
View File

@ -13,13 +13,9 @@ import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.Version;
import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
import org.junit.Test;
import org.jboss.logging.Logger;
import static org.hibernate.testing.transaction.TransactionUtil.doInJPA;
/**

4
documentation/src/test/java/org/hibernate/userguide/mapping/basic/NClobTest.java
View File

@ -18,6 +18,7 @@ import javax.persistence.Lob;
import org.hibernate.Session;
import org.hibernate.annotations.Nationalized;
import org.hibernate.dialect.AbstractHANADialect;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.dialect.MySQL5Dialect;
import org.hibernate.dialect.PostgreSQL81Dialect;
import org.hibernate.engine.jdbc.NClobProxy;
@ -37,7 +38,8 @@ import static org.junit.Assert.fail;
value = {
PostgreSQL81Dialect.class,
MySQL5Dialect.class,
AbstractHANADialect.class
AbstractHANADialect.class,
CockroachDB192Dialect.class
},
comment = "@see https://hibernate.atlassian.net/browse/HHH-10693 and https://hibernate.atlassian.net/browse/HHH-10695"
)

10
gradle/databases.gradle
View File

@ -120,6 +120,14 @@ ext {
'jdbc.user' : 'VLAD',
'jdbc.pass' : 'V1ad_test',
'jdbc.url' : 'jdbc:sap://localhost:39015/'
]
],
cockroachdb : [
'db.dialect' : 'org.hibernate.dialect.CockroachDB192Dialect',
// CockroachDB uses the same pgwire protocol as PostgreSQL, so the driver is the same.
'jdbc.driver': 'org.postgresql.Driver',
'jdbc.user' : 'root',
'jdbc.pass' : '',
'jdbc.url' : 'jdbc:postgresql://localhost:26257/defaultdb?sslmode=disable'
],
]
}

1
gradle/java-module.gradle
View File

@ -85,6 +85,7 @@ dependencies {
testRuntime( libraries.mssql )
testRuntime( libraries.informix )
testRuntime( libraries.hana )
testRuntime( libraries.cockroachdb )
asciidoclet 'org.asciidoctor:asciidoclet:1.+'

1
gradle/libraries.gradle
View File

@ -114,6 +114,7 @@ ext {
postgresql: 'org.postgresql:postgresql:42.2.2',
mysql: 'mysql:mysql-connector-java:8.0.17',
mariadb: 'org.mariadb.jdbc:mariadb-java-client:2.2.3',
cockroachdb: 'org.postgresql:postgresql:42.2.8',
oracle: 'com.oracle.jdbc:ojdbc8:12.2.0.1',
mssql: 'com.microsoft.sqlserver:mssql-jdbc:7.2.1.jre8',

641
hibernate-core/src/main/java/org/hibernate/dialect/CockroachDB192Dialect.java Normal file
View File

@ -0,0 +1,641 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
*/
package org.hibernate.dialect;
import java.sql.DatabaseMetaData;
import java.sql.SQLException;
import java.sql.Types;
import java.util.Iterator;
import java.util.Map;
import org.hibernate.JDBCException;
import org.hibernate.LockMode;
import org.hibernate.LockOptions;
import org.hibernate.PessimisticLockException;
import org.hibernate.boot.model.TypeContributions;
import org.hibernate.cfg.Environment;
import org.hibernate.dialect.function.NoArgSQLFunction;
import org.hibernate.dialect.function.PositionSubstringFunction;
import org.hibernate.dialect.function.SQLFunctionTemplate;
import org.hibernate.dialect.function.StandardSQLFunction;
import org.hibernate.dialect.function.VarArgsSQLFunction;
import org.hibernate.dialect.identity.CockroachDB1920IdentityColumnSupport;
import org.hibernate.dialect.identity.IdentityColumnSupport;
import org.hibernate.dialect.pagination.AbstractLimitHandler;
import org.hibernate.dialect.pagination.LimitHandler;
import org.hibernate.dialect.pagination.LimitHelper;
import org.hibernate.engine.spi.RowSelection;
import org.hibernate.exception.LockAcquisitionException;
import org.hibernate.exception.spi.SQLExceptionConversionDelegate;
import org.hibernate.exception.spi.TemplatedViolatedConstraintNameExtracter;
import org.hibernate.exception.spi.ViolatedConstraintNameExtracter;
import org.hibernate.hql.spi.id.MultiTableBulkIdStrategy;
import org.hibernate.hql.spi.id.inline.InlineIdsInClauseBulkIdStrategy;
import org.hibernate.internal.util.JdbcExceptionHelper;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.type.PostgresUUIDType;
import org.hibernate.type.StandardBasicTypes;
import org.hibernate.type.descriptor.sql.SqlTypeDescriptor;
import org.hibernate.type.descriptor.sql.VarbinaryTypeDescriptor;
import org.hibernate.type.descriptor.sql.VarcharTypeDescriptor;
/**
* An SQL dialect for CockroachDB 19.2 and later. This is the first dialect for CockroachDB. It is largely adapted
* from the PostgreSQL dialects, with changes where appropriate.
*/
public class CockroachDB192Dialect extends Dialect {
private static final AbstractLimitHandler LIMIT_HANDLER = new AbstractLimitHandler() {
@Override
public String processSql(String sql, RowSelection selection) {
final boolean hasOffset = LimitHelper.hasFirstRow( selection );
return sql + (hasOffset ? " limit ? offset ?" : " limit ?");
}
@Override
public boolean supportsLimit() {
return true;
}
@Override
public boolean bindLimitParametersInReverseOrder() {
return true;
}
};
public CockroachDB192Dialect() {
super();
registerColumnType( Types.BIT, "bool" );
registerColumnType( Types.BIGINT, "int8" );
registerColumnType( Types.SMALLINT, "int2" );
registerColumnType( Types.TINYINT, "int2" );
registerColumnType( Types.INTEGER, "int4" );
registerColumnType( Types.CHAR, "char(1)" );
registerColumnType( Types.VARCHAR, "varchar($l)" );
registerColumnType( Types.FLOAT, "float4" );
registerColumnType( Types.DOUBLE, "float8" );
registerColumnType( Types.DATE, "date" );
registerColumnType( Types.TIME, "time" );
registerColumnType( Types.TIMESTAMP, "timestamp" );
registerColumnType( Types.VARBINARY, "bytea" );
registerColumnType( Types.BINARY, "bytea" );
registerColumnType( Types.LONGVARCHAR, "text" );
registerColumnType( Types.LONGVARBINARY, "bytea" );
registerColumnType( Types.CLOB, "text" );
registerColumnType( Types.BLOB, "bytea" );
registerColumnType( Types.NUMERIC, "numeric($p, $s)" );
registerColumnType( Types.OTHER, "uuid" );
registerColumnType( Types.JAVA_OBJECT, "json" );
registerFunction( "abs", new StandardSQLFunction("abs") );
registerFunction( "sign", new StandardSQLFunction("sign", StandardBasicTypes.INTEGER) );
registerFunction( "acos", new StandardSQLFunction("acos", StandardBasicTypes.DOUBLE) );
registerFunction( "asin", new StandardSQLFunction("asin", StandardBasicTypes.DOUBLE) );
registerFunction( "atan", new StandardSQLFunction("atan", StandardBasicTypes.DOUBLE) );
registerFunction( "cos", new StandardSQLFunction("cos", StandardBasicTypes.DOUBLE) );
registerFunction( "cot", new StandardSQLFunction("cot", StandardBasicTypes.DOUBLE) );
registerFunction( "exp", new StandardSQLFunction("exp", StandardBasicTypes.DOUBLE) );
registerFunction( "ln", new StandardSQLFunction("ln", StandardBasicTypes.DOUBLE) );
registerFunction( "log", new StandardSQLFunction("log", StandardBasicTypes.DOUBLE) );
registerFunction( "sin", new StandardSQLFunction("sin", StandardBasicTypes.DOUBLE) );
registerFunction( "sqrt", new StandardSQLFunction("sqrt", StandardBasicTypes.DOUBLE) );
registerFunction( "cbrt", new StandardSQLFunction("cbrt", StandardBasicTypes.DOUBLE) );
registerFunction( "tan", new StandardSQLFunction("tan", StandardBasicTypes.DOUBLE) );
registerFunction( "radians", new StandardSQLFunction("radians", StandardBasicTypes.DOUBLE) );
registerFunction( "degrees", new StandardSQLFunction("degrees", StandardBasicTypes.DOUBLE) );
registerFunction( "random", new NoArgSQLFunction("random", StandardBasicTypes.DOUBLE) );
registerFunction( "round", new StandardSQLFunction("round") );
registerFunction( "trunc", new StandardSQLFunction("trunc") );
registerFunction( "ceil", new StandardSQLFunction("ceil") );
registerFunction( "floor", new StandardSQLFunction("floor") );
registerFunction( "chr", new StandardSQLFunction("chr", StandardBasicTypes.CHARACTER) );
registerFunction( "lower", new StandardSQLFunction("lower") );
registerFunction( "upper", new StandardSQLFunction("upper") );
registerFunction( "substr", new StandardSQLFunction("substr", StandardBasicTypes.STRING) );
registerFunction( "initcap", new StandardSQLFunction("initcap") );
registerFunction( "quote_ident", new StandardSQLFunction("quote_ident", StandardBasicTypes.STRING) );
registerFunction( "quote_literal", new StandardSQLFunction("quote_literal", StandardBasicTypes.STRING) );
registerFunction( "md5", new StandardSQLFunction("md5", StandardBasicTypes.STRING) );
registerFunction( "ascii", new StandardSQLFunction("ascii", StandardBasicTypes.INTEGER) );
registerFunction( "char_length", new StandardSQLFunction("char_length", StandardBasicTypes.LONG) );
registerFunction( "bit_length", new StandardSQLFunction("bit_length", StandardBasicTypes.LONG) );
registerFunction( "octet_length", new StandardSQLFunction("octet_length", StandardBasicTypes.LONG) );
registerFunction( "age", new StandardSQLFunction("age") );
registerFunction( "current_date", new NoArgSQLFunction("current_date", StandardBasicTypes.DATE, false) );
registerFunction( "current_timestamp", new NoArgSQLFunction("current_timestamp", StandardBasicTypes.TIMESTAMP, false) );
registerFunction( "date_trunc", new StandardSQLFunction( "date_trunc", StandardBasicTypes.TIMESTAMP ) );
registerFunction( "now", new NoArgSQLFunction("now", StandardBasicTypes.TIMESTAMP) );
registerFunction( "current_user", new NoArgSQLFunction("current_user", StandardBasicTypes.STRING, false) );
registerFunction( "session_user", new NoArgSQLFunction("session_user", StandardBasicTypes.STRING, false) );
registerFunction( "user", new NoArgSQLFunction("user", StandardBasicTypes.STRING, false) );
registerFunction( "current_database", new NoArgSQLFunction("current_database", StandardBasicTypes.STRING, true) );
registerFunction( "current_schema", new NoArgSQLFunction("current_schema", StandardBasicTypes.STRING, true) );
registerFunction( "concat", new VarArgsSQLFunction( StandardBasicTypes.STRING, "(","||",")" ) );
registerFunction( "locate", new PositionSubstringFunction() );
registerFunction( "str", new SQLFunctionTemplate(StandardBasicTypes.STRING, "cast(?1 as varchar)") );
getDefaultProperties().setProperty( Environment.STATEMENT_BATCH_SIZE, DEFAULT_BATCH_SIZE );
getDefaultProperties().setProperty( Environment.NON_CONTEXTUAL_LOB_CREATION, "true" );
}
@Override
public SqlTypeDescriptor getSqlTypeDescriptorOverride(int sqlCode) {
SqlTypeDescriptor descriptor;
switch (sqlCode) {
case Types.BLOB: {
// Make BLOBs use byte[] storage.
descriptor = VarbinaryTypeDescriptor.INSTANCE;
break;
}
case Types.CLOB: {
// Make CLOBs use string storage.
descriptor = VarcharTypeDescriptor.INSTANCE;
break;
}
default: {
descriptor = super.getSqlTypeDescriptorOverride(sqlCode);
break;
}
}
return descriptor;
}
@Override
public String getAddColumnString() {
return "add column";
}
@Override
public String getSequenceNextValString(String sequenceName) {
return "select " + getSelectSequenceNextValString( sequenceName );
}
@Override
public String getSelectSequenceNextValString(String sequenceName) {
return "nextval ('" + sequenceName + "')";
}
@Override
public String getCreateSequenceString(String sequenceName) {
//starts with 1, implicitly
return "create sequence " + sequenceName;
}
@Override
public String getCascadeConstraintsString() {
return " cascade";
}
@Override
public boolean dropConstraints() {
return true;
}
@Override
public boolean supportsSequences() {
return true;
}
@Override
public String getQuerySequencesString() {
return "select * from information_schema.sequences";
}
@Override
public LimitHandler getLimitHandler() {
return LIMIT_HANDLER;
}
@Override
public boolean supportsLimit() {
return true;
}
@Override
public String getLimitString(String sql, boolean hasOffset) {
return sql + (hasOffset ? " limit ? offset ?" : " limit ?");
}
@Override
public boolean bindLimitParametersInReverseOrder() {
return true;
}
@Override
public String getForUpdateString(String aliases) {
return getForUpdateString() + " of " + aliases;
}
@Override
public String getForUpdateString(String aliases, LockOptions lockOptions) {
/*
* Parent's implementation for (aliases, lockOptions) ignores aliases.
*/
if ( "".equals( aliases ) ) {
LockMode lockMode = lockOptions.getLockMode();
final Iterator<Map.Entry<String, LockMode>> itr = lockOptions.getAliasLockIterator();
while ( itr.hasNext() ) {
// seek the highest lock mode
final Map.Entry<String, LockMode> entry = itr.next();
final LockMode lm = entry.getValue();
if ( lm.greaterThan( lockMode ) ) {
aliases = entry.getKey();
}
}
}
LockMode lockMode = lockOptions.getAliasSpecificLockMode( aliases );
if (lockMode == null ) {
lockMode = lockOptions.getLockMode();
}
switch ( lockMode ) {
case UPGRADE:
return getForUpdateString(aliases);
case PESSIMISTIC_READ:
return getReadLockString( aliases, lockOptions.getTimeOut() );
case PESSIMISTIC_WRITE:
return getWriteLockString( aliases, lockOptions.getTimeOut() );
case UPGRADE_NOWAIT:
case FORCE:
case PESSIMISTIC_FORCE_INCREMENT:
return getForUpdateNowaitString(aliases);
case UPGRADE_SKIPLOCKED:
return getForUpdateSkipLockedString(aliases);
default:
return "";
}
}
@Override
public String getNoColumnsInsertString() {
return "default values";
}
@Override
public String getCaseInsensitiveLike(){
return "ilike";
}
@Override
public boolean supportsCaseInsensitiveLike() {
return true;
}
@Override
public String getNativeIdentifierGeneratorStrategy() {
return "sequence";
}
@Override
public boolean supportsOuterJoinForUpdate() {
return false;
}
@Override
public boolean useInputStreamToInsertBlob() {
return false;
}
@Override
public boolean supportsUnionAll() {
return true;
}
@Override
public String getSelectClauseNullString(int sqlType) {
String typeName = getTypeName( sqlType, 1, 1, 0 );
//trim off the length/precision/scale
final int loc = typeName.indexOf( '(' );
if ( loc > -1 ) {
typeName = typeName.substring( 0, loc );
}
return "null::" + typeName;
}
@Override
public boolean supportsCommentOn() {
return true;
}
@Override
public boolean supportsCurrentTimestampSelection() {
return true;
}
@Override
public boolean isCurrentTimestampSelectStringCallable() {
return false;
}
@Override
public String getCurrentTimestampSelectString() {
return "select now()";
}
@Override
public boolean requiresParensForTupleDistinctCounts() {
return true;
}
@Override
public String toBooleanValueString(boolean bool) {
return bool ? "true" : "false";
}
@Override
public ViolatedConstraintNameExtracter getViolatedConstraintNameExtracter() {
return EXTRACTER;
}
/**
* Constraint-name extractor for CockroachDB constraint violation exceptions.
*/
private static final ViolatedConstraintNameExtracter EXTRACTER = new TemplatedViolatedConstraintNameExtracter() {
@Override
protected String doExtractConstraintName(SQLException sqle) throws NumberFormatException {
final int sqlState = Integer.parseInt( JdbcExceptionHelper.extractSqlState( sqle ) );
switch (sqlState) {
// CHECK VIOLATION
case 23514: return extractUsingTemplate( "failed to satisfy CHECK constraint ","\"", sqle.getMessage() );
// UNIQUE VIOLATION
case 23505: return extractUsingTemplate( "violates unique constraint \"","\"", sqle.getMessage() );
// FOREIGN KEY VIOLATION
case 23503: return extractUsingTemplate( "violates foreign key constraint \"","\"", sqle.getMessage() );
// NOT NULL VIOLATION
case 23502: return extractUsingTemplate( "null value in column \"","\" violates not-null constraint", sqle.getMessage() );
// TODO: RESTRICT VIOLATION
case 23001: return null;
// ALL OTHER
default: return null;
}
}
};
@Override
public SQLExceptionConversionDelegate buildSQLExceptionConversionDelegate() {
return new SQLExceptionConversionDelegate() {
@Override
public JDBCException convert(SQLException sqlException, String message, String sql) {
final String sqlState = JdbcExceptionHelper.extractSqlState( sqlException );
if ( "40P01".equals( sqlState ) ) {
// DEADLOCK DETECTED
return new LockAcquisitionException( message, sqlException, sql );
}
if ( "55P03".equals( sqlState ) ) {
// LOCK NOT AVAILABLE
return new PessimisticLockException( message, sqlException, sql );
}
// returning null allows other delegates to operate
return null;
}
};
}
@Override
public boolean supportsPooledSequences() {
return true;
}
@Override
protected String getCreateSequenceString(String sequenceName, int initialValue, int incrementSize) {
if ( initialValue < 0 && incrementSize > 0 ) {
return
String.format(
"%s minvalue %d start %d increment %d",
getCreateSequenceString( sequenceName ),
initialValue,
initialValue,
incrementSize
);
}
else if ( initialValue > 0 && incrementSize < 0 ) {
return
String.format(
"%s maxvalue %d start %d increment %d",
getCreateSequenceString( sequenceName ),
initialValue,
initialValue,
incrementSize
);
}
else {
return
String.format(
"%s start %d increment %d",
getCreateSequenceString( sequenceName ),
initialValue,
incrementSize
);
}
}
// Overridden informational metadata ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@Override
public boolean supportsEmptyInList() {
return false;
}
@Override
public boolean supportsExpectedLobUsagePattern() {
return false;
}
@Override
public boolean supportsLobValueChangePropogation() {
return false;
}
@Override
public boolean supportsUnboundedLobLocatorMaterialization() {
return false;
}
@Override
public boolean supportsRowValueConstructorSyntax() {
return true;
}
@Override
public boolean qualifyIndexName() {
return false;
}
@Override
public boolean supportsNationalizedTypes() {
return false;
}
@Override
public boolean supportsJdbcConnectionLobCreation(DatabaseMetaData databaseMetaData) {
return false;
}
@Override
public boolean supportsSelectAliasInGroupByClause() {
return true;
}
@Override
public boolean supportsIfExistsBeforeTableName() {
return true;
}
@Override
public void contributeTypes(TypeContributions typeContributions, ServiceRegistry serviceRegistry) {
super.contributeTypes( typeContributions, serviceRegistry );
// CockroachDB UUID type is the same as PostgreSQL.
typeContributions.contributeType( PostgresUUIDType.INSTANCE );
}
@Override
public String getDropSequenceString(String sequenceName) {
return "drop sequence if exists " + sequenceName;
}
@Override
public boolean supportsValuesList() {
return true;
}
public boolean supportsRowValueConstructorSyntaxInInList() {
return true;
}
@Override
public boolean supportsPartitionBy() {
return true;
}
@Override
public boolean supportsNonQueryWithCTE() {
return true;
}
@Override
public boolean supportsIfExistsAfterAlterTable() {
return true;
}
@Override
public String getForUpdateString() {
return " for update";
}
@Override
public String getWriteLockString(int timeout) {
if ( timeout == LockOptions.SKIP_LOCKED ) {
return getForUpdateSkipLockedString();
}
else {
return super.getWriteLockString( timeout );
}
}
@Override
public String getWriteLockString(String aliases, int timeout) {
if ( timeout == LockOptions.SKIP_LOCKED ) {
return getForUpdateSkipLockedString( aliases );
}
else {
return super.getWriteLockString( aliases, timeout );
}
}
@Override
public String getReadLockString(int timeout) {
if ( timeout == LockOptions.SKIP_LOCKED ) {
return " for share skip locked";
}
else {
return super.getReadLockString( timeout );
}
}
@Override
public String getReadLockString(String aliases, int timeout) {
if ( timeout == LockOptions.SKIP_LOCKED ) {
return String.format( " for share of %s skip locked", aliases );
}
else {
return super.getReadLockString( aliases, timeout );
}
}
@Override
public String getForUpdateSkipLockedString() {
return " for update skip locked";
}
@Override
public String getForUpdateSkipLockedString(String aliases) {
return getForUpdateString() + " of " + aliases + " skip locked";
}
@Override
public String getForUpdateNowaitString() {
return getForUpdateString() + " nowait ";
}
@Override
public String getForUpdateNowaitString(String aliases) {
return getForUpdateString( aliases ) + " nowait ";
}
@Override
public boolean supportsLockTimeouts() {
return false;
}
@Override
public boolean supportsSkipLocked() {
// CockroachDB 19.2.0 doesn't support this: https://github.com/cockroachdb/cockroach/issues/40476
// A later version will add support, so the syntax for locks is added above.
return false;
}
@Override
public boolean supportsNoWait() {
// CockroachDB 19.2.0 doesn't support this: https://github.com/cockroachdb/cockroach/issues/40476
// A later version will add support, so the syntax for locks is added above.
return false;
}
@Override
public IdentityColumnSupport getIdentityColumnSupport() {
return new CockroachDB1920IdentityColumnSupport();
}
@Override
public MultiTableBulkIdStrategy getDefaultMultiTableBulkIdStrategy() {
// A later version of CockroachDB will support the same temp table syntax as PostgreSQL.
return new InlineIdsInClauseBulkIdStrategy();
}
@Override
public boolean doesReadCommittedCauseWritersToBlockReaders() {
return true;
}
@Override
public boolean canCreateSchema() {
return false;
}
}

23
hibernate-core/src/main/java/org/hibernate/dialect/CockroachDB201Dialect.java Normal file
View File

@ -0,0 +1,23 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
*/
package org.hibernate.dialect;
import org.hibernate.dialect.function.NoArgSQLFunction;
import org.hibernate.type.StandardBasicTypes;
/**
* An SQL dialect for CockroachDB 20.1 and later. Adds support for a few date/time functions.
*/
public class CockroachDB201Dialect extends CockroachDB192Dialect {
public CockroachDB201Dialect() {
super();
registerFunction( "current_time", new NoArgSQLFunction("current_time", StandardBasicTypes.TIME, false) );
registerFunction( "localtime", new NoArgSQLFunction("localtime", StandardBasicTypes.TIME, false) );
registerFunction( "localtimestamp", new NoArgSQLFunction("localtimestamp", StandardBasicTypes.TIMESTAMP, false) );
registerFunction( "timeofday", new NoArgSQLFunction("timeofday", StandardBasicTypes.STRING) );
}
}

3
hibernate-core/src/main/java/org/hibernate/dialect/Dialect.java
View File

@ -28,7 +28,6 @@ import java.util.Properties;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Interceptor;
@ -85,7 +84,6 @@ import org.hibernate.id.enhanced.SequenceStyleGenerator;
import org.hibernate.internal.CoreLogging;
import org.hibernate.internal.CoreMessageLogger;
import org.hibernate.internal.util.ReflectHelper;
import org.hibernate.internal.util.StringHelper;
import org.hibernate.internal.util.collections.ArrayHelper;
import org.hibernate.internal.util.io.StreamCopier;
import org.hibernate.loader.BatchLoadSizingStrategy;
@ -3052,5 +3050,4 @@ public abstract class Dialect implements ConversionContext {
public boolean supportsSelectAliasInGroupByClause() {
return false;
}
}

1
hibernate-core/src/main/java/org/hibernate/dialect/PostgreSQL81Dialect.java
View File

@ -648,5 +648,4 @@ public class PostgreSQL81Dialect extends Dialect {
public boolean supportsSelectAliasInGroupByClause() {
return true;
}
}

35
hibernate-core/src/main/java/org/hibernate/dialect/identity/CockroachDB1920IdentityColumnSupport.java Normal file
View File

@ -0,0 +1,35 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
*/
package org.hibernate.dialect.identity;
import java.sql.Types;
public class CockroachDB1920IdentityColumnSupport extends IdentityColumnSupportImpl {
@Override
public boolean supportsIdentityColumns() {
// Full support requires setting the sql.defaults.serial_normalization=sql_sequence in CockroachDB.
return false;
}
@Override
// CockroachDB does not create a sequence for id columns
public String getIdentitySelectString(String table, String column, int type) {
return "select 1";
}
@Override
public String getIdentityColumnString(int type) {
return type == Types.SMALLINT ?
"serial4 not null" :
"serial8 not null";
}
@Override
public boolean hasDataTypeInIdentityColumn() {
return false;
}
}

17
hibernate-core/src/main/java/org/hibernate/type/descriptor/java/ClobTypeDescriptor.java
View File

@ -92,7 +92,7 @@ public class ClobTypeDescriptor extends AbstractTypeDescriptor<Clob> {
try {
if ( CharacterStream.class.isAssignableFrom( type ) ) {
if ( ClobImplementer.class.isInstance( value ) ) {
if (value instanceof ClobImplementer) {
// if the incoming Clob is a wrapper, just pass along its CharacterStream
return (X) ( (ClobImplementer) value ).getUnderlyingStream();
}
@ -102,11 +102,21 @@ public class ClobTypeDescriptor extends AbstractTypeDescriptor<Clob> {
}
}
else if (Clob.class.isAssignableFrom( type )) {
final Clob clob = WrappedClob.class.isInstance( value )
final Clob clob = value instanceof WrappedClob
? ( (WrappedClob) value ).getWrappedClob()
: value;
return (X) clob;
}
else if ( String.class.isAssignableFrom( type ) ) {
if (value instanceof ClobImplementer) {
// if the incoming Clob is a wrapper, just get the underlying String.
return (X) ( (ClobImplementer) value ).getUnderlyingStream().asString();
}
else {
// otherwise we need to extract the String.
return (X) DataHelper.extractString( value.getCharacterStream() );
}
}
}
catch ( SQLException e ) {
throw new HibernateException( "Unable to access clob stream", e );
@ -129,6 +139,9 @@ public class ClobTypeDescriptor extends AbstractTypeDescriptor<Clob> {
Reader reader = (Reader) value;
return options.getLobCreator().createClob( DataHelper.extractString( reader ) );
}
else if ( String.class.isAssignableFrom( value.getClass() ) ) {
return options.getLobCreator().createClob( (String) value );
}
throw unknownWrap( value.getClass() );
}

4
hibernate-core/src/test/java/org/hibernate/cache/spi/ReadWriteCacheTest.java vendored
View File

@ -19,6 +19,8 @@ import org.hibernate.Transaction;
import org.hibernate.annotations.CacheConcurrencyStrategy;
import org.hibernate.cfg.Configuration;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.testing.SkipForDialect;
import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase;
import org.junit.Before;
@ -60,6 +62,7 @@ public class ReadWriteCacheTest extends BaseCoreFunctionalTestCase {
}
@Test
@SkipForDialect(value = CockroachDB192Dialect.class, comment = "CockroachDB uses SERIALIZABLE isolation, and does not support this")
public void testDelete() throws InterruptedException {
bookId = 1L;
@ -136,6 +139,7 @@ public class ReadWriteCacheTest extends BaseCoreFunctionalTestCase {
}
@Test
@SkipForDialect(value = CockroachDB192Dialect.class, comment = "CockroachDB uses SERIALIZABLE isolation, and does not support this")
public void testUpdate() throws InterruptedException {
bookId = 4L;

5
hibernate-core/src/test/java/org/hibernate/id/hhh12973/PostgreSQLSequenceGeneratorWithSerialTest.java
View File

@ -15,7 +15,6 @@ import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistry;
@ -27,16 +26,14 @@ import org.hibernate.id.SequenceMismatchStrategy;
import org.hibernate.id.enhanced.SequenceStyleGenerator;
import org.hibernate.internal.CoreMessageLogger;
import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
import org.hibernate.testing.RequiresDialect;
import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.logger.LoggerInspectionRule;
import org.hibernate.testing.logger.Triggerable;
import org.jboss.logging.Logger;
import org.junit.Rule;
import org.junit.Test;
import org.jboss.logging.Logger;
import static org.hibernate.testing.transaction.TransactionUtil.doInJPA;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;

5
hibernate-core/src/test/java/org/hibernate/jpa/test/criteria/QueryBuilderTest.java
View File

@ -18,7 +18,7 @@ import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import javax.persistence.criteria.SetJoin;
import javax.persistence.metamodel.EntityType;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.dialect.H2Dialect;
import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
import org.hibernate.jpa.test.metamodel.Address;
@ -37,9 +37,9 @@ import org.hibernate.jpa.test.metamodel.Spouse;
import org.hibernate.metamodel.internal.MetamodelImpl;
import org.hibernate.query.criteria.internal.CriteriaBuilderImpl;
import org.hibernate.query.criteria.internal.predicate.ComparisonPredicate;
import org.hibernate.testing.FailureExpected;
import org.hibernate.testing.RequiresDialect;
import org.hibernate.testing.SkipForDialect;
import org.hibernate.testing.TestForIssue;
import org.junit.Test;
@ -232,6 +232,7 @@ public class QueryBuilderTest extends BaseEntityManagerFunctionalTestCase {
}
@Test
@SkipForDialect(value = CockroachDB192Dialect.class, strictMatching = true)
public void testDateTimeFunctions() {
EntityManager em = getOrCreateEntityManager();
em.getTransaction().begin();

7
hibernate-core/src/test/java/org/hibernate/jpa/test/criteria/basic/PredicateTest.java
View File

@ -6,8 +6,6 @@
*/
package org.hibernate.jpa.test.criteria.basic;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.criteria.CriteriaBuilder;
@ -15,6 +13,7 @@ import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Path;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.dialect.Oracle12cDialect;
import org.hibernate.jpa.test.metamodel.AbstractMetamodelSpecificTest;
import org.hibernate.jpa.test.metamodel.CreditCard;
@ -29,6 +28,9 @@ import org.hibernate.testing.TestForIssue;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* Test the various predicates.
*
@ -246,6 +248,7 @@ public class PredicateTest extends AbstractMetamodelSpecificTest {
@Test
@TestForIssue( jiraKey = "HHH-5803" )
@SkipForDialect( value = CockroachDB192Dialect.class, comment = "https://github.com/cockroachdb/cockroach/issues/41943")
public void testQuotientConversion() {
EntityManager em = getOrCreateEntityManager();
em.getTransaction().begin();

9
hibernate-core/src/test/java/org/hibernate/jpa/test/lock/LockTest.java
View File

@ -21,21 +21,18 @@ import javax.persistence.PersistenceException;
import javax.persistence.PessimisticLockException;
import javax.persistence.Query;
import javax.persistence.QueryTimeoutException;
import org.hibernate.LockOptions;
import org.hibernate.Session;
import org.hibernate.TransactionException;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.dialect.Dialect;
import org.hibernate.dialect.HSQLDialect;
import org.hibernate.dialect.Oracle10gDialect;
import org.hibernate.dialect.Oracle8iDialect;
import org.hibernate.dialect.PostgreSQL81Dialect;
import org.hibernate.dialect.SQLServerDialect;
import org.hibernate.dialect.SybaseASE15Dialect;
import org.hibernate.jpa.AvailableSettings;
import org.hibernate.jpa.QueryHints;
import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
import org.hibernate.testing.DialectChecks;
import org.hibernate.testing.RequiresDialect;
import org.hibernate.testing.RequiresDialectFeature;
@ -43,9 +40,8 @@ import org.hibernate.testing.SkipForDialect;
import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.transaction.TransactionUtil;
import org.hibernate.testing.util.ExceptionUtil;
import org.junit.Test;
import org.jboss.logging.Logger;
import org.junit.Test;
import static org.hibernate.testing.transaction.TransactionUtil.doInJPA;
import static org.junit.Assert.assertEquals;
@ -61,6 +57,7 @@ public class LockTest extends BaseEntityManagerFunctionalTestCase {
private static final Logger log = Logger.getLogger( LockTest.class );
@Test
@SkipForDialect( value = CockroachDB192Dialect.class )
public void testFindWithTimeoutHint() {
final Lock lock = new Lock();
lock.setName( "name" );

6
hibernate-core/src/test/java/org/hibernate/jpa/test/lock/NativeSQLQueryTimeoutTest.java
View File

@ -6,15 +6,14 @@
*/
package org.hibernate.jpa.test.lock;
import org.hibernate.cfg.AvailableSettings;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.dialect.PostgreSQL82Dialect;
import org.hibernate.jpa.QueryHints;
import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
import org.hibernate.query.NativeQuery;
import org.hibernate.testing.RequiresDialect;
import org.hibernate.testing.SkipForDialect;
import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.util.ExceptionUtil;
import org.hibernate.type.IntegerType;
import org.junit.Test;
import java.util.Map;
@ -27,6 +26,7 @@ import static org.junit.Assert.fail;
* @author Vlad Mihalcea
*/
@RequiresDialect(PostgreSQL82Dialect.class)
@SkipForDialect(value = CockroachDB192Dialect.class, comment = "https://github.com/cockroachdb/cockroach/issues/41335")
@TestForIssue( jiraKey = "HHH-13493")
public class NativeSQLQueryTimeoutTest extends BaseEntityManagerFunctionalTestCase {
@Override

6
hibernate-core/src/test/java/org/hibernate/jpa/test/lock/QueryLockingTest.java
View File

@ -19,18 +19,18 @@ import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.JoinType;
import javax.persistence.criteria.ParameterExpression;
import javax.persistence.criteria.Root;
import org.hibernate.LockMode;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.dialect.SQLServerDialect;
import org.hibernate.internal.SessionImpl;
import org.hibernate.jpa.AvailableSettings;
import org.hibernate.jpa.QueryHints;
import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
import org.hibernate.query.NativeQuery;
import org.hibernate.testing.DialectChecks;
import org.hibernate.testing.RequiresDialect;
import org.hibernate.testing.RequiresDialectFeature;
import org.hibernate.testing.SkipForDialect;
import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.transaction.TransactionUtil;
import org.junit.Test;
@ -145,6 +145,7 @@ public class QueryLockingTest extends BaseEntityManagerFunctionalTestCase {
}
@Test
@SkipForDialect( value = CockroachDB192Dialect.class )
public void testPessimisticForcedIncrementOverall() {
EntityManager em = getOrCreateEntityManager();
em.getTransaction().begin();
@ -170,6 +171,7 @@ public class QueryLockingTest extends BaseEntityManagerFunctionalTestCase {
}
@Test
@SkipForDialect( value = CockroachDB192Dialect.class )
public void testPessimisticForcedIncrementSpecific() {
EntityManager em = getOrCreateEntityManager();
em.getTransaction().begin();

7
hibernate-core/src/test/java/org/hibernate/jpa/test/lock/StatementIsClosedAfterALockExceptionTest.java
View File

@ -11,14 +11,14 @@ import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
import javax.persistence.LockModeType;
import org.hibernate.Session;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
import org.hibernate.test.util.jdbc.PreparedStatementSpyConnectionProvider;
import org.hibernate.testing.DialectChecks;
import org.hibernate.testing.RequiresDialectFeature;
import org.hibernate.testing.SkipForDialect;
import org.hibernate.testing.TestForIssue;
import org.hibernate.test.util.jdbc.PreparedStatementSpyConnectionProvider;
import org.hibernate.testing.transaction.TransactionUtil;
import org.hibernate.testing.util.ExceptionUtil;
import org.junit.Before;
@ -67,6 +67,7 @@ public class StatementIsClosedAfterALockExceptionTest extends BaseEntityManagerF
@Test(timeout = 1000 * 30) //30 seconds
@TestForIssue(jiraKey = "HHH-11617")
@SkipForDialect( value = CockroachDB192Dialect.class )
public void testStatementIsClosed() {
TransactionUtil.doInJPA( this::entityManagerFactory, em1 -> {

3
hibernate-core/src/test/java/org/hibernate/jpa/test/query/NativeQueryOrdinalParametersTest.java
View File

@ -18,6 +18,7 @@ import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import org.hibernate.Session;
import org.hibernate.dialect.CockroachDB201Dialect;
import org.hibernate.dialect.PostgreSQL82Dialect;
import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
import org.hibernate.query.NativeQuery;
@ -116,7 +117,7 @@ public class NativeQueryOrdinalParametersTest extends BaseEntityManagerFunctiona
@Test
@TestForIssue(jiraKey = "HHH-12532")
@RequiresDialect(PostgreSQL82Dialect.class)
@RequiresDialect({ PostgreSQL82Dialect.class, CockroachDB201Dialect.class })
public void testCteNativeQueryOrdinalParameter() {
Node root1 = new Node();

5
hibernate-core/src/test/java/org/hibernate/jpa/test/query/QueryTest.java
View File

@ -25,6 +25,7 @@ import javax.persistence.Tuple;
import org.hibernate.Hibernate;
import org.hibernate.QueryException;
import org.hibernate.cfg.AvailableSettings;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.dialect.Oracle8iDialect;
import org.hibernate.dialect.PostgreSQL9Dialect;
import org.hibernate.dialect.PostgresPlusDialect;
@ -383,6 +384,7 @@ public class QueryTest extends BaseEntityManagerFunctionalTestCase {
@SkipForDialect(value = Oracle8iDialect.class, jiraKey = "HHH-10161", comment = "Cannot convert untyped null (assumed to be BINARY type) to NUMBER")
@SkipForDialect(value = PostgreSQL9Dialect.class, jiraKey = "HHH-10312", comment = "Cannot convert untyped null (assumed to be bytea type) to bigint")
@SkipForDialect(value = PostgresPlusDialect.class, jiraKey = "HHH-10312", comment = "Cannot convert untyped null (assumed to be bytea type) to bigint")
@SkipForDialect(value = CockroachDB192Dialect.class, jiraKey = "HHH-10312", comment = "Cannot convert untyped null (assumed to be bytea type) to bigint")
@SkipForDialect(value = SybaseDialect.class, comment = "Null == null on Sybase")
public void testNativeQueryNullPositionalParameter() throws Exception {
EntityManager em = getOrCreateEntityManager();
@ -418,6 +420,7 @@ public class QueryTest extends BaseEntityManagerFunctionalTestCase {
@TestForIssue(jiraKey = "HHH-10161")
@SkipForDialect(value = PostgreSQL9Dialect.class, jiraKey = "HHH-10312", comment = "Cannot convert untyped null (assumed to be bytea type) to bigint")
@SkipForDialect(value = PostgresPlusDialect.class, jiraKey = "HHH-10312", comment = "Cannot convert untyped null (assumed to be bytea type) to bigint")
@SkipForDialect(value = CockroachDB192Dialect.class, jiraKey = "HHH-10312", comment = "Cannot convert untyped null (assumed to be bytea type) to bigint")
@SkipForDialect(value = Oracle8iDialect.class, comment = "ORA-00932: inconsistent datatypes: expected NUMBER got BINARY")
@SkipForDialect(value = SybaseDialect.class, comment = "Null == null on Sybase")
public void testNativeQueryNullPositionalParameterParameter() throws Exception {
@ -471,6 +474,7 @@ public class QueryTest extends BaseEntityManagerFunctionalTestCase {
@SkipForDialect(value = Oracle8iDialect.class, jiraKey = "HHH-10161", comment = "Cannot convert untyped null (assumed to be BINARY type) to NUMBER")
@SkipForDialect(value = PostgreSQL9Dialect.class, jiraKey = "HHH-10312", comment = "Cannot convert untyped null (assumed to be bytea type) to bigint")
@SkipForDialect(value = PostgresPlusDialect.class, jiraKey = "HHH-10312", comment = "Cannot convert untyped null (assumed to be bytea type) to bigint")
@SkipForDialect(value = CockroachDB192Dialect.class, jiraKey = "HHH-10312", comment = "Cannot convert untyped null (assumed to be bytea type) to bigint")
@SkipForDialect(value = SybaseDialect.class, comment = "Null == null on Sybase")
public void testNativeQueryNullNamedParameter() throws Exception {
EntityManager em = getOrCreateEntityManager();
@ -506,6 +510,7 @@ public class QueryTest extends BaseEntityManagerFunctionalTestCase {
@TestForIssue(jiraKey = "HHH-10161")
@SkipForDialect(value = PostgreSQL9Dialect.class, jiraKey = "HHH-10312", comment = "Cannot convert untyped null (assumed to be bytea type) to bigint")
@SkipForDialect(value = PostgresPlusDialect.class, jiraKey = "HHH-10312", comment = "Cannot convert untyped null (assumed to be bytea type) to bigint")
@SkipForDialect(value = CockroachDB192Dialect.class, jiraKey = "HHH-10312", comment = "Cannot convert untyped null (assumed to be bytea type) to bigint")
@SkipForDialect(value = Oracle8iDialect.class, comment = "ORA-00932: inconsistent datatypes: expected NUMBER got BINARY")
@SkipForDialect(value = SybaseDialect.class, comment = "Null == null on Sybase")
public void testNativeQueryNullNamedParameterParameter() throws Exception {

3
hibernate-core/src/test/java/org/hibernate/test/annotations/query/QueryAndSQLTest.java
View File

@ -23,6 +23,7 @@ import org.hibernate.Transaction;
import org.hibernate.boot.model.naming.ImplicitNamingStrategyLegacyJpaImpl;
import org.hibernate.cfg.Configuration;
import org.hibernate.dialect.AbstractHANADialect;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.dialect.Oracle8iDialect;
import org.hibernate.dialect.PostgreSQL81Dialect;
import org.hibernate.dialect.PostgreSQL9Dialect;
@ -118,6 +119,7 @@ public class QueryAndSQLTest extends BaseCoreFunctionalTestCase {
@SkipForDialect(value = Oracle8iDialect.class, jiraKey = "HHH-10161", comment = "Cannot convert untyped null (assumed to be BINARY type) to NUMBER")
@SkipForDialect(value = PostgreSQL9Dialect.class, jiraKey = "HHH-10312", comment = "Cannot convert untyped null (assumed to be bytea type) to bigint")
@SkipForDialect(value = PostgresPlusDialect.class, jiraKey = "HHH-10312", comment = "Cannot convert untyped null (assumed to be bytea type) to bigint")
@SkipForDialect(value = CockroachDB192Dialect.class, jiraKey = "HHH-10312", comment = "Cannot convert untyped null (assumed to be bytea type) to bigint")
@SkipForDialect(value = SybaseDialect.class, comment = "Null == null on Sybase")
public void testQueryWithNullParameter(){
Chaos c0 = new Chaos();
@ -203,6 +205,7 @@ public class QueryAndSQLTest extends BaseCoreFunctionalTestCase {
@SkipForDialect(value = Oracle8iDialect.class, jiraKey = "HHH-10161", comment = "Cannot convert untyped null (assumed to be BINARY type) to NUMBER")
@SkipForDialect(value = PostgreSQL9Dialect.class, jiraKey = "HHH-10312", comment = "Cannot convert untyped null (assumed to be bytea type) to bigint")
@SkipForDialect(value = PostgresPlusDialect.class, jiraKey = "HHH-10312", comment = "Cannot convert untyped null (assumed to be bytea type) to bigint")
@SkipForDialect(value = CockroachDB192Dialect.class, jiraKey = "HHH-10312", comment = "Cannot convert untyped null (assumed to be bytea type) to bigint")
@SkipForDialect(value = SybaseDialect.class, comment = "Null == null on Sybase")
public void testNativeQueryWithNullParameter(){
Chaos c0 = new Chaos();

3
hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/Ejb3XmlTest.java
View File

@ -12,6 +12,7 @@ import java.util.List;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.dialect.PostgreSQL81Dialect;
import org.hibernate.dialect.PostgreSQLDialect;
import org.hibernate.dialect.TeradataDialect;
@ -29,7 +30,7 @@ import static org.junit.Assert.assertNotNull;
*/
public class Ejb3XmlTest extends BaseCoreFunctionalTestCase {
@Test
@SkipForDialect(value = {PostgreSQL81Dialect.class, PostgreSQLDialect.class},
@SkipForDialect(value = {PostgreSQL81Dialect.class, PostgreSQLDialect.class, CockroachDB192Dialect.class},
comment = "postgresql jdbc driver does not implement the setQueryTimeout method")
@SkipForDialect(value = TeradataDialect.class,
jiraKey = "HHH-8190",

6
hibernate-core/src/test/java/org/hibernate/test/bulkid/GlobalTemporaryTableBulkCompositeIdTest.java
View File

@ -1,18 +1,18 @@
package org.hibernate.test.bulkid;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.dialect.PostgreSQL82Dialect;
import org.hibernate.hql.spi.id.MultiTableBulkIdStrategy;
import org.hibernate.hql.spi.id.global.GlobalTemporaryTableBulkIdStrategy;
import org.hibernate.hql.spi.id.inline.InlineIdsInClauseBulkIdStrategy;
import org.hibernate.testing.DialectChecks;
import org.hibernate.testing.RequiresDialect;
import org.hibernate.testing.RequiresDialectFeature;
import org.hibernate.testing.SkipForDialect;
/**
* @author Vlad Mihalcea
*/
@RequiresDialect(PostgreSQL82Dialect.class)
@SkipForDialect(value = CockroachDB192Dialect.class, comment = "https://github.com/cockroachdb/cockroach/issues/5807")
public class GlobalTemporaryTableBulkCompositeIdTest extends AbstractBulkCompositeIdTest {
@Override

6
hibernate-core/src/test/java/org/hibernate/test/converter/AndLobTest.java
View File

@ -18,10 +18,13 @@ import org.hibernate.boot.Metadata;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.dialect.Dialect;
import org.hibernate.type.Type;
import org.hibernate.type.descriptor.converter.AttributeConverterTypeAdapter;
import org.hibernate.testing.junit4.BaseUnitTestCase;
import org.hibernate.type.descriptor.sql.BlobTypeDescriptor;
import org.hibernate.type.descriptor.sql.SqlTypeDescriptor;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@ -59,7 +62,8 @@ public class AndLobTest extends BaseUnitTestCase {
final Type type = metadata.getEntityBinding( EntityImpl.class.getName() ).getProperty( "status" ).getType();
final AttributeConverterTypeAdapter concreteType = assertTyping( AttributeConverterTypeAdapter.class, type );
assertEquals( Types.BLOB, concreteType.getSqlTypeDescriptor().getSqlType() );
SqlTypeDescriptor sqlTypeDescriptor = concreteType.getSqlTypeDescriptor();
assertEquals( Dialect.getDialect().remapSqlTypeDescriptor(BlobTypeDescriptor.BLOB_BINDING).getSqlType(), sqlTypeDescriptor.getSqlType() );
}
@Converter

9
hibernate-core/src/test/java/org/hibernate/test/converter/AndNationalizedTests.java
View File

@ -12,18 +12,16 @@ import javax.persistence.Convert;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import org.hibernate.annotations.Nationalized;
import org.hibernate.boot.Metadata;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.internal.MetadataImpl;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.dialect.DB2Dialect;
import org.hibernate.dialect.PostgreSQL81Dialect;
import org.hibernate.mapping.PersistentClass;
import org.hibernate.testing.SkipForDialect;
import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.junit4.BaseUnitTestCase;
import org.junit.Test;
@ -47,8 +45,9 @@ public class AndNationalizedTests extends BaseUnitTestCase {
final PersistentClass entityBinding = metadata.getEntityBinding( TestEntity.class.getName() );
if(metadata.getDatabase().getDialect() instanceof PostgreSQL81Dialect
|| metadata.getDatabase().getDialect() instanceof DB2Dialect){
// See issue HHH-10693 for PostgreSQL, HHH-12753 for DB2
|| metadata.getDatabase().getDialect() instanceof DB2Dialect
|| metadata.getDatabase().getDialect() instanceof CockroachDB192Dialect){
// See issue HHH-10693 for PostgreSQL and CockroachDB, HHH-12753 for DB2
assertEquals(
Types.VARCHAR,
entityBinding.getProperty( "name" ).getType().sqlTypes( metadata )[0]

13
hibernate-core/src/test/java/org/hibernate/test/converter/AttributeConverterTest.java
View File

@ -30,6 +30,7 @@ import org.hibernate.boot.spi.MetadataImplementor;
import org.hibernate.cfg.AvailableSettings;
import org.hibernate.cfg.Configuration;
import org.hibernate.dialect.HANACloudColumnStoreDialect;
import org.hibernate.dialect.Dialect;
import org.hibernate.engine.spi.SessionFactoryImplementor;
import org.hibernate.hql.internal.ast.tree.JavaConstantNode;
import org.hibernate.internal.util.ConfigHelper;
@ -47,6 +48,9 @@ import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.boot.MetadataBuildingContextTestingImpl;
import org.hibernate.testing.junit4.BaseUnitTestCase;
import org.hibernate.testing.util.ExceptionUtil;
import org.hibernate.type.descriptor.sql.BlobTypeDescriptor;
import org.hibernate.type.descriptor.sql.ClobTypeDescriptor;
import org.hibernate.type.descriptor.sql.SqlTypeDescriptor;
import org.junit.Test;
import static org.hibernate.testing.junit4.ExtraAssertions.assertTyping;
@ -111,7 +115,8 @@ public class AttributeConverterTest extends BaseUnitTestCase {
}
AbstractStandardBasicType basicType = assertTyping( AbstractStandardBasicType.class, type );
assertSame( StringTypeDescriptor.INSTANCE, basicType.getJavaTypeDescriptor() );
assertEquals( Types.CLOB, basicType.getSqlTypeDescriptor().getSqlType() );
SqlTypeDescriptor sqlTypeDescriptor = basicType.getSqlTypeDescriptor();
assertEquals( Dialect.getDialect().remapSqlTypeDescriptor(ClobTypeDescriptor.CLOB_BINDING).getSqlType(), sqlTypeDescriptor.getSqlType() );
}
@Test
@ -162,7 +167,8 @@ public class AttributeConverterTest extends BaseUnitTestCase {
}
AbstractStandardBasicType basicType = assertTyping( AbstractStandardBasicType.class, type );
assertSame( StringTypeDescriptor.INSTANCE, basicType.getJavaTypeDescriptor() );
assertEquals( Types.CLOB, basicType.getSqlTypeDescriptor().getSqlType() );
SqlTypeDescriptor sqlTypeDescriptor = basicType.getSqlTypeDescriptor();
assertEquals( Dialect.getDialect().remapSqlTypeDescriptor(ClobTypeDescriptor.CLOB_BINDING).getSqlType(), sqlTypeDescriptor.getSqlType() );
}
finally {
StandardServiceRegistryBuilder.destroy( ssr );
@ -191,7 +197,8 @@ public class AttributeConverterTest extends BaseUnitTestCase {
}
AttributeConverterTypeAdapter basicType = assertTyping( AttributeConverterTypeAdapter.class, type );
assertSame( StringTypeDescriptor.INSTANCE, basicType.getJavaTypeDescriptor() );
assertEquals( Types.CLOB, basicType.getSqlTypeDescriptor().getSqlType() );
SqlTypeDescriptor sqlTypeDescriptor = basicType.getSqlTypeDescriptor();
assertEquals( Dialect.getDialect().remapSqlTypeDescriptor(ClobTypeDescriptor.CLOB_BINDING).getSqlType(), sqlTypeDescriptor.getSqlType() );
}
finally {
StandardServiceRegistryBuilder.destroy( ssr );

78
hibernate-core/src/test/java/org/hibernate/test/hql/ASTParserLoadingTest.java
View File

@ -6,30 +6,6 @@
*/
package org.hibernate.test.hql;
import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hibernate.testing.junit4.ExtraAssertions.assertClassAssignability;
import static org.hibernate.testing.junit4.ExtraAssertions.assertTyping;
import static org.hibernate.testing.transaction.TransactionUtil.doInHibernate;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.hibernate.Hibernate;
import org.hibernate.HibernateException;
import org.hibernate.Query;
@ -40,24 +16,7 @@ import org.hibernate.Transaction;
import org.hibernate.TypeMismatchException;
import org.hibernate.cfg.Configuration;
import org.hibernate.cfg.Environment;
import org.hibernate.dialect.AbstractHANADialect;
import org.hibernate.dialect.CUBRIDDialect;
import org.hibernate.dialect.DB2Dialect;
import org.hibernate.dialect.DerbyDialect;
import org.hibernate.dialect.H2Dialect;
import org.hibernate.dialect.HSQLDialect;
import org.hibernate.dialect.IngresDialect;
import org.hibernate.dialect.MySQLDialect;
import org.hibernate.dialect.Oracle8iDialect;
import org.hibernate.dialect.PostgreSQL81Dialect;
import org.hibernate.dialect.PostgreSQLDialect;
import org.hibernate.dialect.SQLServer2008Dialect;
import org.hibernate.dialect.SQLServerDialect;
import org.hibernate.dialect.Sybase11Dialect;
import org.hibernate.dialect.SybaseASE15Dialect;
import org.hibernate.dialect.SybaseAnywhereDialect;
import org.hibernate.dialect.SybaseDialect;
import org.hibernate.dialect.TeradataDialect;
import org.hibernate.dialect.*;
import org.hibernate.engine.spi.SessionImplementor;
import org.hibernate.hql.internal.ast.ASTQueryTranslatorFactory;
import org.hibernate.hql.internal.ast.QuerySyntaxException;
@ -88,6 +47,32 @@ import org.hibernate.type.ManyToOneType;
import org.hibernate.type.Type;
import org.junit.Test;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hibernate.testing.junit4.ExtraAssertions.assertClassAssignability;
import static org.hibernate.testing.junit4.ExtraAssertions.assertTyping;
import static org.hibernate.testing.transaction.TransactionUtil.doInHibernate;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
/**
* Tests the integration of the new AST parser into the loading of query results using
* the Hibernate persisters and loaders.
@ -976,6 +961,7 @@ public class ASTParserLoadingTest extends BaseCoreFunctionalTestCase {
}
@Test
@SkipForDialect(value = CockroachDB192Dialect.class, comment = "https://github.com/cockroachdb/cockroach/issues/41943")
public void testExpressionWithParamInFunction() {
Session s = openSession();
s.beginTransaction();
@ -2948,6 +2934,7 @@ public class ASTParserLoadingTest extends BaseCoreFunctionalTestCase {
}
@Test
@SkipForDialect(value = CockroachDB192Dialect.class, comment = "https://github.com/cockroachdb/cockroach/issues/41943")
@SuppressWarnings( {"UnusedAssignment", "UnusedDeclaration"})
public void testSelectExpressions() {
createTestBaseData();
@ -3281,6 +3268,7 @@ public class ASTParserLoadingTest extends BaseCoreFunctionalTestCase {
}
@Test
@SkipForDialect(value = CockroachDB192Dialect.class, strictMatching = true)
public void testStandardFunctions() throws Exception {
Session session = openSession();
Transaction t = session.beginTransaction();
@ -3841,7 +3829,8 @@ public class ASTParserLoadingTest extends BaseCoreFunctionalTestCase {
* <link>http://www.postgresql.org/docs/current/static/release-8-3.html</link>
*/
if ( getDialect() instanceof PostgreSQLDialect || getDialect() instanceof PostgreSQL81Dialect
|| getDialect() instanceof HSQLDialect ) {
|| getDialect() instanceof HSQLDialect
|| getDialect() instanceof CockroachDB192Dialect ) {
hql = "from Animal a where bit_length(str(a.bodyWeight)) = 24";
}
else {
@ -3850,7 +3839,8 @@ public class ASTParserLoadingTest extends BaseCoreFunctionalTestCase {
session.createQuery(hql).list();
if ( getDialect() instanceof PostgreSQLDialect || getDialect() instanceof PostgreSQL81Dialect
|| getDialect() instanceof HSQLDialect ) {
|| getDialect() instanceof HSQLDialect
|| getDialect() instanceof CockroachDB192Dialect ) {
hql = "select bit_length(str(a.bodyWeight)) from Animal a";
}
else {

10
hibernate-core/src/test/java/org/hibernate/test/hql/HQLTest.java
View File

@ -18,6 +18,7 @@ import org.hibernate.QueryException;
import org.hibernate.Session;
import org.hibernate.cfg.AvailableSettings;
import org.hibernate.dialect.AbstractHANADialect;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.dialect.DB2Dialect;
import org.hibernate.dialect.H2Dialect;
import org.hibernate.dialect.HSQLDialect;
@ -169,7 +170,8 @@ public class HQLTest extends QueryTranslatorTestCase {
Oracle8iDialect.class,
AbstractHANADialect.class,
PostgreSQL81Dialect.class,
MySQLDialect.class
MySQLDialect.class,
CockroachDB192Dialect.class
} )
public void testRowValueConstructorSyntaxInInListBeingTranslated() {
@ -406,6 +408,10 @@ public class HQLTest extends QueryTranslatorTestCase {
// parser does not; so the outputs do not match here...
return;
}
if ( getDialect() instanceof CockroachDB192Dialect ) {
// CockroachDB turns "float" into "float4" so the outputs won't match.
return;
}
assertTranslation( "from Animal where abs(cast(1 as float) - cast(:param as float)) = 1.0" );
}
@ -890,6 +896,7 @@ public class HQLTest extends QueryTranslatorTestCase {
if ( getDialect() instanceof Oracle8iDialect ) return; // the new hiearchy...
if ( getDialect() instanceof PostgreSQLDialect || getDialect() instanceof PostgreSQL81Dialect ) return;
if ( getDialect() instanceof CockroachDB192Dialect ) return;
if ( getDialect() instanceof TeradataDialect) return;
if ( ! H2Dialect.class.isInstance( getDialect() ) ) {
// H2 has no year function
@ -1070,6 +1077,7 @@ public class HQLTest extends QueryTranslatorTestCase {
}
@Test
@SkipForDialect(CockroachDB192Dialect.class)
public void testSelectStandardFunctionsNoParens() throws Exception {
assertTranslation( "select current_date, current_time, current_timestamp from Animal" );
}

10
hibernate-core/src/test/java/org/hibernate/test/id/NonUniqueIdTest.java
View File

@ -32,15 +32,19 @@ public class NonUniqueIdTest extends BaseNonConfigCoreFunctionalTestCase {
@Before
public void setup() {
// Drop and recreate table so it has no primary key. The drop is done in a separate transaction because
// some databases do not support dropping and recreating in the same transaction.
doInHibernate(
this::sessionFactory,
session -> {
// drop and recreate table so it has no primary key
session.createNativeQuery(
"DROP TABLE CATEGORY"
).executeUpdate();
}
);
doInHibernate(
this::sessionFactory,
session -> {
session.createNativeQuery(
"create table CATEGORY( id integer not null, name varchar(255) )"
).executeUpdate();

6
hibernate-core/src/test/java/org/hibernate/test/legacy/CustomSQLTest.java
View File

@ -11,14 +11,12 @@ package org.hibernate.test.legacy;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.dialect.Dialect;
import org.hibernate.dialect.PostgreSQL81Dialect;
import org.hibernate.dialect.PostgreSQLDialect;
import org.hibernate.id.PostInsertIdentifierGenerator;
import org.hibernate.testing.DialectCheck;
import org.hibernate.testing.RequiresDialectFeature;
import org.hibernate.testing.SkipForDialect;
@ -47,7 +45,7 @@ public class CustomSQLTest extends LegacyTestCase {
@Test
@RequiresDialectFeature( NonIdentityGeneratorChecker.class )
@SkipForDialect( value = {PostgreSQL81Dialect.class, PostgreSQLDialect.class}, jiraKey = "HHH-6704")
@SkipForDialect( value = {PostgreSQL81Dialect.class, PostgreSQLDialect.class, CockroachDB192Dialect.class}, jiraKey = "HHH-6704")
public void testInsert() throws HibernateException, SQLException {
Session s = openSession();
s.beginTransaction();

28
hibernate-core/src/test/java/org/hibernate/test/legacy/FooBarTest.java
View File

@ -45,24 +45,7 @@ import org.hibernate.criterion.Example;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.hibernate.dialect.AbstractHANADialect;
import org.hibernate.dialect.DB2Dialect;
import org.hibernate.dialect.DerbyDialect;
import org.hibernate.dialect.H2Dialect;
import org.hibernate.dialect.HSQLDialect;
import org.hibernate.dialect.InterbaseDialect;
import org.hibernate.dialect.MckoiDialect;
import org.hibernate.dialect.MySQLDialect;
import org.hibernate.dialect.Oracle12cDialect;
import org.hibernate.dialect.Oracle8iDialect;
import org.hibernate.dialect.PointbaseDialect;
import org.hibernate.dialect.PostgreSQL81Dialect;
import org.hibernate.dialect.PostgreSQLDialect;
import org.hibernate.dialect.SAPDBDialect;
import org.hibernate.dialect.SQLServerDialect;
import org.hibernate.dialect.SybaseDialect;
import org.hibernate.dialect.TeradataDialect;
import org.hibernate.dialect.TimesTenDialect;
import org.hibernate.dialect.*;
import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider;
import org.hibernate.engine.spi.SessionImplementor;
import org.hibernate.event.spi.EventSource;
@ -81,8 +64,6 @@ import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.env.ConnectionProviderBuilder;
import org.junit.Test;
import org.jboss.logging.Logger;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
@ -391,6 +372,7 @@ public class FooBarTest extends LegacyTestCase {
}
@Test
@SkipForDialect(value = CockroachDB192Dialect.class, comment = "https://github.com/cockroachdb/cockroach/issues/43007")
public void testQuery() throws Exception {
Session s = openSession();
Transaction txn = s.beginTransaction();
@ -2293,6 +2275,7 @@ public class FooBarTest extends LegacyTestCase {
!( SybaseDialect.class.isAssignableFrom( getDialect().getClass() ) ) &&
!( SQLServerDialect.class.isAssignableFrom( getDialect().getClass() ) ) &&
!( getDialect() instanceof PostgreSQLDialect ) && !(getDialect() instanceof PostgreSQL81Dialect ) &&
!(getDialect() instanceof CockroachDB192Dialect ) &&
!( getDialect() instanceof AbstractHANADialect) ) {
// SybaseAnywhereDialect supports implicit conversions from strings to ints
s.createQuery(
@ -2368,7 +2351,10 @@ public class FooBarTest extends LegacyTestCase {
s.delete(bar);
if ( getDialect() instanceof DB2Dialect || getDialect() instanceof PostgreSQLDialect || getDialect() instanceof PostgreSQL81Dialect ) {
if ( getDialect() instanceof DB2Dialect ||
getDialect() instanceof PostgreSQLDialect ||
getDialect() instanceof PostgreSQL81Dialect ||
getDialect() instanceof CockroachDB192Dialect) {
s.createQuery( "select one from One one join one.manies many group by one order by count(many)" ).iterate();
s.createQuery( "select one from One one join one.manies many group by one having count(many) < 5" )
.iterate();

8
hibernate-core/src/test/java/org/hibernate/test/legacy/LegacyTestCase.java
View File

@ -13,6 +13,7 @@ import org.hibernate.Session;
import org.hibernate.cfg.AvailableSettings;
import org.hibernate.cfg.Configuration;
import org.hibernate.cfg.Environment;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.dialect.DB2Dialect;
import org.hibernate.dialect.Dialect;
import org.hibernate.dialect.PostgreSQL81Dialect;
@ -38,8 +39,11 @@ public abstract class LegacyTestCase extends BaseCoreFunctionalTestCase {
}
protected boolean supportsLockingNullableSideOfJoin(Dialect dialect) {
// db2 and pgsql do *NOT*
return ! ( DB2Dialect.class.isInstance( dialect ) || PostgreSQL81Dialect.class.isInstance( dialect ) || PostgreSQLDialect.class.isInstance( dialect ));
// db2. pgsql, and cockroachdb do *NOT*
return ! ( DB2Dialect.class.isInstance( dialect ) ||
PostgreSQL81Dialect.class.isInstance( dialect ) ||
PostgreSQLDialect.class.isInstance( dialect ) ||
CockroachDB192Dialect.class.isInstance( dialect ));
}
protected static String extractFromSystem(String systemPropertyName) {

8
hibernate-core/src/test/java/org/hibernate/test/legacy/MasterDetailTest.java
View File

@ -21,11 +21,7 @@ import org.hibernate.cfg.Configuration;
import org.hibernate.cfg.Environment;
import org.hibernate.criterion.Example;
import org.hibernate.criterion.Restrictions;
import org.hibernate.dialect.AbstractHANADialect;
import org.hibernate.dialect.HSQLDialect;
import org.hibernate.dialect.MckoiDialect;
import org.hibernate.dialect.MySQLDialect;
import org.hibernate.dialect.SAPDBDialect;
import org.hibernate.dialect.*;
import org.hibernate.engine.jdbc.connections.spi.JdbcConnectionAccess;
import org.hibernate.engine.jdbc.spi.JdbcServices;
import org.hibernate.jdbc.AbstractWork;
@ -196,6 +192,7 @@ public class MasterDetailTest extends LegacyTestCase {
}
@Test
@SkipForDialect(value = CockroachDB192Dialect.class, comment = "https://github.com/cockroachdb/cockroach/issues/27871")
public void testSelfManyToOne() throws Exception {
Session s = openSession();
Transaction t = s.beginTransaction();
@ -220,6 +217,7 @@ public class MasterDetailTest extends LegacyTestCase {
}
@Test
@SkipForDialect(value = CockroachDB192Dialect.class, comment = "https://github.com/cockroachdb/cockroach/issues/27871")
public void testExample() throws Exception {
Session s = openSession();
Transaction t = s.beginTransaction();

14
hibernate-core/src/test/java/org/hibernate/test/legacy/MultiTableTest.java
View File

@ -8,10 +8,6 @@
//$Id: MultiTableTest.java 10977 2006-12-12 23:28:04Z steve.ebersole@jboss.com $
package org.hibernate.test.legacy;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import java.io.Serializable;
import java.sql.Connection;
import java.sql.SQLException;
@ -22,7 +18,6 @@ import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import org.hibernate.Criteria;
import org.hibernate.FetchMode;
import org.hibernate.LockMode;
@ -30,6 +25,7 @@ import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.Restrictions;
import org.hibernate.dialect.AbstractHANADialect;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.dialect.H2Dialect;
import org.hibernate.dialect.MySQLDialect;
import org.hibernate.engine.spi.SessionImplementor;
@ -37,6 +33,10 @@ import org.hibernate.jdbc.Work;
import org.hibernate.testing.SkipForDialect;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
public class MultiTableTest extends LegacyTestCase {
@Override
@ -249,6 +249,7 @@ public class MultiTableTest extends LegacyTestCase {
}
@Test
@SkipForDialect( value = CockroachDB192Dialect.class )
public void testMultiTable() throws Exception {
Session s = openSession();
Transaction t = s.beginTransaction();
@ -392,6 +393,7 @@ public class MultiTableTest extends LegacyTestCase {
}
@Test
@SkipForDialect( value = CockroachDB192Dialect.class )
public void testMultiTableGeneratedId() throws Exception {
Session s = openSession();
Transaction t = s.beginTransaction();
@ -515,6 +517,7 @@ public class MultiTableTest extends LegacyTestCase {
}
@Test
@SkipForDialect(value = CockroachDB192Dialect.class, comment = "https://github.com/cockroachdb/cockroach/issues/27871")
public void testMultiTableCollections() throws Exception {
Session s = openSession();
Transaction t = s.beginTransaction();
@ -587,6 +590,7 @@ public class MultiTableTest extends LegacyTestCase {
}
@Test
@SkipForDialect(value = CockroachDB192Dialect.class, comment = "https://github.com/cockroachdb/cockroach/issues/27871")
public void testMultiTableManyToOne() throws Exception {
Session s = openSession();
Transaction t = s.beginTransaction();

9
hibernate-core/src/test/java/org/hibernate/test/legacy/ParentChildTest.java
View File

@ -17,6 +17,7 @@ import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.hibernate.dialect.*;
import org.hibernate.testing.DialectChecks;
import org.hibernate.testing.RequiresDialectFeature;
import org.hibernate.testing.SkipForDialect;
@ -33,12 +34,6 @@ import org.hibernate.ReplicationMode;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.Restrictions;
import org.hibernate.dialect.AbstractHANADialect;
import org.hibernate.dialect.H2Dialect;
import org.hibernate.dialect.HSQLDialect;
import org.hibernate.dialect.IngresDialect;
import org.hibernate.dialect.MySQLDialect;
import org.hibernate.dialect.TeradataDialect;
import org.hibernate.engine.spi.EntityEntry;
import org.hibernate.internal.SessionImpl;
import org.hibernate.jdbc.AbstractWork;
@ -1095,6 +1090,7 @@ public class ParentChildTest extends LegacyTestCase {
}
@Test
@SkipForDialect( value = CockroachDB192Dialect.class )
public void testLocking() throws Exception {
Session s = openSession();
Transaction tx = s.beginTransaction();
@ -1210,6 +1206,7 @@ public class ParentChildTest extends LegacyTestCase {
}
@Test
@SkipForDialect(value = CockroachDB192Dialect.class, comment = "Uses READ_COMMITTED isolation")
public void testLoadAfterNonExists() throws HibernateException, SQLException {
Session session = openSession();
if ( ( getDialect() instanceof MySQLDialect ) || ( getDialect() instanceof IngresDialect ) ) {

9
hibernate-core/src/test/java/org/hibernate/test/lob/LobStringTest.java
View File

@ -16,10 +16,9 @@ import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Lob;
import javax.persistence.Table;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.dialect.PostgreSQL81Dialect;
import org.hibernate.query.Query;
import org.hibernate.testing.RequiresDialect;
import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase;
@ -34,7 +33,7 @@ import static org.junit.Assert.fail;
* @author Andrea Boriero
*/
@TestForIssue(jiraKey = "HHH-11477")
@RequiresDialect(PostgreSQL81Dialect.class)
@RequiresDialect({ PostgreSQL81Dialect.class, CockroachDB192Dialect.class })
public class LobStringTest extends BaseCoreFunctionalTestCase {
private static final int LONG_STRING_SIZE = 3999;
@ -90,6 +89,7 @@ public class LobStringTest extends BaseCoreFunctionalTestCase {
@Test
@TestForIssue(jiraKey = "HHH-11477")
@RequiresDialect(PostgreSQL81Dialect.class)
public void testUsingStringLobAnnotatedPropertyInNativeQuery() {
doInHibernate( this::sessionFactory, session -> {
final List<TestEntity> results = session.createNativeQuery(
@ -116,6 +116,7 @@ public class LobStringTest extends BaseCoreFunctionalTestCase {
@Test
@TestForIssue(jiraKey = "HHH-11477")
@RequiresDialect(PostgreSQL81Dialect.class)
public void testSelectStringLobAnnotatedInNativeQuery() {
doInHibernate( this::sessionFactory, session -> {
final List<String> results = session.createNativeQuery(
@ -133,6 +134,7 @@ public class LobStringTest extends BaseCoreFunctionalTestCase {
@Test
@TestForIssue(jiraKey = "HHH-11477")
@RequiresDialect(PostgreSQL81Dialect.class)
public void testUsingLobPropertyInNativeQuery() {
doInHibernate( this::sessionFactory, session -> {
final List<String> results = session.createNativeQuery(
@ -150,6 +152,7 @@ public class LobStringTest extends BaseCoreFunctionalTestCase {
@Test
@TestForIssue(jiraKey = "HHH-11477")
@RequiresDialect(PostgreSQL81Dialect.class)
public void testSelectClobPropertyInNativeQuery() {
doInHibernate( this::sessionFactory, session -> {
final List<byte[]> results = session.createNativeQuery(

3
hibernate-core/src/test/java/org/hibernate/test/lob/PostgreSqlLobStringTest.java
View File

@ -21,8 +21,7 @@ import javax.persistence.Table;
import org.hibernate.dialect.PostgreSQL81Dialect;
import org.hibernate.query.Query;
import org.hibernate.testing.RequiresDialect;
import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.*;
import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase;
import org.hibernate.testing.util.ExceptionUtil;
import org.junit.Test;

3
hibernate-core/src/test/java/org/hibernate/test/locking/AbstractSkipLockedTest.java
View File

@ -5,17 +5,14 @@ import java.util.List;
import java.util.stream.Collectors;
import javax.persistence.Entity;
import javax.persistence.Id;
import org.hibernate.LockMode;
import org.hibernate.LockOptions;
import org.hibernate.Session;
import org.hibernate.dialect.MySQL57Dialect;
import org.hibernate.dialect.MySQL8Dialect;
import org.hibernate.dialect.Oracle8iDialect;
import org.hibernate.dialect.PostgreSQL95Dialect;
import org.hibernate.dialect.SQLServer2005Dialect;
import org.hibernate.query.Query;
import org.hibernate.testing.RequiresDialect;
import org.hibernate.testing.junit4.BaseNonConfigCoreFunctionalTestCase;
import org.junit.Test;

2
hibernate-core/src/test/java/org/hibernate/test/locking/LockModeTest.java
View File

@ -14,6 +14,7 @@ import javax.persistence.LockModeType;
import org.hibernate.LockMode;
import org.hibernate.LockOptions;
import org.hibernate.Session;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.dialect.SQLServerDialect;
import org.hibernate.dialect.SybaseASE15Dialect;
import org.hibernate.dialect.SybaseDialect;
@ -201,6 +202,7 @@ public class LockModeTest extends BaseCoreFunctionalTestCase {
@Test
@TestForIssue(jiraKey = "HHH-12257")
@SkipForDialect( value = CockroachDB192Dialect.class )
public void testRefreshWithExplicitHigherLevelLockMode() {
doInHibernate( this::sessionFactory, session -> {
A a = session.get( A.class, id );

3
hibernate-core/src/test/java/org/hibernate/test/locking/PessimisticWriteLockTimeoutTest.java
View File

@ -8,10 +8,9 @@ import org.hibernate.dialect.Oracle8iDialect;
import org.hibernate.dialect.PostgreSQL81Dialect;
import org.hibernate.dialect.PostgreSQL95Dialect;
import org.hibernate.dialect.SQLServer2005Dialect;
import org.hibernate.testing.RequiresDialect;
import org.hibernate.testing.junit4.BaseNonConfigCoreFunctionalTestCase;
import org.hibernate.testing.jdbc.SQLStatementInterceptor;
import org.hibernate.testing.junit4.BaseNonConfigCoreFunctionalTestCase;
import org.junit.Before;
import org.junit.Test;

13
hibernate-core/src/test/java/org/hibernate/test/nationalized/SimpleNationalizedTest.java
View File

@ -17,6 +17,7 @@ import org.hibernate.boot.Metadata;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.dialect.PostgreSQL81Dialect;
import org.hibernate.mapping.PersistentClass;
import org.hibernate.mapping.Property;
@ -81,7 +82,8 @@ public class SimpleNationalizedTest extends BaseUnitTestCase {
assertNotNull( pc );
Property prop = pc.getProperty( "nvarcharAtt" );
if(metadata.getDatabase().getDialect() instanceof PostgreSQL81Dialect ){
if(metadata.getDatabase().getDialect() instanceof PostgreSQL81Dialect ||
metadata.getDatabase().getDialect() instanceof CockroachDB192Dialect ){
// See issue HHH-10693
assertSame( StringType.INSTANCE, prop.getType() );
}else{
@ -89,7 +91,8 @@ public class SimpleNationalizedTest extends BaseUnitTestCase {
}
prop = pc.getProperty( "materializedNclobAtt" );
if(metadata.getDatabase().getDialect() instanceof PostgreSQL81Dialect ){
if(metadata.getDatabase().getDialect() instanceof PostgreSQL81Dialect ||
metadata.getDatabase().getDialect() instanceof CockroachDB192Dialect ){
// See issue HHH-10693
assertSame( MaterializedClobType.INSTANCE, prop.getType() );
}else {
@ -102,7 +105,8 @@ public class SimpleNationalizedTest extends BaseUnitTestCase {
assertSame( NTextType.INSTANCE, prop.getType() );
prop = pc.getProperty( "ncharArrAtt" );
if(metadata.getDatabase().getDialect() instanceof PostgreSQL81Dialect ){
if(metadata.getDatabase().getDialect() instanceof PostgreSQL81Dialect ||
metadata.getDatabase().getDialect() instanceof CockroachDB192Dialect ){
// See issue HHH-10693
assertSame( CharacterArrayType.INSTANCE, prop.getType() );
}else {
@ -110,7 +114,8 @@ public class SimpleNationalizedTest extends BaseUnitTestCase {
}
prop = pc.getProperty( "ncharacterAtt" );
if ( metadata.getDatabase().getDialect() instanceof PostgreSQL81Dialect ) {
if ( metadata.getDatabase().getDialect() instanceof PostgreSQL81Dialect ||
metadata.getDatabase().getDialect() instanceof CockroachDB192Dialect ) {
// See issue HHH-10693
assertSame( CharacterType.INSTANCE, prop.getType() );
}

7
hibernate-core/src/test/java/org/hibernate/test/nationalized/UseNationalizedCharDataSettingTest.java
View File

@ -16,6 +16,7 @@ import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.AvailableSettings;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.dialect.PostgreSQL81Dialect;
import org.hibernate.mapping.PersistentClass;
import org.hibernate.mapping.Property;
@ -51,7 +52,8 @@ public class UseNationalizedCharDataSettingTest extends BaseUnitTestCase {
final Metadata metadata = ms.buildMetadata();
final PersistentClass pc = metadata.getEntityBinding( NationalizedBySettingEntity.class.getName() );
final Property nameAttribute = pc.getProperty( "name" );
if(metadata.getDatabase().getDialect() instanceof PostgreSQL81Dialect ){
if(metadata.getDatabase().getDialect() instanceof PostgreSQL81Dialect ||
metadata.getDatabase().getDialect() instanceof CockroachDB192Dialect){
// See issue HHH-10693
assertSame( StringType.INSTANCE, nameAttribute.getType() );
}else {
@ -78,7 +80,8 @@ public class UseNationalizedCharDataSettingTest extends BaseUnitTestCase {
final Metadata metadata = ms.buildMetadata();
final PersistentClass pc = metadata.getEntityBinding( NationalizedBySettingEntity.class.getName() );
final Property nameAttribute = pc.getProperty( "flag" );
if(metadata.getDatabase().getDialect() instanceof PostgreSQL81Dialect ){
if(metadata.getDatabase().getDialect() instanceof PostgreSQL81Dialect ||
metadata.getDatabase().getDialect() instanceof CockroachDB192Dialect ){
assertSame( CharacterType.INSTANCE, nameAttribute.getType() );
}else {
assertSame( CharacterNCharType.INSTANCE, nameAttribute.getType() );

21
hibernate-core/src/test/java/org/hibernate/test/optlock/OptimisticLockTest.java
View File

@ -8,19 +8,17 @@ package org.hibernate.test.optlock;
import javax.persistence.PersistenceException;
import org.hibernate.JDBCException;
import org.hibernate.Session;
import org.hibernate.StaleObjectStateException;
import org.hibernate.StaleStateException;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.dialect.SQLServerDialect;
import org.hibernate.testing.DialectChecks;
import org.hibernate.testing.RequiresDialectFeature;
import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase;
import org.junit.Test;
import static org.hibernate.testing.junit4.ExtraAssertions.assertTyping;
import static org.junit.Assert.fail;
/**
@ -161,20 +159,23 @@ public class OptimisticLockTest extends BaseCoreFunctionalTestCase {
private void checkException(Session mainSession, PersistenceException e) {
final Throwable cause = e.getCause();
if ( cause instanceof JDBCException ) {
if ( getDialect() instanceof SQLServerDialect && ((JDBCException) cause).getErrorCode() == 3960 ) {
// SQLServer will report this condition via a SQLException
// when using its SNAPSHOT transaction isolation...
if ( !(getDialect() instanceof SQLServerDialect && ((JDBCException) cause).getErrorCode() == 3960) ) {
throw e;
}
else {
// when using its SNAPSHOT transaction isolation.
// it seems to "lose track" of the transaction as well...
mainSession.getTransaction().rollback();
mainSession.beginTransaction();
}
else if ( getDialect() instanceof CockroachDB192Dialect && ((JDBCException) cause).getSQLState().equals("40001")) {
// CockroachDB always runs in SERIALIZABLE isolation, and uses SQL state 40001 to indicate
// serialization failure.
}
else {
throw e;
}
}
else if ( !(cause instanceof StaleObjectStateException) && !(cause instanceof StaleStateException) ) {
fail( "expectd StaleObjectStateException or StaleStateException exception but is" + cause );
fail( "expected StaleObjectStateException or StaleStateException exception but is " + cause );
}
}

6
hibernate-core/src/test/java/org/hibernate/test/procedure/PostgreSQLStoredProcedureTest.java
View File

@ -16,19 +16,15 @@ import java.sql.Types;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.util.List;
import java.util.Properties;
import javax.persistence.ParameterMode;
import javax.persistence.StoredProcedureQuery;
import org.hibernate.Session;
import org.hibernate.cfg.AvailableSettings;
import org.hibernate.dialect.PostgreSQL81Dialect;
import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
import org.hibernate.procedure.ProcedureCall;
import org.hibernate.type.StringType;
import org.hibernate.testing.RequiresDialect;
import org.hibernate.testing.TestForIssue;
import org.hibernate.type.StringType;
import org.junit.Before;
import org.junit.Test;

3
hibernate-core/src/test/java/org/hibernate/test/schemaupdate/AlterTableQuoteDefaultSchemaTest.java
View File

@ -26,6 +26,8 @@ import org.hibernate.dialect.H2Dialect;
import org.hibernate.dialect.Oracle8iDialect;
import org.hibernate.dialect.PostgreSQL82Dialect;
import org.hibernate.dialect.SQLServer2012Dialect;
import org.hibernate.testing.DialectChecks;
import org.hibernate.testing.RequiresDialectFeature;
import org.hibernate.tool.hbm2ddl.SchemaUpdate;
import org.hibernate.tool.schema.TargetType;
@ -47,6 +49,7 @@ import static org.junit.Assert.fail;
PostgreSQL82Dialect.class,
SQLServer2012Dialect.class,
})
@RequiresDialectFeature(DialectChecks.SupportSchemaCreation.class)
public class AlterTableQuoteDefaultSchemaTest extends AbstractAlterTableQuoteSchemaTest {
@Override

3
hibernate-core/src/test/java/org/hibernate/test/schemaupdate/AlterTableQuoteSpecifiedSchemaTest.java
View File

@ -24,6 +24,8 @@ import org.hibernate.cfg.AvailableSettings;
import org.hibernate.dialect.H2Dialect;
import org.hibernate.dialect.PostgreSQL82Dialect;
import org.hibernate.dialect.SQLServer2012Dialect;
import org.hibernate.testing.DialectChecks;
import org.hibernate.testing.RequiresDialectFeature;
import org.hibernate.tool.hbm2ddl.SchemaUpdate;
import org.hibernate.tool.schema.TargetType;
@ -45,6 +47,7 @@ import static org.junit.Assert.fail;
PostgreSQL82Dialect.class,
SQLServer2012Dialect.class,
})
@RequiresDialectFeature(DialectChecks.SupportSchemaCreation.class)
public class AlterTableQuoteSpecifiedSchemaTest extends AbstractAlterTableQuoteSchemaTest {
@Override

3
hibernate-core/src/test/java/org/hibernate/test/schemaupdate/PostgreSQLMultipleSchemaSequenceTest.java
View File

@ -31,6 +31,8 @@ import org.hibernate.cfg.Environment;
import org.hibernate.dialect.PostgreSQL81Dialect;
import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider;
import org.hibernate.engine.jdbc.env.internal.JdbcEnvironmentInitiator;
import org.hibernate.testing.DialectChecks;
import org.hibernate.testing.RequiresDialectFeature;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import org.hibernate.tool.schema.TargetType;
@ -48,6 +50,7 @@ import static org.junit.Assert.fail;
* @author Vlad Mihalcea
*/
@RequiresDialect(PostgreSQL81Dialect.class)
@RequiresDialectFeature(DialectChecks.SupportSchemaCreation.class)
public class PostgreSQLMultipleSchemaSequenceTest extends BaseUnitTestCase {
private File output;

8
hibernate-core/src/test/java/org/hibernate/test/schemaupdate/SchemaUpdateWithFunctionIndexTest.java
View File

@ -12,7 +12,6 @@ import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Index;
import javax.persistence.Table;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
@ -22,13 +21,12 @@ import org.hibernate.boot.spi.MetadataImplementor;
import org.hibernate.cfg.Environment;
import org.hibernate.dialect.PostgreSQL81Dialect;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import org.hibernate.tool.hbm2ddl.SchemaUpdate;
import org.hibernate.tool.schema.TargetType;
import org.hibernate.testing.RequiresDialect;
import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.junit4.BaseNonConfigCoreFunctionalTestCase;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import org.hibernate.tool.hbm2ddl.SchemaUpdate;
import org.hibernate.tool.schema.TargetType;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

3
hibernate-core/src/test/java/org/hibernate/test/schemaupdate/SchemaUpdateWithViewsTest.java
View File

@ -20,8 +20,10 @@ import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.boot.spi.MetadataImplementor;
import org.hibernate.cfg.Environment;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.dialect.PostgreSQL81Dialect;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.testing.SkipForDialect;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import org.hibernate.tool.hbm2ddl.SchemaUpdate;
import org.hibernate.tool.schema.TargetType;
@ -38,6 +40,7 @@ import org.junit.Test;
*/
@TestForIssue(jiraKey = "HHH-1872")
@RequiresDialect(PostgreSQL81Dialect.class)
@SkipForDialect(value = CockroachDB192Dialect.class, comment = "https://github.com/cockroachdb/cockroach/issues/24897")
public class SchemaUpdateWithViewsTest extends BaseNonConfigCoreFunctionalTestCase {
protected ServiceRegistry serviceRegistry;

3
hibernate-core/src/test/java/org/hibernate/test/schemaupdate/inheritance/tableperclass/SchemaCreationTest.java
View File

@ -17,6 +17,7 @@ import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.boot.spi.MetadataImplementor;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.dialect.DB2Dialect;
import org.hibernate.dialect.Dialect;
import org.hibernate.dialect.PostgreSQL81Dialect;
@ -87,7 +88,7 @@ public class SchemaCreationTest {
isUniqueConstraintCreated = true;
}
}
else if ( dialect instanceof PostgreSQL81Dialect) {
else if ( dialect instanceof PostgreSQL81Dialect || dialect instanceof CockroachDB192Dialect) {
if (statement.toLowerCase().startsWith("alter table if exists category add constraint")
&& statement.toLowerCase().contains("unique (code)")) {
isUniqueConstraintCreated = true;

3
hibernate-core/src/test/java/org/hibernate/test/schemavalidation/ViewValidationTest.java
View File

@ -16,8 +16,10 @@ import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.AvailableSettings;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.dialect.H2Dialect;
import org.hibernate.dialect.PostgreSQL81Dialect;
import org.hibernate.testing.SkipForDialect;
import org.hibernate.tool.hbm2ddl.SchemaValidator;
import org.hibernate.tool.schema.JdbcMetadaAccessStrategy;
@ -36,6 +38,7 @@ import org.junit.Test;
@RequiresDialect(PostgreSQL81Dialect.class),
@RequiresDialect(H2Dialect.class)
})
@SkipForDialect(value = CockroachDB192Dialect.class, comment = "https://github.com/cockroachdb/cockroach/issues/10028")
public class ViewValidationTest extends BaseCoreFunctionalTestCase {
private StandardServiceRegistry ssr;

3
hibernate-core/src/test/java/org/hibernate/test/timestamp/JdbcTimestampWithoutUTCTimeZoneTest.java
View File

@ -16,9 +16,11 @@ import javax.persistence.Entity;
import javax.persistence.Id;
import org.hibernate.cfg.AvailableSettings;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.dialect.PostgreSQL82Dialect;
import org.hibernate.testing.RequiresDialect;
import org.hibernate.testing.SkipForDialect;
import org.hibernate.testing.junit4.BaseNonConfigCoreFunctionalTestCase;
import org.hibernate.test.util.jdbc.TimeZoneConnectionProvider;
import org.junit.Test;
@ -58,6 +60,7 @@ public class JdbcTimestampWithoutUTCTimeZoneTest
}
@Test
@SkipForDialect(value = CockroachDB192Dialect.class, comment = "https://github.com/cockroachdb/cockroach/issues/3781")
public void testTimeZone() {
doInHibernate( this::sessionFactory, session -> {
Person person = new Person();

20
hibernate-core/src/test/java/org/hibernate/test/typeoverride/TypeOverrideTest.java
View File

@ -13,18 +13,10 @@ import static org.junit.Assert.assertSame;
import org.hibernate.Session;
import org.hibernate.cfg.Configuration;
import org.hibernate.dialect.AbstractHANADialect;
import org.hibernate.dialect.Dialect;
import org.hibernate.dialect.PostgreSQL81Dialect;
import org.hibernate.dialect.PostgreSQLDialect;
import org.hibernate.dialect.SybaseASE15Dialect;
import org.hibernate.dialect.SybaseDialect;
import org.hibernate.dialect.*;
import org.hibernate.testing.SkipForDialect;
import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase;
import org.hibernate.type.descriptor.sql.BlobTypeDescriptor;
import org.hibernate.type.descriptor.sql.IntegerTypeDescriptor;
import org.hibernate.type.descriptor.sql.SqlTypeDescriptor;
import org.hibernate.type.descriptor.sql.VarcharTypeDescriptor;
import org.hibernate.type.descriptor.sql.*;
import org.junit.Test;
/**
@ -47,7 +39,13 @@ public class TypeOverrideTest extends BaseCoreFunctionalTestCase {
assertSame( IntegerTypeDescriptor.INSTANCE, remapSqlTypeDescriptor( IntegerTypeDescriptor.INSTANCE ) );
// A few dialects explicitly override BlobTypeDescriptor.DEFAULT
if ( PostgreSQL81Dialect.class.isInstance( getDialect() ) || PostgreSQLDialect.class.isInstance( getDialect() ) ) {
if ( CockroachDB192Dialect.class.isInstance( getDialect() )) {
assertSame(
VarbinaryTypeDescriptor.INSTANCE,
getDialect().remapSqlTypeDescriptor( BlobTypeDescriptor.DEFAULT )
);
}
else if ( PostgreSQL81Dialect.class.isInstance( getDialect() ) || PostgreSQLDialect.class.isInstance( getDialect() ) ) {
assertSame(
BlobTypeDescriptor.BLOB_BINDING,
getDialect().remapSqlTypeDescriptor( BlobTypeDescriptor.DEFAULT )

13
hibernate-core/src/test/java/org/hibernate/test/where/annotations/LazyManyToManyNonUniqueIdWhereTest.java
View File

@ -53,10 +53,15 @@ public class LazyManyToManyNonUniqueIdWhereTest extends BaseCoreFunctionalTestCa
doInHibernate(
this::sessionFactory, session -> {
session.createSQLQuery( "drop table MATERIAL_RATINGS" ).executeUpdate();
session.createSQLQuery( "drop table BUILDING_RATINGS" ).executeUpdate();
session.createSQLQuery( "drop table ASSOCIATION_TABLE" ).executeUpdate();
session.createSQLQuery( "drop table MAIN_TABLE" ).executeUpdate();
session.createSQLQuery( getDialect().getDropTableString( "MATERIAL_RATINGS" )).executeUpdate();
session.createSQLQuery( getDialect().getDropTableString( "BUILDING_RATINGS" )).executeUpdate();
session.createSQLQuery( getDialect().getDropTableString( "ASSOCIATION_TABLE" )).executeUpdate();
session.createSQLQuery( getDialect().getDropTableString( "MAIN_TABLE" )).executeUpdate();
}
);
doInHibernate(
this::sessionFactory, session -> {
session.createSQLQuery(
"create table MAIN_TABLE( " +

7
hibernate-core/src/test/java/org/hibernate/test/where/annotations/LazyOneToManyNonUniqueIdWhereTest.java
View File

@ -50,7 +50,12 @@ public class LazyOneToManyNonUniqueIdWhereTest extends BaseCoreFunctionalTestCas
doInHibernate(
this::sessionFactory, session -> {
session.createSQLQuery( "DROP TABLE MAIN_TABLE" ).executeUpdate();
session.createSQLQuery( getDialect().getDropTableString( "MAIN_TABLE" )).executeUpdate();
}
);
doInHibernate(
this::sessionFactory, session -> {
session.createSQLQuery(
"create table MAIN_TABLE( " +

19
hibernate-core/src/test/java/org/hibernate/test/where/hbm/LazyManyToManyNonUniqueIdNotFoundWhereTest.java
View File

@ -8,9 +8,7 @@ package org.hibernate.test.where.hbm;
import java.util.HashSet;
import java.util.Set;
import org.hibernate.Hibernate;
import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase;
import org.junit.After;
@ -37,10 +35,15 @@ public class LazyManyToManyNonUniqueIdNotFoundWhereTest extends BaseCoreFunction
doInHibernate(
this::sessionFactory, session -> {
session.createSQLQuery( "drop table MATERIAL_RATINGS" ).executeUpdate();
session.createSQLQuery( "drop table BUILDING_RATINGS" ).executeUpdate();
session.createSQLQuery( "drop table ASSOCIATION_TABLE" ).executeUpdate();
session.createSQLQuery( "drop table MAIN_TABLE" ).executeUpdate();
session.createSQLQuery( getDialect().getDropTableString( "MATERIAL_RATINGS" )).executeUpdate();
session.createSQLQuery( getDialect().getDropTableString( "BUILDING_RATINGS" )).executeUpdate();
session.createSQLQuery( getDialect().getDropTableString( "ASSOCIATION_TABLE" )).executeUpdate();
session.createSQLQuery( getDialect().getDropTableString( "MAIN_TABLE" )).executeUpdate();
}
);
doInHibernate(
this::sessionFactory, session -> {
session.createSQLQuery(
"create table MAIN_TABLE( " +
@ -156,7 +159,7 @@ public class LazyManyToManyNonUniqueIdNotFoundWhereTest extends BaseCoreFunction
}
@Test
@TestForIssue( jiraKey = "HHH-12875")
@TestForIssue( jiraKey = "HHH-12875" )
public void testInitializeFromUniqueAssociationTable() {
doInHibernate(
this::sessionFactory, session -> {
@ -185,7 +188,7 @@ public class LazyManyToManyNonUniqueIdNotFoundWhereTest extends BaseCoreFunction
}
@Test
@TestForIssue( jiraKey = "HHH-12875")
@TestForIssue( jiraKey = "HHH-12875" )
public void testInitializeFromNonUniqueAssociationTable() {
doInHibernate(
this::sessionFactory, session -> {

12
hibernate-core/src/test/java/org/hibernate/test/where/hbm/LazyManyToManyNonUniqueIdWhereTest.java
View File

@ -41,11 +41,15 @@ public class LazyManyToManyNonUniqueIdWhereTest extends BaseCoreFunctionalTestCa
public void setup() {
doInHibernate(
this::sessionFactory, session -> {
session.createSQLQuery( getDialect().getDropTableString( "MATERIAL_RATINGS" ) ).executeUpdate();
session.createSQLQuery( getDialect().getDropTableString( "BUILDING_RATINGS" ) ).executeUpdate();
session.createSQLQuery( getDialect().getDropTableString( "ASSOCIATION_TABLE" ) ).executeUpdate();
session.createSQLQuery( getDialect().getDropTableString( "MAIN_TABLE" ) ).executeUpdate();
}
);
session.createSQLQuery( "drop table MATERIAL_RATINGS" ).executeUpdate();
session.createSQLQuery( "drop table BUILDING_RATINGS" ).executeUpdate();
session.createSQLQuery( "drop table ASSOCIATION_TABLE" ).executeUpdate();
session.createSQLQuery( "drop table MAIN_TABLE" ).executeUpdate();
doInHibernate(
this::sessionFactory, session -> {
session.createSQLQuery(
"create table MAIN_TABLE( " +

7
hibernate-core/src/test/java/org/hibernate/test/where/hbm/LazyOneToManyNonUniqueIdWhereTest.java
View File

@ -41,9 +41,12 @@ public class LazyOneToManyNonUniqueIdWhereTest extends BaseCoreFunctionalTestCas
public void setup() {
doInHibernate(
this::sessionFactory, session -> {
session.createSQLQuery( getDialect().getDropTableString( "MAIN_TABLE" ) ).executeUpdate();
}
);
session.createSQLQuery( "DROP TABLE MAIN_TABLE" ).executeUpdate();
doInHibernate(
this::sessionFactory, session -> {
session.createSQLQuery(
"create table MAIN_TABLE( " +
"ID integer not null, NAME varchar(255) not null, CODE varchar(10) not null, " +

10
hibernate-envers/src/test/java/org/hibernate/envers/test/integration/collection/DetachedMultipleCollectionChangeTest.java
View File

@ -14,8 +14,8 @@ import javax.persistence.EntityManager;
import javax.persistence.Query;
import javax.transaction.Status;
import javax.transaction.TransactionManager;
import org.hibernate.cfg.AvailableSettings;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.dialect.Oracle8iDialect;
import org.hibernate.envers.RevisionType;
import org.hibernate.envers.enhanced.SequenceIdRevisionEntity;
@ -24,8 +24,8 @@ import org.hibernate.envers.test.Priority;
import org.hibernate.envers.test.entities.collection.MultipleCollectionEntity;
import org.hibernate.envers.test.entities.collection.MultipleCollectionRefEntity1;
import org.hibernate.envers.test.entities.collection.MultipleCollectionRefEntity2;
import org.hibernate.testing.SkipForDialect;
import org.hibernate.testing.SkipForDialects;
import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.jta.TestingJtaBootstrap;
import org.hibernate.testing.jta.TestingJtaPlatformImpl;
@ -227,6 +227,12 @@ public class DetachedMultipleCollectionChangeTest extends BaseEnversJPAFunctiona
}
@Test
@SkipForDialects( value = {
@SkipForDialect(value = CockroachDB192Dialect.class,
comment = "requires serial_normalization=sql_sequence setting"),
@SkipForDialect(value = Oracle8iDialect.class,
comment = "Oracle does not support identity key generation")
})
public void testAuditJoinTable() throws Exception {
List<AuditJoinTableInfo> mceRe1AuditJoinTableInfos = getAuditJoinTableRows(
"MCE_RE1_AUD", "MCE_ID",

2
hibernate-envers/src/test/java/org/hibernate/envers/test/integration/jta/IdentifierProxyJtaSessionClosedBeforeCommitTest.java
View File

@ -41,7 +41,7 @@ import static org.junit.Assert.assertEquals;
* @author Chris Cranford
*/
@TestForIssue(jiraKey="HHH-13191")
@RequiresDialectFeature(DialectChecks.SupportsNoColumnInsert.class)
@RequiresDialectFeature({ DialectChecks.SupportsNoColumnInsert.class, DialectChecks.SupportsIdentityColumns.class })
public class IdentifierProxyJtaSessionClosedBeforeCommitTest extends BaseEnversJPAFunctionalTestCase {
@Override
protected Class<?>[] getAnnotatedClasses() {

11
hibernate-envers/src/test/java/org/hibernate/envers/test/integration/manytomany/sametable/BasicSametable.java
View File

@ -44,17 +44,22 @@ public class BasicSametable extends BaseEnversJPAFunctionalTestCase {
public void initData() {
EntityManager em = getEntityManager();
// We need first to modify the columns in the middle (join table) to allow null values. Hbm2ddl doesn't seem
// to allow this.
em.getTransaction().begin();
Session session = (Session) em.getDelegate();
session.createSQLQuery( "DROP TABLE children" ).executeUpdate();
session.createSQLQuery( "DROP TABLE children_AUD" ).executeUpdate();
em.getTransaction().commit();
em.clear();
// We need first to modify the columns in the middle (join table) to allow null values. Hbm2ddl doesn't seem
// to allow this.
em.getTransaction().begin();
session = (Session) em.getDelegate();
session.createSQLQuery(
"CREATE TABLE children ( parent_id " + getDialect().getTypeName( Types.INTEGER ) +
", child1_id " + getDialect().getTypeName( Types.INTEGER ) + getDialect().getNullColumnString() +
", child2_id " + getDialect().getTypeName( Types.INTEGER ) + getDialect().getNullColumnString() + " )"
).executeUpdate();
session.createSQLQuery( "DROP TABLE children_AUD" ).executeUpdate();
session.createSQLQuery(
"CREATE TABLE children_AUD ( REV " + getDialect().getTypeName( Types.INTEGER ) + " NOT NULL" +
", REVEND " + getDialect().getTypeName( Types.INTEGER ) +

3
hibernate-envers/src/test/java/org/hibernate/envers/test/integration/reventity/CustomDate.java
View File

@ -10,6 +10,7 @@ import java.util.Arrays;
import java.util.Date;
import javax.persistence.EntityManager;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.envers.AuditReader;
import org.hibernate.envers.exception.RevisionDoesNotExistException;
import org.hibernate.envers.test.BaseEnversJPAFunctionalTestCase;
@ -17,6 +18,7 @@ import org.hibernate.envers.test.Priority;
import org.hibernate.envers.test.entities.StrTestEntity;
import org.hibernate.envers.test.entities.reventity.CustomDateRevEntity;
import org.hibernate.testing.SkipForDialect;
import org.junit.Test;
/**
@ -69,6 +71,7 @@ public class CustomDate extends BaseEnversJPAFunctionalTestCase {
}
@Test
@SkipForDialect(value = CockroachDB192Dialect.class, comment = "Fails because of int size")
public void testTimestamps() {
assert getAuditReader().getRevisionNumberForDate( new Date( timestamp2 ) ).intValue() == 1;
assert getAuditReader().getRevisionNumberForDate( new Date( timestamp3 ) ).intValue() == 2;

3
hibernate-envers/src/test/java/org/hibernate/envers/test/integration/reventity/CustomPropertyAccess.java
View File

@ -10,6 +10,7 @@ import java.util.Arrays;
import java.util.Date;
import javax.persistence.EntityManager;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.envers.AuditReader;
import org.hibernate.envers.exception.RevisionDoesNotExistException;
import org.hibernate.envers.test.BaseEnversJPAFunctionalTestCase;
@ -17,6 +18,7 @@ import org.hibernate.envers.test.Priority;
import org.hibernate.envers.test.entities.StrTestEntity;
import org.hibernate.envers.test.entities.reventity.CustomPropertyAccessRevEntity;
import org.hibernate.testing.SkipForDialect;
import org.junit.Test;
/**
@ -66,6 +68,7 @@ public class CustomPropertyAccess extends BaseEnversJPAFunctionalTestCase {
}
@Test
@SkipForDialect(value = CockroachDB192Dialect.class, comment = "Fails because of int size")
public void testTimestamps() {
assert getAuditReader().getRevisionNumberForDate( new Date( timestamp2 ) ).intValue() == 1;
assert getAuditReader().getRevisionNumberForDate( new Date( timestamp3 ) ).intValue() == 2;

3
hibernate-envers/src/test/java/org/hibernate/envers/test/integration/reventity/Inherited.java
View File

@ -13,12 +13,14 @@ import java.util.Map;
import java.util.Set;
import javax.persistence.EntityManager;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.envers.AuditReader;
import org.hibernate.envers.exception.RevisionDoesNotExistException;
import org.hibernate.envers.test.BaseEnversJPAFunctionalTestCase;
import org.hibernate.envers.test.Priority;
import org.hibernate.envers.test.entities.StrTestEntity;
import org.hibernate.testing.SkipForDialect;
import org.junit.Test;
/**
@ -68,6 +70,7 @@ public class Inherited extends BaseEnversJPAFunctionalTestCase {
}
@Test
@SkipForDialect(value = CockroachDB192Dialect.class, comment = "Fails because of int size")
public void testTimestamps() {
assert getAuditReader().getRevisionNumberForDate( new Date( timestamp2 ) ).intValue() == 1;
assert getAuditReader().getRevisionNumberForDate( new Date( timestamp3 ) ).intValue() == 2;

5
hibernate-envers/src/test/java/org/hibernate/envers/test/integration/revfordate/RevisionForDate.java
View File

@ -9,12 +9,14 @@ package org.hibernate.envers.test.integration.revfordate;
import java.util.Date;
import javax.persistence.EntityManager;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.envers.AuditReader;
import org.hibernate.envers.exception.RevisionDoesNotExistException;
import org.hibernate.envers.test.BaseEnversJPAFunctionalTestCase;
import org.hibernate.envers.test.Priority;
import org.hibernate.envers.test.entities.StrTestEntity;
import org.hibernate.testing.SkipForDialect;
import org.junit.Test;
/**
@ -81,6 +83,7 @@ public class RevisionForDate extends BaseEnversJPAFunctionalTestCase {
}
@Test
@SkipForDialect(value = CockroachDB192Dialect.class, comment = "Fails because of int size")
public void testTimestamps() {
assert getAuditReader().getRevisionNumberForDate( new Date( timestamp2 ) ).intValue() == 1;
assert getAuditReader().getRevisionNumberForDate( new Date( timestamp3 ) ).intValue() == 2;
@ -88,6 +91,7 @@ public class RevisionForDate extends BaseEnversJPAFunctionalTestCase {
}
@Test
@SkipForDialect(value = CockroachDB192Dialect.class, comment = "Fails because of int size")
public void testEntitiesForTimestamps() {
assert "x".equals( getAuditReader().find( StrTestEntity.class, id, new Date( timestamp2 ) ).getStr() );
assert "y".equals( getAuditReader().find( StrTestEntity.class, id, new Date( timestamp3 ) ).getStr() );
@ -103,6 +107,7 @@ public class RevisionForDate extends BaseEnversJPAFunctionalTestCase {
}
@Test
@SkipForDialect(value = CockroachDB192Dialect.class, comment = "Fails because of int size")
public void testRevisionsForDates() {
AuditReader vr = getAuditReader();

7
hibernate-envers/src/test/java/org/hibernate/envers/test/integration/strategy/ValidityAuditStrategyRevEndTestCustomRevEnt.java
View File

@ -75,6 +75,12 @@ public class ValidityAuditStrategyRevEndTestCustomRevEnt extends BaseEnversJPAFu
em.getTransaction().begin();
Session session = (Session) em.getDelegate();
session.createSQLQuery( "DROP TABLE children" ).executeUpdate();
session.createSQLQuery( "DROP TABLE children_AUD" ).executeUpdate();
em.getTransaction().commit();
em.clear();
em.getTransaction().begin();
session = (Session) em.getDelegate();
session
.createSQLQuery(
"CREATE TABLE children ( parent_id " + getDialect().getTypeName( Types.INTEGER ) +
@ -82,7 +88,6 @@ public class ValidityAuditStrategyRevEndTestCustomRevEnt extends BaseEnversJPAFu
", child2_id " + getDialect().getTypeName( Types.INTEGER ) + getDialect().getNullColumnString() + " )"
)
.executeUpdate();
session.createSQLQuery( "DROP TABLE children_AUD" ).executeUpdate();
session
.createSQLQuery(
"CREATE TABLE children_AUD ( REV " + getDialect().getTypeName( Types.INTEGER ) + " NOT NULL" +

7
hibernate-envers/src/test/java/org/hibernate/envers/test/integration/strategy/ValidityAuditStrategyRevEndTsTest.java
View File

@ -75,6 +75,12 @@ public class ValidityAuditStrategyRevEndTsTest extends BaseEnversJPAFunctionalTe
em.getTransaction().begin();
Session session = (Session) em.getDelegate();
session.createSQLQuery( "DROP TABLE children" ).executeUpdate();
session.createSQLQuery( "DROP TABLE children_AUD" ).executeUpdate();
em.getTransaction().commit();
em.clear();
em.getTransaction().begin();
session = (Session) em.getDelegate();
session
.createSQLQuery(
"CREATE TABLE children ( parent_id " + getDialect().getTypeName( Types.INTEGER ) +
@ -82,7 +88,6 @@ public class ValidityAuditStrategyRevEndTsTest extends BaseEnversJPAFunctionalTe
", child2_id " + getDialect().getTypeName( Types.INTEGER ) + getDialect().getNullColumnString() + " )"
)
.executeUpdate();
session.createSQLQuery( "DROP TABLE children_AUD" ).executeUpdate();
session
.createSQLQuery(
"CREATE TABLE children_AUD ( REV " + getDialect().getTypeName( Types.INTEGER ) + " NOT NULL" +

9
hibernate-jcache/src/test/java/org/hibernate/jcache/test/RefreshUpdatedDataTest.java
View File

@ -14,23 +14,21 @@ import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Version;
import org.hibernate.annotations.Cache;
import org.hibernate.annotations.CacheConcurrencyStrategy;
import org.hibernate.boot.Metadata;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.AvailableSettings;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.dialect.Dialect;
import org.hibernate.dialect.H2Dialect;
import org.hibernate.engine.spi.SessionFactoryImplementor;
import org.hibernate.jcache.test.TestHelper;
import org.hibernate.mapping.Collection;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.tool.schema.Action;
import org.hibernate.testing.SkipForDialect;
import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.junit4.BaseUnitTestCase;
import org.hibernate.tool.schema.Action;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@ -88,6 +86,7 @@ public class RefreshUpdatedDataTest extends BaseUnitTestCase {
}
@Test
@SkipForDialect(value = CockroachDB192Dialect.class, comment = "does not support nested transactions")
public void testUpdateAndFlushThenRefresh() {
final String BEFORE = "before";

4
hibernate-testing/src/main/java/org/hibernate/testing/DialectChecks.java
View File

@ -6,6 +6,7 @@
*/
package org.hibernate.testing;
import org.hibernate.dialect.CockroachDB192Dialect;
import org.hibernate.dialect.DB2Dialect;
import org.hibernate.dialect.Dialect;
import org.hibernate.dialect.MySQLDialect;
@ -285,7 +286,8 @@ abstract public class DialectChecks {
dialect instanceof DB2Dialect ||
dialect instanceof PostgreSQL81Dialect ||
dialect instanceof SybaseDialect ||
dialect instanceof MySQLDialect
dialect instanceof MySQLDialect ||
dialect instanceof CockroachDB192Dialect
);
}
}