From 92aa612f4ebbc89f470af957ac5eb479ae864e7c Mon Sep 17 00:00:00 2001 From: Andrea Boriero Date: Thu, 20 Aug 2020 14:59:28 +0100 Subject: [PATCH] Fix PluralAttributMappingImpl issue when both index and element of a Map are Entity types --- .../internal/PluralAttributeMappingImpl.java | 347 ++++++++++++------ .../collection/map/hhh7557/EntityMapTest.java | 88 +++++ .../collection/map/hhh7557/MapHolder.java | 2 +- .../test/collection/map/hhh7557/MapKey.java | 2 +- .../test/collection/map/hhh7557/MapValue.java | 2 +- .../collection/map/hhh7557/EntityMapTest.java | 88 ----- 6 files changed, 326 insertions(+), 203 deletions(-) create mode 100644 hibernate-core/src/test/java/org/hibernate/orm/test/collection/map/hhh7557/EntityMapTest.java rename hibernate-core/src/test/java/org/hibernate/{ => orm}/test/collection/map/hhh7557/MapHolder.java (96%) rename hibernate-core/src/test/java/org/hibernate/{ => orm}/test/collection/map/hhh7557/MapKey.java (98%) rename hibernate-core/src/test/java/org/hibernate/{ => orm}/test/collection/map/hhh7557/MapValue.java (97%) delete mode 100644 hibernate-core/src/test/java/org/hibernate/test/collection/map/hhh7557/EntityMapTest.java diff --git a/hibernate-core/src/main/java/org/hibernate/metamodel/mapping/internal/PluralAttributeMappingImpl.java b/hibernate-core/src/main/java/org/hibernate/metamodel/mapping/internal/PluralAttributeMappingImpl.java index 6c1f6b48ce..d98358f719 100644 --- a/hibernate-core/src/main/java/org/hibernate/metamodel/mapping/internal/PluralAttributeMappingImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/metamodel/mapping/internal/PluralAttributeMappingImpl.java @@ -29,7 +29,6 @@ import org.hibernate.metamodel.mapping.BasicValuedModelPart; import org.hibernate.metamodel.mapping.CollectionIdentifierDescriptor; import org.hibernate.metamodel.mapping.CollectionMappingType; import org.hibernate.metamodel.mapping.CollectionPart; -import org.hibernate.metamodel.mapping.ColumnConsumer; import org.hibernate.metamodel.mapping.EmbeddableValuedModelPart; import org.hibernate.metamodel.mapping.EntityMappingType; import org.hibernate.metamodel.mapping.ForeignKeyDescriptor; @@ -42,9 +41,7 @@ import org.hibernate.metamodel.mapping.ordering.OrderByFragment; import org.hibernate.metamodel.mapping.ordering.OrderByFragmentTranslator; import org.hibernate.metamodel.mapping.ordering.TranslationContext; import org.hibernate.metamodel.model.domain.NavigableRole; -import org.hibernate.persister.collection.AbstractCollectionPersister; import org.hibernate.persister.collection.CollectionPersister; -import org.hibernate.persister.entity.AbstractEntityPersister; import org.hibernate.persister.entity.EntityPersister; import org.hibernate.persister.entity.Joinable; import org.hibernate.property.access.spi.PropertyAccess; @@ -112,7 +109,8 @@ public class PluralAttributeMappingImpl extends AbstractAttributeMapping private final IndexMetadata indexMetadata; private ForeignKeyDescriptor fkDescriptor; - private ForeignKeyDescriptor manyToManyFkDescriptor; + private ForeignKeyDescriptor elementFkDescriptor; + private ForeignKeyDescriptor indexFkDescriptor; private OrderByFragment orderByFragment; private OrderByFragment manyToManyOrderByFragment; @@ -243,68 +241,34 @@ public class PluralAttributeMappingImpl extends AbstractAttributeMapping Property bootProperty, Collection bootDescriptor, MappingModelCreationProcess creationProcess) { - if ( collectionDescriptor.getElementType() instanceof EntityType - || collectionDescriptor.getIndexType() instanceof EntityType ) { + final Dialect dialect = creationProcess.getCreationContext() + .getSessionFactory() + .getJdbcServices() + .getDialect(); + if ( collectionDescriptor.getElementType() instanceof EntityType ) { creationProcess.registerForeignKeyPostInitCallbacks( () -> { - final EntityPersister associatedEntityDescriptor; - final ModelPart fkTargetPart; - final Value fkBootDescriptorSource; - if ( collectionDescriptor.getElementType() instanceof EntityType ) { - final EntityType elementEntityType = (EntityType) collectionDescriptor.getElementType(); - associatedEntityDescriptor = creationProcess.getEntityPersister( elementEntityType.getAssociatedEntityName() ); - if ( ( (AbstractEntityPersister) associatedEntityDescriptor ).getTableName() - .equals( ( (AbstractCollectionPersister) collectionDescriptor ).getTableName() ) ) { - fkTargetPart = creationProcess - .getEntityPersister( bootDescriptor.getOwner().getEntityName() ) - .getIdentifierMapping(); - } - else { - fkTargetPart = associatedEntityDescriptor.getIdentifierMapping(); - } - fkBootDescriptorSource = bootDescriptor.getElement(); - } - else { - assert collectionDescriptor.getIndexType() != null; - assert bootDescriptor instanceof IndexedCollection; - final EntityType indexEntityType = (EntityType) collectionDescriptor.getIndexType(); - associatedEntityDescriptor = creationProcess.getEntityPersister( indexEntityType.getAssociatedEntityName() ); - fkTargetPart = indexEntityType.isReferenceToPrimaryKey() - ? associatedEntityDescriptor.getIdentifierMapping() - : associatedEntityDescriptor.findSubPart( indexEntityType.getRHSUniqueKeyPropertyName() ); - fkBootDescriptorSource = ( (IndexedCollection) bootDescriptor ).getIndex(); - } + elementFkDescriptor = createForeignKeyDescriptor( + bootDescriptor.getElement(), + (EntityType) collectionDescriptor.getElementType(), + creationProcess, + dialect + ); + return true; + } + ); + } + if ( collectionDescriptor.getIndexType() instanceof EntityType ) { + creationProcess.registerForeignKeyPostInitCallbacks( + () -> { + indexFkDescriptor = createForeignKeyDescriptor( + ( (IndexedCollection) bootDescriptor ).getIndex(), + (EntityType) collectionDescriptor.getIndexType(), + creationProcess, + dialect + ); - final Dialect dialect = creationProcess.getCreationContext() - .getSessionFactory() - .getJdbcServices() - .getDialect(); - if ( fkTargetPart instanceof BasicValuedModelPart ) { - final BasicValuedModelPart basicFkTargetPart = (BasicValuedModelPart) fkTargetPart; - final Joinable collectionDescriptorAsJoinable = (Joinable) collectionDescriptor; - manyToManyFkDescriptor = new SimpleForeignKeyDescriptor( - collectionDescriptorAsJoinable.getTableName(), - fkBootDescriptorSource.getColumnIterator().next().getText( dialect ), - basicFkTargetPart.getContainingTableExpression(), - basicFkTargetPart.getMappedColumnExpression(), - basicFkTargetPart.getJdbcMapping() - ); - } - else if ( fkTargetPart instanceof EmbeddableValuedModelPart ) { - manyToManyFkDescriptor = MappingModelCreationHelper.buildEmbeddedForeignKeyDescriptor( - (EmbeddableValuedModelPart) fkTargetPart, - this, - fkBootDescriptorSource, - dialect, - creationProcess - ); - } - else { - throw new NotYetImplementedFor6Exception( - "Support for composite foreign keys not yet implemented : " + collectionDescriptor.getRole() - ); - } return true; } ); @@ -348,6 +312,44 @@ public class PluralAttributeMappingImpl extends AbstractAttributeMapping } } + private ForeignKeyDescriptor createForeignKeyDescriptor( + Value fkBootDescriptorSource, + EntityType entityType, + MappingModelCreationProcess creationProcess, + Dialect dialect) { + final EntityPersister associatedEntityDescriptor = creationProcess.getEntityPersister( entityType.getAssociatedEntityName() ); + final ModelPart fkTargetPart = entityType.isReferenceToPrimaryKey() + ? associatedEntityDescriptor.getIdentifierMapping() + : associatedEntityDescriptor.findSubPart( entityType.getRHSUniqueKeyPropertyName() ); + + if ( fkTargetPart instanceof BasicValuedModelPart ) { + final BasicValuedModelPart basicFkTargetPart = (BasicValuedModelPart) fkTargetPart; + final Joinable collectionDescriptorAsJoinable = (Joinable) collectionDescriptor; + return new SimpleForeignKeyDescriptor( + collectionDescriptorAsJoinable.getTableName(), + fkBootDescriptorSource.getColumnIterator().next().getText( dialect ), + basicFkTargetPart.getContainingTableExpression(), + basicFkTargetPart.getMappedColumnExpression(), + basicFkTargetPart.getJdbcMapping() + ); + } + else if ( fkTargetPart instanceof EmbeddableValuedModelPart ) { + return MappingModelCreationHelper.buildEmbeddedForeignKeyDescriptor( + (EmbeddableValuedModelPart) fkTargetPart, + this, + fkBootDescriptorSource, + dialect, + creationProcess + ); + } + else { + throw new NotYetImplementedFor6Exception( + "Support for composite foreign keys not yet implemented : " + collectionDescriptor + .getRole() + ); + } + } + @Override public NavigableRole getNavigableRole() { return getCollectionDescriptor().getNavigableRole(); @@ -698,68 +700,121 @@ public class PluralAttributeMappingImpl extends AbstractAttributeMapping creationContext.getSessionFactory() ); + final EntityMappingType elementDescriptorEntityMappingType; + if ( elementDescriptor instanceof EntityCollectionPart ) { + elementDescriptorEntityMappingType = ( (EntityCollectionPart) elementDescriptor ).getEntityMappingType(); + } + else { + elementDescriptorEntityMappingType = null; + } + + final EntityMappingType indexDescriptorEntityMappingType; + if ( indexDescriptor instanceof EntityCollectionPart ) { + indexDescriptorEntityMappingType = ( (EntityCollectionPart) indexDescriptor ).getEntityMappingType(); + } + else { + indexDescriptorEntityMappingType = null; + } final BiFunction tableReferenceJoinCreator; - final java.util.function.Predicate tableReferenceJoinNameChecker; - if ( elementDescriptor instanceof EntityCollectionPart || indexDescriptor instanceof EntityCollectionPart ) { - final EntityCollectionPart entityPartDescriptor; - if ( elementDescriptor instanceof EntityCollectionPart ) { - entityPartDescriptor = (EntityCollectionPart) elementDescriptor; - } - else { - entityPartDescriptor = (EntityCollectionPart) indexDescriptor; - } - final EntityMappingType mappingType = entityPartDescriptor.getEntityMappingType(); - final TableReference associatedPrimaryTable = mappingType.createPrimaryTableReference( + final java.util.function.Predicate tableReferenceJoinNameChecker = createTableReferenceJoinNameChecker( + elementDescriptorEntityMappingType, + indexDescriptorEntityMappingType + ); + + final TableReference elementAssociatedPrimaryTable; + final Function elementTableGroupFinalizer; + // todo (6.0) : not sure it is + final boolean elementUseInnerJoin; + if ( elementDescriptorEntityMappingType != null ) { + elementUseInnerJoin = canUseInnerJoin && !getAttributeMetadataAccess() + .resolveAttributeMetadata( elementDescriptorEntityMappingType ).isNullable(); + final SqlAstJoinType joinType = elementUseInnerJoin + ? SqlAstJoinType.INNER + : SqlAstJoinType.LEFT; + elementAssociatedPrimaryTable = elementDescriptorEntityMappingType.createPrimaryTableReference( sqlAliasBase, sqlExpressionResolver, creationContext ); - final boolean useInnerJoin = canUseInnerJoin && !getAttributeMetadataAccess() - .resolveAttributeMetadata( null ).isNullable(); + elementTableGroupFinalizer = createTableGroupFinalizer( + sqlExpressionResolver, + creationContext, + collectionTableReference, + elementAssociatedPrimaryTable, + joinType, + elementFkDescriptor + ); + } + else { + elementAssociatedPrimaryTable = null; + elementTableGroupFinalizer = null; + elementUseInnerJoin = false; + } - final Function tableGroupFinalizer = tableGroup -> { - final SqlAstJoinType joinType = useInnerJoin - ? SqlAstJoinType.INNER - : SqlAstJoinType.LEFT; - final TableReferenceJoin associationJoin = new TableReferenceJoin( - joinType, - associatedPrimaryTable, - manyToManyFkDescriptor.generateJoinPredicate( - collectionTableReference, - associatedPrimaryTable, - joinType, - sqlExpressionResolver, - creationContext - ) - ); - return associationJoin; - }; + TableReference indexAssociatedPrimaryTable; + final Function indexTableGroupFinalizer; + final boolean indexUseInnerJoin; + if ( indexDescriptorEntityMappingType != null ) { + indexUseInnerJoin = canUseInnerJoin && !getAttributeMetadataAccess() + .resolveAttributeMetadata( indexDescriptorEntityMappingType ).isNullable(); + final SqlAstJoinType joinType = indexUseInnerJoin + ? SqlAstJoinType.INNER + : SqlAstJoinType.LEFT; + indexAssociatedPrimaryTable = indexDescriptorEntityMappingType.createPrimaryTableReference( + sqlAliasBase, + sqlExpressionResolver, + creationContext + ); - tableReferenceJoinNameChecker = mappingType::containsTableReference; + indexTableGroupFinalizer = createTableGroupFinalizer( + sqlExpressionResolver, + creationContext, + collectionTableReference, + indexAssociatedPrimaryTable, + joinType, + indexFkDescriptor + ); + } + else { + indexAssociatedPrimaryTable = null; + indexTableGroupFinalizer = null; + indexUseInnerJoin = false; + } + + if ( elementDescriptorEntityMappingType != null || indexDescriptorEntityMappingType != null ) { tableReferenceJoinCreator = (tableExpression, tableGroup) -> { - if ( associatedPrimaryTable.getTableExpression().equals( tableExpression ) ) { - TableReferenceJoin tableReferenceJoin = tableGroupFinalizer.apply( tableGroup ); - return tableReferenceJoin; + if ( elementDescriptorEntityMappingType != null + && elementDescriptorEntityMappingType.containsTableReference( tableExpression ) ) { + return createTableReferenceJoin( + sqlExpressionResolver, + creationContext, + sqlAliasBase, + elementDescriptorEntityMappingType, + elementAssociatedPrimaryTable, + elementTableGroupFinalizer, + elementUseInnerJoin, + tableExpression, + tableGroup + ); } - else { - StandardTableGroup standardTableGroup = (StandardTableGroup) tableGroup; - if ( standardTableGroup.getTableReferenceJoins().isEmpty() ) { - TableReferenceJoin tableReferenceJoin = tableGroupFinalizer.apply( tableGroup ); - standardTableGroup.addTableReferenceJoin( tableReferenceJoin ); - } - + else if ( indexDescriptorEntityMappingType != null + && indexDescriptorEntityMappingType.containsTableReference( tableExpression ) ) { + return createTableReferenceJoin( + sqlExpressionResolver, + creationContext, + sqlAliasBase, + indexDescriptorEntityMappingType, + indexAssociatedPrimaryTable, + indexTableGroupFinalizer, + indexUseInnerJoin, + tableExpression, + tableGroup + ); } - return mappingType.createTableReferenceJoin( - tableExpression, - sqlAliasBase, - associatedPrimaryTable, - useInnerJoin, - sqlExpressionResolver, - creationContext - ); + throw new IllegalStateException( "could not create join for table `" + tableExpression + "`" ); }; } else { @@ -768,7 +823,6 @@ public class PluralAttributeMappingImpl extends AbstractAttributeMapping "element-collection cannot contain joins : " + collectionTableReference.getTableExpression() + " -> " + tableExpression ); }; - tableReferenceJoinNameChecker = s -> false; } final StandardTableGroup tableGroup = new StandardTableGroup( @@ -785,6 +839,75 @@ public class PluralAttributeMappingImpl extends AbstractAttributeMapping return tableGroup; } + private TableReferenceJoin createTableReferenceJoin( + SqlExpressionResolver sqlExpressionResolver, + SqlAstCreationContext creationContext, + SqlAliasBase sqlAliasBase, + EntityMappingType elementDescriptorEntityMappingType, + TableReference elementAssociatedPrimaryTable, + Function elementTableGroupFinalizer, + boolean useInnerJoin, + String tableExpression, TableGroup tableGroup) { + if ( elementAssociatedPrimaryTable.getTableExpression().equals( tableExpression ) ) { + TableReferenceJoin tableReferenceJoin = elementTableGroupFinalizer.apply( tableGroup ); + return tableReferenceJoin; + } + else { + StandardTableGroup standardTableGroup = (StandardTableGroup) tableGroup; + if ( standardTableGroup.getTableReferenceJoins().isEmpty() ) { + TableReferenceJoin tableReferenceJoin = elementTableGroupFinalizer.apply( tableGroup ); + standardTableGroup.addTableReferenceJoin( tableReferenceJoin ); + } + } + return elementDescriptorEntityMappingType.createTableReferenceJoin( + tableExpression, + sqlAliasBase, + elementAssociatedPrimaryTable, + useInnerJoin, + sqlExpressionResolver, + creationContext + ); + } + + private Function createTableGroupFinalizer( + SqlExpressionResolver sqlExpressionResolver, + SqlAstCreationContext creationContext, + TableReference collectionTableReference, + TableReference elementAssociatedPrimaryTable, + SqlAstJoinType joinType, + ForeignKeyDescriptor elementFkDescriptor) { + return tableGroup -> { + + final TableReferenceJoin associationJoin = new TableReferenceJoin( + joinType, + elementAssociatedPrimaryTable, + elementFkDescriptor.generateJoinPredicate( + collectionTableReference, + elementAssociatedPrimaryTable, + joinType, + sqlExpressionResolver, + creationContext + ) + ); + return associationJoin; + }; + } + + private java.util.function.Predicate createTableReferenceJoinNameChecker( + EntityMappingType elementDescriptorEntityMappingType, + EntityMappingType indexDescriptorEntityMappingType) { + return tableExpression -> { + if ( elementDescriptorEntityMappingType != null + && elementDescriptorEntityMappingType.containsTableReference( tableExpression ) ) { + return true; + } + if ( indexDescriptorEntityMappingType != null + && indexDescriptorEntityMappingType.containsTableReference( tableExpression ) ) { + return true; + } + return false; + }; + } @Override public TableGroup createRootTableGroup( diff --git a/hibernate-core/src/test/java/org/hibernate/orm/test/collection/map/hhh7557/EntityMapTest.java b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/map/hhh7557/EntityMapTest.java new file mode 100644 index 0000000000..91860fd5b0 --- /dev/null +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/map/hhh7557/EntityMapTest.java @@ -0,0 +1,88 @@ +/* + * 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.map.hhh7557; + +import java.util.HashMap; +import java.util.List; + +import org.hibernate.Session; + +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 Elizabeth Chatman + * @author Steve Ebersole + */ +@DomainModel( + annotatedClasses = { + MapValue.class, MapKey.class, MapHolder.class + } +) +@SessionFactory +public class EntityMapTest { + + @Test + public void testInsertIntoMap(SessionFactoryScope scope) { + // Session 1: Insert 3 values into the map + scope.inTransaction( + session -> { + MapHolder mapHolder = new MapHolder(); + mapHolder.setMap( new HashMap<>() ); + addMapEntry( session, mapHolder, "A", "1" ); + addMapEntry( session, mapHolder, "B", "2" ); + addMapEntry( session, mapHolder, "C", "3" ); + session.save( mapHolder ); + // Verify there are 3 entries in the map + assertEquals( 3, mapHolder.getMap().size() ); + } + ); + + + // Session 2: Add a 4th value to the map + scope.inTransaction( + session -> { + MapHolder mapHolder = getMapHolder( session ); + assertEquals( 3, mapHolder.getMap().size() ); + System.out.println( "Got MapHolder; checked map size -----" ); + addMapEntry( session, mapHolder, "D", "4" ); + // Verify there are 4 entries in the map + assertEquals( 4, mapHolder.getMap().size() ); + + } + ); + + // Session 3: Count the entries in the map + scope.inTransaction( + session -> { + MapHolder mapHolder = getMapHolder( session ); + // Fails here (expected:<4> but was:<1>) + assertEquals( 4, mapHolder.getMap().size() ); + } + ); + + } + + private void addMapEntry(Session session, MapHolder mapHolder, String key, String value) { + MapValue entityValue = new MapValue( value ); + session.save( entityValue ); + MapKey entityKey = new MapKey( key, entityValue ); + session.save( entityKey ); + mapHolder.getMap().put( entityKey, entityValue ); + } + + private MapHolder getMapHolder(Session session) { + List mapHolders = session.createQuery( "select distinct mh from MapHolder mh" ).list(); + assertEquals( 1, mapHolders.size() ); + return (MapHolder) mapHolders.get( 0 ); + } +} diff --git a/hibernate-core/src/test/java/org/hibernate/test/collection/map/hhh7557/MapHolder.java b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/map/hhh7557/MapHolder.java similarity index 96% rename from hibernate-core/src/test/java/org/hibernate/test/collection/map/hhh7557/MapHolder.java rename to hibernate-core/src/test/java/org/hibernate/orm/test/collection/map/hhh7557/MapHolder.java index 5fb1858987..794195a410 100644 --- a/hibernate-core/src/test/java/org/hibernate/test/collection/map/hhh7557/MapHolder.java +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/map/hhh7557/MapHolder.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.map.hhh7557; +package org.hibernate.orm.test.collection.map.hhh7557; import javax.persistence.Column; import javax.persistence.Entity; diff --git a/hibernate-core/src/test/java/org/hibernate/test/collection/map/hhh7557/MapKey.java b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/map/hhh7557/MapKey.java similarity index 98% rename from hibernate-core/src/test/java/org/hibernate/test/collection/map/hhh7557/MapKey.java rename to hibernate-core/src/test/java/org/hibernate/orm/test/collection/map/hhh7557/MapKey.java index cad11691df..b6ddced343 100644 --- a/hibernate-core/src/test/java/org/hibernate/test/collection/map/hhh7557/MapKey.java +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/map/hhh7557/MapKey.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.map.hhh7557; +package org.hibernate.orm.test.collection.map.hhh7557; import javax.persistence.Column; import javax.persistence.Entity; diff --git a/hibernate-core/src/test/java/org/hibernate/test/collection/map/hhh7557/MapValue.java b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/map/hhh7557/MapValue.java similarity index 97% rename from hibernate-core/src/test/java/org/hibernate/test/collection/map/hhh7557/MapValue.java rename to hibernate-core/src/test/java/org/hibernate/orm/test/collection/map/hhh7557/MapValue.java index 6607813b76..381bf17797 100644 --- a/hibernate-core/src/test/java/org/hibernate/test/collection/map/hhh7557/MapValue.java +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/collection/map/hhh7557/MapValue.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.map.hhh7557; +package org.hibernate.orm.test.collection.map.hhh7557; import javax.persistence.Column; import javax.persistence.Entity; diff --git a/hibernate-core/src/test/java/org/hibernate/test/collection/map/hhh7557/EntityMapTest.java b/hibernate-core/src/test/java/org/hibernate/test/collection/map/hhh7557/EntityMapTest.java deleted file mode 100644 index d0c26527dc..0000000000 --- a/hibernate-core/src/test/java/org/hibernate/test/collection/map/hhh7557/EntityMapTest.java +++ /dev/null @@ -1,88 +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.map.hhh7557; - -import java.util.HashMap; -import java.util.List; - -import org.hibernate.Session; - -import org.junit.Assert; -import org.junit.Test; - -import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase; - -/** - * @author Elizabeth Chatman - * @author Steve Ebersole - */ -public class EntityMapTest extends BaseCoreFunctionalTestCase { - @Override - protected Class[] getAnnotatedClasses() { - return new Class[] {MapValue.class, MapKey.class, MapHolder.class}; - } - - @Test - public void testInsertIntoMap() throws Exception { - { - // Session 1: Insert 3 values into the map - Session session = openSession(); - session.beginTransaction(); - MapHolder mapHolder = new MapHolder(); - mapHolder.setMap( new HashMap() ); - addMapEntry( session, mapHolder, "A", "1" ); - addMapEntry( session, mapHolder, "B", "2" ); - addMapEntry( session, mapHolder, "C", "3" ); - session.save( mapHolder ); - // Verify there are 3 entries in the map - Assert.assertEquals( 3, mapHolder.getMap().size() ); - session.getTransaction().commit(); - session.close(); - } - - { - // Session 2: Add a 4th value to the map - Session session = openSession(); - session.beginTransaction(); - MapHolder mapHolder = getMapHolder( session ); - System.out.println( "Got MapHolder; checking map size -----" ); - Assert.assertEquals( 3, mapHolder.getMap().size() ); - System.out.println( "Got MapHolder; checked map size -----" ); - addMapEntry( session, mapHolder, "D", "4" ); - // Verify there are 4 entries in the map - Assert.assertEquals( 4, mapHolder.getMap().size() ); - session.getTransaction().commit(); - session.close(); - } - - { - // Session 3: Count the entries in the map - Session session = openSession(); - session.beginTransaction(); - MapHolder mapHolder = getMapHolder( session ); - // Fails here (expected:<4> but was:<1>) - Assert.assertEquals( 4, mapHolder.getMap().size() ); - session.getTransaction().commit(); - session.close(); - } - } - - private void addMapEntry(Session session, MapHolder mapHolder, String key, String value) { - System.out.println( "Inserting (" + key + "," + value + ") into map" ); - MapValue entityValue = new MapValue( value ); - session.save( entityValue ); - MapKey entityKey = new MapKey( key, entityValue ); - session.save( entityKey ); - mapHolder.getMap().put( entityKey, entityValue ); - } - - private MapHolder getMapHolder(Session session) { - List mapHolders = session.createQuery( "select distinct mh from MapHolder mh" ).list(); - Assert.assertEquals( 1, mapHolders.size() ); - return (MapHolder) mapHolders.get( 0 ); - } -}