From ea60c839fbcb34b88271f63a6a23f8ab7866d0c5 Mon Sep 17 00:00:00 2001 From: Koen Aers Date: Wed, 5 Nov 2025 16:08:56 +0100 Subject: [PATCH] HBX-3207: Improve the implementation of the 'binder' helper classes Signed-off-by: Koen Aers --- .../internal/reveng/binder/BinderUtils.java | 63 +-- .../binder/CollectionBinderSecondPass.java | 94 ++-- .../binder/CollectionPropertyBinder.java | 69 ++- .../reveng/binder/EntityPropertyBinder.java | 73 +-- .../reveng/binder/ForeignKeyBinder.java | 228 ++++---- .../reveng/binder/ForeignKeyUtils.java | 94 ++-- .../reveng/binder/OneToManyBinder.java | 350 ++++++------ .../reveng/binder/OneToOneBinder.java | 101 ++-- .../reveng/binder/PrimaryKeyBinder.java | 502 +++++++++--------- .../reveng/binder/RootClassBinder.java | 317 +++++------ .../internal/reveng/binder/TypeUtils.java | 192 +++---- .../reveng/binder/VersionPropertyBinder.java | 148 +++--- 12 files changed, 1117 insertions(+), 1114 deletions(-) diff --git a/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/BinderUtils.java b/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/BinderUtils.java index 5247b1222b..315a8e7e29 100644 --- a/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/BinderUtils.java +++ b/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/BinderUtils.java @@ -37,15 +37,15 @@ import org.hibernate.tool.api.reveng.RevengStrategy; public class BinderUtils { - - public static Logger LOGGER = Logger.getLogger(BinderUtils.class.getName()); + + public static Logger LOGGER = Logger.getLogger(BinderUtils.class.getName()); public static String makeUnique( - Iterator props, - String originalPropertyName) { + Iterator props, + String originalPropertyName) { int cnt = 0; String propertyName = originalPropertyName; - Set uniqueNames = new HashSet(); + Set uniqueNames = new HashSet<>(); while ( props.hasNext() ) { Property element = props.next(); uniqueNames.add( element.getName() ); @@ -58,51 +58,52 @@ public static String makeUnique( } public static String makeUnique(PersistentClass clazz, String propertyName) { - List list = new ArrayList(); + List list = new ArrayList<>(); if( clazz.hasIdentifierProperty() ) { list.add( clazz.getIdentifierProperty() ); } if( clazz.isVersioned() ) { list.add( clazz.getVersion() ); } - JoinedList joinedList = - new JoinedList( - list, - clazz.getProperties()); + JoinedList joinedList = + new JoinedList<>( + list, + clazz.getProperties() ); return BinderUtils.makeUnique(joinedList.iterator(), propertyName); } - - public static String makeUnique(Component clazz, String propertyName) { + + public static String makeUnique(Component clazz, String propertyName) { return BinderUtils.makeUnique(clazz.getProperties().iterator(), propertyName); } - - public static void checkColumnForMultipleBinding(Column column) { - if(column.getValue()!=null) { - LOGGER.log(Level.WARNING, "Binding column twice should not happen. " + column); + + public static void checkColumnForMultipleBinding(Column column) { + if(column.getValue()!=null) { + LOGGER.log(Level.WARNING, "Binding column twice should not happen. " + column); // TODO enable this next line and investigate why the tests fail // throw new RuntimeException("Binding column twice should not happen. " + column); - } - } - + } + } + static void updateFetchMode(Fetchable value, String fetchMode) { if(FetchMode.JOIN.toString().equalsIgnoreCase(fetchMode)) { - value.setFetchMode(FetchMode.JOIN); + value.setFetchMode(FetchMode.JOIN); } else { - value.setFetchMode(FetchMode.SELECT); - } + value.setFetchMode(FetchMode.SELECT); + } } static AssociationInfo getAssociationInfo( - RevengStrategy revengStrategy, - ForeignKey foreignKey, - boolean inverseProperty) { - if (inverseProperty) { - return revengStrategy.foreignKeyToInverseAssociationInfo(foreignKey); - } else { - return revengStrategy.foreignKeyToAssociationInfo(foreignKey); - } + RevengStrategy revengStrategy, + ForeignKey foreignKey, + boolean inverseProperty) { + if (inverseProperty) { + return revengStrategy.foreignKeyToInverseAssociationInfo(foreignKey); + } + else { + return revengStrategy.foreignKeyToAssociationInfo(foreignKey); + } } - + } diff --git a/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/CollectionBinderSecondPass.java b/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/CollectionBinderSecondPass.java index e359dbb764..1cd6acc063 100644 --- a/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/CollectionBinderSecondPass.java +++ b/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/CollectionBinderSecondPass.java @@ -18,6 +18,7 @@ package org.hibernate.tool.internal.reveng.binder; import java.io.ObjectStreamClass; +import java.io.Serial; import java.lang.reflect.Field; import java.util.Map; @@ -30,47 +31,47 @@ import org.hibernate.mapping.Value; public class CollectionBinderSecondPass extends org.hibernate.boot.model.internal.CollectionSecondPass { - - private static final long serialVersionUID = - ObjectStreamClass.lookup(CollectionBinderSecondPass.class).getSerialVersionUID(); - private MetadataBuildingContext mdbc; + @Serial + private static final long serialVersionUID = + ObjectStreamClass.lookup( CollectionBinderSecondPass.class).getSerialVersionUID(); + + private final MetadataBuildingContext mdbc; public CollectionBinderSecondPass(MetadataBuildingContext mdbc, Collection coll) { super(coll); this.mdbc = mdbc; } - @SuppressWarnings("rawtypes") - public void secondPass(Map persistentClasses) throws MappingException { + public void secondPass(Map persistentClasses) throws MappingException { bindCollectionSecondPass(getCollection(), mdbc); - } + } - public void doSecondPass(Map persistentClasses) throws MappingException { - Value element = getCollection().getElement(); - DependantValue elementDependantValue = null; - String oldElementForeignKeyName = null; - if(element instanceof DependantValue) { - elementDependantValue = (DependantValue)element; - oldElementForeignKeyName = elementDependantValue.getForeignKeyName(); - elementDependantValue.setForeignKeyName("none"); // Workaround to avoid DependantValue to create foreignkey just because reference columns are not the same + no need to create keys already in the db! - } - Value key = getCollection().getKey(); - DependantValue keyDependantValue = null; - String oldKeyForeignKeyName = null; - if (key instanceof DependantValue) { - keyDependantValue = (DependantValue)key; - oldKeyForeignKeyName = keyDependantValue.getForeignKeyName(); - keyDependantValue.setForeignKeyName("none"); - } - secondPass(persistentClasses); + public void doSecondPass(Map persistentClasses) throws MappingException { + Value element = getCollection().getElement(); + DependantValue elementDependantValue = null; + String oldElementForeignKeyName = null; + if(element instanceof DependantValue) { + elementDependantValue = (DependantValue)element; + oldElementForeignKeyName = elementDependantValue.getForeignKeyName(); + elementDependantValue.setForeignKeyName("none"); // Workaround to avoid DependantValue to create foreignkey just because reference columns are not the same + no need to create keys already in the db! + } + Value key = getCollection().getKey(); + DependantValue keyDependantValue = null; + String oldKeyForeignKeyName = null; + if (key instanceof DependantValue) { + keyDependantValue = (DependantValue)key; + oldKeyForeignKeyName = keyDependantValue.getForeignKeyName(); + keyDependantValue.setForeignKeyName("none"); + } + secondPass(persistentClasses); // super.doSecondPass(persistentClasses); - if(elementDependantValue!=null) { - elementDependantValue.setForeignKeyName(oldElementForeignKeyName); - } - if (keyDependantValue != null) { - keyDependantValue.setForeignKeyName(oldKeyForeignKeyName); - } + if(elementDependantValue!=null) { + elementDependantValue.setForeignKeyName(oldElementForeignKeyName); + } + if (keyDependantValue != null) { + keyDependantValue.setForeignKeyName(oldKeyForeignKeyName); + } } private void bindCollectionSecondPass( @@ -82,25 +83,26 @@ private void bindCollectionSecondPass( if (persistentClass==null) throw new MappingException( "Association " + collection.getRole() + " references unmapped class: " + oneToMany.getReferencedEntityName() - ); + ); oneToMany.setAssociatedClass(persistentClass); // Child } } - + private Collection getCollection() { - try { - Field field = getClass().getSuperclass().getDeclaredField("collection"); - field.setAccessible(true); - return (Collection)field.get(this); - } catch (NoSuchFieldException e) { - // this will happen if the implementation of the superclass changes - throw new RuntimeException(e); - } catch (IllegalAccessException e) { - // this should not happen - throw new RuntimeException(e); - } + try { + Field field = getClass().getSuperclass().getDeclaredField("collection"); + field.setAccessible(true); + return (Collection)field.get(this); + } + catch (NoSuchFieldException e) { + // this will happen if the implementation of the superclass changes + throw new RuntimeException(e); + } + catch (IllegalAccessException e) { + // this should not happen + throw new RuntimeException(e); + } } - + } - diff --git a/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/CollectionPropertyBinder.java b/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/CollectionPropertyBinder.java index 7d81ba2703..199870b29d 100644 --- a/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/CollectionPropertyBinder.java +++ b/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/CollectionPropertyBinder.java @@ -25,46 +25,43 @@ import org.hibernate.tool.internal.reveng.util.RevengUtils; class CollectionPropertyBinder extends AbstractBinder { - - static CollectionPropertyBinder create(BinderContext binderContext) { - return new CollectionPropertyBinder(binderContext); - } - - private final PropertyBinder propertyBinder; - - private CollectionPropertyBinder(BinderContext binderContext) { - super(binderContext); - this.propertyBinder = PropertyBinder.create(binderContext); - } + + static CollectionPropertyBinder create(BinderContext binderContext) { + return new CollectionPropertyBinder(binderContext); + } + + private final PropertyBinder propertyBinder; + + private CollectionPropertyBinder(BinderContext binderContext) { + super(binderContext); + this.propertyBinder = PropertyBinder.create(binderContext); + } Property bind( - String propertyName, - boolean mutable, - Table table, - ForeignKey fk, - Collection value, - boolean inverseProperty) { - AssociationInfo associationInfo = determineAssociationInfo(fk, inverseProperty, mutable); - BinderUtils.updateFetchMode(value, associationInfo.getFetch()); + String propertyName, + Table table, + ForeignKey fk, + Collection value) { + AssociationInfo associationInfo = determineAssociationInfo(fk); + BinderUtils.updateFetchMode(value, associationInfo.getFetch()); return propertyBinder.bind(table, propertyName, value, associationInfo); - } - + } + private AssociationInfo determineAssociationInfo( - ForeignKey foreignKey, - boolean inverseProperty, - boolean mutable) { - AssociationInfo origin = BinderUtils - .getAssociationInfo(getRevengStrategy(), foreignKey, inverseProperty); - if(origin != null){ - return RevengUtils.createAssociationInfo( - origin.getCascade() != null ? origin.getCascade() : "all", - origin.getFetch(), - origin.getInsert() != null ? origin.getInsert() : mutable, - origin.getUpdate() != null ? origin.getUpdate() : mutable - ); - } else { - return RevengUtils.createAssociationInfo(null, null, mutable, mutable); + ForeignKey foreignKey) { + AssociationInfo origin = BinderUtils + .getAssociationInfo(getRevengStrategy(), foreignKey, true); + if(origin != null){ + return RevengUtils.createAssociationInfo( + origin.getCascade() != null ? origin.getCascade() : "all", + origin.getFetch(), + origin.getInsert() != null ? origin.getInsert() : true, + origin.getUpdate() != null ? origin.getUpdate() : true + ); + } + else { + return RevengUtils.createAssociationInfo(null, null, true, true); } } - + } diff --git a/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/EntityPropertyBinder.java b/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/EntityPropertyBinder.java index 24c12e345a..01365c4d87 100644 --- a/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/EntityPropertyBinder.java +++ b/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/EntityPropertyBinder.java @@ -25,46 +25,47 @@ import org.hibernate.tool.internal.reveng.util.RevengUtils; class EntityPropertyBinder extends AbstractBinder { - - static EntityPropertyBinder create(BinderContext binderContext) { - return new EntityPropertyBinder(binderContext); - } - - private final PropertyBinder propertyBinder; - - private EntityPropertyBinder(BinderContext binderContext) { - super(binderContext); - this.propertyBinder = PropertyBinder.create(binderContext); - } - Property bind( - String propertyName, - boolean mutable, - Table table, - ForeignKey fk, - ToOne value, - boolean inverseProperty) { - AssociationInfo associationInfo = determineAssociationInfo(fk, inverseProperty, mutable); - BinderUtils.updateFetchMode(value, associationInfo.getFetch()); + static EntityPropertyBinder create(BinderContext binderContext) { + return new EntityPropertyBinder(binderContext); + } + + private final PropertyBinder propertyBinder; + + private EntityPropertyBinder(BinderContext binderContext) { + super(binderContext); + this.propertyBinder = PropertyBinder.create(binderContext); + } + + Property bind( + String propertyName, + boolean mutable, + Table table, + ForeignKey fk, + ToOne value, + boolean inverseProperty) { + AssociationInfo associationInfo = determineAssociationInfo(fk, inverseProperty, mutable); + BinderUtils.updateFetchMode(value, associationInfo.getFetch()); return propertyBinder.bind(table, propertyName, value, associationInfo); - } + } private AssociationInfo determineAssociationInfo( - ForeignKey foreignKey, - boolean inverseProperty, - boolean mutable) { - AssociationInfo origin = BinderUtils - .getAssociationInfo(getRevengStrategy(), foreignKey, inverseProperty); - if(origin != null){ - return RevengUtils.createAssociationInfo( - origin.getCascade(), - origin.getFetch(), - origin.getInsert() != null ? origin.getInsert() : mutable, - origin.getUpdate() != null ? origin.getUpdate() : mutable - ); - } else { - return RevengUtils.createAssociationInfo(null, null, mutable, mutable); + ForeignKey foreignKey, + boolean inverseProperty, + boolean mutable) { + AssociationInfo origin = BinderUtils + .getAssociationInfo(getRevengStrategy(), foreignKey, inverseProperty); + if(origin != null){ + return RevengUtils.createAssociationInfo( + origin.getCascade(), + origin.getFetch(), + origin.getInsert() != null ? origin.getInsert() : mutable, + origin.getUpdate() != null ? origin.getUpdate() : mutable + ); + } + else { + return RevengUtils.createAssociationInfo(null, null, mutable, mutable); } } - + } diff --git a/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/ForeignKeyBinder.java b/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/ForeignKeyBinder.java index 0f9afab24d..077f0c2808 100644 --- a/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/ForeignKeyBinder.java +++ b/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/ForeignKeyBinder.java @@ -29,118 +29,122 @@ import org.hibernate.tool.api.reveng.TableIdentifier; class ForeignKeyBinder extends AbstractBinder { - - private static Logger LOGGER = Logger.getLogger(ForeignKeyBinder.class.getName()); - - static ForeignKeyBinder create(BinderContext binderContext) { - return new ForeignKeyBinder(binderContext); - } - - private final OneToOneBinder oneToOneBinder; - private final OneToManyBinder oneToManyBinder; - private final ManyToOneBinder manyToOneBinder; - - private ForeignKeyBinder(BinderContext binderContext) { - super(binderContext); - this.oneToOneBinder = OneToOneBinder.create(binderContext); - this.oneToManyBinder = OneToManyBinder.create(binderContext); - this.manyToOneBinder = ManyToOneBinder.create(binderContext); - } - - void bindIncoming( - ForeignKey foreignKey, - PersistentClass persistentClass, - Set processed) { - if(excludeForeignKeyAsCollection(foreignKey)) { - LOGGER.log(Level.INFO, "Rev.eng excluded one-to-many or one-to-one for foreignkey " + foreignKey.getName()); - } else if (getRevengStrategy().isOneToOne(foreignKey)){ - addOneToOne(foreignKey, persistentClass, processed, false); - } else { - addOneToMany(foreignKey, persistentClass); - } - } - - void bindOutgoing( - ForeignKey foreignKey, - Table table, - PersistentClass rc, - Set processedColumns, - boolean mutable) { + + private static final Logger LOGGER = Logger.getLogger(ForeignKeyBinder.class.getName()); + + static ForeignKeyBinder create(BinderContext binderContext) { + return new ForeignKeyBinder(binderContext); + } + + private final OneToOneBinder oneToOneBinder; + private final OneToManyBinder oneToManyBinder; + private final ManyToOneBinder manyToOneBinder; + + private ForeignKeyBinder(BinderContext binderContext) { + super(binderContext); + this.oneToOneBinder = OneToOneBinder.create(binderContext); + this.oneToManyBinder = OneToManyBinder.create(binderContext); + this.manyToOneBinder = ManyToOneBinder.create(binderContext); + } + + void bindIncoming( + ForeignKey foreignKey, + PersistentClass persistentClass, + Set processed) { + if(excludeForeignKeyAsCollection(foreignKey)) { + LOGGER.log(Level.INFO, "Rev.eng excluded one-to-many or one-to-one for foreignkey " + foreignKey.getName()); + } + else if (getRevengStrategy().isOneToOne(foreignKey)){ + addOneToOne(foreignKey, persistentClass, processed, false); + } + else { + addOneToMany(foreignKey, persistentClass); + } + } + + void bindOutgoing( + ForeignKey foreignKey, + Table table, + PersistentClass rc, + Set processedColumns, + boolean mutable) { if(excludeForeignKeyAsManyToOne(foreignKey)) { - // TODO: if many-to-one is excluded should the column be marked as processed so it won't show up at all ? - LOGGER.log(Level.INFO, "Rev.eng excluded *-to-one for foreignkey " + foreignKey.getName()); - } else if (isOneToOne(foreignKey)){ - addOneToOne(foreignKey, rc, processedColumns, true); - } else { - addManyToOne(foreignKey, table, rc, processedColumns, mutable); - } - } - - private String getForeignKeyToEntityName(ForeignKey foreignKey) { - return getRevengStrategy().foreignKeyToEntityName( - foreignKey.getName(), - TableIdentifier.create(foreignKey.getTable() ), - foreignKey.getColumns(), - TableIdentifier.create(foreignKey.getReferencedTable() ), - foreignKey.getReferencedColumns(), - ForeignKeyUtils.isUniqueReference(foreignKey)); - } - - private void addManyToOne( - ForeignKey foreignKey, - Table table, - PersistentClass rc, - Set processedColumns, - boolean mutable) { - Property property = manyToOneBinder.bind( - BinderUtils.makeUnique(rc, getForeignKeyToEntityName(foreignKey)), - mutable, - table, - foreignKey, - processedColumns); - rc.addProperty(property); - } - - private void addOneToOne( - ForeignKey foreignKey, - PersistentClass rc, - Set processedColumns, - boolean outgoing) { - Table table = outgoing ? foreignKey.getReferencedTable() : foreignKey.getTable(); - Property property = oneToOneBinder.bind( - rc, - table, - foreignKey, - processedColumns, - outgoing, - !outgoing); - rc.addProperty(property); - } - - private void addOneToMany(ForeignKey foreignKey, PersistentClass persistentClass) { - persistentClass.addProperty(oneToManyBinder.bind(persistentClass, foreignKey)); - } - - private boolean excludeForeignKeyAsCollection(ForeignKey foreignKey) { - return getRevengStrategy().excludeForeignKeyAsCollection( - foreignKey.getName(), - TableIdentifier.create(foreignKey.getTable() ), - foreignKey.getColumns(), - TableIdentifier.create(foreignKey.getReferencedTable() ), - foreignKey.getReferencedColumns()); - } - - private boolean excludeForeignKeyAsManyToOne(ForeignKey foreignKey) { - return getRevengStrategy().excludeForeignKeyAsManytoOne( - foreignKey.getName(), - TableIdentifier.create(foreignKey.getTable() ), - foreignKey.getColumns(), - TableIdentifier.create(foreignKey.getReferencedTable()), - foreignKey.getReferencedColumns()); - } - - private boolean isOneToOne(ForeignKey foreignKey) { - return getRevengStrategy().isOneToOne(foreignKey); - } + // TODO: if many-to-one is excluded should the column be marked as processed so it won't show up at all ? + LOGGER.log(Level.INFO, "Rev.eng excluded *-to-one for foreignkey " + foreignKey.getName()); + } + else if (isOneToOne(foreignKey)){ + addOneToOne(foreignKey, rc, processedColumns, true); + } + else { + addManyToOne(foreignKey, table, rc, processedColumns, mutable); + } + } + + private String getForeignKeyToEntityName(ForeignKey foreignKey) { + return getRevengStrategy().foreignKeyToEntityName( + foreignKey.getName(), + TableIdentifier.create(foreignKey.getTable() ), + foreignKey.getColumns(), + TableIdentifier.create(foreignKey.getReferencedTable() ), + foreignKey.getReferencedColumns(), + ForeignKeyUtils.isUniqueReference(foreignKey)); + } + + private void addManyToOne( + ForeignKey foreignKey, + Table table, + PersistentClass rc, + Set processedColumns, + boolean mutable) { + Property property = manyToOneBinder.bind( + BinderUtils.makeUnique(rc, getForeignKeyToEntityName(foreignKey)), + mutable, + table, + foreignKey, + processedColumns); + rc.addProperty(property); + } + + private void addOneToOne( + ForeignKey foreignKey, + PersistentClass rc, + Set processedColumns, + boolean outgoing) { + Table table = outgoing ? foreignKey.getReferencedTable() : foreignKey.getTable(); + Property property = oneToOneBinder.bind( + rc, + table, + foreignKey, + processedColumns, + outgoing, + !outgoing); + rc.addProperty(property); + } + + private void addOneToMany(ForeignKey foreignKey, PersistentClass persistentClass) { + persistentClass.addProperty(oneToManyBinder.bind(persistentClass, foreignKey)); + } + + private boolean excludeForeignKeyAsCollection(ForeignKey foreignKey) { + return getRevengStrategy().excludeForeignKeyAsCollection( + foreignKey.getName(), + TableIdentifier.create(foreignKey.getTable() ), + foreignKey.getColumns(), + TableIdentifier.create(foreignKey.getReferencedTable() ), + foreignKey.getReferencedColumns()); + } + + private boolean excludeForeignKeyAsManyToOne(ForeignKey foreignKey) { + return getRevengStrategy().excludeForeignKeyAsManytoOne( + foreignKey.getName(), + TableIdentifier.create(foreignKey.getTable() ), + foreignKey.getColumns(), + TableIdentifier.create(foreignKey.getReferencedTable()), + foreignKey.getReferencedColumns()); + } + + private boolean isOneToOne(ForeignKey foreignKey) { + return getRevengStrategy().isOneToOne(foreignKey); + } } diff --git a/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/ForeignKeyUtils.java b/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/ForeignKeyUtils.java index 88ce924ba2..1cd3860189 100644 --- a/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/ForeignKeyUtils.java +++ b/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/ForeignKeyUtils.java @@ -27,60 +27,58 @@ public class ForeignKeyUtils { public static boolean isUniqueReference(ForeignKey foreignKey) { - for (ForeignKey element : foreignKey.getTable().getForeignKeys().values()) { - if(element!=foreignKey && element.getReferencedTable().equals(foreignKey.getReferencedTable())) { - return false; - } - } - return true; - } + for (ForeignKey element : foreignKey.getTable().getForeignKeyCollection()) { + if(element!=foreignKey && element.getReferencedTable().equals(foreignKey.getReferencedTable())) { + return false; + } + } + return true; + } public static List findForeignKeys(Collection foreignKeys, List pkColumns) { - List tempList = new ArrayList(); - for (ForeignKey fk : foreignKeys) { - tempList.add(fk); - } - List result = new ArrayList(); - Column[] myPkColumns = pkColumns.toArray(new Column[pkColumns.size()]); - for (int i = 0; i < myPkColumns.length; i++) { - boolean foundKey = false; - for (ForeignKey key : tempList) { - List matchingColumns = columnMatches(myPkColumns, i, key); - if(!matchingColumns.isEmpty()) { - result.add(new ForeignKeyForColumns(key, matchingColumns)); - i+=matchingColumns.size()-1; - foundKey=true; - break; - } - } - if(!foundKey) { - result.add(myPkColumns[i]); - } - } - return result; + List tempList = new ArrayList<>( foreignKeys ); + List result = new ArrayList<>(); + Column[] myPkColumns = pkColumns.toArray( new Column[0] ); + for (int i = 0; i < myPkColumns.length; i++) { + boolean foundKey = false; + for (ForeignKey key : tempList) { + List matchingColumns = columnMatches(myPkColumns, i, key); + if(!matchingColumns.isEmpty()) { + result.add(new ForeignKeyForColumns(key, matchingColumns)); + i+=matchingColumns.size()-1; + foundKey=true; + break; + } + } + if(!foundKey) { + result.add(myPkColumns[i]); + } + } + return result; } private static List columnMatches( - Column[] pkColumns, - int offset, - ForeignKey fk) { - List result = new ArrayList(); - int columnSpan = fk.getColumnSpan(); - if (columnSpan <= pkColumns.length-offset) { - for (int i = 0; i < columnSpan; i++) { - Column column = pkColumns[i + offset]; - if(column.equals(fk.getColumn(i))) { - result.add(column); - } else { - result.clear(); - break; - } - } - } - return result; - } + Column[] pkColumns, + int offset, + ForeignKey fk) { + List result = new ArrayList<>(); + int columnSpan = fk.getColumnSpan(); + if (columnSpan <= pkColumns.length-offset) { + for (int i = 0; i < columnSpan; i++) { + Column column = pkColumns[i + offset]; + if(column.equals(fk.getColumn(i))) { + result.add(column); + } + else { + result.clear(); + break; + } + } + } + return result; + } - public static class ForeignKeyForColumns { + public static class ForeignKeyForColumns { public final List columns; public final ForeignKey key; public ForeignKeyForColumns(ForeignKey key, List columns) { diff --git a/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/OneToManyBinder.java b/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/OneToManyBinder.java index 5393850228..f0c68d38ba 100644 --- a/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/OneToManyBinder.java +++ b/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/OneToManyBinder.java @@ -37,181 +37,179 @@ import org.hibernate.tool.api.reveng.TableIdentifier; class OneToManyBinder extends AbstractBinder { - - static OneToManyBinder create(BinderContext binderContext) { - return new OneToManyBinder(binderContext); - } - - private final CollectionPropertyBinder collectionPropertyBinder; - - private OneToManyBinder(BinderContext binderContext) { - super(binderContext); - this.collectionPropertyBinder = CollectionPropertyBinder.create(binderContext); - } - - Property bind(PersistentClass rc, ForeignKey foreignKey) { - Collection collection = bindCollection(rc, foreignKey); - getMetadataCollector().addCollectionBinding(collection); - return collectionPropertyBinder - .bind( - StringHelper.unqualify(collection.getRole()), - true, - rc.getTable(), - foreignKey, - collection, - true); - } - - private Collection bindCollection(PersistentClass pc, ForeignKey foreignKey) { - Table table = foreignKey.getTable(); - Collection collection = new org.hibernate.mapping.Set(getMetadataBuildingContext(), pc); - collection.setCollectionTable(table); - boolean manyToMany = getRevengStrategy().isManyToManyTable( table ); - if(manyToMany) { - bindManyToMany(pc, foreignKey, collection); - } else { - bindOneToMany(pc, foreignKey, collection); + + static OneToManyBinder create(BinderContext binderContext) { + return new OneToManyBinder(binderContext); + } + + private final CollectionPropertyBinder collectionPropertyBinder; + + private OneToManyBinder(BinderContext binderContext) { + super(binderContext); + this.collectionPropertyBinder = CollectionPropertyBinder.create(binderContext); + } + + Property bind(PersistentClass rc, ForeignKey foreignKey) { + Collection collection = bindCollection(rc, foreignKey); + getMetadataCollector().addCollectionBinding(collection); + return collectionPropertyBinder + .bind( + StringHelper.unqualify(collection.getRole()), + rc.getTable(), + foreignKey, + collection); + } + + private Collection bindCollection(PersistentClass pc, ForeignKey foreignKey) { + Table table = foreignKey.getTable(); + Collection collection = new org.hibernate.mapping.Set(getMetadataBuildingContext(), pc); + collection.setCollectionTable(table); + boolean manyToMany = getRevengStrategy().isManyToManyTable( table ); + if(manyToMany) { + bindManyToMany(pc, foreignKey, collection); + } + else { + bindOneToMany(pc, foreignKey, collection); + } + collection.setKey(createKeyValue(table, foreignKey, getReferencedKeyValue(collection))); + return collection; + } + + private KeyValue createKeyValue(Table collectionTable, ForeignKey foreignKey, KeyValue referencedKeyValue) { + SimpleValue keyValue = new DependantValue(getMetadataBuildingContext(), collectionTable, referencedKeyValue); + //keyValue.setForeignKeyName("none"); // Avoid creating the foreignkey + //key.setCascadeDeleteEnabled( "cascade".equals( subnode.attributeValue("on-delete") ) ); + for (Column fkcolumn : foreignKey.getColumns()) { + if(fkcolumn.getSqlTypeCode()!=null) { // TODO: user defined foreign ref columns does not have a type set. + TypeUtils.determinePreferredType( + getMetadataCollector(), + getRevengStrategy(), + collectionTable, + fkcolumn, + false); // needed to ensure foreign key columns has same type as the "property" column. + } + keyValue.addColumn( fkcolumn ); } - collection.setKey(createKeyValue(table, foreignKey, getReferencedKeyValue(collection))); - return collection; - } - - private KeyValue createKeyValue(Table collectionTable, ForeignKey foreignKey, KeyValue referencedKeyValue) { - SimpleValue keyValue = new DependantValue(getMetadataBuildingContext(), collectionTable, referencedKeyValue); - //keyValue.setForeignKeyName("none"); // Avoid creating the foreignkey - //key.setCascadeDeleteEnabled( "cascade".equals( subnode.attributeValue("on-delete") ) ); - for (Column fkcolumn : foreignKey.getColumns()) { - if(fkcolumn.getSqlTypeCode()!=null) { // TODO: user defined foreign ref columns does not have a type set. - TypeUtils.determinePreferredType( - getMetadataCollector(), - getRevengStrategy(), - collectionTable, - fkcolumn, - false); // needed to ensure foreign key columns has same type as the "property" column. - } - keyValue.addColumn( fkcolumn ); - } - return keyValue; - } - - private KeyValue getReferencedKeyValue(Collection collection) { - String propRef = collection.getReferencedPropertyName(); - if (propRef==null) { - return collection.getOwner().getIdentifier(); - } - else { - return (KeyValue)collection.getOwner().getProperty(propRef).getValue(); - } - } - - private void bindManyToMany(PersistentClass pc, ForeignKey fromForeignKey, Collection collection) { - ForeignKey toForeignKey = getToForeignKey(fromForeignKey); - bindCollection( pc, fromForeignKey, toForeignKey, collection ); - ManyToOne manyToOne = new ManyToOne(getMetadataBuildingContext(), collection.getCollectionTable()); - manyToOne.setReferencedEntityName(getTableToClassName(toForeignKey.getReferencedTable())); - addColumns(manyToOne, toForeignKey); - collection.setElement(manyToOne); - } - - private void addColumns(ManyToOne manyToOne, ForeignKey fk) { - Iterator columnIterator = fk.getColumns().iterator(); - while (columnIterator.hasNext()) { - Column fkcolumn = (Column) columnIterator.next(); - if(fkcolumn.getSqlTypeCode() != null) { // TODO: user defined foreign ref columns does not have a type set. - TypeUtils.determinePreferredType( - getMetadataCollector(), - getRevengStrategy(), - fk.getTable(), - fkcolumn, - false); // needed to ensure foreign key columns has same type as the "property" column. - } - manyToOne.addColumn(fkcolumn); - } - } - - private ForeignKey getToForeignKey(ForeignKey fromForeignKey) { - List keys = new ArrayList(); - for (ForeignKey foreignKey : fromForeignKey.getTable().getForeignKeys().values()) { - if(foreignKey!=fromForeignKey) { - keys.add(foreignKey); - } - } - if(keys.size()>1) { - throw new RuntimeException("more than one other foreign key to choose from!"); // todo: handle better ? - } - return (ForeignKey) keys.get( 0 ); - } - - private void bindOneToMany(PersistentClass pc, ForeignKey fromForeignKey, Collection collection) { - bindCollection(pc, fromForeignKey, null, collection); - OneToMany oneToMany = new OneToMany(getMetadataBuildingContext(), collection.getOwner()); - oneToMany.setReferencedEntityName(getTableToClassName(fromForeignKey.getTable())); - getMetadataCollector().addSecondPass( - new CollectionBinderSecondPass(getMetadataBuildingContext(), collection)); - collection.setElement(oneToMany); - } - - - private void bindCollection(PersistentClass pc, ForeignKey fromForeignKey, ForeignKey toForeignKey, Collection collection) { - ForeignKey targetKey = toForeignKey != null ? toForeignKey : fromForeignKey; - collection.setRole(getFullRolePath(pc, fromForeignKey, toForeignKey)); - collection.setInverse(isCollectionInverse(targetKey)); - collection.setLazy(isCollectionLazy(targetKey)); - collection.setFetchMode(FetchMode.SELECT); - } - - private boolean isCollectionLazy(ForeignKey foreignKey) { - return getRevengStrategy().isForeignKeyCollectionLazy( - foreignKey.getName(), - TableIdentifier.create( foreignKey.getTable()), - foreignKey.getColumns(), - TableIdentifier.create(foreignKey.getReferencedTable()), - foreignKey.getReferencedColumns()); - } - - private boolean isCollectionInverse(ForeignKey foreignKey) { - return getRevengStrategy().isForeignKeyCollectionInverse( - foreignKey.getName(), - foreignKey.getTable(), - foreignKey.getColumns(), - foreignKey.getReferencedTable(), - foreignKey.getReferencedColumns()); - } - - private String getTableToClassName(Table table) { - return getRevengStrategy().tableToClassName(TableIdentifier.create(table)); - } - - private String getFullRolePath( - PersistentClass pc, - ForeignKey fromForeignKey, - ForeignKey toForeignKey) { - String collectionRole = null; - if(toForeignKey==null) { - collectionRole = getForeignKeyToCollectionName(fromForeignKey); - } else { - collectionRole = getForeignKeyToManyToManyName(fromForeignKey, toForeignKey); - } - collectionRole = BinderUtils.makeUnique(pc,collectionRole); - return StringHelper.qualify(pc.getEntityName(), collectionRole); - } - - private String getForeignKeyToCollectionName(ForeignKey foreignKey) { - return getRevengStrategy().foreignKeyToCollectionName( - foreignKey.getName(), - TableIdentifier.create(foreignKey.getTable()), - foreignKey.getColumns(), - TableIdentifier.create( foreignKey.getReferencedTable()), - foreignKey.getReferencedColumns(), - ForeignKeyUtils.isUniqueReference(foreignKey)); - } - - private String getForeignKeyToManyToManyName(ForeignKey fromForeignKey, ForeignKey toForeignKey) { - return getRevengStrategy().foreignKeyToManyToManyName( - fromForeignKey, - TableIdentifier.create(fromForeignKey.getTable()), - toForeignKey, - ForeignKeyUtils.isUniqueReference(toForeignKey)); - } - + return keyValue; + } + + private KeyValue getReferencedKeyValue(Collection collection) { + String propRef = collection.getReferencedPropertyName(); + if (propRef==null) { + return collection.getOwner().getIdentifier(); + } + else { + return (KeyValue)collection.getOwner().getProperty(propRef).getValue(); + } + } + + private void bindManyToMany(PersistentClass pc, ForeignKey fromForeignKey, Collection collection) { + ForeignKey toForeignKey = getToForeignKey(fromForeignKey); + bindCollection( pc, fromForeignKey, toForeignKey, collection ); + ManyToOne manyToOne = new ManyToOne(getMetadataBuildingContext(), collection.getCollectionTable()); + manyToOne.setReferencedEntityName(getTableToClassName(toForeignKey.getReferencedTable())); + addColumns(manyToOne, toForeignKey); + collection.setElement(manyToOne); + } + + private void addColumns(ManyToOne manyToOne, ForeignKey fk) { + for ( Column fkcolumn : fk.getColumns() ) { + if ( fkcolumn.getSqlTypeCode() != null ) { // TODO: user defined foreign ref columns does not have a type set. + TypeUtils.determinePreferredType( + getMetadataCollector(), + getRevengStrategy(), + fk.getTable(), + fkcolumn, + false ); // needed to ensure foreign key columns has same type as the "property" column. + } + manyToOne.addColumn( fkcolumn ); + } + } + + private ForeignKey getToForeignKey(ForeignKey fromForeignKey) { + List keys = new ArrayList<>(); + for (ForeignKey foreignKey : fromForeignKey.getTable().getForeignKeyCollection()) { + if(foreignKey!=fromForeignKey) { + keys.add(foreignKey); + } + } + if(keys.size()>1) { + throw new RuntimeException("more than one other foreign key to choose from!"); // todo: handle better ? + } + return keys.get( 0 ); + } + + private void bindOneToMany(PersistentClass pc, ForeignKey fromForeignKey, Collection collection) { + bindCollection(pc, fromForeignKey, null, collection); + OneToMany oneToMany = new OneToMany(getMetadataBuildingContext(), collection.getOwner()); + oneToMany.setReferencedEntityName(getTableToClassName(fromForeignKey.getTable())); + getMetadataCollector().addSecondPass( + new CollectionBinderSecondPass(getMetadataBuildingContext(), collection)); + collection.setElement(oneToMany); + } + + + private void bindCollection(PersistentClass pc, ForeignKey fromForeignKey, ForeignKey toForeignKey, Collection collection) { + ForeignKey targetKey = toForeignKey != null ? toForeignKey : fromForeignKey; + collection.setRole(getFullRolePath(pc, fromForeignKey, toForeignKey)); + collection.setInverse(isCollectionInverse(targetKey)); + collection.setLazy(isCollectionLazy(targetKey)); + collection.setFetchMode(FetchMode.SELECT); + } + + private boolean isCollectionLazy(ForeignKey foreignKey) { + return getRevengStrategy().isForeignKeyCollectionLazy( + foreignKey.getName(), + TableIdentifier.create( foreignKey.getTable()), + foreignKey.getColumns(), + TableIdentifier.create(foreignKey.getReferencedTable()), + foreignKey.getReferencedColumns()); + } + + private boolean isCollectionInverse(ForeignKey foreignKey) { + return getRevengStrategy().isForeignKeyCollectionInverse( + foreignKey.getName(), + foreignKey.getTable(), + foreignKey.getColumns(), + foreignKey.getReferencedTable(), + foreignKey.getReferencedColumns()); + } + + private String getTableToClassName(Table table) { + return getRevengStrategy().tableToClassName(TableIdentifier.create(table)); + } + + private String getFullRolePath( + PersistentClass pc, + ForeignKey fromForeignKey, + ForeignKey toForeignKey) { + String collectionRole; + if(toForeignKey==null) { + collectionRole = getForeignKeyToCollectionName(fromForeignKey); + } + else { + collectionRole = getForeignKeyToManyToManyName(fromForeignKey, toForeignKey); + } + collectionRole = BinderUtils.makeUnique(pc,collectionRole); + return StringHelper.qualify(pc.getEntityName(), collectionRole); + } + + private String getForeignKeyToCollectionName(ForeignKey foreignKey) { + return getRevengStrategy().foreignKeyToCollectionName( + foreignKey.getName(), + TableIdentifier.create(foreignKey.getTable()), + foreignKey.getColumns(), + TableIdentifier.create( foreignKey.getReferencedTable()), + foreignKey.getReferencedColumns(), + ForeignKeyUtils.isUniqueReference(foreignKey)); + } + + private String getForeignKeyToManyToManyName(ForeignKey fromForeignKey, ForeignKey toForeignKey) { + return getRevengStrategy().foreignKeyToManyToManyName( + fromForeignKey, + TableIdentifier.create(fromForeignKey.getTable()), + toForeignKey, + ForeignKeyUtils.isUniqueReference(toForeignKey)); + } + } diff --git a/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/OneToOneBinder.java b/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/OneToOneBinder.java index 8fc8c0a5fe..bae5d05c90 100644 --- a/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/OneToOneBinder.java +++ b/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/OneToOneBinder.java @@ -30,79 +30,80 @@ import org.hibernate.type.ForeignKeyDirection; class OneToOneBinder extends AbstractBinder { - - static OneToOneBinder create(BinderContext binderContext) { - return new OneToOneBinder(binderContext); - } - - private final EntityPropertyBinder entityPropertyBinder; - - private OneToOneBinder(BinderContext binderContext) { - super(binderContext); - this.entityPropertyBinder = EntityPropertyBinder.create(binderContext); - } + + static OneToOneBinder create(BinderContext binderContext) { + return new OneToOneBinder(binderContext); + } + + private final EntityPropertyBinder entityPropertyBinder; + + private OneToOneBinder(BinderContext binderContext) { + super(binderContext); + this.entityPropertyBinder = EntityPropertyBinder.create(binderContext); + } Property bind( - PersistentClass rc, - Table targetTable, - ForeignKey fk, - Set processedColumns, - boolean constrained, + PersistentClass rc, + Table targetTable, + ForeignKey fk, + Set processedColumns, + boolean constrained, boolean inverseProperty) { OneToOne value = new OneToOne(getMetadataBuildingContext(), targetTable, rc); value.setReferencedEntityName( - getRevengStrategy().tableToClassName(TableIdentifier.create(targetTable))); + getRevengStrategy().tableToClassName(TableIdentifier.create(targetTable))); addColumns(fk, value, processedColumns); value.setFetchMode(FetchMode.SELECT); value.setConstrained(constrained); - value.setForeignKeyType( - constrained ? - ForeignKeyDirection.FROM_PARENT : - ForeignKeyDirection.TO_PARENT ); + value.setForeignKeyType( + constrained ? + ForeignKeyDirection.FROM_PARENT : + ForeignKeyDirection.TO_PARENT ); return entityPropertyBinder - .bind( - getPropertyName(fk, targetTable, inverseProperty), - true, - targetTable, - fk, - value, - inverseProperty); + .bind( + getPropertyName(fk, targetTable, inverseProperty), + true, + targetTable, + fk, + value, + inverseProperty); } - + private void addColumns(ForeignKey foreignKey, OneToOne oneToOne, Set processedColumns) { for (Column fkcolumn : foreignKey.getColumns()) { - BinderUtils.checkColumnForMultipleBinding(fkcolumn); + BinderUtils.checkColumnForMultipleBinding(fkcolumn); oneToOne.addColumn(fkcolumn); processedColumns.add(fkcolumn); } } - + private String getPropertyName(ForeignKey foreignKey, Table table, boolean inverseProperty) { - if (inverseProperty) { - return getForeignKeyToInverseEntityName(foreignKey, table); - } else { - return getForeignKeyToTentityName(foreignKey, table); - } + if (inverseProperty) { + return getForeignKeyToInverseEntityName(foreignKey, table); + } + else { + return getForeignKeyToTentityName(foreignKey, table); + } } - + private String getForeignKeyToTentityName(ForeignKey foreignKey, Table table) { - return getRevengStrategy().foreignKeyToEntityName( - foreignKey.getName(), - TableIdentifier.create(foreignKey.getReferencedTable()), - foreignKey.getReferencedColumns(), - TableIdentifier.create(table), - foreignKey.getColumns(), + return getRevengStrategy().foreignKeyToEntityName( + foreignKey.getName(), + TableIdentifier.create(foreignKey.getReferencedTable()), + foreignKey.getReferencedColumns(), + TableIdentifier.create(table), + foreignKey.getColumns(), ForeignKeyUtils.isUniqueReference(foreignKey)); } - + private String getForeignKeyToInverseEntityName(ForeignKey foreignKey, Table table) { - return getRevengStrategy().foreignKeyToInverseEntityName( - foreignKey.getName(), - TableIdentifier.create(foreignKey.getReferencedTable()), - foreignKey.getReferencedColumns(), - TableIdentifier.create(table), - foreignKey.getColumns(), + return getRevengStrategy().foreignKeyToInverseEntityName( + foreignKey.getName(), + TableIdentifier.create(foreignKey.getReferencedTable()), + foreignKey.getReferencedColumns(), + TableIdentifier.create(table), + foreignKey.getColumns(), ForeignKeyUtils.isUniqueReference(foreignKey)); } } diff --git a/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/PrimaryKeyBinder.java b/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/PrimaryKeyBinder.java index 35243f72f9..e1739e8c3a 100644 --- a/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/PrimaryKeyBinder.java +++ b/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/PrimaryKeyBinder.java @@ -20,7 +20,6 @@ import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; -import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Properties; @@ -46,294 +45,291 @@ import org.hibernate.tool.internal.reveng.util.RevengUtils; class PrimaryKeyBinder extends AbstractBinder { - - private static final Logger LOGGER = Logger.getLogger(PrimaryKeyBinder.class.getName()); - - static PrimaryKeyBinder create(BinderContext binderContext) { - return new PrimaryKeyBinder(binderContext); - } - - private final BasicPropertyBinder basicPropertyBinder; - private final BasicValueBinder simpleValueBinder; - private final ManyToOneBinder manyToOneBinder; - private final PropertyBinder propertyBinder; - - private PrimaryKeyBinder(BinderContext binderContext) { - super(binderContext); - this.basicPropertyBinder = BasicPropertyBinder.create(binderContext); - this.simpleValueBinder = BasicValueBinder.create(binderContext); - this.manyToOneBinder = ManyToOneBinder.create(binderContext); - this.propertyBinder = PropertyBinder.create(binderContext); - } + private static final Logger LOGGER = Logger.getLogger(PrimaryKeyBinder.class.getName()); - PrimaryKeyInfo bind( - Table table, - RootClass rc, - Set processed, - RevengMetadataCollector revengMetadataCollector) { - List keyColumns = getKeyColumns(table); - final TableIdentifier tableIdentifier = TableIdentifier.create(table); - PrimaryKeyInfo pki = createPrimaryKeyInfo(tableIdentifier, keyColumns); - EnhancedValue id = createKeyValue(rc, keyColumns, pki.suggestedStrategy, table, revengMetadataCollector, processed); - id.setIdentifierGeneratorProperties(pki.suggestedProperties); - Property property = propertyBinder.bind( - table, - BinderUtils.makeUnique(rc,getIdPropertyName(tableIdentifier, keyColumns)), - id, - RevengUtils.createAssociationInfo(null, null, true, true)); - rc.setIdentifierProperty(property); - rc.setDeclaredIdentifierProperty(property); - rc.setIdentifier(id); - return pki; - } + static PrimaryKeyBinder create(BinderContext binderContext) { + return new PrimaryKeyBinder(binderContext); + } + + private final BasicPropertyBinder basicPropertyBinder; + private final BasicValueBinder simpleValueBinder; + private final ManyToOneBinder manyToOneBinder; + private final PropertyBinder propertyBinder; + + + private PrimaryKeyBinder(BinderContext binderContext) { + super(binderContext); + this.basicPropertyBinder = BasicPropertyBinder.create(binderContext); + this.simpleValueBinder = BasicValueBinder.create(binderContext); + this.manyToOneBinder = ManyToOneBinder.create(binderContext); + this.propertyBinder = PropertyBinder.create(binderContext); + } + + PrimaryKeyInfo bind( + Table table, + RootClass rc, + Set processed, + RevengMetadataCollector revengMetadataCollector) { + List keyColumns = getKeyColumns(table); + final TableIdentifier tableIdentifier = TableIdentifier.create(table); + PrimaryKeyInfo pki = createPrimaryKeyInfo(tableIdentifier, keyColumns); + EnhancedValue id = createKeyValue(rc, keyColumns, pki.suggestedStrategy, table, revengMetadataCollector, processed); + id.setIdentifierGeneratorProperties(pki.suggestedProperties); + Property property = propertyBinder.bind( + table, + BinderUtils.makeUnique(rc,getIdPropertyName(tableIdentifier, keyColumns)), + id, + RevengUtils.createAssociationInfo(null, null, true, true)); + rc.setIdentifierProperty(property); + rc.setDeclaredIdentifierProperty(property); + rc.setIdentifier(id); + return pki; + } - void updatePrimaryKey(RootClass rc, PrimaryKeyInfo pki) { - EnhancedValue idValue = (EnhancedValue) rc.getIdentifierProperty().getValue(); - Properties defaultStrategyProperties = new Properties(); - Property constrainedOneToOne = getConstrainedOneToOne(rc); - if(constrainedOneToOne!=null) { - if(pki.suggestedStrategy==null) { - idValue.setIdentifierGeneratorStrategy("foreign"); - } - if(pki.suggestedProperties==null) { - defaultStrategyProperties.setProperty("property", constrainedOneToOne.getName()); - idValue.setIdentifierGeneratorProperties(defaultStrategyProperties); - } - } - } - - private EnhancedValue createKeyValue( - PersistentClass rc, - List keyColumns, - String suggestedStrategyName, - Table table, - RevengMetadataCollector revengMetadataCollector, - Set processed) { - if (keyColumns.size()>1) { - LOGGER.log(Level.INFO, "id strategy for " + rc.getEntityName() + " since it has a multiple column primary key"); - return handleCompositeKey(rc, processed, keyColumns); - } - else { - String tableIdentifierStrategyName = - getTableIdentifierStrategyName(suggestedStrategyName, revengMetadataCollector, table); - return handleColumnKey(table, tableIdentifierStrategyName, processed, keyColumns); - } - } - - private PrimaryKeyInfo createPrimaryKeyInfo( - TableIdentifier tableIdentifier, - List keyColumns) { - PrimaryKeyInfo result = new PrimaryKeyInfo(); - result.suggestedProperties = getRevengStrategy().getTableIdentifierProperties(tableIdentifier); - if (keyColumns.size() == 1) { - result.suggestedStrategy = RevengUtils.getTableIdentifierStrategyNameInRevengStrategy( - getRevengStrategy(), - tableIdentifier, - getDefaultCatalog(), - getDefaultSchema()); - } - return result; - } - - private String getTableIdentifierStrategyName( - String suggestedStrategy, - RevengMetadataCollector revengMetadataCollector, - Table table) { - if(suggestedStrategy==null) { - suggestedStrategy = revengMetadataCollector.getSuggestedIdentifierStrategy( - table.getCatalog(), - table.getSchema(), - table.getName() ); - return suggestedStrategy == null ? "assigned" : suggestedStrategy; - } else { - return suggestedStrategy; - } - } - - private String getIdPropertyName( - TableIdentifier tableIdentifier, - - List keyColumns) { - String result = getRevengStrategy().tableToIdentifierPropertyName(tableIdentifier); - if (result == null) { - if (keyColumns.size() > 1) { - result = "id"; - } else { - result = getRevengStrategy().columnToPropertyName( - tableIdentifier, - keyColumns.get(0).getName()); - } - } - return result; - } - - private boolean isGeneratedId( - List keyColumns, - String tableIdentifierStrategyName) { - boolean result = false; - if (keyColumns.size() == 1) { - result = !"assigned".equals(tableIdentifierStrategyName); - } - return result; - } - - private List getKeyColumns(Table table) { - List result = null; - if (table.getPrimaryKey()!=null) { - result = table.getPrimaryKey().getColumns(); - } - else { - LOGGER.log(Level.INFO, "No primary key found for " + table + ", using all properties as the identifier."); - result = new ArrayList(); - for (Column col : table.getColumns()) { - result.add(col); - } - } - return result; - } - - private EnhancedBasicValue handleColumnKey( - Table table, - String tableIdentifierStrategyName, - Set processed, - List keyColumns) { - Column pkc = (Column) keyColumns.get(0); - BinderUtils.checkColumnForMultipleBinding(pkc); - processed.add(pkc); - EnhancedBasicValue result = simpleValueBinder.bind( - table, - pkc, - isGeneratedId(keyColumns, tableIdentifierStrategyName)); - result.setIdentifierGeneratorStrategy(tableIdentifierStrategyName); - return result; - } + void updatePrimaryKey(RootClass rc, PrimaryKeyInfo pki) { + EnhancedValue idValue = (EnhancedValue) rc.getIdentifierProperty().getValue(); + Properties defaultStrategyProperties = new Properties(); + Property constrainedOneToOne = getConstrainedOneToOne(rc); + if(constrainedOneToOne!=null) { + if(pki.suggestedStrategy==null) { + idValue.setIdentifierGeneratorStrategy("foreign"); + } + if(pki.suggestedProperties==null) { + defaultStrategyProperties.setProperty("property", constrainedOneToOne.getName()); + idValue.setIdentifierGeneratorProperties(defaultStrategyProperties); + } + } + } + + private EnhancedValue createKeyValue( + PersistentClass rc, + List keyColumns, + String suggestedStrategyName, + Table table, + RevengMetadataCollector revengMetadataCollector, + Set processed) { + if (keyColumns.size()>1) { + LOGGER.log(Level.INFO, "id strategy for " + rc.getEntityName() + " since it has a multiple column primary key"); + return handleCompositeKey(rc, processed, keyColumns); + } + else { + String tableIdentifierStrategyName = + getTableIdentifierStrategyName(suggestedStrategyName, revengMetadataCollector, table); + return handleColumnKey(table, tableIdentifierStrategyName, processed, keyColumns); + } + } - private EnhancedComponent handleCompositeKey( - PersistentClass rc, - Set processedColumns, - List keyColumns) { - EnhancedComponent result = new EnhancedComponent(getMetadataBuildingContext(), rc); + private PrimaryKeyInfo createPrimaryKeyInfo( + TableIdentifier tableIdentifier, + List keyColumns) { + PrimaryKeyInfo result = new PrimaryKeyInfo(); + result.suggestedProperties = getRevengStrategy().getTableIdentifierProperties(tableIdentifier); + if (keyColumns.size() == 1) { + result.suggestedStrategy = RevengUtils.getTableIdentifierStrategyNameInRevengStrategy( + getRevengStrategy(), + tableIdentifier, + getDefaultCatalog(), + getDefaultSchema()); + } + return result; + } + + private String getTableIdentifierStrategyName( + String suggestedStrategy, + RevengMetadataCollector revengMetadataCollector, + Table table) { + if(suggestedStrategy==null) { + suggestedStrategy = revengMetadataCollector.getSuggestedIdentifierStrategy( + table.getCatalog(), + table.getSchema(), + table.getName() ); + return suggestedStrategy == null ? "assigned" : suggestedStrategy; + } + else { + return suggestedStrategy; + } + } + + private String getIdPropertyName( + TableIdentifier tableIdentifier, + + List keyColumns) { + String result = getRevengStrategy().tableToIdentifierPropertyName(tableIdentifier); + if (result == null) { + if (keyColumns.size() > 1) { + result = "id"; + } + else { + result = getRevengStrategy().columnToPropertyName( + tableIdentifier, + keyColumns.get(0).getName()); + } + } + return result; + } + + private boolean isGeneratedId( + List keyColumns, + String tableIdentifierStrategyName) { + boolean result = false; + if (keyColumns.size() == 1) { + result = !"assigned".equals(tableIdentifierStrategyName); + } + return result; + } + + private List getKeyColumns(Table table) { + List result; + if (table.getPrimaryKey()!=null) { + result = table.getPrimaryKey().getColumns(); + } + else { + LOGGER.log(Level.INFO, "No primary key found for " + table + ", using all properties as the identifier."); + result = new ArrayList<>( table.getColumns() ); + } + return result; + } + + private EnhancedBasicValue handleColumnKey( + Table table, + String tableIdentifierStrategyName, + Set processed, + List keyColumns) { + Column pkc = keyColumns.get(0); + BinderUtils.checkColumnForMultipleBinding(pkc); + processed.add(pkc); + EnhancedBasicValue result = simpleValueBinder.bind( + table, + pkc, + isGeneratedId(keyColumns, tableIdentifierStrategyName)); + result.setIdentifierGeneratorStrategy(tableIdentifierStrategyName); + return result; + } + + private EnhancedComponent handleCompositeKey( + PersistentClass rc, + Set processedColumns, + List keyColumns) { + EnhancedComponent result = new EnhancedComponent(getMetadataBuildingContext(), rc); result.setMetaAttributes(Collections.emptyMap()); result.setEmbedded(false); result.setComponentClassName(getCompositeIdName(rc)); addKeyColumns(result, rc.getTable(), getKeyColumns(rc.getTable(), keyColumns), processedColumns); result.setNullValue("undefined"); result.setIdentifierGeneratorStrategy("assigned"); - return result; - } + return result; + } private static void markAsUseInEquals(Property property) { - Map m = new HashMap(); + Map m = new HashMap<>(); MetaAttribute ma = new MetaAttribute("use-in-equals"); ma.addValue("true"); m.put(ma.getName(),ma); property.setMetaAttributes(m); } - private Property getConstrainedOneToOne(RootClass rc) { - for (Property property : rc.getProperties()) { - if(property.getValue() instanceof OneToOne) { - OneToOne oto = (OneToOne) property.getValue(); - if(oto.isConstrained()) { - return property; - } - } - } - return null; - } - - private Property bindManyToOneProperty( - Component pkc, - ForeignKeyForColumns fkfc, - Table table, Set - processedColumns) { + private Property getConstrainedOneToOne(RootClass rc) { + for (Property property : rc.getProperties()) { + if( property.getValue() instanceof OneToOne oto ) { + if(oto.isConstrained()) { + return property; + } + } + } + return null; + } + + private Property bindManyToOneProperty( + Component pkc, + ForeignKeyForColumns fkfc, + Table table, Set + processedColumns) { ForeignKey foreignKey = fkfc.key; Property property = manyToOneBinder.bind( - BinderUtils.makeUnique(pkc, getForeignKeyToEntityName(foreignKey)), - true, - table, - foreignKey, - processedColumns); + BinderUtils.makeUnique(pkc, getForeignKeyToEntityName(foreignKey)), + true, + table, + foreignKey, + processedColumns); processedColumns.addAll(fkfc.columns); return property; - } - - private Property bindBasicProperty( - Component pkc, - Column column, - Table table, - Set processedColumns) { - Property result = null; + } + + private Property bindBasicProperty( + Component pkc, + Column column, + Table table, + Set processedColumns) { + Property result; if ( processedColumns.contains(column) ) { throw new RuntimeException("Binding column twice for primary key should not happen: " + column); } - else { - BinderUtils.checkColumnForMultipleBinding(column); + else { + BinderUtils.checkColumnForMultipleBinding(column); result = basicPropertyBinder.bind( - BinderUtils.makeUnique(pkc, getColumnToPropertyName(table, column)), - table, - column); + BinderUtils.makeUnique(pkc, getColumnToPropertyName(table, column)), + table, + column); processedColumns.add(column); } - return result; - } - - private String getForeignKeyToEntityName(ForeignKey foreignKey) { - return getRevengStrategy().foreignKeyToEntityName( - foreignKey.getName(), - TableIdentifier.create(foreignKey.getTable()), - foreignKey.getColumns(), - TableIdentifier.create(foreignKey.getReferencedTable()), - foreignKey.getReferencedColumns(), - true - ); - } - - private String getColumnToPropertyName(Table table, Column column) { - return getRevengStrategy().columnToPropertyName( - TableIdentifier.create(table), - column.getName()); - } - - private void addKeyColumns( - Component pkc, - Table table, - List list, - Set processedColumns) { - for (Iterator iter = list.iterator(); iter.hasNext();) { - Object element = iter.next(); - Property property; - if (element instanceof Column) { - property = bindBasicProperty(pkc, (Column)element, table, processedColumns); + return result; + } + + private String getForeignKeyToEntityName(ForeignKey foreignKey) { + return getRevengStrategy().foreignKeyToEntityName( + foreignKey.getName(), + TableIdentifier.create(foreignKey.getTable()), + foreignKey.getColumns(), + TableIdentifier.create(foreignKey.getReferencedTable()), + foreignKey.getReferencedColumns(), + true + ); + } + + private String getColumnToPropertyName(Table table, Column column) { + return getRevengStrategy().columnToPropertyName( + TableIdentifier.create(table), + column.getName()); + } + + private void addKeyColumns( + Component pkc, + Table table, + List list, + Set processedColumns) { + for ( Object element : list ) { + Property property; + if ( element instanceof Column ) { + property = bindBasicProperty( pkc, (Column) element, table, processedColumns ); } - else if (element instanceof ForeignKeyForColumns) { - property = bindManyToOneProperty(pkc, (ForeignKeyForColumns)element, table, processedColumns); + else if ( element instanceof ForeignKeyForColumns ) { + property = bindManyToOneProperty( pkc, (ForeignKeyForColumns) element, table, processedColumns ); } - else { - throw new RuntimeException("unknown thing"); - } - markAsUseInEquals(property); - pkc.addProperty(property); - } - } - - private List getKeyColumns(Table table, List keyColumns) { - if (preferBasicCompositeIds() ) { + else { + throw new RuntimeException( "unknown thing" ); + } + markAsUseInEquals( property ); + pkc.addProperty( property ); + } + } + + private List getKeyColumns(Table table, List keyColumns) { + if (preferBasicCompositeIds() ) { return new ArrayList(keyColumns); } - else { - return ForeignKeyUtils.findForeignKeys(table.getForeignKeys().values(), keyColumns); + else { + return ForeignKeyUtils.findForeignKeys(table.getForeignKeyCollection(), keyColumns); } - } - - private String getCompositeIdName(PersistentClass pc) { + } + + private String getCompositeIdName(PersistentClass pc) { String compositeIdName = getRevengStrategy().tableToCompositeIdName( - TableIdentifier.create(pc.getTable())); + TableIdentifier.create(pc.getTable())); if(compositeIdName==null) { - compositeIdName = getRevengStrategy().classNameToCompositeIdName(pc.getClassName()); + compositeIdName = getRevengStrategy().classNameToCompositeIdName(pc.getClassName()); } return compositeIdName; - } + } } diff --git a/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/RootClassBinder.java b/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/RootClassBinder.java index 648b1e4ab3..03c78c1fc4 100644 --- a/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/RootClassBinder.java +++ b/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/RootClassBinder.java @@ -41,139 +41,140 @@ import org.hibernate.tool.internal.reveng.util.RevengUtils; public class RootClassBinder extends AbstractBinder { - - private static final Logger LOGGER = Logger.getLogger(RootClassBinder.class.getName()); - - public static RootClassBinder create( - BinderContext binderContext) { - return new RootClassBinder(binderContext); - } - - private final PrimaryKeyBinder primaryKeyBinder; - private final VersionPropertyBinder versionPropertyBinder; - private final ForeignKeyBinder foreignKeyBinder; - private final BasicPropertyBinder basicPropertyBinder; - - private RootClassBinder(BinderContext binderContext) { - super(binderContext); - this.primaryKeyBinder = PrimaryKeyBinder.create(binderContext); - this.versionPropertyBinder = VersionPropertyBinder.create(binderContext); - this.foreignKeyBinder = ForeignKeyBinder.create(binderContext); - this.basicPropertyBinder = BasicPropertyBinder.create(binderContext); - } - - public void bind(Table table, RevengMetadataCollector revengMetadataCollector) { - Set processed = new HashSet(); - nullifyDefaultCatalogAndSchema(table); - RootClass rc = createRootClass(table); - addToMetadataCollector(rc, table); - PrimaryKeyInfo pki = bindPrimaryKey(table, rc, processed, revengMetadataCollector); - bindVersionProperty(table, rc, processed); - bindOutgoingForeignKeys(table, rc, processed); - bindColumnsToProperties(table, rc, processed); - bindIncomingForeignKeys(rc, processed, revengMetadataCollector); - updatePrimaryKey(rc, pki); - } - - private PrimaryKeyInfo bindPrimaryKey( - Table table, - RootClass rc, - Set processed, - RevengMetadataCollector revengMetadataCollector) { - return primaryKeyBinder.bind(table, rc, processed, revengMetadataCollector); - } - - private void updatePrimaryKey(RootClass rc, PrimaryKeyInfo pki) { - primaryKeyBinder.updatePrimaryKey(rc, pki); - } - - private void addToMetadataCollector(RootClass rc, Table table) { - try { - getMetadataCollector().addEntityBinding(rc); - getMetadataCollector().addImport( rc.getEntityName(), rc.getEntityName() ); - } catch(DuplicateMappingException dme) { - // TODO: detect this and generate a "permutation" of it ? - PersistentClass class1 = getMetadataCollector().getEntityBinding(dme.getName()); - Table table2 = class1.getTable(); - throw new RuntimeException("Duplicate class name '" + rc.getEntityName() + "' generated for '" + table + "'. Same name where generated for '" + table2 + "'"); - } - } - - private RootClass createRootClass(Table table) { - RootClass rc = new RootClass(getMetadataBuildingContext()); - TableIdentifier tableIdentifier = TableIdentifier.create(table); - String className = getRevengStrategy().tableToClassName( tableIdentifier ); - LOGGER.log(Level.INFO, "Building entity " + className + " based on " + tableIdentifier); - rc.setEntityName( className ); - rc.setJpaEntityName( StringHelper.unqualify( className ) ); - rc.setClassName( className ); - rc.setProxyInterfaceName( rc.getEntityName() ); // TODO: configurable ? - rc.setLazy(true); - rc.setMetaAttributes(getMetaAttributes(table)); - rc.setDiscriminatorValue( rc.getEntityName() ); - rc.setTable(table); - rc.setOptimisticLockStyle(OptimisticLockStyle.NONE); - return rc; - } - - private void nullifyDefaultCatalogAndSchema(Table table) { - if (table.getCatalog() != null && table.getCatalog().equals(getDefaultCatalog())) { - table.setCatalog(null); - } - if (table.getSchema() != null && table.getSchema().equals(getDefaultSchema())) { - table.setSchema(null); - } - } - - private void bindVersionProperty( - Table table, - RootClass rc, - Set processed) { - versionPropertyBinder.bind(table, rc, processed); - } - - private void bindIncomingForeignKeys( - PersistentClass rc, - Set processed, - RevengMetadataCollector revengMetadataCollector) { - List foreignKeys = revengMetadataCollector.getOneToManyCandidates().get(rc.getEntityName()); - if(foreignKeys!=null) { - for (Iterator iter = foreignKeys.iterator(); iter.hasNext();) { - foreignKeyBinder.bindIncoming(iter.next(), rc, processed); - } - } - } - - - private void bindOutgoingForeignKeys(Table table, RootClass rc, Set processedColumns) { - // Iterate the outgoing foreign keys and create many-to-one's - for (ForeignKey foreignKey : table.getForeignKeys().values()) { - boolean mutable = true; + + private static final Logger LOGGER = Logger.getLogger(RootClassBinder.class.getName()); + + public static RootClassBinder create( + BinderContext binderContext) { + return new RootClassBinder(binderContext); + } + + private final PrimaryKeyBinder primaryKeyBinder; + private final VersionPropertyBinder versionPropertyBinder; + private final ForeignKeyBinder foreignKeyBinder; + private final BasicPropertyBinder basicPropertyBinder; + + private RootClassBinder(BinderContext binderContext) { + super(binderContext); + this.primaryKeyBinder = PrimaryKeyBinder.create(binderContext); + this.versionPropertyBinder = VersionPropertyBinder.create(binderContext); + this.foreignKeyBinder = ForeignKeyBinder.create(binderContext); + this.basicPropertyBinder = BasicPropertyBinder.create(binderContext); + } + + public void bind(Table table, RevengMetadataCollector revengMetadataCollector) { + Set processed = new HashSet<>(); + nullifyDefaultCatalogAndSchema(table); + RootClass rc = createRootClass(table); + addToMetadataCollector(rc, table); + PrimaryKeyInfo pki = bindPrimaryKey(table, rc, processed, revengMetadataCollector); + bindVersionProperty(table, rc, processed); + bindOutgoingForeignKeys(table, rc, processed); + bindColumnsToProperties(table, rc, processed); + bindIncomingForeignKeys(rc, processed, revengMetadataCollector); + updatePrimaryKey(rc, pki); + } + + private PrimaryKeyInfo bindPrimaryKey( + Table table, + RootClass rc, + Set processed, + RevengMetadataCollector revengMetadataCollector) { + return primaryKeyBinder.bind(table, rc, processed, revengMetadataCollector); + } + + private void updatePrimaryKey(RootClass rc, PrimaryKeyInfo pki) { + primaryKeyBinder.updatePrimaryKey(rc, pki); + } + + private void addToMetadataCollector(RootClass rc, Table table) { + try { + getMetadataCollector().addEntityBinding(rc); + getMetadataCollector().addImport( rc.getEntityName(), rc.getEntityName() ); + } + catch(DuplicateMappingException dme) { + // TODO: detect this and generate a "permutation" of it ? + PersistentClass class1 = getMetadataCollector().getEntityBinding(dme.getName()); + Table table2 = class1.getTable(); + throw new RuntimeException("Duplicate class name '" + rc.getEntityName() + "' generated for '" + table + "'. Same name where generated for '" + table2 + "'"); + } + } + + private RootClass createRootClass(Table table) { + RootClass rc = new RootClass(getMetadataBuildingContext()); + TableIdentifier tableIdentifier = TableIdentifier.create(table); + String className = getRevengStrategy().tableToClassName( tableIdentifier ); + LOGGER.log(Level.INFO, "Building entity " + className + " based on " + tableIdentifier); + rc.setEntityName( className ); + rc.setJpaEntityName( StringHelper.unqualify( className ) ); + rc.setClassName( className ); + rc.setProxyInterfaceName( rc.getEntityName() ); // TODO: configurable ? + rc.setLazy(true); + rc.setMetaAttributes(getMetaAttributes(table)); + rc.setDiscriminatorValue( rc.getEntityName() ); + rc.setTable(table); + rc.setOptimisticLockStyle(OptimisticLockStyle.NONE); + return rc; + } + + private void nullifyDefaultCatalogAndSchema(Table table) { + if (table.getCatalog() != null && table.getCatalog().equals(getDefaultCatalog())) { + table.setCatalog(null); + } + if (table.getSchema() != null && table.getSchema().equals(getDefaultSchema())) { + table.setSchema(null); + } + } + + private void bindVersionProperty( + Table table, + RootClass rc, + Set processed) { + versionPropertyBinder.bind(table, rc, processed); + } + + private void bindIncomingForeignKeys( + PersistentClass rc, + Set processed, + RevengMetadataCollector revengMetadataCollector) { + List foreignKeys = revengMetadataCollector.getOneToManyCandidates().get(rc.getEntityName()); + if(foreignKeys!=null) { + for ( ForeignKey foreignKey : foreignKeys ) { + foreignKeyBinder.bindIncoming( foreignKey, rc, processed ); + } + } + } + + + private void bindOutgoingForeignKeys(Table table, RootClass rc, Set processedColumns) { + // Iterate the outgoing foreign keys and create many-to-one's + for (ForeignKey foreignKey : table.getForeignKeyCollection()) { + boolean mutable = true; if ( contains( foreignKey.getColumns().iterator(), processedColumns ) ) { - if ( !preferBasicCompositeIds() ) continue; //it's in the pk, so skip this one - mutable = false; - } + if ( !preferBasicCompositeIds() ) continue; //it's in the pk, so skip this one + mutable = false; + } foreignKeyBinder.bindOutgoing(foreignKey, table, rc, processedColumns, mutable); - } - } - - private void bindColumnsToProperties(Table table, RootClass rc, Set processedColumns) { - for (Column column : table.getColumns()) { - if ( !processedColumns.contains(column) ) { - BinderUtils.checkColumnForMultipleBinding(column); - String propertyName = getColumnToPropertyNameInRevengStrategy(table, column); - Property property = basicPropertyBinder.bind( - BinderUtils.makeUnique(rc,propertyName), - table, - column); - rc.addProperty(property); - } - } - } + } + } + + private void bindColumnsToProperties(Table table, RootClass rc, Set processedColumns) { + for (Column column : table.getColumns()) { + if ( !processedColumns.contains(column) ) { + BinderUtils.checkColumnForMultipleBinding(column); + String propertyName = getColumnToPropertyNameInRevengStrategy(table, column); + Property property = basicPropertyBinder.bind( + BinderUtils.makeUnique(rc,propertyName), + table, + column); + rc.addProperty(property); + } + } + } private boolean contains(Iterator columnIterator, Set processedColumns) { while (columnIterator.hasNext() ) { - Column element = (Column) columnIterator.next(); + Column element = columnIterator.next(); if(processedColumns.contains(element) ) { return true; } @@ -181,35 +182,35 @@ private boolean contains(Iterator columnIterator, Set processedC return false; } - private Map getMetaAttributes(Table table) { - Map result = null; - TableIdentifier tableIdentifier = TableIdentifier.create(table); - result = getRevengStrategy().tableToMetaAttributes(tableIdentifier); - if (result == null) { - tableIdentifier = RevengUtils.createTableIdentifier( - table, - getDefaultCatalog(), - getDefaultSchema()); - result = getRevengStrategy().tableToMetaAttributes(tableIdentifier); - } - if (result == null) { - result = Collections.emptyMap(); - } - return result; - } - - private String getColumnToPropertyNameInRevengStrategy( - Table table, - Column column) { - String result = null; - String columnName = column.getName(); - TableIdentifier tableIdentifier = TableIdentifier.create(table); - result = getRevengStrategy().columnToPropertyName(tableIdentifier, columnName); - if (result == null) { - tableIdentifier = RevengUtils.createTableIdentifier(table, getDefaultCatalog(), getDefaultSchema()); - result = getRevengStrategy().columnToPropertyName(tableIdentifier, columnName); - } - return result; - } + private Map getMetaAttributes(Table table) { + Map result; + TableIdentifier tableIdentifier = TableIdentifier.create(table); + result = getRevengStrategy().tableToMetaAttributes(tableIdentifier); + if (result == null) { + tableIdentifier = RevengUtils.createTableIdentifier( + table, + getDefaultCatalog(), + getDefaultSchema()); + result = getRevengStrategy().tableToMetaAttributes(tableIdentifier); + } + if (result == null) { + result = Collections.emptyMap(); + } + return result; + } + + private String getColumnToPropertyNameInRevengStrategy( + Table table, + Column column) { + String result; + String columnName = column.getName(); + TableIdentifier tableIdentifier = TableIdentifier.create(table); + result = getRevengStrategy().columnToPropertyName(tableIdentifier, columnName); + if (result == null) { + tableIdentifier = RevengUtils.createTableIdentifier(table, getDefaultCatalog(), getDefaultSchema()); + result = getRevengStrategy().columnToPropertyName(tableIdentifier, columnName); + } + return result; + } } diff --git a/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/TypeUtils.java b/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/TypeUtils.java index 466038b7a2..a4c67d8631 100644 --- a/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/TypeUtils.java +++ b/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/TypeUtils.java @@ -31,101 +31,103 @@ import org.hibernate.type.Type; public class TypeUtils { - - private static final Logger LOGGER = Logger.getLogger(TypeUtils.class.getName()); - - public static final int DEFAULT_COLUMN_LENGTH = 255; - public static final int DEFAULT_COLUMN_PRECISION = 19; - public static final int DEFAULT_COLUMN_SCALE = 2; - - public static String determinePreferredType( - InFlightMetadataCollector metadataCollector, - RevengStrategy revengStrategy, - Table table, - Column column, - boolean generatedIdentifier) { - - String location = - "Table: " + - TableNameQualifier.qualify( - table.getCatalog(), - table.getSchema(), - table.getQuotedName() ) + - " column: " + - column.getQuotedName(); - - Integer sqlTypeCode = column.getSqlTypeCode(); - if(sqlTypeCode==null) { - throw new RuntimeException("sqltype is null for " + location); - } - - String preferredHibernateType = revengStrategy.columnToHibernateTypeName( - TableIdentifier.create(table), - column.getName(), - sqlTypeCode.intValue(), - column.getLength() != null ? column.getLength().intValue() : DEFAULT_COLUMN_LENGTH, - column.getPrecision() != null ? column.getPrecision().intValue() : DEFAULT_COLUMN_PRECISION, - column.getScale() != null ? column.getScale().intValue() : DEFAULT_COLUMN_SCALE, - column.isNullable(), - generatedIdentifier - ); - - Type wantedType = metadataCollector - .getTypeConfiguration() - .getBasicTypeRegistry() - .getRegisteredType(preferredHibernateType); - - if(wantedType!=null) { - - int[] wantedSqlTypes = wantedType.getSqlTypeCodes(metadataCollector); - - if(wantedSqlTypes.length>1) { - throw new RuntimeException("The type " + preferredHibernateType + " found on " + location + " spans multiple columns. Only single column types allowed."); - } - - int wantedSqlType = wantedSqlTypes[0]; - if(wantedSqlType!=sqlTypeCode.intValue() ) { - LOGGER.log( - Level.INFO, - "Sql type mismatch for " + location + " between DB and wanted hibernate type. Sql type set to " + typeCodeName( sqlTypeCode.intValue() ) + " instead of " + typeCodeName(wantedSqlType) ); - forceSqlTypeCode(column, wantedSqlType); - } - - } - - else { - - LOGGER.log( - Level.INFO, - "No Hibernate type found for " + preferredHibernateType + ". Most likely cause is a missing UserType class."); - - } - - - - if(preferredHibernateType==null) { - throw new RuntimeException("Could not find javatype for " + typeCodeName(sqlTypeCode.intValue())); - } - - return preferredHibernateType; - } - - private static String typeCodeName(int sqlTypeCode) { - return sqlTypeCode + "(" + JdbcToHibernateTypeHelper.getJDBCTypeName(sqlTypeCode) + ")"; - } - - private static void forceSqlTypeCode(Column column, int sqlCode) { - try { - Field sqlCodeField = Column.class.getDeclaredField("sqlTypeCode"); - sqlCodeField.setAccessible(true); - sqlCodeField.set(column, Integer.valueOf(sqlCode)); - } catch (NoSuchFieldException | - SecurityException | - IllegalArgumentException | - IllegalAccessException e) { - throw new RuntimeException(e); - } - } + + private static final Logger LOGGER = Logger.getLogger(TypeUtils.class.getName()); + + public static final int DEFAULT_COLUMN_LENGTH = 255; + public static final int DEFAULT_COLUMN_PRECISION = 19; + public static final int DEFAULT_COLUMN_SCALE = 2; + + public static String determinePreferredType( + InFlightMetadataCollector metadataCollector, + RevengStrategy revengStrategy, + Table table, + Column column, + boolean generatedIdentifier) { + + String location = + "Table: " + + TableNameQualifier.qualify( + table.getCatalog(), + table.getSchema(), + table.getQuotedName() ) + + " column: " + + column.getQuotedName(); + + Integer sqlTypeCode = column.getSqlTypeCode(); + if(sqlTypeCode==null) { + throw new RuntimeException("sqltype is null for " + location); + } + + String preferredHibernateType = revengStrategy.columnToHibernateTypeName( + TableIdentifier.create(table), + column.getName(), + sqlTypeCode, + column.getLength() != null ? column.getLength().intValue() : DEFAULT_COLUMN_LENGTH, + column.getPrecision() != null ? column.getPrecision() : DEFAULT_COLUMN_PRECISION, + column.getScale() != null ? column.getScale() : DEFAULT_COLUMN_SCALE, + column.isNullable(), + generatedIdentifier + ); + + Type wantedType = metadataCollector + .getTypeConfiguration() + .getBasicTypeRegistry() + .getRegisteredType(preferredHibernateType); + + if(wantedType!=null) { + + int[] wantedSqlTypes = wantedType.getSqlTypeCodes(metadataCollector); + + if(wantedSqlTypes.length>1) { + throw new RuntimeException("The type " + preferredHibernateType + " found on " + location + " spans multiple columns. Only single column types allowed."); + } + + int wantedSqlType = wantedSqlTypes[0]; + if( wantedSqlType != sqlTypeCode ) { + LOGGER.log( + Level.INFO, + "Sql type mismatch for " + location + " between DB and wanted hibernate type. Sql type set to " + typeCodeName( + sqlTypeCode ) + " instead of " + typeCodeName(wantedSqlType) ); + forceSqlTypeCode(column, wantedSqlType); + } + + } + + else { + + LOGGER.log( + Level.INFO, + "No Hibernate type found for " + preferredHibernateType + ". Most likely cause is a missing UserType class."); + + } + + + + if(preferredHibernateType==null) { + throw new RuntimeException("Could not find javatype for " + typeCodeName( sqlTypeCode )); + } + + return preferredHibernateType; + } + + private static String typeCodeName(int sqlTypeCode) { + return sqlTypeCode + "(" + JdbcToHibernateTypeHelper.getJDBCTypeName(sqlTypeCode) + ")"; + } + + private static void forceSqlTypeCode(Column column, int sqlCode) { + try { + Field sqlCodeField = Column.class.getDeclaredField("sqlTypeCode"); + sqlCodeField.setAccessible(true); + sqlCodeField.set(column, sqlCode ); + } + catch (NoSuchFieldException | + SecurityException | + IllegalArgumentException | + IllegalAccessException e) { + throw new RuntimeException(e); + } + } } diff --git a/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/VersionPropertyBinder.java b/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/VersionPropertyBinder.java index 9437c6542c..08db76ff70 100644 --- a/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/VersionPropertyBinder.java +++ b/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/VersionPropertyBinder.java @@ -29,79 +29,81 @@ import org.hibernate.tool.api.reveng.TableIdentifier; class VersionPropertyBinder extends AbstractBinder { - - private final static Logger LOGGER = Logger.getLogger(VersionPropertyBinder.class.getName()); - - static VersionPropertyBinder create(BinderContext binderContext) { - return new VersionPropertyBinder(binderContext); - } - - private final BasicPropertyBinder basicPropertyBinder; - - private VersionPropertyBinder(BinderContext binderContext) { - super(binderContext); - this.basicPropertyBinder = BasicPropertyBinder.create(binderContext); - } - - void bind( - Table table, - RootClass rc, - Set processed) { - String optimisticLockColumnName = getRevengStrategy() - .getOptimisticLockColumnName(TableIdentifier.create(table)); - if(optimisticLockColumnName!=null) { - handleSpecifiedVersionColumn(table, optimisticLockColumnName, rc, processed); - } else { - scanForAppropriateVersionColumn(table, rc, processed); - } - } - - private void scanForAppropriateVersionColumn( - Table table, - RootClass rc, - Set processed) { - TableIdentifier identifier = TableIdentifier.create(table); - LOGGER.log(Level.INFO, "Scanning " + identifier + " for / columns."); - for (Column column : table.getColumns()) { - boolean useIt = getRevengStrategy().useColumnForOptimisticLock(identifier, column.getName()); - if(useIt && !processed.contains(column)) { - bindVersionProperty(table, column, rc, processed); - return; - } - } - LOGGER.log(Level.INFO, "No columns reported while scanning for / columns in " + identifier); - } - - private void handleSpecifiedVersionColumn( - Table table, - String optimisticLockColumnName, - RootClass rc, - Set processed) { - TableIdentifier identifier = TableIdentifier.create(table); - Column column = table.getColumn(new Column(optimisticLockColumnName)); - if(column==null) { - LOGGER.log(Level.WARNING, "Column " + column + " wanted for / not found in " + identifier); - } else { - bindVersionProperty(table, column, rc, processed); - } - } - private void bindVersionProperty( - Table table, - Column column, - RootClass rc, - Set processed) { - TableIdentifier identifier = TableIdentifier.create(table); - processed.add(column); - String propertyName = getRevengStrategy().columnToPropertyName( identifier, column.getName() ); - Property property = basicPropertyBinder.bind( - BinderUtils.makeUnique(rc, propertyName), - table, - column); - rc.addProperty(property); - rc.setVersion(property); - rc.setOptimisticLockStyle(OptimisticLockStyle.VERSION); - LOGGER.log(Level.INFO, "Column " + column.getName() + " will be used for / columns in " + identifier); + private final static Logger LOGGER = Logger.getLogger(VersionPropertyBinder.class.getName()); - } + static VersionPropertyBinder create(BinderContext binderContext) { + return new VersionPropertyBinder(binderContext); + } + + private final BasicPropertyBinder basicPropertyBinder; + + private VersionPropertyBinder(BinderContext binderContext) { + super(binderContext); + this.basicPropertyBinder = BasicPropertyBinder.create(binderContext); + } + + void bind( + Table table, + RootClass rc, + Set processed) { + String optimisticLockColumnName = getRevengStrategy() + .getOptimisticLockColumnName(TableIdentifier.create(table)); + if(optimisticLockColumnName!=null) { + handleSpecifiedVersionColumn(table, optimisticLockColumnName, rc, processed); + } + else { + scanForAppropriateVersionColumn(table, rc, processed); + } + } + + private void scanForAppropriateVersionColumn( + Table table, + RootClass rc, + Set processed) { + TableIdentifier identifier = TableIdentifier.create(table); + LOGGER.log(Level.INFO, "Scanning " + identifier + " for / columns."); + for (Column column : table.getColumns()) { + boolean useIt = getRevengStrategy().useColumnForOptimisticLock(identifier, column.getName()); + if(useIt && !processed.contains(column)) { + bindVersionProperty(table, column, rc, processed); + return; + } + } + LOGGER.log(Level.INFO, "No columns reported while scanning for / columns in " + identifier); + } + + private void handleSpecifiedVersionColumn( + Table table, + String optimisticLockColumnName, + RootClass rc, + Set processed) { + TableIdentifier identifier = TableIdentifier.create(table); + Column column = table.getColumn(new Column(optimisticLockColumnName)); + if(column==null) { + LOGGER.log(Level.WARNING, "Column " + optimisticLockColumnName + " wanted for / not found in " + identifier); + } + else { + bindVersionProperty(table, column, rc, processed); + } + } + + private void bindVersionProperty( + Table table, + Column column, + RootClass rc, + Set processed) { + TableIdentifier identifier = TableIdentifier.create(table); + processed.add(column); + String propertyName = getRevengStrategy().columnToPropertyName( identifier, column.getName() ); + Property property = basicPropertyBinder.bind( + BinderUtils.makeUnique(rc, propertyName), + table, + column); + rc.addProperty(property); + rc.setVersion(property); + rc.setOptimisticLockStyle(OptimisticLockStyle.VERSION); + LOGGER.log(Level.INFO, "Column " + column.getName() + " will be used for / columns in " + identifier); + + } }