From 82de2b0a3f5814634ed6bb7213b54cc3b411b477 Mon Sep 17 00:00:00 2001 From: Andrea Boriero Date: Thu, 20 Aug 2020 08:55:12 +0100 Subject: [PATCH] Re-enabled additional tests --- .../collection/bag/BagDuplicatesTest.java | 169 +++++ .../bag/BagElementNullBasicTest.java | 199 +++++ .../test/collection/bag/BagOwner.java | 2 +- .../{ => orm}/test/collection/bag/Item.java | 2 +- .../test/collection/bag/Mappings.hbm.xml | 2 +- .../{ => orm}/test/collection/bag/Order.java | 4 +- .../bag/PersistentBagContainsTest.java | 48 +- .../collection/bag/PersistentBagTest.java | 116 +++ .../idbag/IdBagElementNullBasicTest.java | 104 ++- .../test/collection/idbag/IdbagOwner.java | 2 +- .../test/collection/idbag/Mappings.hbm.xml | 2 +- .../collection/idbag/PersistentIdBagTest.java | 73 ++ .../test/collection/list/LineItem.java | 2 +- .../list/ListElementNullBasicTest.java | 108 ++- ...ListIndexReferenceFromListElementTest.java | 139 ++++ .../test/collection/list/ListOwner.java | 2 +- .../test/collection/list/Mappings.hbm.xml | 2 +- .../{ => orm}/test/collection/list/Order.java | 4 +- .../collection/list/PersistentListTest.java | 207 ++++++ .../MultipleSessionCollectionTest.java | 676 +++++++++++++++++ .../MultipleSessionCollectionWarningTest.java | 374 ++++++++++ .../NonInsertableColumnTest.java | 90 +++ .../test/collectionalias/ATable.java | 2 +- .../collectionalias/CollectionAliasTest.java | 65 ++ .../ReorderedMappingsCollectionAliasTest.java | 67 ++ .../test/collectionalias/TableA.java | 2 +- .../test/collectionalias/TableB.java | 2 +- .../test/collectionalias/TableBId.java | 2 +- .../collection/bag/BagDuplicatesTest.java | 230 ------ .../bag/BagElementNullBasicTest.java | 203 ----- .../collection/bag/PersistentBagTest.java | 112 --- .../collection/idbag/PersistentIdBagTest.java | 71 -- ...ListIndexReferenceFromListElementTest.java | 139 ---- .../collection/list/PersistentListTest.java | 202 ----- .../MultipleSessionCollectionTest.java | 694 ------------------ .../MultipleSessionCollectionWarningTest.java | 328 --------- .../NonInsertableColumnTest.java | 108 --- .../collectionalias/CollectionAliasTest.java | 61 -- .../ReorderedMappingsCollectionAliasTest.java | 28 - .../orm/junit/DialectFeatureChecks.java | 7 +- 40 files changed, 2325 insertions(+), 2325 deletions(-) create mode 100644 hibernate-core/src/test/java/org/hibernate/orm/test/collection/bag/BagDuplicatesTest.java create mode 100644 hibernate-core/src/test/java/org/hibernate/orm/test/collection/bag/BagElementNullBasicTest.java rename hibernate-core/src/test/java/org/hibernate/{ => orm}/test/collection/bag/BagOwner.java (95%) rename hibernate-core/src/test/java/org/hibernate/{ => orm}/test/collection/bag/Item.java (93%) rename hibernate-core/src/test/java/org/hibernate/{ => orm}/test/collection/bag/Mappings.hbm.xml (94%) rename hibernate-core/src/test/java/org/hibernate/{ => orm}/test/collection/bag/Order.java (87%) rename hibernate-core/src/test/java/org/hibernate/{ => orm}/test/collection/bag/PersistentBagContainsTest.java (73%) create mode 100644 hibernate-core/src/test/java/org/hibernate/orm/test/collection/bag/PersistentBagTest.java rename hibernate-core/src/test/java/org/hibernate/{ => orm}/test/collection/idbag/IdBagElementNullBasicTest.java (58%) rename hibernate-core/src/test/java/org/hibernate/{ => orm}/test/collection/idbag/IdbagOwner.java (93%) rename hibernate-core/src/test/java/org/hibernate/{ => orm}/test/collection/idbag/Mappings.hbm.xml (92%) create mode 100644 hibernate-core/src/test/java/org/hibernate/orm/test/collection/idbag/PersistentIdBagTest.java rename hibernate-core/src/test/java/org/hibernate/{ => orm}/test/collection/list/LineItem.java (95%) rename hibernate-core/src/test/java/org/hibernate/{ => orm}/test/collection/list/ListElementNullBasicTest.java (56%) create mode 100644 hibernate-core/src/test/java/org/hibernate/orm/test/collection/list/ListIndexReferenceFromListElementTest.java rename hibernate-core/src/test/java/org/hibernate/{ => orm}/test/collection/list/ListOwner.java (94%) rename hibernate-core/src/test/java/org/hibernate/{ => orm}/test/collection/list/Mappings.hbm.xml (95%) rename hibernate-core/src/test/java/org/hibernate/{ => orm}/test/collection/list/Order.java (90%) create mode 100644 hibernate-core/src/test/java/org/hibernate/orm/test/collection/list/PersistentListTest.java create mode 100644 hibernate-core/src/test/java/org/hibernate/orm/test/collection/multisession/MultipleSessionCollectionTest.java create mode 100644 hibernate-core/src/test/java/org/hibernate/orm/test/collection/multisession/MultipleSessionCollectionWarningTest.java create mode 100644 hibernate-core/src/test/java/org/hibernate/orm/test/collection/nonInsertable/NonInsertableColumnTest.java rename hibernate-core/src/test/java/org/hibernate/{ => orm}/test/collectionalias/ATable.java (92%) create mode 100644 hibernate-core/src/test/java/org/hibernate/orm/test/collectionalias/CollectionAliasTest.java create mode 100644 hibernate-core/src/test/java/org/hibernate/orm/test/collectionalias/ReorderedMappingsCollectionAliasTest.java rename hibernate-core/src/test/java/org/hibernate/{ => orm}/test/collectionalias/TableA.java (91%) rename hibernate-core/src/test/java/org/hibernate/{ => orm}/test/collectionalias/TableB.java (94%) rename hibernate-core/src/test/java/org/hibernate/{ => orm}/test/collectionalias/TableBId.java (93%) delete mode 100644 hibernate-core/src/test/java/org/hibernate/test/collection/bag/BagDuplicatesTest.java delete mode 100644 hibernate-core/src/test/java/org/hibernate/test/collection/bag/BagElementNullBasicTest.java delete mode 100644 hibernate-core/src/test/java/org/hibernate/test/collection/bag/PersistentBagTest.java delete mode 100644 hibernate-core/src/test/java/org/hibernate/test/collection/idbag/PersistentIdBagTest.java delete mode 100644 hibernate-core/src/test/java/org/hibernate/test/collection/list/ListIndexReferenceFromListElementTest.java delete mode 100644 hibernate-core/src/test/java/org/hibernate/test/collection/list/PersistentListTest.java delete mode 100644 hibernate-core/src/test/java/org/hibernate/test/collection/multisession/MultipleSessionCollectionTest.java delete mode 100644 hibernate-core/src/test/java/org/hibernate/test/collection/multisession/MultipleSessionCollectionWarningTest.java delete mode 100644 hibernate-core/src/test/java/org/hibernate/test/collection/nonInsertable/NonInsertableColumnTest.java delete mode 100644 hibernate-core/src/test/java/org/hibernate/test/collectionalias/CollectionAliasTest.java delete mode 100644 hibernate-core/src/test/java/org/hibernate/test/collectionalias/ReorderedMappingsCollectionAliasTest.java diff --git a/hibernate-core/src/test/java/org/hibernate/orm/test/collection/bag/BagDuplicatesTest.java b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/bag/BagDuplicatesTest.java new file mode 100644 index 0000000000..c0c9829f1d --- /dev/null +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/bag/BagDuplicatesTest.java @@ -0,0 +1,169 @@ +/* + * Copyright 2014 JBoss Inc + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.hibernate.orm.test.collection.bag; + +import java.util.ArrayList; +import java.util.List; +import javax.persistence.CascadeType; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.ManyToOne; +import javax.persistence.OneToMany; + +import org.hibernate.testing.orm.junit.DomainModel; +import org.hibernate.testing.orm.junit.SessionFactory; +import org.hibernate.testing.orm.junit.SessionFactoryScope; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + + +/** + * This template demonstrates how to develop a test case for Hibernate ORM, using its built-in unit test framework. + * Although ORMStandaloneTestCase is perfectly acceptable as a reproducer, usage of this class is much preferred. + * Since we nearly always include a regression test with bug fixes, providing your reproducer using this method + * simplifies the process. + *

+ * What's even better? Fork hibernate-orm itself, add your test case directly to a module's unit tests, then + * submit it as a PR! + */ +@DomainModel( + annotatedClasses = { + BagDuplicatesTest.Parent.class, + BagDuplicatesTest.Child.class + } +) +@SessionFactory +public class BagDuplicatesTest { + + @Test + public void HHH10385Test(SessionFactoryScope scope) { + + Long parentId = scope.fromTransaction( + session -> { + Parent parent = new Parent(); + session.persist( parent ); + session.flush(); + return parent.getId(); + } + ); + + + scope.inTransaction( + session -> { + Parent parent = session.get( Parent.class, parentId ); + Child child1 = new Child(); + child1.setName( "child1" ); + child1.setParent( parent ); + parent.addChild( child1 ); + parent = (Parent) session.merge( parent ); + session.flush(); + } + ); + + + scope.inTransaction( + session -> { + + Parent parent = session.get( Parent.class, parentId ); + assertEquals( 1, parent.getChildren().size() ); + } + ); + } + + @Entity(name = "Parent") + public static class Parent { + + @Id + @GeneratedValue(strategy = GenerationType.AUTO) + private Long id; + + @OneToMany(cascade = CascadeType.ALL, mappedBy = "parent", orphanRemoval = true) + private List children = new ArrayList<>(); + + public Parent() { + } + + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public List getChildren() { + return children; + } + + public void addChild(Child child) { + children.add( child ); + child.setParent( this ); + } + + public void removeChild(Child child) { + children.remove( child ); + child.setParent( null ); + } + } + + @Entity(name = "Child") + public static class Child { + + @Id + @GeneratedValue(strategy = GenerationType.AUTO) + private Long id; + + private String name; + + @ManyToOne + private Parent parent; + + public Child() { + } + + public Long getId() { + return id; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public Parent getParent() { + return parent; + } + + public void setParent(Parent parent) { + this.parent = parent; + } + + @Override + public String toString() { + return "Child{" + + "id=" + id + + ", name='" + name + '\'' + + '}'; + } + } + +} diff --git a/hibernate-core/src/test/java/org/hibernate/orm/test/collection/bag/BagElementNullBasicTest.java b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/bag/BagElementNullBasicTest.java new file mode 100644 index 0000000000..4785abfd91 --- /dev/null +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/bag/BagElementNullBasicTest.java @@ -0,0 +1,199 @@ +/* + * 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 . + */ +package org.hibernate.orm.test.collection.bag; + +import java.util.ArrayList; +import java.util.List; +import javax.persistence.CollectionTable; +import javax.persistence.Column; +import javax.persistence.ElementCollection; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.Id; +import javax.persistence.JoinColumn; +import javax.persistence.OrderBy; +import javax.persistence.Table; + +import org.hibernate.testing.TestForIssue; +import org.hibernate.testing.orm.junit.DomainModel; +import org.hibernate.testing.orm.junit.SessionFactory; +import org.hibernate.testing.orm.junit.SessionFactoryScope; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + + +/** + * @author Gail Badner + */ +@DomainModel(annotatedClasses = { + BagElementNullBasicTest.AnEntity.class, + BagElementNullBasicTest.NullableElementsEntity.class +}) +@SessionFactory +public class BagElementNullBasicTest { + + @Test + public void testPersistNullValue(SessionFactoryScope scope) { + int entityId = scope.fromTransaction( + session -> { + AnEntity e = new AnEntity(); + e.aCollection.add( null ); + session.persist( e ); + return e.id; + } + ); + + scope.inTransaction( + session -> { + AnEntity e = session.get( AnEntity.class, entityId ); + assertEquals( 0, e.aCollection.size() ); + assertEquals( 0, getCollectionElementRows( entityId, scope ).size() ); + session.delete( e ); + } + ); + } + + @Test + public void addNullValue(SessionFactoryScope scope) { + int entityId = scope.fromTransaction( + session -> { + AnEntity e = new AnEntity(); + session.persist( e ); + return e.id; + } + ); + + scope.inTransaction( + session -> { + AnEntity e = session.get( AnEntity.class, entityId ); + assertEquals( 0, e.aCollection.size() ); + assertEquals( 0, getCollectionElementRows( entityId, scope ).size() ); + e.aCollection.add( null ); + } + ); + + scope.inTransaction( + session -> { + AnEntity e = session.get( AnEntity.class, entityId ); + assertEquals( 0, e.aCollection.size() ); + assertEquals( 0, getCollectionElementRows( entityId, scope ).size() ); + session.delete( e ); + } + ); + } + + @Test + @TestForIssue(jiraKey = "HHH-13651") + public void addNullValueToNullableCollections(SessionFactoryScope scope) { + scope.inTransaction( + session -> { + NullableElementsEntity e = new NullableElementsEntity(); + e.list.add( null ); + session.persist( e ); + session.flush(); + } + ); + } + + @Test + public void testUpdateNonNullValueToNull(SessionFactoryScope scope) { + int entityId = scope.fromTransaction( + session -> { + AnEntity e = new AnEntity(); + e.aCollection.add( "def" ); + session.persist( e ); + return e.id; + } + ); + + scope.inTransaction( + session -> { + AnEntity e = session.get( AnEntity.class, entityId ); + assertEquals( 1, e.aCollection.size() ); + assertEquals( 1, getCollectionElementRows( entityId, scope ).size() ); + e.aCollection.set( 0, null ); + } + ); + + scope.inTransaction( + session -> { + AnEntity e = session.get( AnEntity.class, entityId ); + assertEquals( 0, e.aCollection.size() ); + assertEquals( 0, getCollectionElementRows( entityId, scope ).size() ); + session.delete( e ); + } + ); + } + + @Test + public void testUpdateNonNullValueToNullWithExtraValue(SessionFactoryScope scope) { + int entityId = scope.fromTransaction( + session -> { + AnEntity e = new AnEntity(); + e.aCollection.add( "def" ); + e.aCollection.add( "ghi" ); + session.persist( e ); + return e.id; + } + ); + + scope.inTransaction( + session -> { + AnEntity e = session.get( AnEntity.class, entityId ); + assertEquals( 2, e.aCollection.size() ); + assertEquals( 2, getCollectionElementRows( e.id, scope ).size() ); + e.aCollection.set( 0, null ); + } + ); + + scope.inTransaction( + session -> { + AnEntity e = session.get( AnEntity.class, entityId ); + assertEquals( 1, e.aCollection.size() ); + assertEquals( 1, getCollectionElementRows( e.id, scope ).size() ); + assertEquals( "ghi", e.aCollection.get( 0 ) ); + session.delete( e ); + } + ); + } + + private List getCollectionElementRows(int id, SessionFactoryScope scope) { + return scope.fromTransaction( + session -> + session.createNativeQuery( + "SELECT aCollection FROM AnEntity_aCollection where AnEntity_id = " + id + ).list() + ); + } + + @Entity + @Table(name = "AnEntity") + public static class AnEntity { + @Id + @GeneratedValue + private int id; + + @ElementCollection + @CollectionTable(name = "AnEntity_aCollection", joinColumns = { @JoinColumn(name = "AnEntity_id") }) + @OrderBy + private List aCollection = new ArrayList<>(); + } + + @Entity + @Table(name = "NullableElementsEntity") + public static class NullableElementsEntity { + @Id + @GeneratedValue + private int id; + + @ElementCollection + @CollectionTable(name = "e_2_string", joinColumns = @JoinColumn(name = "e_id")) + @Column(name = "string_value", unique = false, nullable = true, insertable = true, updatable = true) + private List list = new ArrayList<>(); + } +} diff --git a/hibernate-core/src/test/java/org/hibernate/test/collection/bag/BagOwner.java b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/bag/BagOwner.java similarity index 95% rename from hibernate-core/src/test/java/org/hibernate/test/collection/bag/BagOwner.java rename to hibernate-core/src/test/java/org/hibernate/orm/test/collection/bag/BagOwner.java index 0686f1645c..ca7a776bf4 100644 --- a/hibernate-core/src/test/java/org/hibernate/test/collection/bag/BagOwner.java +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/bag/BagOwner.java @@ -4,7 +4,7 @@ * License: GNU Lesser General Public License (LGPL), version 2.1 or later. * See the lgpl.txt file in the root directory or . */ -package org.hibernate.test.collection.bag; +package org.hibernate.orm.test.collection.bag; import java.util.ArrayList; import java.util.List; diff --git a/hibernate-core/src/test/java/org/hibernate/test/collection/bag/Item.java b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/bag/Item.java similarity index 93% rename from hibernate-core/src/test/java/org/hibernate/test/collection/bag/Item.java rename to hibernate-core/src/test/java/org/hibernate/orm/test/collection/bag/Item.java index 3429c588aa..1124390d31 100644 --- a/hibernate-core/src/test/java/org/hibernate/test/collection/bag/Item.java +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/bag/Item.java @@ -4,7 +4,7 @@ * License: GNU Lesser General Public License (LGPL), version 2.1 or later. * See the lgpl.txt file in the root directory or . */ -package org.hibernate.test.collection.bag; +package org.hibernate.orm.test.collection.bag; /** * @author Gail Badner diff --git a/hibernate-core/src/test/java/org/hibernate/test/collection/bag/Mappings.hbm.xml b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/bag/Mappings.hbm.xml similarity index 94% rename from hibernate-core/src/test/java/org/hibernate/test/collection/bag/Mappings.hbm.xml rename to hibernate-core/src/test/java/org/hibernate/orm/test/collection/bag/Mappings.hbm.xml index 134f3018fe..8dcfd99cec 100644 --- a/hibernate-core/src/test/java/org/hibernate/test/collection/bag/Mappings.hbm.xml +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/bag/Mappings.hbm.xml @@ -10,7 +10,7 @@ "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> - + diff --git a/hibernate-core/src/test/java/org/hibernate/test/collection/bag/Order.java b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/bag/Order.java similarity index 87% rename from hibernate-core/src/test/java/org/hibernate/test/collection/bag/Order.java rename to hibernate-core/src/test/java/org/hibernate/orm/test/collection/bag/Order.java index 116390a927..ec92c141ee 100644 --- a/hibernate-core/src/test/java/org/hibernate/test/collection/bag/Order.java +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/bag/Order.java @@ -4,7 +4,7 @@ * License: GNU Lesser General Public License (LGPL), version 2.1 or later. * See the lgpl.txt file in the root directory or . */ -package org.hibernate.test.collection.bag; +package org.hibernate.orm.test.collection.bag; import java.util.ArrayList; import java.util.List; @@ -15,7 +15,7 @@ import java.util.List; public class Order { private Long id; - private List items = new ArrayList(); + private List items = new ArrayList<>(); public Order() { } diff --git a/hibernate-core/src/test/java/org/hibernate/test/collection/bag/PersistentBagContainsTest.java b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/bag/PersistentBagContainsTest.java similarity index 73% rename from hibernate-core/src/test/java/org/hibernate/test/collection/bag/PersistentBagContainsTest.java rename to hibernate-core/src/test/java/org/hibernate/orm/test/collection/bag/PersistentBagContainsTest.java index e738f8584c..2c53b01c2f 100644 --- a/hibernate-core/src/test/java/org/hibernate/test/collection/bag/PersistentBagContainsTest.java +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/bag/PersistentBagContainsTest.java @@ -4,7 +4,7 @@ * License: GNU Lesser General Public License (LGPL), version 2.1 or later. * See the lgpl.txt file in the root directory or . */ -package org.hibernate.test.collection.bag; +package org.hibernate.orm.test.collection.bag; import java.util.ArrayList; import java.util.List; @@ -17,26 +17,26 @@ import javax.persistence.ManyToOne; import javax.persistence.OneToMany; 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.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.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; /** * Tests related to contains operations on a PersistentBag. * * @author Vlad Mihalcea */ -public class PersistentBagContainsTest extends BaseCoreFunctionalTestCase { - - @Override - protected Class[] getAnnotatedClasses() { - return new Class[] { - Order.class, - Item.class - }; - } +@DomainModel( + annotatedClasses = { + PersistentBagContainsTest.Order.class, + PersistentBagContainsTest.Item.class + } +) +@SessionFactory +public class PersistentBagContainsTest { /** * This test does not verify how equals is implemented for Bags, @@ -44,9 +44,9 @@ public class PersistentBagContainsTest extends BaseCoreFunctionalTestCase { * managed and detached entities. */ @Test - @TestForIssue( jiraKey = "HHH-5409") - public void testContains() { - Order _order = doInHibernate( this::sessionFactory, session -> { + @TestForIssue(jiraKey = "HHH-5409") + public void testContains(SessionFactoryScope scope) { + Order _order = scope.fromTransaction( session -> { Order order = new Order(); session.persist( order ); @@ -60,23 +60,23 @@ public class PersistentBagContainsTest extends BaseCoreFunctionalTestCase { return order; } ); - doInHibernate( this::sessionFactory, session -> { + scope.inTransaction( session -> { Item item1 = new Item(); item1.setName( "i1" ); Item item2 = new Item(); item2.setName( "i2" ); - assertTrue(_order.getItems().contains( item1 )); - assertTrue(_order.getItems().contains( item2 )); + assertTrue( _order.getItems().contains( item1 ) ); + assertTrue( _order.getItems().contains( item2 ) ); Order order = session.find( Order.class, _order.getId() ); - assertTrue(order.getItems().contains( item1 )); - assertTrue(order.getItems().contains( item2 )); + assertTrue( order.getItems().contains( item1 ) ); + assertTrue( order.getItems().contains( item2 ) ); } ); - doInHibernate( this::sessionFactory, session -> { + scope.inTransaction( session -> { Order order = session.find( Order.class, _order.getId() ); session.delete( order ); } ); @@ -90,7 +90,7 @@ public class PersistentBagContainsTest extends BaseCoreFunctionalTestCase { private Long id; @OneToMany(mappedBy = "order", cascade = CascadeType.ALL, orphanRemoval = true) - private List items = new ArrayList(); + private List items = new ArrayList<>(); public Long getId() { return id; diff --git a/hibernate-core/src/test/java/org/hibernate/orm/test/collection/bag/PersistentBagTest.java b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/bag/PersistentBagTest.java new file mode 100644 index 0000000000..580fb3deac --- /dev/null +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/bag/PersistentBagTest.java @@ -0,0 +1,116 @@ +/* + * 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 . + */ +package org.hibernate.orm.test.collection.bag; + +import java.util.ArrayList; + +import org.hibernate.collection.internal.PersistentBag; +import org.hibernate.dialect.AbstractHANADialect; + +import org.hibernate.testing.orm.junit.DialectFeatureChecks; +import org.hibernate.testing.orm.junit.DomainModel; +import org.hibernate.testing.orm.junit.RequiresDialectFeature; +import org.hibernate.testing.orm.junit.SessionFactory; +import org.hibernate.testing.orm.junit.SessionFactoryScope; +import org.hibernate.testing.orm.junit.SkipForDialect; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * Tests related to operations on a PersistentBag. + * + * @author Steve Ebersole + */ +@RequiresDialectFeature(feature = DialectFeatureChecks.SupportsNoColumnInsert.class) +@DomainModel( + xmlMappings = "org/hibernate/orm/test/collection/bag/Mappings.hbm.xml" +) +@SessionFactory +public class PersistentBagTest { + + @Test + public void testWriteMethodDirtying(SessionFactoryScope scope) { + BagOwner parent = new BagOwner( "root" ); + BagOwner child = new BagOwner( "c1" ); + parent.getChildren().add( child ); + child.setParent( parent ); + BagOwner otherChild = new BagOwner( "c2" ); + + scope.inTransaction( + session -> { + session.save( parent ); + session.flush(); + // at this point, the list on parent has now been replaced with a PersistentBag... + PersistentBag children = (PersistentBag) parent.getChildren(); + + assertFalse( children.remove( otherChild ) ); + assertFalse( children.isDirty() ); + + ArrayList otherCollection = new ArrayList(); + otherCollection.add( child ); + assertFalse( children.retainAll( otherCollection ) ); + assertFalse( children.isDirty() ); + + otherCollection = new ArrayList(); + otherCollection.add( otherChild ); + assertFalse( children.removeAll( otherCollection ) ); + assertFalse( children.isDirty() ); + + children.clear(); + session.delete( child ); + assertTrue( children.isDirty() ); + + session.flush(); + + children.clear(); + assertFalse( children.isDirty() ); + + session.delete( parent ); + } + ); + } + + @Test + @SkipForDialect(dialectClass = AbstractHANADialect.class, reason = " HANA doesn't support tables consisting of only a single auto-generated column") + public void testMergePersistentEntityWithNewOneToManyElements(SessionFactoryScope scope) { + + Long orderId = scope.fromTransaction( + session -> { + Order order = new Order(); + + session.persist( order ); + session.flush(); + return order.getId(); + } + ); + + + scope.inTransaction( + session -> { + Order order = session.get( Order.class, orderId ); + Item item1 = new Item(); + item1.setName( "i1" ); + Item item2 = new Item(); + item2.setName( "i2" ); + order.addItem( item1 ); + order.addItem( item2 ); + order = (Order) session.merge( order ); + } + ); + + scope.inTransaction( + session -> { + Order order = session.get( Order.class, orderId ); + assertEquals( 2, order.getItems().size() ); + session.delete( order ); + } + ); + } +} diff --git a/hibernate-core/src/test/java/org/hibernate/test/collection/idbag/IdBagElementNullBasicTest.java b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/idbag/IdBagElementNullBasicTest.java similarity index 58% rename from hibernate-core/src/test/java/org/hibernate/test/collection/idbag/IdBagElementNullBasicTest.java rename to hibernate-core/src/test/java/org/hibernate/orm/test/collection/idbag/IdBagElementNullBasicTest.java index 87a6f6f9dc..5eca62f1c9 100644 --- a/hibernate-core/src/test/java/org/hibernate/test/collection/idbag/IdBagElementNullBasicTest.java +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/idbag/IdBagElementNullBasicTest.java @@ -4,7 +4,7 @@ * License: GNU Lesser General Public License (LGPL), version 2.1 or later. * See the lgpl.txt file in the root directory or . */ -package org.hibernate.test.collection.idbag; +package org.hibernate.orm.test.collection.idbag; import java.util.ArrayList; import java.util.List; @@ -21,28 +21,26 @@ import org.hibernate.annotations.CollectionId; import org.hibernate.annotations.GenericGenerator; import org.hibernate.annotations.Type; -import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase; -import org.junit.Test; +import org.hibernate.testing.orm.junit.DomainModel; +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.jupiter.api.Assertions.assertEquals; /** * @author Gail Badner */ -public class IdBagElementNullBasicTest extends BaseCoreFunctionalTestCase { - - @Override - protected Class[] getAnnotatedClasses() { - return new Class[] { - AnEntity.class - }; - } +@DomainModel( + annotatedClasses = IdBagElementNullBasicTest.AnEntity.class +) +@SessionFactory +public class IdBagElementNullBasicTest { @Test - public void testPersistNullValue() { - int entityId = doInHibernate( - this::sessionFactory, session -> { + public void testPersistNullValue(SessionFactoryScope scope) { + int entityId = scope.fromTransaction( + session -> { AnEntity e = new AnEntity(); e.aCollection.add( null ); session.persist( e ); @@ -50,49 +48,49 @@ public class IdBagElementNullBasicTest extends BaseCoreFunctionalTestCase { } ); - doInHibernate( - this::sessionFactory, session -> { + scope.inTransaction( + session -> { AnEntity e = session.get( AnEntity.class, entityId ); assertEquals( 0, e.aCollection.size() ); - assertEquals( 0, getCollectionElementRows( entityId ).size() ); + assertEquals( 0, getCollectionElementRows( entityId, scope ).size() ); session.delete( e ); } ); } @Test - public void addNullValue() { - int entityId = doInHibernate( - this::sessionFactory, session -> { + public void addNullValue(SessionFactoryScope scope) { + int entityId = scope.fromTransaction( + session -> { AnEntity e = new AnEntity(); session.persist( e ); return e.id; } ); - doInHibernate( - this::sessionFactory, session -> { + scope.inTransaction( + session -> { AnEntity e = session.get( AnEntity.class, entityId ); assertEquals( 0, e.aCollection.size() ); - assertEquals( 0, getCollectionElementRows( entityId ).size() ); + assertEquals( 0, getCollectionElementRows( entityId, scope ).size() ); e.aCollection.add( null ); } ); - doInHibernate( - this::sessionFactory, session -> { + scope.inTransaction( + session -> { AnEntity e = session.get( AnEntity.class, entityId ); assertEquals( 0, e.aCollection.size() ); - assertEquals( 0, getCollectionElementRows( entityId ).size() ); + assertEquals( 0, getCollectionElementRows( entityId, scope ).size() ); session.delete( e ); } ); } @Test - public void testUpdateNonNullValueToNull() { - int entityId = doInHibernate( - this::sessionFactory, session -> { + public void testUpdateNonNullValueToNull(SessionFactoryScope scope) { + int entityId = scope.fromTransaction( + session -> { AnEntity e = new AnEntity(); e.aCollection.add( "def" ); session.persist( e ); @@ -100,29 +98,29 @@ public class IdBagElementNullBasicTest extends BaseCoreFunctionalTestCase { } ); - doInHibernate( - this::sessionFactory, session -> { + scope.inTransaction( + session -> { AnEntity e = session.get( AnEntity.class, entityId ); assertEquals( 1, e.aCollection.size() ); - assertEquals( 1, getCollectionElementRows( entityId ).size() ); + assertEquals( 1, getCollectionElementRows( entityId, scope ).size() ); e.aCollection.set( 0, null ); } ); - doInHibernate( - this::sessionFactory, session -> { + scope.inTransaction( + session -> { AnEntity e = session.get( AnEntity.class, entityId ); assertEquals( 0, e.aCollection.size() ); - assertEquals( 0, getCollectionElementRows( entityId ).size() ); + assertEquals( 0, getCollectionElementRows( entityId, scope ).size() ); session.delete( e ); } ); } @Test - public void testUpdateNonNullValueToNullWithExtraValue() { - int entityId = doInHibernate( - this::sessionFactory, session -> { + public void testUpdateNonNullValueToNullWithExtraValue(SessionFactoryScope scope) { + int entityId = scope.fromTransaction( + session -> { AnEntity e = new AnEntity(); e.aCollection.add( "def" ); e.aCollection.add( "ghi" ); @@ -131,11 +129,11 @@ public class IdBagElementNullBasicTest extends BaseCoreFunctionalTestCase { } ); - doInHibernate( - this::sessionFactory, session -> { + scope.inTransaction( + session -> { AnEntity e = session.get( AnEntity.class, entityId ); assertEquals( 2, e.aCollection.size() ); - assertEquals( 2, getCollectionElementRows( e.id ).size() ); + assertEquals( 2, getCollectionElementRows( e.id, scope ).size() ); if ( "def".equals( e.aCollection.get( 0 ) ) ) { e.aCollection.set( 0, null ); } @@ -145,20 +143,20 @@ public class IdBagElementNullBasicTest extends BaseCoreFunctionalTestCase { } ); - doInHibernate( - this::sessionFactory, session -> { + scope.inTransaction( + session -> { AnEntity e = session.get( AnEntity.class, entityId ); assertEquals( 1, e.aCollection.size() ); - assertEquals( 1, getCollectionElementRows( e.id ).size() ); + assertEquals( 1, getCollectionElementRows( e.id, scope ).size() ); assertEquals( "ghi", e.aCollection.get( 0 ) ); session.delete( e ); } ); } - private List getCollectionElementRows(int id) { - return doInHibernate( - this::sessionFactory, session -> { + private List getCollectionElementRows(int id, SessionFactoryScope scope) { + return scope.fromTransaction( + session -> { return session.createNativeQuery( "SELECT aCollection FROM AnEntity_aCollection where AnEntity_id = " + id ).list(); @@ -167,20 +165,20 @@ public class IdBagElementNullBasicTest extends BaseCoreFunctionalTestCase { } @Entity - @Table(name="AnEntity") - @GenericGenerator(name="increment", strategy = "increment") + @Table(name = "AnEntity") + @GenericGenerator(name = "increment", strategy = "increment") public static class AnEntity { @Id @GeneratedValue private int id; @ElementCollection - @CollectionTable(name = "AnEntity_aCollection", joinColumns = { @JoinColumn( name = "AnEntity_id" ) }) + @CollectionTable(name = "AnEntity_aCollection", joinColumns = { @JoinColumn(name = "AnEntity_id") }) @CollectionId( columns = { @Column }, type = @Type(type = "long"), generator = "increment" ) - private List aCollection = new ArrayList(); + private List aCollection = new ArrayList<>(); } } diff --git a/hibernate-core/src/test/java/org/hibernate/test/collection/idbag/IdbagOwner.java b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/idbag/IdbagOwner.java similarity index 93% rename from hibernate-core/src/test/java/org/hibernate/test/collection/idbag/IdbagOwner.java rename to hibernate-core/src/test/java/org/hibernate/orm/test/collection/idbag/IdbagOwner.java index 142cde9277..b03e84013c 100644 --- a/hibernate-core/src/test/java/org/hibernate/test/collection/idbag/IdbagOwner.java +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/idbag/IdbagOwner.java @@ -4,7 +4,7 @@ * License: GNU Lesser General Public License (LGPL), version 2.1 or later. * See the lgpl.txt file in the root directory or . */ -package org.hibernate.test.collection.idbag; +package org.hibernate.orm.test.collection.idbag; import java.util.ArrayList; import java.util.List; diff --git a/hibernate-core/src/test/java/org/hibernate/test/collection/idbag/Mappings.hbm.xml b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/idbag/Mappings.hbm.xml similarity index 92% rename from hibernate-core/src/test/java/org/hibernate/test/collection/idbag/Mappings.hbm.xml rename to hibernate-core/src/test/java/org/hibernate/orm/test/collection/idbag/Mappings.hbm.xml index 3b44924fa3..f797f60e69 100644 --- a/hibernate-core/src/test/java/org/hibernate/test/collection/idbag/Mappings.hbm.xml +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/idbag/Mappings.hbm.xml @@ -10,7 +10,7 @@ "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> - + diff --git a/hibernate-core/src/test/java/org/hibernate/orm/test/collection/idbag/PersistentIdBagTest.java b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/idbag/PersistentIdBagTest.java new file mode 100644 index 0000000000..9c57fb32c5 --- /dev/null +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/idbag/PersistentIdBagTest.java @@ -0,0 +1,73 @@ +/* + * 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 . + */ +package org.hibernate.orm.test.collection.idbag; + +import java.util.ArrayList; + +import org.hibernate.collection.internal.PersistentIdentifierBag; + +import org.hibernate.testing.orm.junit.DomainModel; +import org.hibernate.testing.orm.junit.SessionFactory; +import org.hibernate.testing.orm.junit.SessionFactoryScope; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + + +/** + * Tests related to operations on a PersistentIdentifierBag + * + * @author Steve Ebersole + */ +@DomainModel( + xmlMappings = "org/hibernate/orm/test/collection/idbag/Mappings.hbm.xml" +) +@SessionFactory +public class PersistentIdBagTest { + + @Test + public void testWriteMethodDirtying(SessionFactoryScope scope) { + IdbagOwner parent = new IdbagOwner( "root" ); + IdbagOwner child = new IdbagOwner( "c1" ); + parent.getChildren().add( child ); + IdbagOwner otherChild = new IdbagOwner( "c2" ); + + scope.inTransaction( + session -> { + session.save( parent ); + session.flush(); + // at this point, the list on parent has now been replaced with a PersistentBag... + PersistentIdentifierBag children = (PersistentIdentifierBag) parent.getChildren(); + + assertFalse( children.remove( otherChild ) ); + assertFalse( children.isDirty() ); + + ArrayList otherCollection = new ArrayList(); + otherCollection.add( child ); + assertFalse( children.retainAll( otherCollection ) ); + assertFalse( children.isDirty() ); + + otherCollection = new ArrayList(); + otherCollection.add( otherChild ); + assertFalse( children.removeAll( otherCollection ) ); + assertFalse( children.isDirty() ); + + children.clear(); + session.delete( child ); + assertTrue( children.isDirty() ); + + session.flush(); + + children.clear(); + assertFalse( children.isDirty() ); + + session.delete( parent ); + } + ); + } +} diff --git a/hibernate-core/src/test/java/org/hibernate/test/collection/list/LineItem.java b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/list/LineItem.java similarity index 95% rename from hibernate-core/src/test/java/org/hibernate/test/collection/list/LineItem.java rename to hibernate-core/src/test/java/org/hibernate/orm/test/collection/list/LineItem.java index 2d58f97716..ba77597d04 100644 --- a/hibernate-core/src/test/java/org/hibernate/test/collection/list/LineItem.java +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/list/LineItem.java @@ -4,7 +4,7 @@ * License: GNU Lesser General Public License (LGPL), version 2.1 or later. * See the lgpl.txt file in the root directory or . */ -package org.hibernate.test.collection.list; +package org.hibernate.orm.test.collection.list; /** diff --git a/hibernate-core/src/test/java/org/hibernate/test/collection/list/ListElementNullBasicTest.java b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/list/ListElementNullBasicTest.java similarity index 56% rename from hibernate-core/src/test/java/org/hibernate/test/collection/list/ListElementNullBasicTest.java rename to hibernate-core/src/test/java/org/hibernate/orm/test/collection/list/ListElementNullBasicTest.java index 6d0199791f..5fd5c7f701 100644 --- a/hibernate-core/src/test/java/org/hibernate/test/collection/list/ListElementNullBasicTest.java +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/list/ListElementNullBasicTest.java @@ -4,7 +4,7 @@ * License: GNU Lesser General Public License (LGPL), version 2.1 or later. * See the lgpl.txt file in the root directory or . */ -package org.hibernate.test.collection.list; +package org.hibernate.orm.test.collection.list; import java.util.ArrayList; import java.util.List; @@ -17,28 +17,26 @@ import javax.persistence.JoinColumn; import javax.persistence.OrderColumn; import javax.persistence.Table; -import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase; -import org.junit.Test; +import org.hibernate.testing.orm.junit.DomainModel; +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.jupiter.api.Assertions.assertEquals; /** * @author Gail Badner */ -public class ListElementNullBasicTest extends BaseCoreFunctionalTestCase { - - @Override - protected Class[] getAnnotatedClasses() { - return new Class[] { - AnEntity.class - }; - } +@DomainModel( + annotatedClasses = ListElementNullBasicTest.AnEntity.class +) +@SessionFactory +public class ListElementNullBasicTest { @Test - public void testPersistNullValue() { - int entityId = doInHibernate( - this::sessionFactory, session -> { + public void testPersistNullValue(SessionFactoryScope scope) { + int entityId = scope.fromTransaction( + session -> { AnEntity e = new AnEntity(); e.aCollection.add( null ); session.persist( e ); @@ -46,49 +44,49 @@ public class ListElementNullBasicTest extends BaseCoreFunctionalTestCase { } ); - doInHibernate( - this::sessionFactory, session -> { + scope.inTransaction( + session -> { AnEntity e = session.get( AnEntity.class, entityId ); assertEquals( 0, e.aCollection.size() ); - assertEquals( 0, getCollectionElementRows( entityId ).size() ); + assertEquals( 0, getCollectionElementRows( entityId, scope ).size() ); session.delete( e ); } ); } @Test - public void addNullValue() { - int entityId = doInHibernate( - this::sessionFactory, session -> { + public void addNullValue(SessionFactoryScope scope) { + int entityId = scope.fromTransaction( + session -> { AnEntity e = new AnEntity(); session.persist( e ); return e.id; } ); - doInHibernate( - this::sessionFactory, session -> { + scope.inTransaction( + session -> { AnEntity e = session.get( AnEntity.class, entityId ); assertEquals( 0, e.aCollection.size() ); - assertEquals( 0, getCollectionElementRows( entityId ).size() ); + assertEquals( 0, getCollectionElementRows( entityId, scope ).size() ); e.aCollection.add( null ); } ); - doInHibernate( - this::sessionFactory, session -> { + scope.inTransaction( + session -> { AnEntity e = session.get( AnEntity.class, entityId ); assertEquals( 0, e.aCollection.size() ); - assertEquals( 0, getCollectionElementRows( entityId ).size() ); + assertEquals( 0, getCollectionElementRows( entityId, scope ).size() ); session.delete( e ); } ); } @Test - public void testUpdateNonNullValueToNull() { - int entityId = doInHibernate( - this::sessionFactory, session -> { + public void testUpdateNonNullValueToNull(SessionFactoryScope scope) { + int entityId = scope.fromTransaction( + session -> { AnEntity e = new AnEntity(); e.aCollection.add( "def" ); session.persist( e ); @@ -96,29 +94,29 @@ public class ListElementNullBasicTest extends BaseCoreFunctionalTestCase { } ); - doInHibernate( - this::sessionFactory, session -> { + scope.inTransaction( + session -> { AnEntity e = session.get( AnEntity.class, entityId ); assertEquals( 1, e.aCollection.size() ); - assertEquals( 1, getCollectionElementRows( entityId ).size() ); + assertEquals( 1, getCollectionElementRows( entityId, scope ).size() ); e.aCollection.set( 0, null ); } ); - doInHibernate( - this::sessionFactory, session -> { + scope.inTransaction( + session -> { AnEntity e = session.get( AnEntity.class, entityId ); assertEquals( 0, e.aCollection.size() ); - assertEquals( 0, getCollectionElementRows( entityId ).size() ); + assertEquals( 0, getCollectionElementRows( entityId, scope ).size() ); session.delete( e ); } ); } @Test - public void testUpdateNonNullValueToNullToNonNull() { - int entityId = doInHibernate( - this::sessionFactory, session -> { + public void testUpdateNonNullValueToNullToNonNull(SessionFactoryScope scope) { + int entityId = scope.fromTransaction( + session -> { AnEntity e = new AnEntity(); e.aCollection.add( "def" ); e.aCollection.add( "ghi" ); @@ -127,29 +125,29 @@ public class ListElementNullBasicTest extends BaseCoreFunctionalTestCase { } ); - doInHibernate( - this::sessionFactory, session -> { + scope.inTransaction( + session -> { AnEntity e = session.get( AnEntity.class, entityId ); assertEquals( 2, e.aCollection.size() ); - assertEquals( 2, getCollectionElementRows( e.id ).size() ); + assertEquals( 2, getCollectionElementRows( e.id, scope ).size() ); e.aCollection.set( 0, null ); } ); - doInHibernate( - this::sessionFactory, session -> { + scope.inTransaction( + session -> { AnEntity e = session.get( AnEntity.class, entityId ); assertEquals( 2, e.aCollection.size() ); - assertEquals( 1, getCollectionElementRows( e.id ).size() ); + assertEquals( 1, getCollectionElementRows( e.id, scope ).size() ); e.aCollection.set( 0, "not null" ); } ); - doInHibernate( - this::sessionFactory, session -> { + scope.inTransaction( + session -> { AnEntity e = session.get( AnEntity.class, entityId ); assertEquals( 2, e.aCollection.size() ); - assertEquals( 2, getCollectionElementRows( e.id ).size() ); + assertEquals( 2, getCollectionElementRows( e.id, scope ).size() ); assertEquals( "not null", e.aCollection.get( 0 ) ); assertEquals( "ghi", e.aCollection.get( 1 ) ); session.delete( e ); @@ -157,9 +155,9 @@ public class ListElementNullBasicTest extends BaseCoreFunctionalTestCase { ); } - private List getCollectionElementRows(int id) { - return doInHibernate( - this::sessionFactory, session -> { + private List getCollectionElementRows(int id, SessionFactoryScope scope) { + return scope.fromTransaction( + session -> { return session.createNativeQuery( "SELECT aCollection FROM AnEntity_aCollection where AnEntity_id = " + id ).list(); @@ -168,15 +166,15 @@ public class ListElementNullBasicTest extends BaseCoreFunctionalTestCase { } @Entity - @Table(name="AnEntity") + @Table(name = "AnEntity") public static class AnEntity { @Id @GeneratedValue private int id; @ElementCollection - @CollectionTable(name = "AnEntity_aCollection", joinColumns = { @JoinColumn( name = "AnEntity_id" ) }) + @CollectionTable(name = "AnEntity_aCollection", joinColumns = { @JoinColumn(name = "AnEntity_id") }) @OrderColumn - private List aCollection = new ArrayList(); + private List aCollection = new ArrayList<>(); } } diff --git a/hibernate-core/src/test/java/org/hibernate/orm/test/collection/list/ListIndexReferenceFromListElementTest.java b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/list/ListIndexReferenceFromListElementTest.java new file mode 100644 index 0000000000..9b9f070385 --- /dev/null +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/list/ListIndexReferenceFromListElementTest.java @@ -0,0 +1,139 @@ +/* + * 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 . + */ +package org.hibernate.orm.test.collection.list; + +import java.util.ArrayList; +import java.util.List; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.FetchType; +import javax.persistence.GeneratedValue; +import javax.persistence.Id; +import javax.persistence.JoinColumn; +import javax.persistence.ManyToOne; +import javax.persistence.OneToMany; +import javax.persistence.OrderColumn; +import javax.persistence.Table; + +import org.hibernate.testing.orm.junit.DomainModel; +import org.hibernate.testing.orm.junit.SessionFactory; +import org.hibernate.testing.orm.junit.SessionFactoryScope; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + + +/** + * Test initially developed for HHH-9195 + * + * @author Steve Ebersole + */ +@DomainModel( + annotatedClasses = { + ListIndexReferenceFromListElementTest.LocalOrder.class, + ListIndexReferenceFromListElementTest.LocalLineItem.class + } +) +@SessionFactory +public class ListIndexReferenceFromListElementTest { + + @BeforeEach + public void before(SessionFactoryScope scope) { + scope.inTransaction( + session -> { + LocalOrder localOrder = new LocalOrder(); + localOrder.makeLineItem( "Shoes" ); + localOrder.makeLineItem( "Socks" ); + session.save( localOrder ); + } + ); + } + + @AfterEach + public void after(SessionFactoryScope scope) { + scope.inTransaction( + session -> { + session.createQuery( "delete LocalLineItem" ).executeUpdate(); + session.createQuery( "delete LocalOrder" ).executeUpdate(); + } + ); + } + + @Test + public void testIt(SessionFactoryScope scope) { + scope.inTransaction( + session -> { + LocalOrder order = session.byId( LocalOrder.class ).load( 1 ); + assertEquals( 2, order.lineItems.size() ); + LocalLineItem shoes = order.lineItems.get( 0 ); + LocalLineItem socks = order.lineItems.get( 1 ); + assertEquals( "Shoes", shoes.name ); + assertEquals( 0, shoes.position ); + assertEquals( 1, socks.position ); + order.lineItems.remove( socks ); + order.lineItems.add( 0, socks ); + } + ); + + scope.inTransaction( + session -> { + LocalOrder order = session.byId( LocalOrder.class ).load( 1 ); + assertEquals( 2, order.lineItems.size() ); + LocalLineItem socks = order.lineItems.get( 0 ); + LocalLineItem shoes = order.lineItems.get( 1 ); + assertEquals( "Shoes", shoes.name ); + assertEquals( 0, socks.position ); + assertEquals( 1, shoes.position ); + } + ); + } + + @Entity(name = "LocalOrder") + @Table(name = "LocalOrder") + public static class LocalOrder { + @Id + @GeneratedValue + public Integer id; + @OneToMany(mappedBy = "order", cascade = CascadeType.ALL, fetch = FetchType.LAZY) + @OrderColumn(name = "position") + public List lineItems = new ArrayList<>(); + + public LocalOrder() { + } + + public LocalLineItem makeLineItem(String name) { + LocalLineItem lineItem = new LocalLineItem( name, this ); + lineItems.add( lineItem ); + return lineItem; + } + } + + @Entity(name = "LocalLineItem") + @Table(name = "LocalLineItem") + public static class LocalLineItem { + @Id + @GeneratedValue + public Integer id; + public String name; + @ManyToOne + @JoinColumn + public LocalOrder order; + @Column(insertable = false, updatable = false) + public int position; + + public LocalLineItem() { + } + + public LocalLineItem(String name, LocalOrder order) { + this.name = name; + this.order = order; + } + } +} diff --git a/hibernate-core/src/test/java/org/hibernate/test/collection/list/ListOwner.java b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/list/ListOwner.java similarity index 94% rename from hibernate-core/src/test/java/org/hibernate/test/collection/list/ListOwner.java rename to hibernate-core/src/test/java/org/hibernate/orm/test/collection/list/ListOwner.java index a0bf05aeba..a364d5fb6e 100644 --- a/hibernate-core/src/test/java/org/hibernate/test/collection/list/ListOwner.java +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/list/ListOwner.java @@ -4,7 +4,7 @@ * License: GNU Lesser General Public License (LGPL), version 2.1 or later. * See the lgpl.txt file in the root directory or . */ -package org.hibernate.test.collection.list; +package org.hibernate.orm.test.collection.list; import java.util.ArrayList; import java.util.List; diff --git a/hibernate-core/src/test/java/org/hibernate/test/collection/list/Mappings.hbm.xml b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/list/Mappings.hbm.xml similarity index 95% rename from hibernate-core/src/test/java/org/hibernate/test/collection/list/Mappings.hbm.xml rename to hibernate-core/src/test/java/org/hibernate/orm/test/collection/list/Mappings.hbm.xml index b0b9b6e6c1..8b831310f8 100644 --- a/hibernate-core/src/test/java/org/hibernate/test/collection/list/Mappings.hbm.xml +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/list/Mappings.hbm.xml @@ -10,7 +10,7 @@ "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> - + diff --git a/hibernate-core/src/test/java/org/hibernate/test/collection/list/Order.java b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/list/Order.java similarity index 90% rename from hibernate-core/src/test/java/org/hibernate/test/collection/list/Order.java rename to hibernate-core/src/test/java/org/hibernate/orm/test/collection/list/Order.java index 6615cd0321..1ca30f9a61 100644 --- a/hibernate-core/src/test/java/org/hibernate/test/collection/list/Order.java +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/list/Order.java @@ -4,7 +4,7 @@ * License: GNU Lesser General Public License (LGPL), version 2.1 or later. * See the lgpl.txt file in the root directory or . */ -package org.hibernate.test.collection.list; +package org.hibernate.orm.test.collection.list; import java.util.ArrayList; import java.util.List; @@ -15,7 +15,7 @@ import java.util.List; public class Order { private Integer id; private String code; - private List lineItems = new ArrayList(); + private List lineItems = new ArrayList<>(); public Order() { } diff --git a/hibernate-core/src/test/java/org/hibernate/orm/test/collection/list/PersistentListTest.java b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/list/PersistentListTest.java new file mode 100644 index 0000000000..3780b87185 --- /dev/null +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/list/PersistentListTest.java @@ -0,0 +1,207 @@ +/* + * 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 . + */ +package org.hibernate.orm.test.collection.list; + +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Map; + +import org.hibernate.collection.internal.PersistentList; +import org.hibernate.engine.spi.SessionFactoryImplementor; +import org.hibernate.engine.spi.SessionImplementor; +import org.hibernate.persister.collection.CollectionPersister; +import org.hibernate.persister.collection.QueryableCollection; +import org.hibernate.sql.SimpleSelect; + +import org.hibernate.testing.TestForIssue; +import org.hibernate.testing.orm.junit.DomainModel; +import org.hibernate.testing.orm.junit.SessionFactory; +import org.hibernate.testing.orm.junit.SessionFactoryScope; +import org.junit.jupiter.api.Test; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +/** + * Tests related to operations on a PersistentList + * + * @author Steve Ebersole + */ +@DomainModel( + xmlMappings = "org/hibernate/orm/test/collection/list/Mappings.hbm.xml" +) +@SessionFactory +public class PersistentListTest { + + @Test + @TestForIssue(jiraKey = "HHH-5732") + public void testInverseListIndex(SessionFactoryScope scope) { + // make sure no one changes the mapping + SessionFactoryImplementor sessionFactory = scope.getSessionFactory(); + final CollectionPersister collectionPersister = sessionFactory + .getCollectionPersister( ListOwner.class.getName() + ".children" ); + assertTrue( collectionPersister.isInverse() ); + + // do some creations... + ListOwner root = new ListOwner( "root" ); + scope.inTransaction( + session -> { + ListOwner child1 = new ListOwner( "c1" ); + root.getChildren().add( child1 ); + child1.setParent( root ); + ListOwner child2 = new ListOwner( "c2" ); + root.getChildren().add( child2 ); + child2.setParent( root ); + + session.save( root ); + } + ); + + + // now, make sure the list-index column gotten written... + scope.inTransaction( + session2 -> { + session2.doWork( + connection -> { + final QueryableCollection queryableCollection = (QueryableCollection) collectionPersister; + SimpleSelect select = new SimpleSelect( sessionFactory.getDialect() ) + .setTableName( queryableCollection.getTableName() ) + .addColumn( "NAME" ) + .addColumn( "LIST_INDEX" ) + .addCondition( "NAME", "<>", "?" ); + PreparedStatement preparedStatement = ( (SessionImplementor) session2 ).getJdbcCoordinator() + .getStatementPreparer() + .prepareStatement( select.toStatementString() ); + preparedStatement.setString( 1, "root" ); + ResultSet resultSet = ( (SessionImplementor) session2 ).getJdbcCoordinator() + .getResultSetReturn() + .extract( preparedStatement ); + Map valueMap = new HashMap(); + while ( resultSet.next() ) { + final String name = resultSet.getString( 1 ); + assertFalse( "NAME column was null", resultSet.wasNull() ); + final int position = resultSet.getInt( 2 ); + assertFalse( "LIST_INDEX column was null", resultSet.wasNull() ); + valueMap.put( name, position ); + } + assertEquals( 2, valueMap.size() ); + + // c1 should be list index 0 + assertEquals( Integer.valueOf( 0 ), valueMap.get( "c1" ) ); + // c2 should be list index 1 + assertEquals( Integer.valueOf( 1 ), valueMap.get( "c2" ) ); + } + ); + session2.delete( root ); + + } + ); + } + + @Test + @TestForIssue(jiraKey = "HHH-5732") + public void testInverseListIndex2(SessionFactoryScope scope) { + // make sure no one changes the mapping + SessionFactoryImplementor sessionFactory = scope.getSessionFactory(); + final CollectionPersister collectionPersister = sessionFactory + .getCollectionPersister( Order.class.getName() + ".lineItems" ); + assertTrue( collectionPersister.isInverse() ); + + // do some creations... + Order order = new Order( "acme-1" ); + scope.inTransaction( + session -> { + order.addLineItem( "abc", 2 ); + order.addLineItem( "def", 200 ); + order.addLineItem( "ghi", 13 ); + session.save( order ); + } + ); + + // now, make sure the list-index column gotten written... + scope.inTransaction( + session2 -> { + session2.doWork( + connection -> { + final QueryableCollection queryableCollection = (QueryableCollection) collectionPersister; + SimpleSelect select = new SimpleSelect( sessionFactory.getDialect() ) + .setTableName( queryableCollection.getTableName() ) + .addColumn( "ORDER_ID" ) + .addColumn( "INDX" ) + .addColumn( "PRD_CODE" ); + PreparedStatement preparedStatement = ( (SessionImplementor) session2 ).getJdbcCoordinator() + .getStatementPreparer() + .prepareStatement( select.toStatementString() ); + ResultSet resultSet = ( (SessionImplementor) session2 ).getJdbcCoordinator() + .getResultSetReturn() + .extract( preparedStatement ); + Map valueMap = new HashMap(); + while ( resultSet.next() ) { + final int fk = resultSet.getInt( 1 ); + assertFalse( "Collection key (FK) column was null", resultSet.wasNull() ); + final int indx = resultSet.getInt( 2 ); + assertFalse( "List index column was null", resultSet.wasNull() ); + final String prodCode = resultSet.getString( 3 ); + assertFalse( "Prod code column was null", resultSet.wasNull() ); + valueMap.put( prodCode, indx ); + } + assertEquals( 3, valueMap.size() ); + assertEquals( Integer.valueOf( 0 ), valueMap.get( "abc" ) ); + assertEquals( Integer.valueOf( 1 ), valueMap.get( "def" ) ); + assertEquals( Integer.valueOf( 2 ), valueMap.get( "ghi" ) ); + } + ); + session2.delete( order ); + } + ); + } + + @Test + public void testWriteMethodDirtying(SessionFactoryScope scope) { + ListOwner parent = new ListOwner( "root" ); + ListOwner child = new ListOwner( "c1" ); + parent.getChildren().add( child ); + child.setParent( parent ); + ListOwner otherChild = new ListOwner( "c2" ); + + scope.inTransaction( + session -> { + session.save( parent ); + session.flush(); + // at this point, the list on parent has now been replaced with a PersistentList... + PersistentList children = (PersistentList) parent.getChildren(); + + assertFalse( children.remove( otherChild ) ); + assertFalse( children.isDirty() ); + + ArrayList otherCollection = new ArrayList(); + otherCollection.add( child ); + assertFalse( children.retainAll( otherCollection ) ); + assertFalse( children.isDirty() ); + + otherCollection = new ArrayList(); + otherCollection.add( otherChild ); + assertFalse( children.removeAll( otherCollection ) ); + assertFalse( children.isDirty() ); + + children.clear(); + session.delete( child ); + assertTrue( children.isDirty() ); + + session.flush(); + + children.clear(); + assertFalse( children.isDirty() ); + + session.delete( parent ); + } + ); + } +} diff --git a/hibernate-core/src/test/java/org/hibernate/orm/test/collection/multisession/MultipleSessionCollectionTest.java b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/multisession/MultipleSessionCollectionTest.java new file mode 100644 index 0000000000..9e4da6131c --- /dev/null +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/multisession/MultipleSessionCollectionTest.java @@ -0,0 +1,676 @@ +/* + * Hibernate, Relational Persistence for Idiomatic Java + * + * Copyright (c) 2014, Red Hat Inc. or third-party contributors as + * indicated by the @author tags or express copyright attribution + * statements applied by the authors. All third-party contributions are + * distributed under license by Red Hat Inc. + * + * This copyrighted material is made available to anyone wishing to use, modify, + * copy, or redistribute it subject to the terms and conditions of the GNU + * Lesser General Public License, as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License + * for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this distribution; if not, write to: + * Free Software Foundation, Inc. + * 51 Franklin Street, Fifth Floor + * Boston, MA 02110-1301 USA + */ +package org.hibernate.orm.test.collection.multisession; + +import java.util.HashSet; +import java.util.Set; +import javax.persistence.CascadeType; +import javax.persistence.ElementCollection; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.Id; +import javax.persistence.JoinColumn; +import javax.persistence.OneToMany; +import javax.persistence.Table; + +import org.hibernate.Hibernate; +import org.hibernate.HibernateException; +import org.hibernate.collection.internal.AbstractPersistentCollection; +import org.hibernate.collection.spi.PersistentCollection; +import org.hibernate.engine.spi.CollectionEntry; + +import org.hibernate.testing.TestForIssue; +import org.hibernate.testing.orm.junit.DomainModel; +import org.hibernate.testing.orm.junit.SessionFactory; +import org.hibernate.testing.orm.junit.SessionFactoryScope; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.fail; + + +/** + * @author Gail Badner + */ +@DomainModel( + annotatedClasses = { + MultipleSessionCollectionTest.Parent.class, + MultipleSessionCollectionTest.Child.class + } +) +@SessionFactory +public class MultipleSessionCollectionTest { + + @Test + @TestForIssue(jiraKey = "HHH-9518") + public void testSaveOrUpdateOwnerWithCollectionInNewSessionBeforeFlush(SessionFactoryScope scope) { + Parent p = new Parent(); + Child c = new Child(); + p.children.add( c ); + + scope.inTransaction( + s1 -> { + s1.saveOrUpdate( p ); + + // try to save the same entity in a new session before flushing the first session + + scope.inSession( + s2 -> { + try { + s2.getTransaction().begin(); + s2.saveOrUpdate( p ); + s2.getTransaction().commit(); + fail( "should have thrown HibernateException" ); + } + catch (HibernateException ex) { + //expected + s2.getTransaction().rollback(); + } + } + ); + } + ); + + scope.inTransaction( + session -> { + Parent pGet = session.get( Parent.class, p.id ); + assertEquals( c.id, pGet.children.iterator().next().id ); + session.delete( pGet ); + } + ); + + } + + + @Test + @TestForIssue(jiraKey = "HHH-9518") + public void testSaveOrUpdateOwnerWithCollectionInNewSessionAfterFlush(SessionFactoryScope scope) { + Parent p = new Parent(); + Child c = new Child(); + p.children.add( c ); + + scope.inTransaction( + s1 -> { + s1.saveOrUpdate( p ); + s1.flush(); + + // try to save the same entity in a new session after flushing the first session + + scope.inSession( + s2 -> { + s2.getTransaction().begin(); + try { + s2.saveOrUpdate( p ); + s2.getTransaction().commit(); + fail( "should have thrown HibernateException" ); + } + catch (HibernateException ex) { + //expected + } + } + ); + } + ); + + scope.inTransaction( + session -> { + Parent pGet = session.get( Parent.class, p.id ); + assertEquals( c.id, pGet.children.iterator().next().id ); + session.delete( pGet ); + } + ); + } + + @Test + @TestForIssue(jiraKey = "HHH-9518") + public void testSaveOrUpdateOwnerWithUninitializedCollectionInNewSession(SessionFactoryScope scope) { + + Parent parent = new Parent(); + scope.inTransaction( + session -> { + Child c = new Child(); + parent.children.add( c ); + session.persist( parent ); + } + ); + + scope.inTransaction( + s1 -> { + Parent p = s1.get( Parent.class, parent.id ); + assertFalse( Hibernate.isInitialized( p.children ) ); + + // try to save the same entity (with an uninitialized collection) in a new session + + scope.inSession( + s2 -> { + s2.getTransaction().begin(); + try { + s2.saveOrUpdate( p ); + s2.getTransaction().commit(); + fail( "should have thrown HibernateException" ); + } + catch (HibernateException ex) { + //expected + s2.getTransaction().rollback(); + } + } + ); + + // should still be able to initialize collection, modify and commit in first session + assertFalse( Hibernate.isInitialized( p.children ) ); + Hibernate.initialize( p.children ); + p.children.add( new Child() ); + } + ); + + scope.inTransaction( + session -> { + Parent pGet = session.get( Parent.class, parent.id ); + assertEquals( 2, pGet.children.size() ); + session.delete( pGet ); + } + ); + } + + @Test + @TestForIssue(jiraKey = "HHH-9518") + public void testSaveOrUpdateOwnerWithInitializedCollectionInNewSession(SessionFactoryScope scope) { + Parent parent = new Parent(); + Child c = new Child(); + parent.children.add( c ); + + scope.inTransaction( + session -> session.persist( parent ) + ); + + scope.inTransaction( + s1 -> { + Parent p = s1.get( Parent.class, parent.id ); + Hibernate.initialize( p.children ); + + // try to save the same entity (with an initialized collection) in a new session + + scope.inSession( + s2 -> { + s2.getTransaction().begin(); + try { + s2.saveOrUpdate( p ); + s2.getTransaction().commit(); + fail( "should have thrown HibernateException" ); + } + catch (HibernateException ex) { + // expected + s2.getTransaction().rollback(); + } + } + ); + + } + ); + + scope.inTransaction( + session -> { + Parent pGet = session.get( Parent.class, parent.id ); + assertEquals( c.id, pGet.children.iterator().next().id ); + session.delete( pGet ); + } + ); + } + + @Test + @TestForIssue(jiraKey = "HHH-9518") + public void testCopyPersistentCollectionReferenceBeforeFlush(SessionFactoryScope scope) { + Parent parent = new Parent(); + Child c = new Child(); + parent.children.add( c ); + + scope.inTransaction( + s1 -> { + s1.persist( parent ); + + // Copy p.children into a different Parent before flush and try to save in new session. + + Parent pWithSameChildren = new Parent(); + pWithSameChildren.children = parent.children; + + scope.inSession( + s2 -> { + s2.getTransaction().begin(); + try { + s2.saveOrUpdate( pWithSameChildren ); + s2.getTransaction().commit(); + fail( "should have thrown HibernateException" ); + } + catch (HibernateException ex) { + // expected + s2.getTransaction().rollback(); + } + } + + ); + } + ); + + scope.inTransaction( + session -> { + Parent pGet = session.get( Parent.class, parent.id ); + assertEquals( c.id, pGet.children.iterator().next().id ); + session.delete( pGet ); + } + ); + } + + @Test + @TestForIssue(jiraKey = "HHH-9518") + public void testCopyPersistentCollectionReferenceAfterFlush(SessionFactoryScope scope) { + Parent p = new Parent(); + Child c = new Child(); + p.children.add( c ); + + scope.inTransaction( + s1 -> { + s1.persist( p ); + s1.flush(); + + // Copy p.children into a different Parent after flush and try to save in new session. + + Parent pWithSameChildren = new Parent(); + pWithSameChildren.children = p.children; + + scope.inSession( + s2 -> { + s2.getTransaction().begin(); + try { + s2.saveOrUpdate( pWithSameChildren ); + s2.getTransaction().commit(); + fail( "should have thrown HibernateException" ); + } + catch (HibernateException ex) { + // expected + s2.getTransaction().rollback(); + } + } + ); + } + ); + + scope.inTransaction( + session -> { + Parent pGet = session.get( Parent.class, p.id ); + assertEquals( c.id, pGet.children.iterator().next().id ); + session.delete( pGet ); + } + ); + } + + @Test + @TestForIssue(jiraKey = "HHH-9518") + public void testCopyUninitializedCollectionReferenceAfterGet(SessionFactoryScope scope) { + Parent parent = new Parent(); + Child c = new Child(); + parent.children.add( c ); + + scope.inTransaction( + session -> session.persist( parent ) + ); + + scope.inTransaction( + s1 -> { + Parent p = s1.get( Parent.class, parent.id ); + assertFalse( Hibernate.isInitialized( p.children ) ); + + // Copy p.children (uninitialized) into a different Parent and try to save in new session. + + Parent pWithSameChildren = new Parent(); + pWithSameChildren.children = p.children; + + scope.inSession( + s2 -> { + s2.getTransaction().begin(); + try { + s2.saveOrUpdate( pWithSameChildren ); + s2.getTransaction().commit(); + fail( "should have thrown HibernateException" ); + } + catch (HibernateException ex) { + // expected + s2.getTransaction().rollback(); + } + } + ); + } + ); + + scope.inTransaction( + session -> { + Parent pGet = session.get( Parent.class, parent.id ); + assertEquals( c.id, pGet.children.iterator().next().id ); + session.delete( pGet ); + } + ); + } + + @Test + @TestForIssue(jiraKey = "HHH-9518") + public void testCopyInitializedCollectionReferenceAfterGet(SessionFactoryScope scope) { + Parent parent = new Parent(); + Child c = new Child(); + parent.children.add( c ); + + scope.inTransaction( + session -> session.persist( parent ) + ); + + scope.inTransaction( + s1 -> { + Parent p = s1.get( Parent.class, parent.id ); + Hibernate.initialize( p.children ); + + // Copy p.children (initialized) into a different Parent.children and try to save in new session. + + Parent pWithSameChildren = new Parent(); + pWithSameChildren.children = p.children; + + scope.inSession( + s2 -> { + s2.getTransaction().begin(); + try { + s2.saveOrUpdate( pWithSameChildren ); + s2.getTransaction().commit(); + fail( "should have thrown HibernateException" ); + } + catch (HibernateException ex) { + // expected + s2.getTransaction().rollback(); + } + } + ); + + } + ); + + scope.inTransaction( + session -> { + Parent pGet = session.get( Parent.class, parent.id ); + assertEquals( c.id, pGet.children.iterator().next().id ); + session.delete( pGet ); + } + ); + } + + @Test + @TestForIssue(jiraKey = "HHH-9518") + public void testCopyInitializedCollectionReferenceToNewEntityCollectionRoleAfterGet(SessionFactoryScope scope) { + Parent parent = new Parent(); + Child c = new Child(); + parent.children.add( c ); + + scope.inTransaction( + session -> session.persist( parent ) + ); + + scope.inTransaction( + s1 -> { + Parent p = s1.get( Parent.class, parent.id ); + Hibernate.initialize( p.children ); + + // Copy p.children (initialized) into a different Parent.oldChildren (note different collection role) + // and try to save in new session. + + Parent pWithSameChildren = new Parent(); + pWithSameChildren.oldChildren = p.children; + + scope.inSession( + s2 -> { + s2.getTransaction().begin(); + try { + s2.saveOrUpdate( pWithSameChildren ); + s2.getTransaction().commit(); + fail( "should have thrown HibernateException" ); + } + catch (HibernateException ex) { + // expected + s2.getTransaction().rollback(); + } + } + ); + + } + ); + + scope.inTransaction( + session -> { + Parent pGet = session.get( Parent.class, parent.id ); + assertEquals( c.id, pGet.children.iterator().next().id ); + session.delete( pGet ); + } + ); + } + + @Test + @TestForIssue(jiraKey = "HHH-9518") + public void testDeleteCommitCopyToNewOwnerInNewSession(SessionFactoryScope scope) { + Parent p1 = new Parent(); + p1.nickNames.add( "nick" ); + Parent p2 = new Parent(); + + scope.inTransaction( + session -> { + session.save( p1 ); + session.save( p2 ); + } + ); + + scope.inSession( + s1 -> { + s1.getTransaction().begin(); + s1.delete( p1 ); + s1.flush(); + s1.getTransaction().commit(); + + // need to commit after flushing; otherwise, will get lock failure when try to move the collection below + + assertNull( s1.getPersistenceContext().getEntry( p1 ) ); + CollectionEntry ceChildren = s1.getPersistenceContext() + .getCollectionEntry( (PersistentCollection) p1.children ); + CollectionEntry ceNickNames = s1.getPersistenceContext() + .getCollectionEntry( (PersistentCollection) p1.nickNames ); + assertNull( ceChildren ); + assertNull( ceNickNames ); + assertNull( ( (AbstractPersistentCollection) p1.children ).getSession() ); + assertNull( ( (AbstractPersistentCollection) p1.oldChildren ).getSession() ); + assertNull( ( (AbstractPersistentCollection) p1.nickNames ).getSession() ); + assertNull( ( (AbstractPersistentCollection) p1.oldNickNames ).getSession() ); + + // Assign the deleted collection to a different entity with same collection role (p2.nickNames) + + p2.nickNames = p1.nickNames; + scope.inTransaction( + s2 -> s2.saveOrUpdate( p2 ) + ); + } + ); + } + + @Test + @TestForIssue(jiraKey = "HHH-9518") + public void testDeleteCommitCopyToNewOwnerNewCollectionRoleInNewSession(SessionFactoryScope scope) { + Parent p1 = new Parent(); + p1.nickNames.add( "nick" ); + Parent p2 = new Parent(); + + scope.inTransaction( + session -> { + session.save( p1 ); + session.save( p2 ); + } + ); + + scope.inSession( + s1 -> { + s1.getTransaction().begin(); + s1.delete( p1 ); + s1.flush(); + s1.getTransaction().commit(); + + // need to commit after flushing; otherwise, will get lock failure when try to move the collection below + + assertNull( s1.getPersistenceContext().getEntry( p1 ) ); + CollectionEntry ceChildren = s1.getPersistenceContext() + .getCollectionEntry( (PersistentCollection) p1.children ); + CollectionEntry ceNickNames = s1.getPersistenceContext() + .getCollectionEntry( (PersistentCollection) p1.nickNames ); + assertNull( ceChildren ); + assertNull( ceNickNames ); + assertNull( ( (AbstractPersistentCollection) p1.children ).getSession() ); + assertNull( ( (AbstractPersistentCollection) p1.oldChildren ).getSession() ); + assertNull( ( (AbstractPersistentCollection) p1.nickNames ).getSession() ); + assertNull( ( (AbstractPersistentCollection) p1.oldNickNames ).getSession() ); + + // Assign the deleted collection to a different entity with different collection role (p2.oldNickNames) + + p2.oldNickNames = p1.nickNames; + + scope.inTransaction( + s2 -> s2.saveOrUpdate( p2 ) + ); + } + ); + } + + @Test + @TestForIssue(jiraKey = "HHH-9518") + public void testDeleteCopyToNewOwnerInNewSessionBeforeFlush(SessionFactoryScope scope) { + Parent p1 = new Parent(); + p1.nickNames.add( "nick" ); + Parent p2 = new Parent(); + + scope.inTransaction( + session -> { + session.save( p1 ); + session.save( p2 ); + } + ); + + scope.inTransaction( + s1 -> { + s1.delete( p1 ); + + // Assign the deleted collection to a different entity with same collection role (p2.nickNames) + // before committing delete. + + p2.nickNames = p1.nickNames; + + scope.inSession( + s2 -> { + s2.getTransaction().begin(); + try { + s2.saveOrUpdate( p2 ); + fail( "should have thrown HibernateException" ); + } + catch (HibernateException ex) { + // expected + s2.getTransaction().rollback(); + } + } + ); + } + ); + + + } + + @Test + @TestForIssue(jiraKey = "HHH-9518") + public void testDeleteCopyToNewOwnerNewCollectionRoleInNewSessionBeforeFlush(SessionFactoryScope scope) { + Parent p1 = new Parent(); + p1.nickNames.add( "nick" ); + Parent p2 = new Parent(); + + scope.inTransaction( + session -> { + session.save( p1 ); + session.save( p2 ); + } + ); + + scope.inTransaction( + s1 -> { + s1.delete( p1 ); + + // Assign the deleted collection to a different entity with different collection role (p2.oldNickNames) + // before committing delete. + + p2.oldNickNames = p1.nickNames; + scope.inSession( + s2 -> { + s2.getTransaction().begin(); + try { + s2.saveOrUpdate( p2 ); + fail( "should have thrown HibernateException" ); + } + catch (HibernateException ex) { + // expected + s2.getTransaction().rollback(); + } + } + ); + } + ); + } + + @Entity + @Table(name = "Parent") + public static class Parent { + @Id + @GeneratedValue + private Long id; + + @ElementCollection + private Set nickNames = new HashSet(); + + @ElementCollection + private Set oldNickNames = new HashSet(); + + @OneToMany(cascade = CascadeType.ALL) + @JoinColumn + private Set children = new HashSet(); + + @OneToMany(cascade = CascadeType.ALL) + @JoinColumn + private Set oldChildren = new HashSet(); + + } + + @Entity + @Table(name = "Child") + public static class Child { + @Id + @GeneratedValue + private Long id; + + } +} diff --git a/hibernate-core/src/test/java/org/hibernate/orm/test/collection/multisession/MultipleSessionCollectionWarningTest.java b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/multisession/MultipleSessionCollectionWarningTest.java new file mode 100644 index 0000000000..888662a9a4 --- /dev/null +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/multisession/MultipleSessionCollectionWarningTest.java @@ -0,0 +1,374 @@ +/* + * Hibernate, Relational Persistence for Idiomatic Java + * + * Copyright (c) 2014, Red Hat Inc. or third-party contributors as + * indicated by the @author tags or express copyright attribution + * statements applied by the authors. All third-party contributions are + * distributed under license by Red Hat Inc. + * + * This copyrighted material is made available to anyone wishing to use, modify, + * copy, or redistribute it subject to the terms and conditions of the GNU + * Lesser General Public License, as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License + * for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this distribution; if not, write to: + * Free Software Foundation, Inc. + * 51 Franklin Street, Fifth Floor + * Boston, MA 02110-1301 USA + */ +package org.hibernate.orm.test.collection.multisession; + +import java.util.HashSet; +import java.util.Set; +import javax.persistence.CascadeType; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.Id; +import javax.persistence.JoinColumn; +import javax.persistence.OneToMany; +import javax.persistence.Table; + +import org.hibernate.collection.internal.AbstractPersistentCollection; +import org.hibernate.collection.internal.PersistentSet; +import org.hibernate.collection.spi.PersistentCollection; +import org.hibernate.engine.spi.CollectionEntry; +import org.hibernate.internal.CoreLogging; +import org.hibernate.internal.CoreMessageLogger; + +import org.hibernate.testing.TestForIssue; +import org.hibernate.testing.logger.LoggerInspectionRule; +import org.hibernate.testing.logger.Triggerable; +import org.hibernate.testing.orm.junit.DomainModel; +import org.hibernate.testing.orm.junit.SessionFactory; +import org.hibernate.testing.orm.junit.SessionFactoryScope; +import org.junit.Rule; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + + +/** + * @author Gail Badner + */ +@DomainModel( + annotatedClasses = { + MultipleSessionCollectionWarningTest.Parent.class, + MultipleSessionCollectionWarningTest.Child.class + } +) +@SessionFactory +public class MultipleSessionCollectionWarningTest { + private static final CoreMessageLogger LOG = CoreLogging.messageLogger( AbstractPersistentCollection.class ); + + @Rule + public LoggerInspectionRule logInspection = new LoggerInspectionRule( LOG ); + + @Test + @TestForIssue(jiraKey = "HHH-9518") + public void testSetCurrentSessionOverwritesNonConnectedSesssion(SessionFactoryScope scope) { + Parent p = new Parent(); + Child c = new Child(); + p.children.add( c ); + + scope.inSession( + s1 -> { + s1.getTransaction().begin(); + try { + s1.saveOrUpdate( p ); + + // Now remove the collection from the PersistenceContext without unsetting its session + // This should never be done in practice; it is done here only to test that the warning + // gets logged. s1 will not function properly so the transaction will ultimately need + // to be rolled-back. + + CollectionEntry ce = s1.getPersistenceContext() + .removeCollectionEntry( (PersistentSet) p.children ); + assertNotNull( ce ); + + // the collection session should still be s1; the collection is no longer "connected" because its + // CollectionEntry has been removed. + assertSame( s1, ( (AbstractPersistentCollection) p.children ).getSession() ); + + scope.inSession( + s2 -> { + s2.getTransaction().begin(); + try { + Triggerable triggerable = logInspection.watchForLogMessages( "HHH000470:" ); + assertFalse( triggerable.wasTriggered() ); + + // The following should trigger warning because we're setting a new session when the collection already + // has a non-null session (and the collection is not "connected" to that session); + // Since s1 was not flushed, the collection role will not be known (no way to test that other than inspection). + s2.saveOrUpdate( p ); + + assertTrue( triggerable.wasTriggered() ); + + // collection's session should be overwritten with s2 + assertSame( s2, ( (AbstractPersistentCollection) p.children ).getSession() ); + } + finally { + s2.getTransaction().rollback(); + } + } + ); + } + finally { + s1.getTransaction().rollback(); + } + } + ); + } + + @Test + @TestForIssue(jiraKey = "HHH-9518") + public void testSetCurrentSessionOverwritesNonConnectedSesssionFlushed(SessionFactoryScope scope) { + Parent p = new Parent(); + Child c = new Child(); + p.children.add( c ); + + scope.inSession( + s1 -> { + s1.getTransaction().begin(); + try { + s1.saveOrUpdate( p ); + + // flush the session so that p.children will contain its role + s1.flush(); + + // Now remove the collection from the PersistenceContext without unsetting its session + // This should never be done in practice; it is done here only to test that the warning + // gets logged. s1 will not function properly so the transaction will ultimately need + // to be rolled-back. + + CollectionEntry ce = s1.getPersistenceContext() + .removeCollectionEntry( (PersistentSet) p.children ); + assertNotNull( ce ); + + // the collection session should still be s1; the collection is no longer "connected" because its + // CollectionEntry has been removed. + assertSame( s1, ( (AbstractPersistentCollection) p.children ).getSession() ); + + scope.inSession( + s2 -> { + s2.getTransaction().begin(); + try { + Triggerable triggerable = logInspection.watchForLogMessages( "HHH000470:" ); + assertFalse( triggerable.wasTriggered() ); + + // The following should trigger warning because we're setting a new session when the collection already + // has a non-null session (and the collection is not "connected" to that session); + // The collection role and key should be included in the message (no way to test that other than inspection). + s2.saveOrUpdate( p ); + + assertTrue( triggerable.wasTriggered() ); + + // collection's session should be overwritten with s2 + assertSame( s2, ( (AbstractPersistentCollection) p.children ).getSession() ); + } + finally { + s2.getTransaction().rollback(); + } + } + ); + } + finally { + s1.getTransaction().rollback(); + } + } + + ); + } + + @Test + @TestForIssue(jiraKey = "HHH-9518") + public void testUnsetSessionCannotOverwriteNonConnectedSesssion(SessionFactoryScope scope) { + Parent p = new Parent(); + Child c = new Child(); + p.children.add( c ); + + scope.inSession( + s1 -> { + s1.getTransaction().begin(); + try { + s1.saveOrUpdate( p ); + + // Now remove the collection from the PersistenceContext without unsetting its session + // This should never be done in practice; it is done here only to test that the warning + // gets logged. s1 will not function properly so the transaction will ultimately need + // to be rolled-back. + + CollectionEntry ce = s1.getPersistenceContext() + .removeCollectionEntry( (PersistentSet) p.children ); + assertNotNull( ce ); + + // the collection session should still be s1; the collection is no longer "connected" because its + // CollectionEntry has been removed. + assertSame( s1, ( (AbstractPersistentCollection) p.children ).getSession() ); + + scope.inSession( + s2 -> { + s2.getTransaction().begin(); + try { + Triggerable triggerable = logInspection.watchForLogMessages( "HHH000471:" ); + assertFalse( triggerable.wasTriggered() ); + + // The following should trigger warning because we're unsetting a different session. + // We should not do this in practice; it is done here only to force the warning. + // Since s1 was not flushed, the collection role will not be known (no way to test that). + assertFalse( ( (PersistentCollection) p.children ).unsetSession( s2 ) ); + + assertTrue( triggerable.wasTriggered() ); + + // collection's session should still be s1 + assertSame( s1, ( (AbstractPersistentCollection) p.children ).getSession() ); + } + finally { + s2.getTransaction().rollback(); + } + + } + + ); + } + finally { + s1.getTransaction().rollback(); + } + } + ); + } + + @Test + @TestForIssue(jiraKey = "HHH-9518") + public void testUnsetSessionCannotOverwriteConnectedSesssion(SessionFactoryScope scope) { + Parent p = new Parent(); + Child c = new Child(); + p.children.add( c ); + + scope.inSession( + s1 -> { + s1.getTransaction().begin(); + try { + s1.saveOrUpdate( p ); + + // The collection is "connected" to s1 because it contains the CollectionEntry + CollectionEntry ce = s1.getPersistenceContext() + .getCollectionEntry( (PersistentCollection) p.children ); + assertNotNull( ce ); + + // the collection session should be s1 + assertSame( s1, ( (AbstractPersistentCollection) p.children ).getSession() ); + + scope.inSession( + s2 -> { + s2.getTransaction().begin(); + try { + Triggerable triggerable = logInspection.watchForLogMessages( "HHH000471:" ); + assertFalse( triggerable.wasTriggered() ); + + // The following should trigger warning because we're unsetting a different session + // We should not do this in practice; it is done here only to force the warning. + // Since s1 was not flushed, the collection role will not be known (no way to test that). + assertFalse( ( (PersistentCollection) p.children ).unsetSession( s2 ) ); + + assertTrue( triggerable.wasTriggered() ); + + // collection's session should still be s1 + assertSame( s1, ( (AbstractPersistentCollection) p.children ).getSession() ); + } + finally { + s2.getTransaction().rollback(); + } + } + ); + } + finally { + s1.getTransaction().rollback(); + } + } + ); + } + + @Test + @TestForIssue(jiraKey = "HHH-9518") + public void testUnsetSessionCannotOverwriteConnectedSesssionFlushed(SessionFactoryScope scope) { + Parent p = new Parent(); + Child c = new Child(); + p.children.add( c ); + + scope.inSession( + s1 -> { + s1.getTransaction().begin(); + try { + s1.saveOrUpdate( p ); + + // flush the session so that p.children will contain its role + s1.flush(); + + // The collection is "connected" to s1 because it contains the CollectionEntry + CollectionEntry ce = s1.getPersistenceContext() + .getCollectionEntry( (PersistentCollection) p.children ); + assertNotNull( ce ); + + // the collection session should be s1 + assertSame( s1, ( (AbstractPersistentCollection) p.children ).getSession() ); + + scope.inSession( + s2 -> { + s2.getTransaction().begin(); + try { + Triggerable triggerable = logInspection.watchForLogMessages( "HHH000471:" ); + assertFalse( triggerable.wasTriggered() ); + + // The following should trigger warning because we're unsetting a different session + // We should not do this in practice; it is done here only to force the warning. + // The collection role and key should be included in the message (no way to test that other than inspection). + assertFalse( ( (PersistentCollection) p.children ).unsetSession( s2 ) ); + + assertTrue( triggerable.wasTriggered() ); + + // collection's session should still be s1 + assertSame( s1, ( (AbstractPersistentCollection) p.children ).getSession() ); + + } + finally { + s2.getTransaction().rollback(); + } + } + ); + } + finally { + s1.getTransaction().rollback(); + } + } + ); + } + + @Entity(name = "Parent") + @Table(name = "Parent") + public static class Parent { + @Id + @GeneratedValue + private Long id; + + @OneToMany(cascade = CascadeType.ALL) + @JoinColumn + private Set children = new HashSet<>(); + } + + @Entity(name = "Child") + @Table(name = "Child") + public static class Child { + @Id + @GeneratedValue + private Long id; + + } +} diff --git a/hibernate-core/src/test/java/org/hibernate/orm/test/collection/nonInsertable/NonInsertableColumnTest.java b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/nonInsertable/NonInsertableColumnTest.java new file mode 100644 index 0000000000..7dac2b2ddf --- /dev/null +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/nonInsertable/NonInsertableColumnTest.java @@ -0,0 +1,90 @@ +package org.hibernate.orm.test.collection.nonInsertable; + +import java.util.Arrays; +import java.util.List; +import javax.persistence.Column; +import javax.persistence.ElementCollection; +import javax.persistence.Embeddable; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; + +import org.hibernate.testing.TestForIssue; +import org.hibernate.testing.orm.junit.DomainModel; +import org.hibernate.testing.orm.junit.SessionFactory; +import org.hibernate.testing.orm.junit.SessionFactoryScope; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; + +@TestForIssue(jiraKey = "HHH-13236") +@DomainModel( + annotatedClasses = { + NonInsertableColumnTest.Parent.class, + NonInsertableColumnTest.Child.class + } +) +@SessionFactory +public class NonInsertableColumnTest { + + @Test + public void test(SessionFactoryScope scope) { + Long parentId = scope.fromTransaction( + session -> { + Child child = new Child(); + child.field = "Test"; + child.nonInsertable = "nonInsertable"; + child.nonUpdatable = "nonUpdatable"; + + Parent parent = new Parent(); + parent.children = Arrays.asList( child ); + + session.persist( parent ); + + session.flush(); + + return parent.id; + } + ); + + scope.inSession( + session -> { + Parent loaded = session.get( Parent.class, parentId ); + assertEquals( "nonUpdatable", loaded.children.get( 0 ).nonUpdatable ); + assertNull( loaded.children.get( 0 ).nonInsertable ); + assertEquals( "Test", loaded.children.get( 0 ).field ); + assertEquals( "Test", loaded.children.get( 0 ).shadowField ); + } + ); + + } + + @Entity(name = "Parent") + public static class Parent { + @Id + @GeneratedValue(strategy = GenerationType.AUTO) + public Long id; + + @ElementCollection + public List children; + } + + @Embeddable + public static class Child { + + @Column(name = "field") + public String field; + + @Column(insertable = false) + public String nonInsertable; + + @Column(updatable = false) + public String nonUpdatable; + + @Column(name = "field", insertable = false, updatable = false) + public String shadowField; + } + +} diff --git a/hibernate-core/src/test/java/org/hibernate/test/collectionalias/ATable.java b/hibernate-core/src/test/java/org/hibernate/orm/test/collectionalias/ATable.java similarity index 92% rename from hibernate-core/src/test/java/org/hibernate/test/collectionalias/ATable.java rename to hibernate-core/src/test/java/org/hibernate/orm/test/collectionalias/ATable.java index 72f88a1b5f..d1482469e3 100644 --- a/hibernate-core/src/test/java/org/hibernate/test/collectionalias/ATable.java +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collectionalias/ATable.java @@ -4,7 +4,7 @@ * License: GNU Lesser General Public License (LGPL), version 2.1 or later. * See the lgpl.txt file in the root directory or . */ -package org.hibernate.test.collectionalias; +package org.hibernate.orm.test.collectionalias; import java.io.Serializable; import java.util.ArrayList; diff --git a/hibernate-core/src/test/java/org/hibernate/orm/test/collectionalias/CollectionAliasTest.java b/hibernate-core/src/test/java/org/hibernate/orm/test/collectionalias/CollectionAliasTest.java new file mode 100644 index 0000000000..140762f6ef --- /dev/null +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collectionalias/CollectionAliasTest.java @@ -0,0 +1,65 @@ +/* + * 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 . + */ +package org.hibernate.orm.test.collectionalias; + +import org.hibernate.testing.TestForIssue; +import org.hibernate.testing.orm.junit.DomainModel; +import org.hibernate.testing.orm.junit.SessionFactory; +import org.hibernate.testing.orm.junit.SessionFactoryScope; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertSame; + +/** + * @author Dave Stephan + * @author Gail Badner + */ +@DomainModel( + annotatedClasses = { + TableBId.class, + TableB.class, + TableA.class, + ATable.class + } +) +@SessionFactory +public class CollectionAliasTest { + + @TestForIssue(jiraKey = "HHH-7545") + @Test + public void test(SessionFactoryScope scope) { + scope.inTransaction( + session -> { + + ATable aTable = new ATable( 1 ); + TableB tableB = new TableB( + new TableBId( 1, "a", "b" ) + ); + aTable.getTablebs().add( tableB ); + tableB.setTablea( aTable ); + session.save( aTable ); + } + ); + + scope.inSession( + session -> { + ATable aTable = (ATable) session.createQuery( + "select distinct tablea from ATable tablea LEFT JOIN FETCH tablea.tablebs " ) + .uniqueResult(); + assertEquals( new Integer( 1 ), aTable.getFirstId() ); + assertEquals( 1, aTable.getTablebs().size() ); + TableB tableB = aTable.getTablebs().get( 0 ); + assertSame( aTable, tableB.getTablea() ); + assertEquals( new Integer( 1 ), tableB.getId().getFirstId() ); + assertEquals( "a", tableB.getId().getSecondId() ); + assertEquals( "b", tableB.getId().getThirdId() ); + } + ); + } + +} diff --git a/hibernate-core/src/test/java/org/hibernate/orm/test/collectionalias/ReorderedMappingsCollectionAliasTest.java b/hibernate-core/src/test/java/org/hibernate/orm/test/collectionalias/ReorderedMappingsCollectionAliasTest.java new file mode 100644 index 0000000000..18d50d13a7 --- /dev/null +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collectionalias/ReorderedMappingsCollectionAliasTest.java @@ -0,0 +1,67 @@ +/* + * 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 . + */ +package org.hibernate.orm.test.collectionalias; + +import org.hibernate.testing.TestForIssue; +import org.hibernate.testing.orm.junit.DomainModel; +import org.hibernate.testing.orm.junit.SessionFactory; +import org.hibernate.testing.orm.junit.SessionFactoryScope; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertSame; + +/** + * The bug fixed by HHH-7545 showed showed different results depending on the order + * in which entity mappings were processed. + * + * This mappings are in the opposite order here than in CollectionAliasTest. + * + * @Author Gail Badner + */ +@DomainModel( + annotatedClasses = { + ATable.class, + TableA.class, + TableB.class, + TableBId.class, + } +) +@SessionFactory +public class ReorderedMappingsCollectionAliasTest { + + @TestForIssue(jiraKey = "HHH-7545") + @Test + public void test(SessionFactoryScope scope) { + scope.inTransaction( + session -> { + ATable aTable = new ATable( 1 ); + TableB tableB = new TableB( + new TableBId( 1, "a", "b" ) + ); + aTable.getTablebs().add( tableB ); + tableB.setTablea( aTable ); + session.save( aTable ); + } + ); + + scope.inSession( + session -> { + ATable aTable = (ATable) session.createQuery( + "select distinct tablea from ATable tablea LEFT JOIN FETCH tablea.tablebs " ) + .uniqueResult(); + assertEquals( new Integer( 1 ), aTable.getFirstId() ); + assertEquals( 1, aTable.getTablebs().size() ); + TableB tableB = aTable.getTablebs().get( 0 ); + assertSame( aTable, tableB.getTablea() ); + assertEquals( new Integer( 1 ), tableB.getId().getFirstId() ); + assertEquals( "a", tableB.getId().getSecondId() ); + assertEquals( "b", tableB.getId().getThirdId() ); + } + ); + } +} diff --git a/hibernate-core/src/test/java/org/hibernate/test/collectionalias/TableA.java b/hibernate-core/src/test/java/org/hibernate/orm/test/collectionalias/TableA.java similarity index 91% rename from hibernate-core/src/test/java/org/hibernate/test/collectionalias/TableA.java rename to hibernate-core/src/test/java/org/hibernate/orm/test/collectionalias/TableA.java index 3d3c17dcc5..cd7a9492bc 100644 --- a/hibernate-core/src/test/java/org/hibernate/test/collectionalias/TableA.java +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collectionalias/TableA.java @@ -4,7 +4,7 @@ * License: GNU Lesser General Public License (LGPL), version 2.1 or later. * See the lgpl.txt file in the root directory or . */ -package org.hibernate.test.collectionalias; +package org.hibernate.orm.test.collectionalias; import javax.persistence.Entity; import javax.persistence.Id; diff --git a/hibernate-core/src/test/java/org/hibernate/test/collectionalias/TableB.java b/hibernate-core/src/test/java/org/hibernate/orm/test/collectionalias/TableB.java similarity index 94% rename from hibernate-core/src/test/java/org/hibernate/test/collectionalias/TableB.java rename to hibernate-core/src/test/java/org/hibernate/orm/test/collectionalias/TableB.java index 32be006fab..99f650bfd8 100644 --- a/hibernate-core/src/test/java/org/hibernate/test/collectionalias/TableB.java +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collectionalias/TableB.java @@ -4,7 +4,7 @@ * License: GNU Lesser General Public License (LGPL), version 2.1 or later. * See the lgpl.txt file in the root directory or . */ -package org.hibernate.test.collectionalias; +package org.hibernate.orm.test.collectionalias; import java.io.Serializable; diff --git a/hibernate-core/src/test/java/org/hibernate/test/collectionalias/TableBId.java b/hibernate-core/src/test/java/org/hibernate/orm/test/collectionalias/TableBId.java similarity index 93% rename from hibernate-core/src/test/java/org/hibernate/test/collectionalias/TableBId.java rename to hibernate-core/src/test/java/org/hibernate/orm/test/collectionalias/TableBId.java index c32c1e32c4..6246621a1d 100644 --- a/hibernate-core/src/test/java/org/hibernate/test/collectionalias/TableBId.java +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collectionalias/TableBId.java @@ -4,7 +4,7 @@ * License: GNU Lesser General Public License (LGPL), version 2.1 or later. * See the lgpl.txt file in the root directory or . */ -package org.hibernate.test.collectionalias; +package org.hibernate.orm.test.collectionalias; import java.io.Serializable; diff --git a/hibernate-core/src/test/java/org/hibernate/test/collection/bag/BagDuplicatesTest.java b/hibernate-core/src/test/java/org/hibernate/test/collection/bag/BagDuplicatesTest.java deleted file mode 100644 index d3dcb34ec0..0000000000 --- a/hibernate-core/src/test/java/org/hibernate/test/collection/bag/BagDuplicatesTest.java +++ /dev/null @@ -1,230 +0,0 @@ -/* - * Copyright 2014 JBoss Inc - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.hibernate.test.collection.bag; - -import org.hibernate.HibernateException; -import org.hibernate.Session; -import org.hibernate.Transaction; -import org.hibernate.cfg.AvailableSettings; -import org.hibernate.cfg.Configuration; -import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase; -import org.junit.Test; - -import javax.persistence.*; -import java.util.ArrayList; -import java.util.List; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.fail; - -/** - * This template demonstrates how to develop a test case for Hibernate ORM, using its built-in unit test framework. - * Although ORMStandaloneTestCase is perfectly acceptable as a reproducer, usage of this class is much preferred. - * Since we nearly always include a regression test with bug fixes, providing your reproducer using this method - * simplifies the process. - * - * What's even better? Fork hibernate-orm itself, add your test case directly to a module's unit tests, then - * submit it as a PR! - */ -public class BagDuplicatesTest extends BaseCoreFunctionalTestCase { - - // Add your entities here. - @Override - protected Class[] getAnnotatedClasses() { - return new Class[] { - Parent.class, - Child.class - }; - } - - // If you use *.hbm.xml mappings, instead of annotations, add the mappings here. - @Override - protected String[] getMappings() { - return new String[] { -// "Foo.hbm.xml", -// "Bar.hbm.xml" - }; - } - // If those mappings reside somewhere other than resources/org/hibernate/test, change this. - @Override - protected String getBaseForMappings() { - return "org/hibernate/test/"; - } - - // Add in any settings that are specific to your test. See resources/hibernate.properties for the defaults. - @Override - protected void configure(Configuration configuration) { - super.configure( configuration ); - - configuration.setProperty( AvailableSettings.SHOW_SQL, "true" ); - } - - // Add your tests, using standard JUnit. - @Test - public void HHH10385Test() throws Exception { - // BaseCoreFunctionalTestCase automatically creates the SessionFactory and provides the Session. - Session session = null; - Transaction transaction = null; - - Long parentId = null; - - try { - session = openSession(); - transaction = session.beginTransaction(); - - Parent parent = new Parent(); - session.persist(parent); - session.flush(); - parentId = parent.getId(); - - transaction.commit(); - } catch (HibernateException e) { - if (transaction != null) { - transaction.rollback(); - } - fail(e.getMessage()); - } finally { - if (session != null) { - session.close(); - } - } - - try { - session = openSession(); - transaction = session.beginTransaction(); - - Parent parent = session.get(Parent.class, parentId); - Child child1 = new Child(); - child1.setName("child1"); - child1.setParent(parent); - parent.addChild(child1); - parent = (Parent) session.merge(parent); - session.flush(); - //assertEquals(1, parent.getChildren().size()); - - transaction.commit(); - } catch (HibernateException e) { - if (transaction != null) { - transaction.rollback(); - } - fail(e.getMessage()); - } finally { - if (session != null) { - session.close(); - } - } - - try { - session = openSession(); - transaction = session.beginTransaction(); - - Parent parent = session.get(Parent.class, parentId); - assertEquals(1, parent.getChildren().size()); - - transaction.commit(); - } catch (HibernateException e) { - if (transaction != null) { - transaction.rollback(); - } - fail(e.getMessage()); - } finally { - if (session != null) { - session.close(); - } - } - } - - @Entity(name = "Parent") - public static class Parent { - - @Id - @GeneratedValue(strategy = GenerationType.AUTO) - private Long id; - - @OneToMany(cascade = CascadeType.ALL, mappedBy = "parent", orphanRemoval = true) - private List children = new ArrayList(); - - public Parent() { - } - - public Long getId() { - return id; - } - - public void setId(Long id) { - this.id = id; - } - - public List getChildren() { - return children; - } - - public void addChild(Child child) { - children.add(child); - child.setParent(this); - } - - public void removeChild(Child child) { - children.remove(child); - child.setParent(null); - } - } - - @Entity(name = "Child") - public static class Child { - - @Id - @GeneratedValue(strategy = GenerationType.AUTO) - private Long id; - - private String name; - - @ManyToOne - private Parent parent; - - public Child() { - } - - public Long getId() { - return id; - } - - public String getName() { - return name; - } - - public void setName(String name) { - this.name = name; - } - - public Parent getParent() { - return parent; - } - - public void setParent(Parent parent) { - this.parent = parent; - } - - @Override - public String toString() { - return "Child{" + - "id=" + id + - ", name='" + name + '\'' + - '}'; - } - } - -} diff --git a/hibernate-core/src/test/java/org/hibernate/test/collection/bag/BagElementNullBasicTest.java b/hibernate-core/src/test/java/org/hibernate/test/collection/bag/BagElementNullBasicTest.java deleted file mode 100644 index 6f4986e9c9..0000000000 --- a/hibernate-core/src/test/java/org/hibernate/test/collection/bag/BagElementNullBasicTest.java +++ /dev/null @@ -1,203 +0,0 @@ -/* - * 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 . - */ -package org.hibernate.test.collection.bag; - -import java.util.ArrayList; -import java.util.List; -import javax.persistence.CollectionTable; -import javax.persistence.Column; -import javax.persistence.ElementCollection; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.Id; -import javax.persistence.JoinColumn; -import javax.persistence.OrderBy; -import javax.persistence.Table; - -import org.hibernate.Session; -import org.hibernate.Transaction; -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; - -/** - * @author Gail Badner - */ -public class BagElementNullBasicTest extends BaseCoreFunctionalTestCase { - - @Override - protected Class[] getAnnotatedClasses() { - return new Class[] { - AnEntity.class, - NullableElementsEntity.class - }; - } - - @Test - public void testPersistNullValue() { - int entityId = doInHibernate( - this::sessionFactory, session -> { - AnEntity e = new AnEntity(); - e.aCollection.add( null ); - session.persist( e ); - return e.id; - } - ); - - doInHibernate( - this::sessionFactory, session -> { - AnEntity e = session.get( AnEntity.class, entityId ); - assertEquals( 0, e.aCollection.size() ); - assertEquals( 0, getCollectionElementRows( entityId ).size() ); - session.delete( e ); - } - ); - } - - @Test - public void addNullValue() { - int entityId = doInHibernate( - this::sessionFactory, session -> { - AnEntity e = new AnEntity(); - session.persist( e ); - return e.id; - } - ); - - doInHibernate( - this::sessionFactory, session -> { - AnEntity e = session.get( AnEntity.class, entityId ); - assertEquals( 0, e.aCollection.size() ); - assertEquals( 0, getCollectionElementRows( entityId ).size() ); - e.aCollection.add( null ); - } - ); - - doInHibernate( - this::sessionFactory, session -> { - AnEntity e = session.get( AnEntity.class, entityId ); - assertEquals( 0, e.aCollection.size() ); - assertEquals( 0, getCollectionElementRows( entityId ).size() ); - session.delete( e ); - } - ); - } - - @Test - @TestForIssue(jiraKey = "HHH-13651") - public void addNullValueToNullableCollections() { - try (final Session s = sessionFactory().openSession()) { - final Transaction tx = s.beginTransaction(); - NullableElementsEntity e = new NullableElementsEntity(); - e.list.add( null ); - s.persist( e ); - s.flush(); - tx.commit(); - } - } - - @Test - public void testUpdateNonNullValueToNull() { - int entityId = doInHibernate( - this::sessionFactory, session -> { - AnEntity e = new AnEntity(); - e.aCollection.add( "def" ); - session.persist( e ); - return e.id; - } - ); - - doInHibernate( - this::sessionFactory, session -> { - AnEntity e = session.get( AnEntity.class, entityId ); - assertEquals( 1, e.aCollection.size() ); - assertEquals( 1, getCollectionElementRows( entityId ).size() ); - e.aCollection.set( 0, null ); - } - ); - - doInHibernate( - this::sessionFactory, session -> { - AnEntity e = session.get( AnEntity.class, entityId ); - assertEquals( 0, e.aCollection.size() ); - assertEquals( 0, getCollectionElementRows( entityId ).size() ); - session.delete( e ); - } - ); - } - - @Test - public void testUpdateNonNullValueToNullWithExtraValue() { - int entityId = doInHibernate( - this::sessionFactory, session -> { - AnEntity e = new AnEntity(); - e.aCollection.add( "def" ); - e.aCollection.add( "ghi" ); - session.persist( e ); - return e.id; - } - ); - - doInHibernate( - this::sessionFactory, session -> { - AnEntity e = session.get( AnEntity.class, entityId ); - assertEquals( 2, e.aCollection.size() ); - assertEquals( 2, getCollectionElementRows( e.id ).size() ); - e.aCollection.set( 0, null ); - } - ); - - doInHibernate( - this::sessionFactory, session -> { - AnEntity e = session.get( AnEntity.class, entityId ); - assertEquals( 1, e.aCollection.size() ); - assertEquals( 1, getCollectionElementRows( e.id ).size() ); - assertEquals( "ghi", e.aCollection.get( 0 ) ); - session.delete( e ); - } - ); - } - - private List getCollectionElementRows(int id) { - return doInHibernate( - this::sessionFactory, session -> { - return session.createNativeQuery( - "SELECT aCollection FROM AnEntity_aCollection where AnEntity_id = " + id - ).list(); - } - ); - } - - @Entity - @Table(name="AnEntity") - public static class AnEntity { - @Id - @GeneratedValue - private int id; - - @ElementCollection - @CollectionTable(name = "AnEntity_aCollection", joinColumns = { @JoinColumn( name = "AnEntity_id" ) }) - @OrderBy - private List aCollection = new ArrayList(); - } - - @Entity - @Table(name="NullableElementsEntity") - public static class NullableElementsEntity { - @Id - @GeneratedValue - private int id; - - @ElementCollection - @CollectionTable(name="e_2_string", joinColumns=@JoinColumn(name="e_id")) - @Column(name="string_value", unique = false, nullable = true, insertable = true, updatable = true) - private List list = new ArrayList(); - } -} diff --git a/hibernate-core/src/test/java/org/hibernate/test/collection/bag/PersistentBagTest.java b/hibernate-core/src/test/java/org/hibernate/test/collection/bag/PersistentBagTest.java deleted file mode 100644 index 101d48f94c..0000000000 --- a/hibernate-core/src/test/java/org/hibernate/test/collection/bag/PersistentBagTest.java +++ /dev/null @@ -1,112 +0,0 @@ -/* - * 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 . - */ -package org.hibernate.test.collection.bag; - -import java.util.ArrayList; - -import org.hibernate.Session; -import org.hibernate.collection.internal.PersistentBag; -import org.hibernate.dialect.AbstractHANADialect; - -import org.hibernate.testing.DialectChecks; -import org.hibernate.testing.RequiresDialectFeature; -import org.hibernate.testing.SkipForDialect; -import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase; -import org.junit.Test; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; - -/** - * Tests related to operations on a PersistentBag. - * - * @author Steve Ebersole - */ -@RequiresDialectFeature(DialectChecks.SupportsNoColumnInsert.class) -public class PersistentBagTest extends BaseCoreFunctionalTestCase { - @Override - public String[] getMappings() { - return new String[] { "collection/bag/Mappings.hbm.xml" }; - } - - @Test - public void testWriteMethodDirtying() { - BagOwner parent = new BagOwner( "root" ); - BagOwner child = new BagOwner( "c1" ); - parent.getChildren().add( child ); - child.setParent( parent ); - BagOwner otherChild = new BagOwner( "c2" ); - - Session session = openSession(); - session.beginTransaction(); - session.save( parent ); - session.flush(); - // at this point, the list on parent has now been replaced with a PersistentBag... - PersistentBag children = ( PersistentBag ) parent.getChildren(); - - assertFalse( children.remove( otherChild ) ); - assertFalse( children.isDirty() ); - - ArrayList otherCollection = new ArrayList(); - otherCollection.add( child ); - assertFalse( children.retainAll( otherCollection ) ); - assertFalse( children.isDirty() ); - - otherCollection = new ArrayList(); - otherCollection.add( otherChild ); - assertFalse( children.removeAll( otherCollection ) ); - assertFalse( children.isDirty() ); - - children.clear(); - session.delete( child ); - assertTrue( children.isDirty() ); - - session.flush(); - - children.clear(); - assertFalse( children.isDirty() ); - - session.delete( parent ); - session.getTransaction().commit(); - session.close(); - } - - @Test - @SkipForDialect(value = AbstractHANADialect.class, comment = " HANA doesn't support tables consisting of only a single auto-generated column") - public void testMergePersistentEntityWithNewOneToManyElements() { - Order order = new Order(); - - Session s = openSession(); - s.getTransaction().begin(); - s.persist( order ); - s.getTransaction().commit(); - s.close(); - - s = openSession(); - s.getTransaction().begin(); - order = s.get( Order.class, order.getId() ); - Item item1 = new Item(); - item1.setName( "i1" ); - Item item2 = new Item(); - item2.setName( "i2" ); - order.addItem( item1 ); - order.addItem( item2 ); - order = (Order) s.merge( order ); - //s.flush(); - s.getTransaction().commit(); - s.close(); - - s = openSession(); - s.getTransaction().begin(); - order = s.get( Order.class, order.getId() ); - assertEquals( 2, order.getItems().size() ); - s.delete( order ); - s.getTransaction().commit(); - s.close(); - } -} diff --git a/hibernate-core/src/test/java/org/hibernate/test/collection/idbag/PersistentIdBagTest.java b/hibernate-core/src/test/java/org/hibernate/test/collection/idbag/PersistentIdBagTest.java deleted file mode 100644 index 0d8be35cdc..0000000000 --- a/hibernate-core/src/test/java/org/hibernate/test/collection/idbag/PersistentIdBagTest.java +++ /dev/null @@ -1,71 +0,0 @@ -/* - * 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 . - */ -package org.hibernate.test.collection.idbag; - -import java.util.ArrayList; - -import org.hibernate.Session; -import org.hibernate.collection.internal.PersistentIdentifierBag; - -import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase; -import org.junit.Test; - -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; - -/** - * Tests related to operations on a PersistentIdentifierBag - * - * @author Steve Ebersole - */ -public class PersistentIdBagTest extends BaseCoreFunctionalTestCase { - @Override - public String[] getMappings() { - return new String[] { "collection/idbag/Mappings.hbm.xml" }; - } - - @Test - public void testWriteMethodDirtying() { - IdbagOwner parent = new IdbagOwner( "root" ); - IdbagOwner child = new IdbagOwner( "c1" ); - parent.getChildren().add( child ); - IdbagOwner otherChild = new IdbagOwner( "c2" ); - - Session session = openSession(); - session.beginTransaction(); - session.save( parent ); - session.flush(); - // at this point, the list on parent has now been replaced with a PersistentBag... - PersistentIdentifierBag children = ( PersistentIdentifierBag ) parent.getChildren(); - - assertFalse( children.remove( otherChild ) ); - assertFalse( children.isDirty() ); - - ArrayList otherCollection = new ArrayList(); - otherCollection.add( child ); - assertFalse( children.retainAll( otherCollection ) ); - assertFalse( children.isDirty() ); - - otherCollection = new ArrayList(); - otherCollection.add( otherChild ); - assertFalse( children.removeAll( otherCollection ) ); - assertFalse( children.isDirty() ); - - children.clear(); - session.delete( child ); - assertTrue( children.isDirty() ); - - session.flush(); - - children.clear(); - assertFalse( children.isDirty() ); - - session.delete( parent ); - session.getTransaction().commit(); - session.close(); - } -} diff --git a/hibernate-core/src/test/java/org/hibernate/test/collection/list/ListIndexReferenceFromListElementTest.java b/hibernate-core/src/test/java/org/hibernate/test/collection/list/ListIndexReferenceFromListElementTest.java deleted file mode 100644 index 1cd452d8b6..0000000000 --- a/hibernate-core/src/test/java/org/hibernate/test/collection/list/ListIndexReferenceFromListElementTest.java +++ /dev/null @@ -1,139 +0,0 @@ -/* - * 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 . - */ -package org.hibernate.test.collection.list; - -import java.util.ArrayList; -import java.util.List; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.FetchType; -import javax.persistence.GeneratedValue; -import javax.persistence.Id; -import javax.persistence.JoinColumn; -import javax.persistence.ManyToOne; -import javax.persistence.OneToMany; -import javax.persistence.OrderColumn; -import javax.persistence.Table; - -import org.hibernate.Session; - -import org.hibernate.testing.junit4.BaseNonConfigCoreFunctionalTestCase; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; - -import static junit.framework.Assert.assertEquals; - -/** - * Test initially developed for HHH-9195 - * @author Steve Ebersole - */ -public class ListIndexReferenceFromListElementTest extends BaseNonConfigCoreFunctionalTestCase { - @Entity( name = "LocalOrder" ) - @Table( name = "LocalOrder" ) - public static class LocalOrder { - @Id - @GeneratedValue - public Integer id; - @OneToMany( mappedBy = "order", cascade = CascadeType.ALL, fetch = FetchType.LAZY ) - @OrderColumn( name = "position" ) - public List lineItems = new ArrayList(); - - public LocalOrder() { - } - - public LocalLineItem makeLineItem(String name) { - LocalLineItem lineItem = new LocalLineItem( name, this ); - lineItems.add( lineItem ); - return lineItem; - } - } - - @Entity( name = "LocalLineItem" ) - @Table( name = "LocalLineItem" ) - public static class LocalLineItem { - @Id - @GeneratedValue - public Integer id; - public String name; - @ManyToOne - @JoinColumn - public LocalOrder order; - @Column( insertable = false, updatable = false ) - public int position; - - public LocalLineItem() { - } - - public LocalLineItem(String name, LocalOrder order) { - this.name = name; - this.order = order; - } - } - - @Override - protected Class[] getAnnotatedClasses() { - return new Class[] { LocalOrder.class, LocalLineItem.class }; - } - - @Before - public void before() { - Session s = sessionFactory().openSession(); - s.beginTransaction(); - LocalOrder localOrder = new LocalOrder(); - localOrder.makeLineItem( "Shoes" ); - localOrder.makeLineItem( "Socks" ); - s.save( localOrder ); - s.getTransaction().commit(); - s.close(); - } - - @After - public void after() { - Session s = sessionFactory().openSession(); - s.beginTransaction(); - s.createQuery( "delete LocalLineItem" ).executeUpdate(); - s.createQuery( "delete LocalOrder" ).executeUpdate(); - s.getTransaction().commit(); - s.close(); - } - - @Test - public void testIt() { - { - Session s = openSession(); - s.beginTransaction(); - LocalOrder order = s.byId( LocalOrder.class ).load( 1 ); - assertEquals( 2, order.lineItems.size() ); - LocalLineItem shoes = order.lineItems.get( 0 ); - LocalLineItem socks = order.lineItems.get( 1 ); - assertEquals( "Shoes", shoes.name ); - assertEquals( 0, shoes.position ); - assertEquals( 1, socks.position ); - order.lineItems.remove( socks ); - order.lineItems.add( 0, socks ); - s.getTransaction().commit(); - s.close(); - } - - { - Session s = openSession(); - s.beginTransaction(); - LocalOrder order = s.byId( LocalOrder.class ).load( 1 ); - assertEquals( 2, order.lineItems.size() ); - LocalLineItem socks = order.lineItems.get( 0 ); - LocalLineItem shoes = order.lineItems.get( 1 ); - assertEquals( "Shoes", shoes.name ); - assertEquals( 0, socks.position ); - assertEquals( 1, shoes.position ); - - s.getTransaction().commit(); - s.close(); - } - } -} diff --git a/hibernate-core/src/test/java/org/hibernate/test/collection/list/PersistentListTest.java b/hibernate-core/src/test/java/org/hibernate/test/collection/list/PersistentListTest.java deleted file mode 100644 index 6f315ba71d..0000000000 --- a/hibernate-core/src/test/java/org/hibernate/test/collection/list/PersistentListTest.java +++ /dev/null @@ -1,202 +0,0 @@ -/* - * 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 . - */ -package org.hibernate.test.collection.list; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; - -import java.sql.Connection; -import java.sql.PreparedStatement; -import java.sql.ResultSet; -import java.sql.SQLException; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.Map; - -import org.hibernate.Session; -import org.hibernate.collection.internal.PersistentList; -import org.hibernate.engine.spi.SessionImplementor; -import org.hibernate.jdbc.Work; -import org.hibernate.persister.collection.CollectionPersister; -import org.hibernate.persister.collection.QueryableCollection; -import org.hibernate.sql.SimpleSelect; -import org.hibernate.testing.TestForIssue; -import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase; -import org.junit.Test; - -/** - * Tests related to operations on a PersistentList - * - * @author Steve Ebersole - */ -public class PersistentListTest extends BaseCoreFunctionalTestCase { - - @Override - public String[] getMappings() { - return new String[] { "collection/list/Mappings.hbm.xml" }; - } - - @Test - @TestForIssue( jiraKey = "HHH-5732" ) - public void testInverseListIndex() { - // make sure no one changes the mapping - final CollectionPersister collectionPersister = sessionFactory().getCollectionPersister( ListOwner.class.getName() + ".children" ); - assertTrue( collectionPersister.isInverse() ); - - // do some creations... - Session session = openSession(); - session.beginTransaction(); - - ListOwner root = new ListOwner( "root" ); - ListOwner child1 = new ListOwner( "c1" ); - root.getChildren().add( child1 ); - child1.setParent( root ); - ListOwner child2 = new ListOwner( "c2" ); - root.getChildren().add( child2 ); - child2.setParent( root ); - - session.save( root ); - session.getTransaction().commit(); - session.close(); - - // now, make sure the list-index column gotten written... - final Session session2 = openSession(); - session2.beginTransaction(); - session2.doWork( - new Work() { - @Override - public void execute(Connection connection) throws SQLException { - final QueryableCollection queryableCollection = (QueryableCollection) collectionPersister; - SimpleSelect select = new SimpleSelect( getDialect() ) - .setTableName( queryableCollection.getTableName() ) - .addColumn( "NAME" ) - .addColumn( "LIST_INDEX" ) - .addCondition( "NAME", "<>", "?" ); - PreparedStatement preparedStatement = ((SessionImplementor)session2).getJdbcCoordinator().getStatementPreparer().prepareStatement( select.toStatementString() ); - preparedStatement.setString( 1, "root" ); - ResultSet resultSet = ((SessionImplementor)session2).getJdbcCoordinator().getResultSetReturn().extract( preparedStatement ); - Map valueMap = new HashMap(); - while ( resultSet.next() ) { - final String name = resultSet.getString( 1 ); - assertFalse( "NAME column was null", resultSet.wasNull() ); - final int position = resultSet.getInt( 2 ); - assertFalse( "LIST_INDEX column was null", resultSet.wasNull() ); - valueMap.put( name, position ); - } - assertEquals( 2, valueMap.size() ); - - // c1 should be list index 0 - assertEquals( Integer.valueOf( 0 ), valueMap.get( "c1" ) ); - // c2 should be list index 1 - assertEquals( Integer.valueOf( 1 ), valueMap.get( "c2" ) ); - } - } - ); - session2.delete( root ); - session2.getTransaction().commit(); - session2.close(); - } - - @Test - @TestForIssue( jiraKey = "HHH-5732" ) - public void testInverseListIndex2() { - // make sure no one changes the mapping - final CollectionPersister collectionPersister = sessionFactory().getCollectionPersister( Order.class.getName() + ".lineItems" ); - assertTrue( collectionPersister.isInverse() ); - - // do some creations... - Session session = openSession(); - session.beginTransaction(); - - Order order = new Order( "acme-1" ); - order.addLineItem( "abc", 2 ); - order.addLineItem( "def", 200 ); - order.addLineItem( "ghi", 13 ); - session.save( order ); - session.getTransaction().commit(); - session.close(); - - // now, make sure the list-index column gotten written... - final Session session2 = openSession(); - session2.beginTransaction(); - session2.doWork( - new Work() { - @Override - public void execute(Connection connection) throws SQLException { - final QueryableCollection queryableCollection = (QueryableCollection) collectionPersister; - SimpleSelect select = new SimpleSelect( getDialect() ) - .setTableName( queryableCollection.getTableName() ) - .addColumn( "ORDER_ID" ) - .addColumn( "INDX" ) - .addColumn( "PRD_CODE" ); - PreparedStatement preparedStatement = ((SessionImplementor)session2).getJdbcCoordinator().getStatementPreparer().prepareStatement( select.toStatementString() ); - ResultSet resultSet = ((SessionImplementor)session2).getJdbcCoordinator().getResultSetReturn().extract( preparedStatement ); - Map valueMap = new HashMap(); - while ( resultSet.next() ) { - final int fk = resultSet.getInt( 1 ); - assertFalse( "Collection key (FK) column was null", resultSet.wasNull() ); - final int indx = resultSet.getInt( 2 ); - assertFalse( "List index column was null", resultSet.wasNull() ); - final String prodCode = resultSet.getString( 3 ); - assertFalse( "Prod code column was null", resultSet.wasNull() ); - valueMap.put( prodCode, indx ); - } - assertEquals( 3, valueMap.size() ); - assertEquals( Integer.valueOf( 0 ), valueMap.get( "abc" ) ); - assertEquals( Integer.valueOf( 1 ), valueMap.get( "def" ) ); - assertEquals( Integer.valueOf( 2 ), valueMap.get( "ghi" ) ); - } - } - ); - session2.delete( order ); - session2.getTransaction().commit(); - session2.close(); - } - - @Test - public void testWriteMethodDirtying() { - ListOwner parent = new ListOwner( "root" ); - ListOwner child = new ListOwner( "c1" ); - parent.getChildren().add( child ); - child.setParent( parent ); - ListOwner otherChild = new ListOwner( "c2" ); - - Session session = openSession(); - session.beginTransaction(); - session.save( parent ); - session.flush(); - // at this point, the list on parent has now been replaced with a PersistentList... - PersistentList children = (PersistentList) parent.getChildren(); - - assertFalse( children.remove( otherChild ) ); - assertFalse( children.isDirty() ); - - ArrayList otherCollection = new ArrayList(); - otherCollection.add( child ); - assertFalse( children.retainAll( otherCollection ) ); - assertFalse( children.isDirty() ); - - otherCollection = new ArrayList(); - otherCollection.add( otherChild ); - assertFalse( children.removeAll( otherCollection ) ); - assertFalse( children.isDirty() ); - - children.clear(); - session.delete( child ); - assertTrue( children.isDirty() ); - - session.flush(); - - children.clear(); - assertFalse( children.isDirty() ); - - session.delete( parent ); - session.getTransaction().commit(); - session.close(); - } -} diff --git a/hibernate-core/src/test/java/org/hibernate/test/collection/multisession/MultipleSessionCollectionTest.java b/hibernate-core/src/test/java/org/hibernate/test/collection/multisession/MultipleSessionCollectionTest.java deleted file mode 100644 index 763664e9f4..0000000000 --- a/hibernate-core/src/test/java/org/hibernate/test/collection/multisession/MultipleSessionCollectionTest.java +++ /dev/null @@ -1,694 +0,0 @@ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * Copyright (c) 2014, Red Hat Inc. or third-party contributors as - * indicated by the @author tags or express copyright attribution - * statements applied by the authors. All third-party contributions are - * distributed under license by Red Hat Inc. - * - * This copyrighted material is made available to anyone wishing to use, modify, - * copy, or redistribute it subject to the terms and conditions of the GNU - * Lesser General Public License, as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY - * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License - * for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this distribution; if not, write to: - * Free Software Foundation, Inc. - * 51 Franklin Street, Fifth Floor - * Boston, MA 02110-1301 USA - */ -package org.hibernate.test.collection.multisession; - -import java.util.HashSet; -import java.util.Set; -import javax.persistence.CascadeType; -import javax.persistence.ElementCollection; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.Id; -import javax.persistence.JoinColumn; -import javax.persistence.OneToMany; -import javax.persistence.Table; - -import org.hibernate.Hibernate; -import org.hibernate.HibernateException; -import org.hibernate.Session; -import org.hibernate.collection.internal.AbstractPersistentCollection; -import org.hibernate.collection.spi.PersistentCollection; -import org.hibernate.engine.spi.CollectionEntry; -import org.hibernate.engine.spi.SessionImplementor; - -import org.hibernate.testing.TestForIssue; -import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase; -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; -import static org.junit.Assert.fail; - -/** - * @author Gail Badner - */ -public class MultipleSessionCollectionTest extends BaseCoreFunctionalTestCase { - - @Test - @TestForIssue( jiraKey = "HHH-9518" ) - public void testSaveOrUpdateOwnerWithCollectionInNewSessionBeforeFlush() { - Parent p = new Parent(); - Child c = new Child(); - p.children.add( c ); - - Session s1 = openSession(); - s1.getTransaction().begin(); - s1.saveOrUpdate( p ); - - // try to save the same entity in a new session before flushing the first session - - Session s2 = openSession(); - s2.getTransaction().begin(); - try { - s2.saveOrUpdate( p ); - s2.getTransaction().commit(); - fail( "should have thrown HibernateException" ); - } - catch (HibernateException ex) { - log.error( ex ); - s2.getTransaction().rollback(); - } - finally { - s2.close(); - } - - // should still be able to commit in first session - s1.getTransaction().commit(); - s1.close(); - - s1 = openSession(); - s1.getTransaction().begin(); - Parent pGet = s1.get( Parent.class, p.id ); - assertEquals( c.id, pGet.children.iterator().next().id ); - session.delete( pGet ); - s1.getTransaction().commit(); - session.close(); - } - - - @Test - @TestForIssue( jiraKey = "HHH-9518" ) - public void testSaveOrUpdateOwnerWithCollectionInNewSessionAfterFlush() { - Parent p = new Parent(); - Child c = new Child(); - p.children.add( c ); - - Session s1 = openSession(); - s1.getTransaction().begin(); - s1.saveOrUpdate( p ); - s1.flush(); - - // try to save the same entity in a new session after flushing the first session - - Session s2 = openSession(); - s2.getTransaction().begin(); - try { - s2.saveOrUpdate( p ); - s2.getTransaction().commit(); - fail( "should have thrown HibernateException" ); - } - catch (HibernateException ex) { - log.error( ex ); - s2.getTransaction().rollback(); - } - finally { - s2.close(); - } - - // should still be able to commit in first session - s1.getTransaction().commit(); - s1.close(); - - s1 = openSession(); - s1.getTransaction().begin(); - Parent pGet = s1.get( Parent.class, p.id ); - assertEquals( c.id, pGet.children.iterator().next().id ); - session.delete( pGet ); - s1.getTransaction().commit(); - session.close(); - } - - @Test - @TestForIssue( jiraKey = "HHH-9518" ) - public void testSaveOrUpdateOwnerWithUninitializedCollectionInNewSession() { - Parent p = new Parent(); - Child c = new Child(); - p.children.add( c ); - - Session s = openSession(); - s.getTransaction().begin(); - s.persist( p ); - s.getTransaction().commit(); - s.close(); - - Session s1 = openSession(); - s1.getTransaction().begin(); - p = s1.get( Parent.class, p.id ); - assertFalse( Hibernate.isInitialized( p.children ) ); - - // try to save the same entity (with an uninitialized collection) in a new session - - Session s2 = openSession(); - s2.getTransaction().begin(); - try { - s2.saveOrUpdate( p ); - s2.getTransaction().commit(); - fail( "should have thrown HibernateException" ); - } - catch (HibernateException ex) { - log.error( ex ); - s2.getTransaction().rollback(); - } - finally { - s2.close(); - } - - // should still be able to initialize collection, modify and commit in first session - assertFalse( Hibernate.isInitialized( p.children ) ); - Hibernate.initialize( p.children ); - p.children.add( new Child() ); - s1.getTransaction().commit(); - s1.close(); - - s1 = openSession(); - s1.getTransaction().begin(); - Parent pGet = s1.get( Parent.class, p.id ); - assertEquals( 2, pGet.children.size()); - session.delete( pGet ); - s1.getTransaction().commit(); - session.close(); - } - - @Test - @TestForIssue( jiraKey = "HHH-9518" ) - public void testSaveOrUpdateOwnerWithInitializedCollectionInNewSession() { - Parent p = new Parent(); - Child c = new Child(); - p.children.add( c ); - - Session s = openSession(); - s.getTransaction().begin(); - s.persist( p ); - s.getTransaction().commit(); - s.close(); - - Session s1 = openSession(); - s1.getTransaction().begin(); - p = s1.get( Parent.class, p.id ); - Hibernate.initialize( p.children ); - - // try to save the same entity (with an initialized collection) in a new session - - Session s2 = openSession(); - s2.getTransaction().begin(); - try { - s2.saveOrUpdate( p ); - s2.getTransaction().commit(); - fail( "should have thrown HibernateException" ); - } - catch (HibernateException ex) { - log.error( ex ); - s2.getTransaction().rollback(); - } - finally { - s2.close(); - } - - // should still be able to commit in first session - s1.getTransaction().commit(); - s1.close(); - - s1 = openSession(); - s1.getTransaction().begin(); - Parent pGet = s1.get( Parent.class, p.id ); - assertEquals( c.id, pGet.children.iterator().next().id ); - session.delete( pGet ); - s1.getTransaction().commit(); - session.close(); - } - - // - - @Test - @TestForIssue( jiraKey = "HHH-9518" ) - public void testCopyPersistentCollectionReferenceBeforeFlush() { - Parent p = new Parent(); - Child c = new Child(); - p.children.add( c ); - - Session s1 = openSession(); - s1.getTransaction().begin(); - s1.persist( p ); - - // Copy p.children into a different Parent before flush and try to save in new session. - - Parent pWithSameChildren = new Parent(); - pWithSameChildren.children = p.children; - - Session s2 = openSession(); - s2.getTransaction().begin(); - try { - s2.saveOrUpdate( pWithSameChildren ); - s2.getTransaction().commit(); - fail( "should have thrown HibernateException" ); - } - catch (HibernateException ex) { - log.error( ex ); - s2.getTransaction().rollback(); - } - finally { - s2.close(); - } - - // should still be able to commit in first session - s1.getTransaction().commit(); - s1.close(); - - s1 = openSession(); - s1.getTransaction().begin(); - Parent pGet = s1.get( Parent.class, p.id ); - assertEquals( c.id, pGet.children.iterator().next().id ); - session.delete( pGet ); - s1.getTransaction().commit(); - session.close(); - } - - @Test - @TestForIssue( jiraKey = "HHH-9518" ) - public void testCopyPersistentCollectionReferenceAfterFlush() { - Parent p = new Parent(); - Child c = new Child(); - p.children.add( c ); - - Session s1 = openSession(); - s1.getTransaction().begin(); - s1.persist( p ); - s1.flush(); - - // Copy p.children into a different Parent after flush and try to save in new session. - - Parent pWithSameChildren = new Parent(); - pWithSameChildren.children = p.children; - - Session s2 = openSession(); - s2.getTransaction().begin(); - try { - s2.saveOrUpdate( pWithSameChildren ); - s2.getTransaction().commit(); - fail( "should have thrown HibernateException" ); - } - catch (HibernateException ex) { - log.error( ex ); - s2.getTransaction().rollback(); - } - finally { - s2.close(); - } - - // should still be able to commit in first session - s1.getTransaction().commit(); - s1.close(); - - s1 = openSession(); - s1.getTransaction().begin(); - Parent pGet = s1.get( Parent.class, p.id ); - assertEquals( c.id, pGet.children.iterator().next().id ); - session.delete( pGet ); - s1.getTransaction().commit(); - session.close(); - } - - @Test - @TestForIssue( jiraKey = "HHH-9518" ) - public void testCopyUninitializedCollectionReferenceAfterGet() { - Parent p = new Parent(); - Child c = new Child(); - p.children.add( c ); - - Session s = openSession(); - s.getTransaction().begin(); - s.persist( p ); - s.getTransaction().commit(); - s.close(); - - Session s1 = openSession(); - s1.getTransaction().begin(); - p = s1.get( Parent.class, p.id ); - assertFalse( Hibernate.isInitialized( p.children ) ); - - // Copy p.children (uninitialized) into a different Parent and try to save in new session. - - Parent pWithSameChildren = new Parent(); - pWithSameChildren.children = p.children; - - Session s2 = openSession(); - s2.getTransaction().begin(); - try { - s2.saveOrUpdate( pWithSameChildren ); - s2.getTransaction().commit(); - fail( "should have thrown HibernateException" ); - } - catch (HibernateException ex) { - log.error( ex ); - s2.getTransaction().rollback(); - } - finally { - s2.close(); - } - - // should still be able to commit in first session - s1.getTransaction().commit(); - s1.close(); - - s1 = openSession(); - s1.getTransaction().begin(); - Parent pGet = s1.get( Parent.class, p.id ); - assertEquals( c.id, pGet.children.iterator().next().id ); - session.delete( pGet ); - s1.getTransaction().commit(); - session.close(); - } - - @Test - @TestForIssue( jiraKey = "HHH-9518" ) - public void testCopyInitializedCollectionReferenceAfterGet() { - Parent p = new Parent(); - Child c = new Child(); - p.children.add( c ); - - Session s = openSession(); - s.getTransaction().begin(); - s.persist( p ); - s.getTransaction().commit(); - s.close(); - - Session s1 = openSession(); - s1.getTransaction().begin(); - p = s1.get( Parent.class, p.id ); - Hibernate.initialize( p.children ); - - // Copy p.children (initialized) into a different Parent.children and try to save in new session. - - Parent pWithSameChildren = new Parent(); - pWithSameChildren.children = p.children; - - Session s2 = openSession(); - s2.getTransaction().begin(); - try { - s2.saveOrUpdate( pWithSameChildren ); - s2.getTransaction().commit(); - fail( "should have thrown HibernateException" ); - } - catch (HibernateException ex) { - log.error( ex ); - s2.getTransaction().rollback(); - } - finally { - s2.close(); - } - - // should still be able to commit in first session - s1.getTransaction().commit(); - s1.close(); - - s1 = openSession(); - s1.getTransaction().begin(); - Parent pGet = s1.get( Parent.class, p.id ); - assertEquals( c.id, pGet.children.iterator().next().id ); - session.delete( pGet ); - s1.getTransaction().commit(); - session.close(); - } - - @Test - @TestForIssue( jiraKey = "HHH-9518" ) - public void testCopyInitializedCollectionReferenceToNewEntityCollectionRoleAfterGet() { - Parent p = new Parent(); - Child c = new Child(); - p.children.add( c ); - - Session s = openSession(); - s.getTransaction().begin(); - s.persist( p ); - s.getTransaction().commit(); - s.close(); - - Session s1 = openSession(); - s1.getTransaction().begin(); - p = s1.get( Parent.class, p.id ); - Hibernate.initialize( p.children ); - - // Copy p.children (initialized) into a different Parent.oldChildren (note different collection role) - // and try to save in new session. - - Parent pWithSameChildren = new Parent(); - pWithSameChildren.oldChildren = p.children; - - Session s2 = openSession(); - s2.getTransaction().begin(); - try { - s2.saveOrUpdate( pWithSameChildren ); - s2.getTransaction().commit(); - fail( "should have thrown HibernateException" ); - } - catch (HibernateException ex) { - log.error( ex ); - s2.getTransaction().rollback(); - } - finally { - s2.close(); - } - - // should still be able to commit in first session - s1.getTransaction().commit(); - s1.close(); - - s1 = openSession(); - s1.getTransaction().begin(); - Parent pGet = s1.get( Parent.class, p.id ); - assertEquals( c.id, pGet.children.iterator().next().id ); - session.delete( pGet ); - s1.getTransaction().commit(); - session.close(); - } - - @Test - @TestForIssue( jiraKey = "HHH-9518" ) - public void testDeleteCommitCopyToNewOwnerInNewSession() { - Parent p1 = new Parent(); - p1.nickNames.add( "nick" ); - Parent p2 = new Parent(); - Session s1 = openSession(); - s1.getTransaction().begin(); - s1.save( p1 ); - s1.save( p2 ); - s1.getTransaction().commit(); - s1.close(); - - s1 = openSession(); - s1.getTransaction().begin(); - s1.delete( p1 ); - s1.flush(); - s1.getTransaction().commit(); - - // need to commit after flushing; otherwise, will get lock failure when try to move the collection below - - assertNull( ( (SessionImplementor) s1 ).getPersistenceContext().getEntry( p1 ) ); - CollectionEntry ceChildren = ( (SessionImplementor) s1 ).getPersistenceContext().getCollectionEntry( (PersistentCollection) p1.children ); - CollectionEntry ceNickNames = ( (SessionImplementor) s1 ).getPersistenceContext().getCollectionEntry( (PersistentCollection) p1.nickNames ); - assertNull( ceChildren ); - assertNull( ceNickNames ); - assertNull( ( ( AbstractPersistentCollection) p1.children ).getSession() ); - assertNull( ( ( AbstractPersistentCollection) p1.oldChildren ).getSession() ); - assertNull( ( ( AbstractPersistentCollection) p1.nickNames ).getSession() ); - assertNull( ( (AbstractPersistentCollection) p1.oldNickNames ).getSession() ); - - // Assign the deleted collection to a different entity with same collection role (p2.nickNames) - - p2.nickNames = p1.nickNames; - Session s2 = openSession(); - s2.getTransaction().begin(); - s2.saveOrUpdate( p2 ); - s2.getTransaction().commit(); - s2.close(); - - s1.close(); - } - - @Test - @TestForIssue( jiraKey = "HHH-9518" ) - public void testDeleteCommitCopyToNewOwnerNewCollectionRoleInNewSession() { - Parent p1 = new Parent(); - p1.nickNames.add( "nick" ); - Parent p2 = new Parent(); - Session s1 = openSession(); - s1.getTransaction().begin(); - s1.save( p1 ); - s1.save( p2 ); - s1.getTransaction().commit(); - s1.close(); - - s1 = openSession(); - s1.getTransaction().begin(); - s1.delete( p1 ); - s1.flush(); - s1.getTransaction().commit(); - - // need to commit after flushing; otherwise, will get lock failure when try to move the collection below - - assertNull( ( (SessionImplementor) s1 ).getPersistenceContext().getEntry( p1 ) ); - CollectionEntry ceChildren = ( (SessionImplementor) s1 ).getPersistenceContext().getCollectionEntry( (PersistentCollection) p1.children ); - CollectionEntry ceNickNames = ( (SessionImplementor) s1 ).getPersistenceContext().getCollectionEntry( (PersistentCollection) p1.nickNames ); - assertNull( ceChildren ); - assertNull( ceNickNames ); - assertNull( ( ( AbstractPersistentCollection) p1.children ).getSession() ); - assertNull( ( ( AbstractPersistentCollection) p1.oldChildren ).getSession() ); - assertNull( ( ( AbstractPersistentCollection) p1.nickNames ).getSession() ); - assertNull( ( (AbstractPersistentCollection) p1.oldNickNames ).getSession() ); - - // Assign the deleted collection to a different entity with different collection role (p2.oldNickNames) - - p2.oldNickNames = p1.nickNames; - Session s2 = openSession(); - s2.getTransaction().begin(); - s2.saveOrUpdate( p2 ); - s2.getTransaction().commit(); - s2.close(); - - s1.close(); - } - - @Test - @TestForIssue( jiraKey = "HHH-9518" ) - public void testDeleteCopyToNewOwnerInNewSessionBeforeFlush() { - Parent p1 = new Parent(); - p1.nickNames.add( "nick" ); - Parent p2 = new Parent(); - Session s1 = openSession(); - s1.getTransaction().begin(); - s1.save( p1 ); - s1.save( p2 ); - s1.getTransaction().commit(); - s1.close(); - - s1 = openSession(); - s1.getTransaction().begin(); - s1.delete( p1 ); - - // Assign the deleted collection to a different entity with same collection role (p2.nickNames) - // before committing delete. - - p2.nickNames = p1.nickNames; - Session s2 = openSession(); - s2.getTransaction().begin(); - try { - s2.saveOrUpdate( p2 ); - fail( "should have thrown HibernateException" ); - } - catch (HibernateException ex) { - log.error( ex ); - s2.getTransaction().rollback(); - } - finally { - s2.close(); - } - - // should still be able to commit the original delete - s1.getTransaction().commit(); - s1.close(); - } - - @Test - @TestForIssue( jiraKey = "HHH-9518" ) - public void testDeleteCopyToNewOwnerNewCollectionRoleInNewSessionBeforeFlush() { - Parent p1 = new Parent(); - p1.nickNames.add( "nick" ); - Parent p2 = new Parent(); - Session s1 = openSession(); - s1.getTransaction().begin(); - s1.save( p1 ); - s1.save( p2 ); - s1.getTransaction().commit(); - s1.close(); - - s1 = openSession(); - s1.getTransaction().begin(); - s1.delete( p1 ); - - // Assign the deleted collection to a different entity with different collection role (p2.oldNickNames) - // before committing delete. - - p2.oldNickNames = p1.nickNames; - Session s2 = openSession(); - s2.getTransaction().begin(); - try { - s2.saveOrUpdate( p2 ); - fail( "should have thrown HibernateException" ); - } - catch (HibernateException ex) { - log.error( ex ); - s2.getTransaction().rollback(); - } - finally { - s2.close(); - } - - // should still be able to commit the original delete - s1.getTransaction().commit(); - s1.close(); - } - - @Override - public Class[] getAnnotatedClasses() { - return new Class[] { - Parent.class, - Child.class - }; - } - - @Entity - @Table(name="Parent") - public static class Parent { - @Id - @GeneratedValue - private Long id; - - @ElementCollection - private Set nickNames = new HashSet(); - - @ElementCollection - private Set oldNickNames = new HashSet(); - - @OneToMany(cascade = CascadeType.ALL) - @JoinColumn - private Set children = new HashSet(); - - @OneToMany(cascade = CascadeType.ALL) - @JoinColumn - private Set oldChildren = new HashSet(); - - } - - @Entity - @Table(name="Child") - public static class Child { - @Id - @GeneratedValue - private Long id; - - } -} diff --git a/hibernate-core/src/test/java/org/hibernate/test/collection/multisession/MultipleSessionCollectionWarningTest.java b/hibernate-core/src/test/java/org/hibernate/test/collection/multisession/MultipleSessionCollectionWarningTest.java deleted file mode 100644 index e7a0090c74..0000000000 --- a/hibernate-core/src/test/java/org/hibernate/test/collection/multisession/MultipleSessionCollectionWarningTest.java +++ /dev/null @@ -1,328 +0,0 @@ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * Copyright (c) 2014, Red Hat Inc. or third-party contributors as - * indicated by the @author tags or express copyright attribution - * statements applied by the authors. All third-party contributions are - * distributed under license by Red Hat Inc. - * - * This copyrighted material is made available to anyone wishing to use, modify, - * copy, or redistribute it subject to the terms and conditions of the GNU - * Lesser General Public License, as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY - * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License - * for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this distribution; if not, write to: - * Free Software Foundation, Inc. - * 51 Franklin Street, Fifth Floor - * Boston, MA 02110-1301 USA - */ -package org.hibernate.test.collection.multisession; - -import java.util.HashSet; -import java.util.Set; -import javax.persistence.CascadeType; -import javax.persistence.ElementCollection; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.Id; -import javax.persistence.JoinColumn; -import javax.persistence.OneToMany; -import javax.persistence.Table; - -import org.junit.Rule; -import org.junit.Test; - -import org.hibernate.Hibernate; -import org.hibernate.HibernateException; -import org.hibernate.Session; -import org.hibernate.collection.internal.AbstractPersistentCollection; -import org.hibernate.collection.internal.PersistentSet; -import org.hibernate.collection.spi.PersistentCollection; -import org.hibernate.engine.spi.CollectionEntry; -import org.hibernate.engine.spi.SessionImplementor; -import org.hibernate.internal.CoreLogging; -import org.hibernate.internal.CoreMessageLogger; -import org.hibernate.testing.TestForIssue; -import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase; -import org.hibernate.testing.logger.LoggerInspectionRule; -import org.hibernate.testing.logger.Triggerable; - -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertSame; -import static org.junit.Assert.assertTrue; - -/** - * @author Gail Badner - */ -public class MultipleSessionCollectionWarningTest extends BaseCoreFunctionalTestCase { - private static final CoreMessageLogger LOG = CoreLogging.messageLogger( AbstractPersistentCollection.class ); - - @Rule - public LoggerInspectionRule logInspection = new LoggerInspectionRule( LOG ); - - @Test - @TestForIssue( jiraKey = "HHH-9518" ) - public void testSetCurrentSessionOverwritesNonConnectedSesssion() { - Parent p = new Parent(); - Child c = new Child(); - p.children.add( c ); - - Session s1 = openSession(); - s1.getTransaction().begin(); - s1.saveOrUpdate( p ); - - // Now remove the collection from the PersistenceContext without unsetting its session - // This should never be done in practice; it is done here only to test that the warning - // gets logged. s1 will not function properly so the transaction will ultimately need - // to be rolled-back. - - CollectionEntry ce = ( (SessionImplementor) s1 ).getPersistenceContext() - .removeCollectionEntry( (PersistentSet) p.children ); - assertNotNull( ce ); - - // the collection session should still be s1; the collection is no longer "connected" because its - // CollectionEntry has been removed. - assertSame( s1, ( (AbstractPersistentCollection) p.children ).getSession() ); - - Session s2 = openSession(); - s2.getTransaction().begin(); - - Triggerable triggerable = logInspection.watchForLogMessages( "HHH000470:" ); - assertFalse( triggerable.wasTriggered() ); - - // The following should trigger warning because we're setting a new session when the collection already - // has a non-null session (and the collection is not "connected" to that session); - // Since s1 was not flushed, the collection role will not be known (no way to test that other than inspection). - s2.saveOrUpdate( p ); - - assertTrue( triggerable.wasTriggered() ); - - // collection's session should be overwritten with s2 - assertSame( s2, ( (AbstractPersistentCollection) p.children ).getSession() ); - - s2.getTransaction().rollback(); - s2.close(); - - s1.getTransaction().rollback(); - s1.close(); - } - - @Test - @TestForIssue( jiraKey = "HHH-9518" ) - public void testSetCurrentSessionOverwritesNonConnectedSesssionFlushed() { - Parent p = new Parent(); - Child c = new Child(); - p.children.add( c ); - - Session s1 = openSession(); - s1.getTransaction().begin(); - s1.saveOrUpdate( p ); - - // flush the session so that p.children will contain its role - s1.flush(); - - // Now remove the collection from the PersistenceContext without unsetting its session - // This should never be done in practice; it is done here only to test that the warning - // gets logged. s1 will not function properly so the transaction will ultimately need - // to be rolled-back. - - CollectionEntry ce = ( (SessionImplementor) s1 ).getPersistenceContext() - .removeCollectionEntry( (PersistentSet) p.children ); - assertNotNull( ce ); - - // the collection session should still be s1; the collection is no longer "connected" because its - // CollectionEntry has been removed. - assertSame( s1, ( (AbstractPersistentCollection) p.children ).getSession() ); - - Session s2 = openSession(); - s2.getTransaction().begin(); - - Triggerable triggerable = logInspection.watchForLogMessages( "HHH000470:" ); - assertFalse( triggerable.wasTriggered() ); - - // The following should trigger warning because we're setting a new session when the collection already - // has a non-null session (and the collection is not "connected" to that session); - // The collection role and key should be included in the message (no way to test that other than inspection). - s2.saveOrUpdate( p ); - - assertTrue( triggerable.wasTriggered() ); - - // collection's session should be overwritten with s2 - assertSame( s2, ( (AbstractPersistentCollection) p.children ).getSession() ); - - s2.getTransaction().rollback(); - s2.close(); - - s1.getTransaction().rollback(); - s1.close(); - } - - @Test - @TestForIssue( jiraKey = "HHH-9518" ) - public void testUnsetSessionCannotOverwriteNonConnectedSesssion() { - Parent p = new Parent(); - Child c = new Child(); - p.children.add( c ); - - Session s1 = openSession(); - s1.getTransaction().begin(); - s1.saveOrUpdate( p ); - - // Now remove the collection from the PersistenceContext without unsetting its session - // This should never be done in practice; it is done here only to test that the warning - // gets logged. s1 will not function properly so the transaction will ultimately need - // to be rolled-back. - - CollectionEntry ce = ( (SessionImplementor) s1 ).getPersistenceContext() - .removeCollectionEntry( (PersistentSet) p.children ); - assertNotNull( ce ); - - // the collection session should still be s1; the collection is no longer "connected" because its - // CollectionEntry has been removed. - assertSame( s1, ( (AbstractPersistentCollection) p.children ).getSession() ); - - Session s2 = openSession(); - s2.getTransaction().begin(); - - Triggerable triggerable = logInspection.watchForLogMessages( "HHH000471:" ); - assertFalse( triggerable.wasTriggered() ); - - // The following should trigger warning because we're unsetting a different session. - // We should not do this in practice; it is done here only to force the warning. - // Since s1 was not flushed, the collection role will not be known (no way to test that). - assertFalse( ( (PersistentCollection) p.children ).unsetSession( (SessionImplementor) s2 ) ); - - assertTrue( triggerable.wasTriggered() ); - - // collection's session should still be s1 - assertSame( s1, ( (AbstractPersistentCollection) p.children ).getSession() ); - - s2.getTransaction().rollback(); - s2.close(); - - s1.getTransaction().rollback(); - s1.close(); - } - - @Test - @TestForIssue( jiraKey = "HHH-9518" ) - public void testUnsetSessionCannotOverwriteConnectedSesssion() { - Parent p = new Parent(); - Child c = new Child(); - p.children.add( c ); - - Session s1 = openSession(); - s1.getTransaction().begin(); - s1.saveOrUpdate( p ); - - // The collection is "connected" to s1 because it contains the CollectionEntry - CollectionEntry ce = ( (SessionImplementor) s1 ).getPersistenceContext() - .getCollectionEntry( (PersistentCollection) p.children ); - assertNotNull( ce ); - - // the collection session should be s1 - assertSame( s1, ( (AbstractPersistentCollection) p.children ).getSession() ); - - Session s2 = openSession(); - s2.getTransaction().begin(); - - Triggerable triggerable = logInspection.watchForLogMessages( "HHH000471:" ); - assertFalse( triggerable.wasTriggered() ); - - // The following should trigger warning because we're unsetting a different session - // We should not do this in practice; it is done here only to force the warning. - // Since s1 was not flushed, the collection role will not be known (no way to test that). - assertFalse( ( (PersistentCollection) p.children ).unsetSession( (SessionImplementor) s2 ) ); - - assertTrue( triggerable.wasTriggered() ); - - // collection's session should still be s1 - assertSame( s1, ( (AbstractPersistentCollection) p.children ).getSession() ); - - s2.getTransaction().rollback(); - s2.close(); - - s1.getTransaction().rollback(); - s1.close(); - } - - @Test - @TestForIssue( jiraKey = "HHH-9518" ) - public void testUnsetSessionCannotOverwriteConnectedSesssionFlushed() { - Parent p = new Parent(); - Child c = new Child(); - p.children.add( c ); - - Session s1 = openSession(); - s1.getTransaction().begin(); - s1.saveOrUpdate( p ); - - // flush the session so that p.children will contain its role - s1.flush(); - - // The collection is "connected" to s1 because it contains the CollectionEntry - CollectionEntry ce = ( (SessionImplementor) s1 ).getPersistenceContext() - .getCollectionEntry( (PersistentCollection) p.children ); - assertNotNull( ce ); - - // the collection session should be s1 - assertSame( s1, ( (AbstractPersistentCollection) p.children ).getSession() ); - - Session s2 = openSession(); - s2.getTransaction().begin(); - - Triggerable triggerable = logInspection.watchForLogMessages( "HHH000471:" ); - assertFalse( triggerable.wasTriggered() ); - - // The following should trigger warning because we're unsetting a different session - // We should not do this in practice; it is done here only to force the warning. - // The collection role and key should be included in the message (no way to test that other than inspection). - assertFalse( ( (PersistentCollection) p.children ).unsetSession( (SessionImplementor) s2 ) ); - - assertTrue( triggerable.wasTriggered() ); - - // collection's session should still be s1 - assertSame( s1, ( (AbstractPersistentCollection) p.children ).getSession() ); - - s2.getTransaction().rollback(); - s2.close(); - - s1.getTransaction().rollback(); - s1.close(); - } - - @Override - public Class[] getAnnotatedClasses() { - return new Class[] { - Parent.class, - Child.class - }; - } - - @Entity - @Table(name="Parent") - public static class Parent { - @Id - @GeneratedValue - private Long id; - - @OneToMany(cascade = CascadeType.ALL) - @JoinColumn - private Set children = new HashSet(); - } - - @Entity - @Table(name="Child") - public static class Child { - @Id - @GeneratedValue - private Long id; - - } -} diff --git a/hibernate-core/src/test/java/org/hibernate/test/collection/nonInsertable/NonInsertableColumnTest.java b/hibernate-core/src/test/java/org/hibernate/test/collection/nonInsertable/NonInsertableColumnTest.java deleted file mode 100644 index ef664eaca9..0000000000 --- a/hibernate-core/src/test/java/org/hibernate/test/collection/nonInsertable/NonInsertableColumnTest.java +++ /dev/null @@ -1,108 +0,0 @@ -package org.hibernate.test.collection.nonInsertable; - -import org.hibernate.HibernateException; -import org.hibernate.Session; -import org.hibernate.Transaction; - -import javax.persistence.*; - -import org.hibernate.cfg.AvailableSettings; -import org.hibernate.cfg.Configuration; -import org.hibernate.testing.TestForIssue; -import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase; -import org.junit.Test; - -import java.util.Arrays; -import java.util.List; - -import static org.junit.Assert.*; - -@TestForIssue(jiraKey = "HHH-13236") -public class NonInsertableColumnTest extends BaseCoreFunctionalTestCase { - - - @Override - protected Class[] getAnnotatedClasses() { - return new Class[] { - Parent.class, - Child.class - }; - } - - @Override - protected void configure(Configuration configuration) { - super.configure( configuration ); - - configuration.setProperty( AvailableSettings.SHOW_SQL, "true" ); - } - - @Test - public void test() { - Session session = null; - Transaction transaction = null; - - try { - session = openSession(); - transaction = session.beginTransaction(); - - Child child = new Child(); - child.field = "Test"; - child.nonInsertable = "nonInsertable"; - child.nonUpdatable = "nonUpdatable"; - - Parent parent = new Parent(); - parent.children = Arrays.asList(child); - - session.persist(parent); - - session.flush(); - - transaction.commit(); - - session.clear(); - - Parent loaded = session.get(Parent.class, parent.id); - assertEquals("nonUpdatable", loaded.children.get(0).nonUpdatable); - assertNull(loaded.children.get(0).nonInsertable); - assertEquals("Test", loaded.children.get(0).field); - assertEquals("Test", loaded.children.get(0).shadowField); - } catch (HibernateException e) { - if (transaction != null) { - transaction.rollback(); - } - fail(e.getMessage()); - } finally { - if (session != null) { - session.close(); - } - } - - } - - @Entity(name="Parent") - public static class Parent { - @Id - @GeneratedValue(strategy = GenerationType.AUTO) - public Long id; - - @ElementCollection - public List children; - } - - @Embeddable - public static class Child { - - @Column(name="field") - public String field; - - @Column(insertable = false) - public String nonInsertable; - - @Column(updatable = false) - public String nonUpdatable; - - @Column(name="field", insertable = false, updatable = false) - public String shadowField; - } - -} diff --git a/hibernate-core/src/test/java/org/hibernate/test/collectionalias/CollectionAliasTest.java b/hibernate-core/src/test/java/org/hibernate/test/collectionalias/CollectionAliasTest.java deleted file mode 100644 index 6fb668c975..0000000000 --- a/hibernate-core/src/test/java/org/hibernate/test/collectionalias/CollectionAliasTest.java +++ /dev/null @@ -1,61 +0,0 @@ -/* - * 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 . - */ -package org.hibernate.test.collectionalias; - -import org.hibernate.Session; - -import org.hibernate.testing.TestForIssue; -import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase; -import org.junit.Test; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertSame; - -/** - * @author Dave Stephan - * @author Gail Badner - */ -public class CollectionAliasTest extends BaseCoreFunctionalTestCase { - - @TestForIssue( jiraKey = "HHH-7545" ) - @Test - public void test() { - Session s = openSession(); - s.getTransaction().begin(); - ATable aTable = new ATable( 1 ); - TableB tableB = new TableB( - new TableBId( 1, "a", "b" ) - ); - aTable.getTablebs().add( tableB ); - tableB.setTablea( aTable ); - s.save( aTable ); - s.getTransaction().commit(); - s.close(); - - s = openSession(); - aTable = (ATable) s.createQuery( "select distinct tablea from ATable tablea LEFT JOIN FETCH tablea.tablebs " ).uniqueResult(); - assertEquals( new Integer( 1 ), aTable.getFirstId() ); - assertEquals( 1, aTable.getTablebs().size() ); - tableB = aTable.getTablebs().get( 0 ); - assertSame( aTable, tableB.getTablea() ); - assertEquals( new Integer( 1 ), tableB.getId().getFirstId() ); - assertEquals( "a", tableB.getId().getSecondId() ); - assertEquals( "b", tableB.getId().getThirdId() ); - s.close(); - } - - @Override - protected Class[] getAnnotatedClasses() { - return new Class[] { - TableBId.class, - TableB.class, - TableA.class, - ATable.class - }; - } - -} diff --git a/hibernate-core/src/test/java/org/hibernate/test/collectionalias/ReorderedMappingsCollectionAliasTest.java b/hibernate-core/src/test/java/org/hibernate/test/collectionalias/ReorderedMappingsCollectionAliasTest.java deleted file mode 100644 index e096ea390c..0000000000 --- a/hibernate-core/src/test/java/org/hibernate/test/collectionalias/ReorderedMappingsCollectionAliasTest.java +++ /dev/null @@ -1,28 +0,0 @@ -/* - * 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 . - */ -package org.hibernate.test.collectionalias; - -/** - * The bug fixed by HHH-7545 showed showed different results depending on the order - * in which entity mappings were processed. - * - * This mappings are in the opposite order here than in CollectionAliasTest. - * - * @Author Gail Badner - */ -public class ReorderedMappingsCollectionAliasTest extends CollectionAliasTest { - - @Override - protected Class[] getAnnotatedClasses() { - return new Class[] { - ATable.class, - TableA.class, - TableB.class, - TableBId.class, - }; - } -} diff --git a/hibernate-testing/src/main/java/org/hibernate/testing/orm/junit/DialectFeatureChecks.java b/hibernate-testing/src/main/java/org/hibernate/testing/orm/junit/DialectFeatureChecks.java index ff61889e9b..d860f10227 100644 --- a/hibernate-testing/src/main/java/org/hibernate/testing/orm/junit/DialectFeatureChecks.java +++ b/hibernate-testing/src/main/java/org/hibernate/testing/orm/junit/DialectFeatureChecks.java @@ -8,7 +8,6 @@ package org.hibernate.testing.orm.junit; import org.hibernate.dialect.Dialect; - /** * Container class for different implementation of the {@link DialectFeatureCheck} interface. * @@ -58,6 +57,12 @@ abstract public class DialectFeatureChecks { } } + public static class SupportsNoColumnInsert implements DialectFeatureCheck { + public boolean apply(Dialect dialect) { + return dialect.supportsNoColumnsInsert(); + } + } + public static class SupportsResultSetPositioningOnForwardOnlyCursorCheck implements DialectFeatureCheck { public boolean apply(Dialect dialect) { return dialect.supportsResultSetPositionQueryMethodsOnForwardOnlyCursor();