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

HHH-15406 Tests annotated with org.hibernate.testing.RequiresDialect having as value a deprecated dialect are not executed

This commit is contained in:
Andrea Boriero 2022-07-20 13:16:41 +02:00 committed by Andrea Boriero
parent 38589b5e7b
commit 0f599da6c4
17 changed files with 562 additions and 528 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
documentation/src/test/java/org/hibernate/userguide/inheritance/SingleTableDiscriminatorFormulaTest.java
View File

@ -15,32 +15,30 @@ import jakarta.persistence.Inheritance;
import jakarta.persistence.InheritanceType;
import org.hibernate.annotations.DiscriminatorFormula;
import org.hibernate.dialect.PostgreSQL81Dialect;
import org.hibernate.orm.test.jpa.BaseEntityManagerFunctionalTestCase;
import org.hibernate.dialect.PostgreSQLDialect;
import org.hibernate.testing.RequiresDialect;
import org.junit.Assert;
import org.junit.Test;
import org.hibernate.testing.orm.junit.EntityManagerFactoryScope;
import org.hibernate.testing.orm.junit.Jpa;
import org.hibernate.testing.orm.junit.RequiresDialect;
import org.junit.jupiter.api.Test;
import static org.hibernate.testing.transaction.TransactionUtil.doInJPA;
import static org.junit.jupiter.api.Assertions.assertEquals;
/**
* @author Vlad Mihalcea
*/
public class SingleTableDiscriminatorFormulaTest extends BaseEntityManagerFunctionalTestCase {
@Override
protected Class<?>[] getAnnotatedClasses() {
return new Class<?>[] {
DebitAccount.class,
CreditAccount.class,
};
}
@Jpa(
annotatedClasses = {
SingleTableDiscriminatorFormulaTest.DebitAccount.class,
SingleTableDiscriminatorFormulaTest.CreditAccount.class,
}
)
public class SingleTableDiscriminatorFormulaTest {
@Test
@RequiresDialect({PostgreSQL81Dialect.class})
public void test() {
doInJPA(this::entityManagerFactory, entityManager -> {
@RequiresDialect(value = PostgreSQLDialect.class, majorVersion = 8, minorVersion = 1)
public void test(EntityManagerFactoryScope scope) {
scope.inTransaction(entityManager -> {
DebitAccount debitAccount = new DebitAccount("123-debit");
debitAccount.setId(1L);
debitAccount.setOwner("John Doe");
@ -59,10 +57,10 @@ public class SingleTableDiscriminatorFormulaTest extends BaseEntityManagerFuncti
entityManager.persist(creditAccount);
});
doInJPA(this::entityManagerFactory, entityManager -> {
scope.inTransaction(entityManager -> {
List<Account> accounts =
entityManager.createQuery("select a from Account a").getResultList();
Assert.assertEquals(2, accounts.size());
assertEquals(2, accounts.size());
});
}

81
documentation/src/test/java/org/hibernate/userguide/locking/ExplicitLockingTest.java
View File

@ -23,38 +23,51 @@ import jakarta.persistence.PessimisticLockScope;
import org.hibernate.LockMode;
import org.hibernate.LockOptions;
import org.hibernate.Session;
import org.hibernate.dialect.Oracle8iDialect;
import org.hibernate.orm.test.jpa.BaseEntityManagerFunctionalTestCase;
import org.hibernate.dialect.OracleDialect;
import org.hibernate.query.Query;
import org.hibernate.testing.RequiresDialect;
import org.junit.Test;
import org.hibernate.testing.orm.junit.EntityManagerFactoryScope;
import org.hibernate.testing.orm.junit.Jpa;
import org.hibernate.testing.orm.junit.RequiresDialect;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
import org.jboss.logging.Logger;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.hibernate.testing.transaction.TransactionUtil.doInJPA;
import static org.junit.Assert.assertEquals;
/**
* @author Vlad Mihalcea
*/
public class ExplicitLockingTest extends BaseEntityManagerFunctionalTestCase {
@Jpa(
annotatedClasses = {
ExplicitLockingTest.Person.class,
ExplicitLockingTest.Phone.class,
}
)
public class ExplicitLockingTest {
@Override
protected Class<?>[] getAnnotatedClasses() {
return new Class<?>[] {
Person.class,
Phone.class,
};
protected final Logger log = Logger.getLogger( getClass() );
@AfterEach
public void tearDown(EntityManagerFactoryScope scope) {
scope.inTransaction(
entityManager ->
entityManager.createQuery( "delete from Person" ).executeUpdate()
);
}
@Test
public void testJPALockTimeout() {
doInJPA(this::entityManagerFactory, entityManager -> {
public void testJPALockTimeout(EntityManagerFactoryScope scope) {
Person p = scope.fromTransaction( entityManager -> {
Person person = new Person("John Doe");
entityManager.persist(person);
return person;
});
doInJPA(this::entityManagerFactory, entityManager -> {
scope.inTransaction( entityManager -> {
log.info("testJPALockTimeout");
Long id = 1L;
Long id = p.getId();
//tag::locking-jpa-query-hints-timeout-example[]
entityManager.find(
Person.class, id, LockModeType.PESSIMISTIC_WRITE,
@ -65,8 +78,8 @@ public class ExplicitLockingTest extends BaseEntityManagerFunctionalTestCase {
}
@Test
public void testJPALockScope() {
doInJPA(this::entityManagerFactory, entityManager -> {
public void testJPALockScope(EntityManagerFactoryScope scope) {
Person p = scope.fromTransaction( entityManager -> {
Person person = new Person("John Doe");
entityManager.persist(person);
Phone home = new Phone("123-456-7890");
@ -74,10 +87,11 @@ public class ExplicitLockingTest extends BaseEntityManagerFunctionalTestCase {
person.getPhones().add(home);
person.getPhones().add(office);
entityManager.persist(person);
return person;
});
doInJPA(this::entityManagerFactory, entityManager -> {
scope.inTransaction( entityManager -> {
log.info("testJPALockScope");
Long id = 1L;
Long id = p.getId();
//tag::locking-jpa-query-hints-scope-example[]
Person person = entityManager.find(
Person.class, id, LockModeType.PESSIMISTIC_WRITE,
@ -91,8 +105,8 @@ public class ExplicitLockingTest extends BaseEntityManagerFunctionalTestCase {
}
@Test
public void testBuildLockRequest() {
doInJPA(this::entityManagerFactory, entityManager -> {
public void testBuildLockRequest(EntityManagerFactoryScope scope) {
Person p = scope.fromTransaction( entityManager -> {
log.info("testBuildLockRequest");
Person person = new Person("John Doe");
Phone home = new Phone("123-456-7890");
@ -101,9 +115,10 @@ public class ExplicitLockingTest extends BaseEntityManagerFunctionalTestCase {
person.getPhones().add(office);
entityManager.persist(person);
entityManager.flush();
return person;
});
doInJPA(this::entityManagerFactory, entityManager -> {
Long id = 1L;
scope.inTransaction( entityManager -> {
Long id = p.getId();
//tag::locking-buildLockRequest-example[]
Person person = entityManager.find(Person.class, id);
Session session = entityManager.unwrap(Session.class);
@ -115,8 +130,8 @@ public class ExplicitLockingTest extends BaseEntityManagerFunctionalTestCase {
//end::locking-buildLockRequest-example[]
});
doInJPA(this::entityManagerFactory, entityManager -> {
Long id = 1L;
scope.inTransaction( entityManager -> {
Long id = p.getId();
//tag::locking-buildLockRequest-scope-example[]
Person person = entityManager.find(Person.class, id);
Session session = entityManager.unwrap(Session.class);
@ -132,9 +147,9 @@ public class ExplicitLockingTest extends BaseEntityManagerFunctionalTestCase {
}
@Test
@RequiresDialect(Oracle8iDialect.class)
public void testFollowOnLocking() {
doInJPA(this::entityManagerFactory, entityManager -> {
@RequiresDialect(value = OracleDialect.class, majorVersion = 8)
public void testFollowOnLocking(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
log.info("testBuildLockRequest");
Person person1 = new Person("John Doe");
Person person2 = new Person("Mrs. John Doe");
@ -144,7 +159,7 @@ public class ExplicitLockingTest extends BaseEntityManagerFunctionalTestCase {
entityManager.flush();
});
doInJPA(this::entityManagerFactory, entityManager -> {
scope.inTransaction( entityManager -> {
//tag::locking-follow-on-example[]
List<Person> persons = entityManager.createQuery(
"select DISTINCT p from Person p", Person.class)
@ -153,7 +168,7 @@ public class ExplicitLockingTest extends BaseEntityManagerFunctionalTestCase {
//end::locking-follow-on-example[]
});
doInJPA(this::entityManagerFactory, entityManager -> {
scope.inTransaction( entityManager -> {
//tag::locking-follow-on-secondary-query-example[]
List<Person> persons = entityManager.createQuery(
"select DISTINCT p from Person p", Person.class)
@ -167,7 +182,7 @@ public class ExplicitLockingTest extends BaseEntityManagerFunctionalTestCase {
//end::locking-follow-on-secondary-query-example[]
});
doInJPA(this::entityManagerFactory, entityManager -> {
scope.inTransaction( entityManager -> {
//tag::locking-follow-on-explicit-example[]
List<Person> persons = entityManager.createQuery(
"select p from Person p", Person.class)

30
documentation/src/test/java/org/hibernate/userguide/mapping/generated/GeneratedTest.java
View File

@ -13,30 +13,26 @@ import jakarta.persistence.Id;
import org.hibernate.annotations.Generated;
import org.hibernate.annotations.GenerationTime;
import org.hibernate.dialect.SQLServer2005Dialect;
import org.hibernate.orm.test.jpa.BaseEntityManagerFunctionalTestCase;
import org.hibernate.testing.RequiresDialect;
import org.junit.Test;
import org.hibernate.testing.orm.junit.EntityManagerFactoryScope;
import org.hibernate.testing.orm.junit.Jpa;
import org.hibernate.testing.orm.junit.RequiresDialect;
import org.junit.jupiter.api.Test;
import static org.hibernate.testing.transaction.TransactionUtil.doInJPA;
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
/**
* @author Vlad Mihalcea
*/
@RequiresDialect(SQLServer2005Dialect.class)
public class GeneratedTest extends BaseEntityManagerFunctionalTestCase {
@Override
protected Class<?>[] getAnnotatedClasses() {
return new Class<?>[] {
Person.class
};
}
@RequiresDialect(value = SQLServer2005Dialect.class, majorVersion = 9)
@Jpa(
annotatedClasses = GeneratedTest.Person.class
)
public class GeneratedTest {
@Test
public void test() {
doInJPA(this::entityManagerFactory, entityManager -> {
public void test(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
//tag::mapping-generated-Generated-persist-example[]
Person person = new Person();
person.setId(1L);
@ -54,7 +50,7 @@ public class GeneratedTest extends BaseEntityManagerFunctionalTestCase {
assertEquals("John Flávio André Frederico Rúben Artur Doe", person.getFullName());
//end::mapping-generated-Generated-persist-example[]
});
doInJPA(this::entityManagerFactory, entityManager -> {
scope.inTransaction( entityManager -> {
//tag::mapping-generated-Generated-update-example[]
Person person = entityManager.find(Person.class, 1L);
person.setLastName("Doe Jr");

31
documentation/src/test/java/org/hibernate/userguide/mapping/identifier/RowIdTest.java
View File

@ -11,37 +11,32 @@ import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import org.hibernate.annotations.RowId;
import org.hibernate.dialect.Oracle8iDialect;
import org.hibernate.orm.test.jpa.BaseEntityManagerFunctionalTestCase;
import org.hibernate.dialect.OracleDialect;
import org.hibernate.testing.RequiresDialect;
import org.junit.Test;
import static org.hibernate.testing.transaction.TransactionUtil.doInJPA;
import org.hibernate.testing.orm.junit.EntityManagerFactoryScope;
import org.hibernate.testing.orm.junit.Jpa;
import org.hibernate.testing.orm.junit.RequiresDialect;
import org.junit.jupiter.api.Test;
/**
* @author Vlad Mihalcea
*/
@RequiresDialect(Oracle8iDialect.class)
public class RowIdTest extends BaseEntityManagerFunctionalTestCase {
@Override
protected Class<?>[] getAnnotatedClasses() {
return new Class<?>[] {
Product.class
};
}
@RequiresDialect(value = OracleDialect.class, majorVersion = 8)
@Jpa(
annotatedClasses = RowIdTest.Product.class
)
public class RowIdTest {
@Test
public void test() {
doInJPA(this::entityManagerFactory, entityManager -> {
public void test(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
Product product = new Product();
product.setId(1L);
product.setName("Mobile phone");
product.setNumber("123-456-7890");
entityManager.persist(product);
});
doInJPA(this::entityManagerFactory, entityManager -> {
scope.inTransaction( entityManager -> {
//tag::identifiers-rowid-example[]
Product product = entityManager.find(Product.class, 1L);

73
documentation/src/test/java/org/hibernate/userguide/schema/SchemaGenerationTest.java → documentation/src/test/java/org/hibernate/userguide/schema/BaseSchemaGeneratorTest.java
View File

@ -9,8 +9,11 @@ package org.hibernate.userguide.schema;
import java.sql.Blob;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import org.hibernate.annotations.LazyGroup;
import org.hibernate.annotations.NaturalId;
import jakarta.persistence.Basic;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
@ -19,61 +22,7 @@ import jakarta.persistence.Lob;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.OneToMany;
import org.hibernate.annotations.LazyGroup;
import org.hibernate.annotations.NaturalId;
import org.hibernate.cfg.AvailableSettings;
import org.hibernate.dialect.H2Dialect;
import org.hibernate.dialect.PostgreSQL81Dialect;
import org.hibernate.orm.test.jpa.BaseEntityManagerFunctionalTestCase;
import org.hibernate.testing.RequiresDialect;
import org.junit.Test;
/**
* @author Vlad Mihalcea
*/
public class SchemaGenerationTest extends BaseEntityManagerFunctionalTestCase {
@Override
protected Class<?>[] getAnnotatedClasses() {
return new Class<?>[] {
Person.class,
Book.class,
Customer.class
};
}
@Override
protected Map buildSettings() {
Map settings = super.buildSettings();
if (getDialect().getClass().equals(H2Dialect.class)) {
settings.put(
AvailableSettings.HBM2DDL_IMPORT_FILES,
"schema-generation.sql"
);
settings.put(AvailableSettings.HBM2DDL_AUTO, "update");
}
return settings;
}
@Override
protected String[] getMappings() {
if (PostgreSQL81Dialect.class.isAssignableFrom(getDialect().getClass())) {
return new String[] { "org/hibernate/userguide/schema/SchemaGenerationTest.hbm.xml" };
}
return super.getMappings();
}
@Test
@RequiresDialect(H2Dialect.class)
public void testH2() {
}
@Test
@RequiresDialect(PostgreSQL81Dialect.class)
public void testPostgres() {
}
public abstract class BaseSchemaGeneratorTest {
//tag::schema-generation-domain-model-example[]
@Entity(name = "Customer")
public class Customer {
@ -93,7 +42,7 @@ public class SchemaGenerationTest extends BaseEntityManagerFunctionalTestCase {
//Getters and setters are omitted for brevity
//end::schema-generation-domain-model-example[]
//end::schema-generation-domain-model-example[]
public Integer getId() {
return id;
@ -126,7 +75,7 @@ public class SchemaGenerationTest extends BaseEntityManagerFunctionalTestCase {
public void setImage(Blob image) {
this.image = image;
}
//tag::schema-generation-domain-model-example[]
//tag::schema-generation-domain-model-example[]
}
@Entity(name = "Person")
@ -142,7 +91,7 @@ public class SchemaGenerationTest extends BaseEntityManagerFunctionalTestCase {
//Getters and setters are omitted for brevity
//end::schema-generation-domain-model-example[]
//end::schema-generation-domain-model-example[]
public Long getId() {
return id;
@ -163,7 +112,7 @@ public class SchemaGenerationTest extends BaseEntityManagerFunctionalTestCase {
public List<Book> getBooks() {
return books;
}
//tag::schema-generation-domain-model-example[]
//tag::schema-generation-domain-model-example[]
}
@Entity(name = "Book")
@ -182,7 +131,7 @@ public class SchemaGenerationTest extends BaseEntityManagerFunctionalTestCase {
//Getters and setters are omitted for brevity
//end::schema-generation-domain-model-example[]
//end::schema-generation-domain-model-example[]
public Long getId() {
return id;
@ -215,7 +164,7 @@ public class SchemaGenerationTest extends BaseEntityManagerFunctionalTestCase {
public void setIsbn(String isbn) {
this.isbn = isbn;
}
//tag::schema-generation-domain-model-example[]
//tag::schema-generation-domain-model-example[]
}
//end::schema-generation-domain-model-example[]
}

38
documentation/src/test/java/org/hibernate/userguide/schema/H2SchemaGenerationTest.java Normal file
View File

@ -0,0 +1,38 @@
/*
* 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.userguide.schema;
import org.hibernate.cfg.AvailableSettings;
import org.hibernate.dialect.H2Dialect;
import org.hibernate.testing.orm.junit.Jpa;
import org.hibernate.testing.orm.junit.RequiresDialect;
import org.hibernate.testing.orm.junit.Setting;
import org.junit.jupiter.api.Test;
/**
* @author Vlad Mihalcea
*/
@RequiresDialect( H2Dialect.class )
@Jpa(
annotatedClasses = {
BaseSchemaGeneratorTest.Person.class,
BaseSchemaGeneratorTest.Book.class,
BaseSchemaGeneratorTest.Customer.class
},
integrationSettings = {
@Setting( name = AvailableSettings.HBM2DDL_IMPORT_FILES, value = "schema-generation.sql"),
@Setting( name = AvailableSettings.HBM2DDL_AUTO, value = "update")
}
)
public class H2SchemaGenerationTest extends BaseSchemaGeneratorTest {
@Test
public void testH2() {
}
}

34
documentation/src/test/java/org/hibernate/userguide/schema/PostgreSQLSchemaGenerationTest.java Normal file
View File

@ -0,0 +1,34 @@
/*
* 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.userguide.schema;
import org.hibernate.cfg.AvailableSettings;
import org.hibernate.dialect.PostgreSQLDialect;
import org.hibernate.testing.orm.junit.Jpa;
import org.hibernate.testing.orm.junit.RequiresDialect;
import org.hibernate.testing.orm.junit.Setting;
import org.junit.jupiter.api.Test;
@RequiresDialect(value = PostgreSQLDialect.class, majorVersion = 8)
@Jpa(
annotatedClasses = {
BaseSchemaGeneratorTest.Person.class,
BaseSchemaGeneratorTest.Book.class,
BaseSchemaGeneratorTest.Customer.class
},
xmlMappings = "org/hibernate/userguide/schema/SchemaGenerationTest.hbm.xml",
integrationSettings = {
@Setting(name = AvailableSettings.HBM2DDL_IMPORT_FILES, value = "schema-generation.sql"),
@Setting(name = AvailableSettings.HBM2DDL_AUTO, value = "update")
}
)
public class PostgreSQLSchemaGenerationTest extends BaseSchemaGeneratorTest {
@Test
public void testPostgres() {
}
}

429
documentation/src/test/java/org/hibernate/userguide/sql/MySQLStoredProcedureTest.java
View File

@ -8,256 +8,265 @@ import java.time.LocalDateTime;
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;
import java.util.regex.Pattern;
import jakarta.persistence.ParameterMode;
import jakarta.persistence.StoredProcedureQuery;
import org.hibernate.Session;
import org.hibernate.dialect.MySQL5Dialect;
import org.hibernate.orm.test.jpa.BaseEntityManagerFunctionalTestCase;
import org.hibernate.dialect.MySQLDialect;
import org.hibernate.dialect.TiDBDialect;
import org.hibernate.procedure.ProcedureCall;
import org.hibernate.query.procedure.ProcedureParameter;
import org.hibernate.result.Output;
import org.hibernate.result.ResultSetOutput;
import org.hibernate.userguide.model.Account;
import org.hibernate.userguide.model.AddressType;
import org.hibernate.userguide.model.Call;
import org.hibernate.userguide.model.Partner;
import org.hibernate.userguide.model.Payment;
import org.hibernate.userguide.model.Person;
import org.hibernate.userguide.model.Phone;
import org.hibernate.userguide.model.PhoneType;
import org.hibernate.testing.RequiresDialect;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.hibernate.testing.orm.junit.EntityManagerFactoryScope;
import org.hibernate.testing.orm.junit.Jpa;
import org.hibernate.testing.orm.junit.RequiresDialect;
import org.hibernate.testing.orm.junit.SkipForDialect;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import static org.hibernate.testing.transaction.TransactionUtil.doInJPA;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import jakarta.persistence.ParameterMode;
import jakarta.persistence.StoredProcedureQuery;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* @author Vlad Mihalcea
*/
@RequiresDialect(MySQL5Dialect.class)
public class MySQLStoredProcedureTest extends BaseEntityManagerFunctionalTestCase {
@RequiresDialect(value = MySQLDialect.class, majorVersion = 5)
@SkipForDialect(dialectClass = TiDBDialect.class, reason = "TiDB doesn't support stored procedures")
@Jpa(
annotatedClasses = {
Person.class,
Partner.class,
Phone.class,
Call.class,
Payment.class,
Account.class
}
)
public class MySQLStoredProcedureTest {
@Override
protected Class<?>[] getAnnotatedClasses() {
return new Class<?>[] {
Person.class,
Partner.class,
Phone.class,
Call.class,
};
}
@BeforeAll
public void init(EntityManagerFactoryScope scope) {
destroy( scope );
scope.inTransaction( entityManager -> {
Session session = entityManager.unwrap( Session.class );
session.doWork( connection -> {
try (Statement statement = connection.createStatement()) {
//tag::sql-sp-out-mysql-example[]
statement.executeUpdate(
"CREATE PROCEDURE sp_count_phones (" +
" IN personId INT, " +
" OUT phoneCount INT " +
") " +
"BEGIN " +
" SELECT COUNT(*) INTO phoneCount " +
" FROM Phone p " +
" WHERE p.person_id = personId; " +
"END"
);
//end::sql-sp-out-mysql-example[]
//tag::sql-sp-no-out-mysql-example[]
statement.executeUpdate(
"CREATE PROCEDURE sp_phones(IN personId INT) " +
"BEGIN " +
" SELECT * " +
" FROM Phone " +
" WHERE person_id = personId; " +
"END"
);
//end::sql-sp-no-out-mysql-example[]
//tag::sql-function-mysql-example[]
statement.executeUpdate(
"CREATE FUNCTION fn_count_phones(personId integer) " +
"RETURNS integer " +
"DETERMINISTIC " +
"READS SQL DATA " +
"BEGIN " +
" DECLARE phoneCount integer; " +
" SELECT COUNT(*) INTO phoneCount " +
" FROM Phone p " +
" WHERE p.person_id = personId; " +
" RETURN phoneCount; " +
"END"
);
//end::sql-function-mysql-example[]
}
} );
} );
scope.inTransaction( entityManager -> {
Person person1 = new Person( "John Doe" );
person1.setNickName( "JD" );
person1.setAddress( "Earth" );
person1.setCreatedOn( LocalDateTime.of( 2000, 1, 1, 0, 0, 0 ) );
person1.getAddresses().put( AddressType.HOME, "Home address" );
person1.getAddresses().put( AddressType.OFFICE, "Office address" );
@Before
public void init() {
destroy();
doInJPA(this::entityManagerFactory, entityManager -> {
Session session = entityManager.unwrap(Session.class);
session.doWork(connection -> {
try(Statement statement = connection.createStatement()) {
//tag::sql-sp-out-mysql-example[]
statement.executeUpdate(
"CREATE PROCEDURE sp_count_phones (" +
" IN personId INT, " +
" OUT phoneCount INT " +
") " +
"BEGIN " +
" SELECT COUNT(*) INTO phoneCount " +
" FROM Phone p " +
" WHERE p.person_id = personId; " +
"END"
);
//end::sql-sp-out-mysql-example[]
//tag::sql-sp-no-out-mysql-example[]
statement.executeUpdate(
"CREATE PROCEDURE sp_phones(IN personId INT) " +
"BEGIN " +
" SELECT * " +
" FROM Phone " +
" WHERE person_id = personId; " +
"END"
);
//end::sql-sp-no-out-mysql-example[]
//tag::sql-function-mysql-example[]
statement.executeUpdate(
"CREATE FUNCTION fn_count_phones(personId integer) " +
"RETURNS integer " +
"DETERMINISTIC " +
"READS SQL DATA " +
"BEGIN " +
" DECLARE phoneCount integer; " +
" SELECT COUNT(*) INTO phoneCount " +
" FROM Phone p " +
" WHERE p.person_id = personId; " +
" RETURN phoneCount; " +
"END"
);
//end::sql-function-mysql-example[]
}
});
});
doInJPA(this::entityManagerFactory, entityManager -> {
Person person1 = new Person("John Doe");
person1.setNickName("JD");
person1.setAddress("Earth");
person1.setCreatedOn(LocalDateTime.of(2000, 1, 1, 0, 0, 0)) ;
person1.getAddresses().put(AddressType.HOME, "Home address");
person1.getAddresses().put(AddressType.OFFICE, "Office address");
entityManager.persist( person1 );
entityManager.persist(person1);
Phone phone1 = new Phone( "123-456-7890" );
phone1.setId( 1L );
phone1.setType( PhoneType.MOBILE );
Phone phone1 = new Phone("123-456-7890");
phone1.setId(1L);
phone1.setType(PhoneType.MOBILE);
person1.addPhone( phone1 );
person1.addPhone(phone1);
Phone phone2 = new Phone( "098_765-4321" );
phone2.setId( 2L );
phone2.setType( PhoneType.LAND_LINE );
Phone phone2 = new Phone("098_765-4321");
phone2.setId(2L);
phone2.setType(PhoneType.LAND_LINE);
person1.addPhone( phone2 );
} );
}
person1.addPhone(phone2);
});
}
@AfterAll
public void destroy(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
Session session = entityManager.unwrap( Session.class );
session.doWork( connection -> {
try (Statement statement = connection.createStatement()) {
statement.executeUpdate( "DROP PROCEDURE IF EXISTS sp_count_phones" );
}
catch (SQLException ignore) {
}
} );
} );
scope.inTransaction( entityManager -> {
Session session = entityManager.unwrap( Session.class );
session.doWork( connection -> {
try (Statement statement = connection.createStatement()) {
statement.executeUpdate( "DROP PROCEDURE IF EXISTS sp_phones" );
}
catch (SQLException ignore) {
}
} );
} );
scope.inTransaction( entityManager -> {
Session session = entityManager.unwrap( Session.class );
session.doWork( connection -> {
try (Statement statement = connection.createStatement()) {
statement.executeUpdate( "DROP FUNCTION IF EXISTS fn_count_phones" );
}
catch (SQLException ignore) {
}
} );
} );
}
@After
public void destroy() {
doInJPA(this::entityManagerFactory, entityManager -> {
Session session = entityManager.unwrap(Session.class);
session.doWork(connection -> {
try(Statement statement = connection.createStatement()) {
statement.executeUpdate("DROP PROCEDURE IF EXISTS sp_count_phones");
}
catch (SQLException ignore) {
}
});
});
doInJPA(this::entityManagerFactory, entityManager -> {
Session session = entityManager.unwrap(Session.class);
session.doWork(connection -> {
try(Statement statement = connection.createStatement()) {
statement.executeUpdate("DROP PROCEDURE IF EXISTS sp_phones");
}
catch (SQLException ignore) {
}
});
});
doInJPA(this::entityManagerFactory, entityManager -> {
Session session = entityManager.unwrap(Session.class);
session.doWork(connection -> {
try(Statement statement = connection.createStatement()) {
statement.executeUpdate("DROP FUNCTION IF EXISTS fn_count_phones");
}
catch (SQLException ignore) {
}
});
});
}
@Test
public void testStoredProcedureOutParameter(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
//tag::sql-jpa-call-sp-out-mysql-example[]
StoredProcedureQuery query = entityManager.createStoredProcedureQuery( "sp_count_phones" );
query.registerStoredProcedureParameter( "personId", Long.class, ParameterMode.IN );
query.registerStoredProcedureParameter( "phoneCount", Long.class, ParameterMode.OUT );
@Test
public void testStoredProcedureOutParameter() {
doInJPA(this::entityManagerFactory, entityManager -> {
//tag::sql-jpa-call-sp-out-mysql-example[]
StoredProcedureQuery query = entityManager.createStoredProcedureQuery("sp_count_phones");
query.registerStoredProcedureParameter("personId", Long.class, ParameterMode.IN);
query.registerStoredProcedureParameter("phoneCount", Long.class, ParameterMode.OUT);
query.setParameter( "personId", 1L );
query.setParameter("personId", 1L);
query.execute();
Long phoneCount = (Long) query.getOutputParameterValue( "phoneCount" );
//end::sql-jpa-call-sp-out-mysql-example[]
assertEquals( 2l, phoneCount );
} );
}
query.execute();
Long phoneCount = (Long) query.getOutputParameterValue("phoneCount");
//end::sql-jpa-call-sp-out-mysql-example[]
assertEquals(Long.valueOf(2), phoneCount);
});
}
@Test
public void testHibernateProcedureCallOutParameter(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
//tag::sql-hibernate-call-sp-out-mysql-example[]
Session session = entityManager.unwrap( Session.class );
@Test
public void testHibernateProcedureCallOutParameter() {
doInJPA(this::entityManagerFactory, entityManager -> {
//tag::sql-hibernate-call-sp-out-mysql-example[]
Session session = entityManager.unwrap(Session.class);
ProcedureCall call = session.createStoredProcedureCall( "sp_count_phones" );
ProcedureParameter<Long> parameter = call.registerParameter( "personId", Long.class, ParameterMode.IN );
call.setParameter( parameter, 1L );
call.registerParameter( "phoneCount", Long.class, ParameterMode.OUT );
ProcedureCall call = session.createStoredProcedureCall("sp_count_phones");
ProcedureParameter<Long> parameter = call.registerParameter("personId", Long.class, ParameterMode.IN);
call.setParameter(parameter, 1L);
call.registerParameter("phoneCount", Long.class, ParameterMode.OUT);
Long phoneCount = (Long) call.getOutputs().getOutputParameterValue( "phoneCount" );
assertEquals( Long.valueOf( 2 ), phoneCount );
//end::sql-hibernate-call-sp-out-mysql-example[]
} );
}
Long phoneCount = (Long) call.getOutputs().getOutputParameterValue("phoneCount");
assertEquals(Long.valueOf(2), phoneCount);
//end::sql-hibernate-call-sp-out-mysql-example[]
});
}
@Test
public void testStoredProcedureRefCursor(EntityManagerFactoryScope scope) {
try {
scope.inTransaction( entityManager -> {
StoredProcedureQuery query = entityManager.createStoredProcedureQuery( "sp_phones" );
query.registerStoredProcedureParameter( 1, void.class, ParameterMode.REF_CURSOR );
query.registerStoredProcedureParameter( 2, Long.class, ParameterMode.IN );
@Test
public void testStoredProcedureRefCursor() {
try {
doInJPA(this::entityManagerFactory, entityManager -> {
StoredProcedureQuery query = entityManager.createStoredProcedureQuery("sp_phones");
query.registerStoredProcedureParameter(1, void.class, ParameterMode.REF_CURSOR);
query.registerStoredProcedureParameter(2, Long.class, ParameterMode.IN);
query.setParameter( 2, 1L );
query.setParameter(2, 1L);
List<Object[]> personComments = query.getResultList();
assertEquals( 2, personComments.size() );
} );
}
catch (Exception e) {
assertTrue( Pattern.compile( "Dialect .*? not known to support REF_CURSOR parameters" )
.matcher( e.getCause().getMessage() )
.matches() );
}
}
List<Object[]> personComments = query.getResultList();
assertEquals(2, personComments.size());
});
} catch (Exception e) {
assertTrue(Pattern.compile("Dialect .*? not known to support REF_CURSOR parameters").matcher(e.getCause().getMessage()).matches());
}
}
@Test
public void testStoredProcedureReturnValue(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
//tag::sql-jpa-call-sp-no-out-mysql-example[]
StoredProcedureQuery query = entityManager.createStoredProcedureQuery( "sp_phones" );
query.registerStoredProcedureParameter( 1, Long.class, ParameterMode.IN );
@Test
public void testStoredProcedureReturnValue() {
doInJPA(this::entityManagerFactory, entityManager -> {
//tag::sql-jpa-call-sp-no-out-mysql-example[]
StoredProcedureQuery query = entityManager.createStoredProcedureQuery("sp_phones");
query.registerStoredProcedureParameter(1, Long.class, ParameterMode.IN);
query.setParameter( 1, 1L );
query.setParameter(1, 1L);
List<Object[]> personComments = query.getResultList();
//end::sql-jpa-call-sp-no-out-mysql-example[]
assertEquals( 2, personComments.size() );
} );
}
List<Object[]> personComments = query.getResultList();
//end::sql-jpa-call-sp-no-out-mysql-example[]
assertEquals(2, personComments.size());
});
}
@Test
public void testHibernateProcedureCallReturnValueParameter(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
//tag::sql-hibernate-call-sp-no-out-mysql-example[]
Session session = entityManager.unwrap( Session.class );
@Test
public void testHibernateProcedureCallReturnValueParameter() {
doInJPA(this::entityManagerFactory, entityManager -> {
//tag::sql-hibernate-call-sp-no-out-mysql-example[]
Session session = entityManager.unwrap(Session.class);
ProcedureCall call = session.createStoredProcedureCall( "sp_phones" );
ProcedureParameter<Long> parameter = call.registerParameter( 1, Long.class, ParameterMode.IN );
call.setParameter( parameter, 1L );
ProcedureCall call = session.createStoredProcedureCall("sp_phones");
ProcedureParameter<Long> parameter = call.registerParameter(1, Long.class, ParameterMode.IN);
call.setParameter(parameter, 1L);
Output output = call.getOutputs().getCurrent();
Output output = call.getOutputs().getCurrent();
List<Object[]> personComments = ( (ResultSetOutput) output ).getResultList();
//end::sql-hibernate-call-sp-no-out-mysql-example[]
assertEquals( 2, personComments.size() );
} );
}
List<Object[]> personComments = ((ResultSetOutput) output).getResultList();
//end::sql-hibernate-call-sp-no-out-mysql-example[]
assertEquals(2, personComments.size());
});
}
@Test
public void testFunctionWithJDBC() {
doInJPA(this::entityManagerFactory, entityManager -> {
//tag::sql-call-function-mysql-example[]
final AtomicReference<Integer> phoneCount = new AtomicReference<>();
Session session = entityManager.unwrap(Session.class);
session.doWork(connection -> {
try (CallableStatement function = connection.prepareCall(
"{ ? = call fn_count_phones(?) }")) {
function.registerOutParameter(1, Types.INTEGER);
function.setInt(2, 1);
function.execute();
phoneCount.set(function.getInt(1));
}
});
//end::sql-call-function-mysql-example[]
assertEquals(Integer.valueOf(2), phoneCount.get());
});
}
@Test
public void testFunctionWithJDBC(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
//tag::sql-call-function-mysql-example[]
final AtomicReference<Integer> phoneCount = new AtomicReference<>();
Session session = entityManager.unwrap( Session.class );
session.doWork( connection -> {
try (CallableStatement function = connection.prepareCall(
"{ ? = call fn_count_phones(?) }" )) {
function.registerOutParameter( 1, Types.INTEGER );
function.setInt( 2, 1 );
function.execute();
phoneCount.set( function.getInt( 1 ) );
}
} );
//end::sql-call-function-mysql-example[]
assertEquals( Integer.valueOf( 2 ), phoneCount.get() );
} );
}
}

125
documentation/src/test/java/org/hibernate/userguide/sql/OracleCustomSQLWithStoredProcedureTest.java
View File

@ -7,107 +7,106 @@
package org.hibernate.userguide.sql;
import java.sql.Statement;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.Id;
import jakarta.persistence.NamedNativeQueries;
import jakarta.persistence.NamedNativeQuery;
import org.hibernate.Session;
import org.hibernate.annotations.Loader;
import org.hibernate.annotations.ResultCheckStyle;
import org.hibernate.annotations.SQLDelete;
import org.hibernate.annotations.SQLInsert;
import org.hibernate.dialect.Oracle8iDialect;
import org.hibernate.orm.test.jpa.BaseEntityManagerFunctionalTestCase;
import org.hibernate.dialect.OracleDialect;
import org.hibernate.testing.RequiresDialect;
import org.junit.Before;
import org.junit.Test;
import org.hibernate.testing.orm.junit.EntityManagerFactoryScope;
import org.hibernate.testing.orm.junit.Jpa;
import org.hibernate.testing.orm.junit.RequiresDialect;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.Id;
import jakarta.persistence.NamedNativeQueries;
import jakarta.persistence.NamedNativeQuery;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.hibernate.testing.transaction.TransactionUtil.doInJPA;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
/**
* @author Vlad Mihalcea
*/
@RequiresDialect(Oracle8iDialect.class)
public class OracleCustomSQLWithStoredProcedureTest extends BaseEntityManagerFunctionalTestCase {
@RequiresDialect(value = OracleDialect.class, majorVersion = 8)
@Jpa(
annotatedClasses = OracleCustomSQLWithStoredProcedureTest.Person.class
)
public class OracleCustomSQLWithStoredProcedureTest {
@Override
protected Class<?>[] getAnnotatedClasses() {
return new Class<?>[] {
Person.class
};
}
@Before
public void init() {
doInJPA(this::entityManagerFactory, entityManager -> {
Session session = entityManager.unwrap(Session.class);
session.doWork(connection -> {
try(Statement statement = connection.createStatement();) {
statement.executeUpdate("ALTER TABLE person ADD valid NUMBER(1) DEFAULT 0 NOT NULL");
@BeforeAll
public void init(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
Session session = entityManager.unwrap( Session.class );
session.doWork( connection -> {
try (Statement statement = connection.createStatement();) {
statement.executeUpdate( "ALTER TABLE person ADD valid NUMBER(1) DEFAULT 0 NOT NULL" );
//tag::sql-sp-soft-delete-example[]
statement.executeUpdate(
"CREATE OR REPLACE PROCEDURE sp_delete_person (" +
" personId IN NUMBER) " +
"AS " +
"BEGIN " +
" UPDATE person SET valid = 0 WHERE id = personId; " +
"END;"
);}
"CREATE OR REPLACE PROCEDURE sp_delete_person (" +
" personId IN NUMBER) " +
"AS " +
"BEGIN " +
" UPDATE person SET valid = 0 WHERE id = personId; " +
"END;"
);
}
//end::sql-sp-soft-delete-example[]
});
});
} );
} );
}
@Test
public void test_sql_custom_crud() {
public void test_sql_custom_crud(EntityManagerFactoryScope scope) {
Person _person = doInJPA(this::entityManagerFactory, entityManager -> {
Person _person = scope.fromTransaction( entityManager -> {
Person person = new Person();
person.setName("John Doe");
entityManager.persist(person);
person.setName( "John Doe" );
entityManager.persist( person );
return person;
});
} );
doInJPA(this::entityManagerFactory, entityManager -> {
scope.inTransaction( entityManager -> {
Long postId = _person.getId();
Person person = entityManager.find(Person.class, postId);
assertNotNull(person);
entityManager.remove(person);
});
Person person = entityManager.find( Person.class, postId );
assertNotNull( person );
entityManager.remove( person );
} );
doInJPA(this::entityManagerFactory, entityManager -> {
scope.inTransaction( entityManager -> {
Long postId = _person.getId();
Person person = entityManager.find(Person.class, postId);
assertNull(person);
});
Person person = entityManager.find( Person.class, postId );
assertNull( person );
} );
}
@Entity(name = "Person")
@SQLInsert(
sql = "INSERT INTO person (name, id, valid) VALUES (?, ?, 1) ",
check = ResultCheckStyle.COUNT
sql = "INSERT INTO person (name, id, valid) VALUES (?, ?, 1) ",
check = ResultCheckStyle.COUNT
)
//tag::sql-sp-custom-crud-example[]
@SQLDelete(
sql = "{ call sp_delete_person(?) } ",
callable = true
sql = "{ call sp_delete_person(?) } ",
callable = true
)
//end::sql-sp-custom-crud-example[]
@Loader(namedQuery = "find_valid_person")
@NamedNativeQueries({
@NamedNativeQuery(
name = "find_valid_person",
query = "SELECT id, name " +
"FROM person " +
"WHERE id = ? and valid = 1",
resultClass = Person.class
)
@NamedNativeQuery(
name = "find_valid_person",
query = "SELECT id, name " +
"FROM person " +
"WHERE id = ? and valid = 1",
resultClass = Person.class
)
})
public static class Person {

109
documentation/src/test/java/org/hibernate/userguide/sql/OracleStoredProcedureTest.java
View File

@ -3,55 +3,57 @@ package org.hibernate.userguide.sql;
import java.math.BigDecimal;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Timestamp;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.util.List;
import jakarta.persistence.ParameterMode;
import jakarta.persistence.StoredProcedureQuery;
import org.hibernate.Session;
import org.hibernate.dialect.Oracle8iDialect;
import org.hibernate.orm.test.jpa.BaseEntityManagerFunctionalTestCase;
import org.hibernate.dialect.OracleDialect;
import org.hibernate.procedure.ProcedureCall;
import org.hibernate.query.procedure.ProcedureParameter;
import org.hibernate.result.Output;
import org.hibernate.result.ResultSetOutput;
import org.hibernate.userguide.model.Account;
import org.hibernate.userguide.model.AddressType;
import org.hibernate.userguide.model.Call;
import org.hibernate.userguide.model.Partner;
import org.hibernate.userguide.model.Payment;
import org.hibernate.userguide.model.Person;
import org.hibernate.userguide.model.Phone;
import org.hibernate.userguide.model.PhoneType;
import org.hibernate.testing.RequiresDialect;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.hibernate.testing.orm.junit.EntityManagerFactoryScope;
import org.hibernate.testing.orm.junit.Jpa;
import org.hibernate.testing.orm.junit.RequiresDialect;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import jakarta.persistence.ParameterMode;
import jakarta.persistence.StoredProcedureQuery;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.hibernate.testing.transaction.TransactionUtil.doInJPA;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
/**
* @author Vlad Mihalcea
*/
@RequiresDialect(Oracle8iDialect.class)
public class OracleStoredProcedureTest extends BaseEntityManagerFunctionalTestCase {
@RequiresDialect(value = OracleDialect.class, majorVersion = 8)
@Jpa(
annotatedClasses = {
Person.class,
Partner.class,
Phone.class,
Call.class,
Payment.class,
Account.class
}
)
public class OracleStoredProcedureTest {
@Override
protected Class<?>[] getAnnotatedClasses() {
return new Class<?>[] {
Person.class,
Partner.class,
Phone.class,
Call.class,
};
}
@Before
public void init() {
doInJPA(this::entityManagerFactory, entityManager -> {
@BeforeAll
public void init(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
Session session = entityManager.unwrap(Session.class);
session.doWork(connection -> {
try(Statement statement = connection.createStatement()) {
@ -96,7 +98,7 @@ public class OracleStoredProcedureTest extends BaseEntityManagerFunctionalTestCa
}
});
});
doInJPA(this::entityManagerFactory, entityManager -> {
scope.inTransaction( entityManager -> {
Person person1 = new Person("John Doe");
person1.setNickName("JD");
person1.setAddress("Earth");
@ -120,9 +122,9 @@ public class OracleStoredProcedureTest extends BaseEntityManagerFunctionalTestCa
});
}
@After
public void destroy() {
doInJPA(this::entityManagerFactory, entityManager -> {
@AfterAll
public void destroy(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
Session session = entityManager.unwrap(Session.class);
session.doWork(connection -> {
try(Statement statement = connection.createStatement()) {
@ -132,7 +134,7 @@ public class OracleStoredProcedureTest extends BaseEntityManagerFunctionalTestCa
}
});
});
doInJPA(this::entityManagerFactory, entityManager -> {
scope.inTransaction( entityManager -> {
Session session = entityManager.unwrap(Session.class);
session.doWork(connection -> {
try(Statement statement = connection.createStatement()) {
@ -142,7 +144,7 @@ public class OracleStoredProcedureTest extends BaseEntityManagerFunctionalTestCa
}
});
});
doInJPA(this::entityManagerFactory, entityManager -> {
scope.inTransaction( entityManager -> {
Session session = entityManager.unwrap(Session.class);
session.doWork(connection -> {
try(Statement statement = connection.createStatement()) {
@ -155,8 +157,8 @@ public class OracleStoredProcedureTest extends BaseEntityManagerFunctionalTestCa
}
@Test
public void testStoredProcedureOutParameter() {
doInJPA(this::entityManagerFactory, entityManager -> {
public void testStoredProcedureOutParameter(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
StoredProcedureQuery query = entityManager.createStoredProcedureQuery("sp_count_phones");
query.registerStoredProcedureParameter(1, Long.class, ParameterMode.IN);
query.registerStoredProcedureParameter(2, Long.class, ParameterMode.OUT);
@ -165,13 +167,13 @@ public class OracleStoredProcedureTest extends BaseEntityManagerFunctionalTestCa
query.execute();
Long phoneCount = (Long) query.getOutputParameterValue(2);
assertEquals(Long.valueOf(2), phoneCount);
assertEquals(2l, phoneCount);
});
}
@Test
public void testStoredProcedureRefCursor() {
doInJPA(this::entityManagerFactory, entityManager -> {
public void testStoredProcedureRefCursor(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
//tag::sql-jpa-call-sp-ref-cursor-oracle-example[]
StoredProcedureQuery query = entityManager.createStoredProcedureQuery("sp_person_phones");
query.registerStoredProcedureParameter(1, Long.class, ParameterMode.IN);
@ -186,8 +188,8 @@ public class OracleStoredProcedureTest extends BaseEntityManagerFunctionalTestCa
}
@Test
public void testStoredProcedureRefCursorUsingNamedQuery() {
doInJPA(this::entityManagerFactory, entityManager -> {
public void testStoredProcedureRefCursorUsingNamedQuery(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
//tag::sql-jpa-call-sp-ref-cursor-oracle-named-query-example[]
List<Object[]> postComments = entityManager
.createNamedStoredProcedureQuery("sp_person_phones")
@ -200,8 +202,8 @@ public class OracleStoredProcedureTest extends BaseEntityManagerFunctionalTestCa
}
@Test
public void testHibernateProcedureCallRefCursor() {
doInJPA(this::entityManagerFactory, entityManager -> {
public void testHibernateProcedureCallRefCursor(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
//tag::sql-hibernate-call-sp-ref-cursor-oracle-example[]
Session session = entityManager.unwrap(Session.class);
@ -218,18 +220,13 @@ public class OracleStoredProcedureTest extends BaseEntityManagerFunctionalTestCa
}
@Test
public void testStoredProcedureReturnValue() {
try {
doInJPA(this::entityManagerFactory, entityManager -> {
BigDecimal phoneCount = (BigDecimal) entityManager
.createNativeQuery("SELECT fn_count_phones(:personId) FROM DUAL")
.setParameter("personId", 1)
.getSingleResult();
assertEquals(BigDecimal.valueOf(2), phoneCount);
});
}
catch (Exception e) {
e.printStackTrace();
}
public void testStoredProcedureReturnValue(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
BigDecimal phoneCount = (BigDecimal) entityManager
.createNativeQuery( "SELECT fn_count_phones(:personId) FROM DUAL" )
.setParameter( "personId", 1 )
.getSingleResult();
assertEquals( BigDecimal.valueOf( 2 ), phoneCount );
} );
}
}

45
hibernate-c3p0/src/test/java/org/hibernate/test/c3p0/JdbcCompatibilityTest.java
View File

@ -8,41 +8,46 @@ package org.hibernate.test.c3p0;
import java.sql.Statement;
import org.hibernate.dialect.SQLServer2005Dialect;
import org.hibernate.dialect.SQLServerDialect;
import org.hibernate.testing.RequiresDialect;
import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase;
import org.junit.Test;
import org.hibernate.testing.orm.junit.DomainModel;
import org.hibernate.testing.orm.junit.RequiresDialect;
import org.hibernate.testing.orm.junit.SessionFactory;
import org.hibernate.testing.orm.junit.SessionFactoryScope;
import org.junit.jupiter.api.Test;
import static org.hibernate.testing.transaction.TransactionUtil.doInHibernate;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
/**
* Tests that checks the JDBC 4.2 compatibility of c3p0
*
* @author Vlad Mihalcea
*/
@RequiresDialect(SQLServer2005Dialect.class)
public class JdbcCompatibilityTest extends BaseCoreFunctionalTestCase {
@RequiresDialect(value = SQLServerDialect.class, majorVersion = 9)
@DomainModel(
annotatedClasses = { IrrelevantEntity.class }
)
@SessionFactory
public class JdbcCompatibilityTest {
@Test
@TestForIssue( jiraKey = "HHH-11308" )
public void testJdbc41() {
doInHibernate( this::sessionFactory, session -> {
@TestForIssue(jiraKey = "HHH-11308")
public void testJdbc41(SessionFactoryScope scope) {
scope.inTransaction( session -> {
session.doWork( connection -> {
//Connection#getSchema was added in Java 1.7
String schema = connection.getSchema();
assertNotNull(schema);
assertNotNull( schema );
} );
} );
}
@Test
@TestForIssue( jiraKey = "HHH-11308" )
public void testJdbc42() {
doInHibernate( this::sessionFactory, session -> {
@TestForIssue(jiraKey = "HHH-11308")
public void testJdbc42(SessionFactoryScope scope) {
scope.inTransaction( session -> {
for ( int i = 0; i < 5; i++ ) {
IrrelevantEntity entity = new IrrelevantEntity();
entity.setName( getClass().getName() );
@ -50,16 +55,12 @@ public class JdbcCompatibilityTest extends BaseCoreFunctionalTestCase {
}
session.flush();
session.doWork( connection -> {
try( Statement statement = connection.createStatement()) {
try (Statement statement = connection.createStatement()) {
statement.executeUpdate( "DELETE FROM IrrelevantEntity" );
assertEquals( 5, statement.getLargeUpdateCount());
assertEquals( 5, statement.getLargeUpdateCount() );
}
} );
} );
}
@Override
protected Class<?>[] getAnnotatedClasses() {
return new Class[]{ IrrelevantEntity.class };
}
}

1
hibernate-core/src/test/java/org/hibernate/orm/test/jpa/procedure/StoreProcedureRefCursorOutParameterByNameTest.java
View File

@ -20,7 +20,6 @@ import jakarta.persistence.StoredProcedureParameter;
import jakarta.persistence.StoredProcedureQuery;
import jakarta.persistence.Table;
import org.hibernate.dialect.Oracle10gDialect;
import org.hibernate.dialect.OracleDialect;
import org.hibernate.engine.jdbc.connections.spi.JdbcConnectionAccess;
import org.hibernate.engine.jdbc.spi.JdbcServices;

1
hibernate-core/src/test/java/org/hibernate/orm/test/jpa/procedure/StoreProcedureRefCursorOutParameterByPositionTest.java
View File

@ -20,7 +20,6 @@ import jakarta.persistence.StoredProcedureParameter;
import jakarta.persistence.StoredProcedureQuery;
import jakarta.persistence.Table;
import org.hibernate.dialect.Oracle10gDialect;
import org.hibernate.dialect.OracleDialect;
import org.hibernate.engine.jdbc.connections.spi.JdbcConnectionAccess;
import org.hibernate.engine.jdbc.spi.JdbcServices;

3
hibernate-core/src/test/java/org/hibernate/orm/test/procedure/MySQLStoredProcedureTest.java
View File

@ -20,6 +20,7 @@ import java.util.regex.Pattern;
import org.hibernate.Session;
import org.hibernate.dialect.MariaDBDialect;
import org.hibernate.dialect.MySQLDialect;
import org.hibernate.dialect.TiDBDialect;
import org.hibernate.procedure.ProcedureCall;
import org.hibernate.query.procedure.ProcedureParameter;
import org.hibernate.result.Output;
@ -30,6 +31,7 @@ import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.orm.junit.EntityManagerFactoryScope;
import org.hibernate.testing.orm.junit.Jpa;
import org.hibernate.testing.orm.junit.RequiresDialect;
import org.hibernate.testing.orm.junit.SkipForDialect;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@ -48,6 +50,7 @@ import static org.junit.jupiter.api.Assertions.fail;
*/
@RequiresDialect(value = MySQLDialect.class, matchSubTypes = false, majorVersion = 5)
@RequiresDialect(value = MariaDBDialect.class, majorVersion = 5)
@SkipForDialect(dialectClass = TiDBDialect.class, reason = "TiDB doesn't support stored procedures")
@Jpa(
annotatedClasses = {
Person.class,

40
hibernate-core/src/test/java/org/hibernate/orm/test/query/SQLServer2008NationalizedScalarQueryTest.java
View File

@ -7,46 +7,48 @@
package org.hibernate.orm.test.query;
import java.util.List;
import org.hibernate.annotations.Nationalized;
import org.hibernate.dialect.SQLServerDialect;
import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.orm.junit.DomainModel;
import org.hibernate.testing.orm.junit.RequiresDialect;
import org.hibernate.testing.orm.junit.SessionFactory;
import org.hibernate.testing.orm.junit.SessionFactoryScope;
import org.junit.jupiter.api.Test;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import org.hibernate.annotations.Nationalized;
import org.hibernate.dialect.SQLServer2008Dialect;
import org.hibernate.testing.RequiresDialect;
import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase;
import org.junit.Test;
import static org.hibernate.testing.transaction.TransactionUtil.doInHibernate;
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
/**
* @author Vlad Mihalcea
*/
@TestForIssue(jiraKey = "HHH-10183")
@RequiresDialect(SQLServer2008Dialect.class)
public class SQLServer2008NationalizedScalarQueryTest extends BaseCoreFunctionalTestCase {
@RequiresDialect(value = SQLServerDialect.class, majorVersion = 10)
@DomainModel(
annotatedClasses = SQLServer2008NationalizedScalarQueryTest.User.class
)
@SessionFactory
public class SQLServer2008NationalizedScalarQueryTest {
@Override
protected Class<?>[] getAnnotatedClasses() {
return new Class[] { User.class };
}
@Test
public void testScalarResult() {
public void testScalarResult(SessionFactoryScope scope) {
User user1 = new User( 1, "Chris" );
User user2 = new User( 2, "Steve" );
doInHibernate( this::sessionFactory, session -> {
scope.inTransaction( session -> {
session.save( user1 );
session.save( user2 );
} );
doInHibernate( this::sessionFactory, session -> {
scope.inTransaction( session -> {
List<Object[]> users = session.createNativeQuery(
"select * from users" ).getResultList();
assertEquals( 2, users.size() );

4
hibernate-envers/src/test/java/org/hibernate/orm/test/envers/integration/basic/EmptyStringTest.java
View File

@ -9,7 +9,7 @@ package org.hibernate.orm.test.envers.integration.basic;
import java.util.Arrays;
import jakarta.persistence.EntityManager;
import org.hibernate.dialect.Oracle8iDialect;
import org.hibernate.dialect.OracleDialect;
import org.hibernate.orm.test.envers.BaseEnversJPAFunctionalTestCase;
import org.hibernate.orm.test.envers.Priority;
import org.hibernate.orm.test.envers.entities.StrTestEntity;
@ -23,7 +23,7 @@ import junit.framework.Assert;
* @author Lukasz Antoniak (lukasz dot antoniak at gmail dot com)
*/
@TestForIssue(jiraKey = "HHH-7246")
@RequiresDialect(Oracle8iDialect.class)
@RequiresDialect(OracleDialect.class)
public class EmptyStringTest extends BaseEnversJPAFunctionalTestCase {
private Integer emptyId = null;
private Integer nullId = null;

4
hibernate-envers/src/test/java/org/hibernate/orm/test/envers/integration/reventity/MonotonicRevisionNumberTest.java
View File

@ -14,7 +14,7 @@ import org.hibernate.boot.model.relational.AuxiliaryDatabaseObject;
import org.hibernate.boot.model.relational.Database;
import org.hibernate.boot.model.relational.SqlStringGenerationContext;
import org.hibernate.boot.model.relational.internal.SqlStringGenerationContextImpl;
import org.hibernate.dialect.Oracle8iDialect;
import org.hibernate.dialect.OracleDialect;
import org.hibernate.envers.enhanced.OrderedSequenceGenerator;
import org.hibernate.envers.enhanced.SequenceIdRevisionEntity;
import org.hibernate.orm.test.envers.BaseEnversFunctionalTestCase;
@ -31,7 +31,7 @@ import org.junit.Test;
* @author Lukasz Antoniak (lukasz dot antoniak at gmail dot com)
*/
@TestForIssue(jiraKey = "HHH-7669")
@RequiresDialect(Oracle8iDialect.class)
@RequiresDialect(OracleDialect.class)
public class MonotonicRevisionNumberTest extends BaseEnversFunctionalTestCase {
@Override
protected Class<?>[] getAnnotatedClasses() {