Package org.hibernate.boot.model.internal

Class BinderHelper

java.lang.Object
org.hibernate.boot.model.internal.BinderHelper
public class BinderHelper extends Object

  • Field Details

    • PRIMITIVE_NAMES

      public static final Set<String> PRIMITIVE_NAMES

  • Method Details

    • isPrimitive

      public static boolean isPrimitive(String elementTypeName)

    • createSyntheticPropertyReference

      public static void createSyntheticPropertyReference(AnnotatedJoinColumns joinColumns, PersistentClass targetEntity, PersistentClass associatedEntity, Value value, String propertyName, boolean inverse, MetadataBuildingContext context)
      Here we address a fundamental problem: the @JoinColumn annotation specifies the referenced column in the target table via referencedColumnName, but Hibernate needs to know which property or field of the target entity class holds the value of the referenced column at the Java level. (It's going to need the value when it writes the association.)

      Complicating this hugely is the fact that an association might be based on a composite key with multiple @JoinColumns, and so the referenced columns might even be spread out over multiple fields or properties of the target entity. There's even some extra minor complications resulting from multi-table inheritance and secondary tables.

      The solution here is:

      • if the referenced columns correspond to exactly one property of the target entity, we're good, just use it, or
      • otherwise, if a composite key is spread out over multiple properties, then create a "synthetic" Component in the model that aggregates these properties and is considered the target of the association.

      Certain limitations arise from the way this solution is currently implemented: for example, if a referenced column belongs to a property of an @Embeddable, then every column of that embeddable must occur in the list of referenced columns, and the order of the columns must line up! Some of these limitations could be relaxed by writing a better algorithm for building the synthetic Component.

    • shallowCopy

      public static Property shallowCopy(Property property)
      Create a copy of the Property, reusing the same Value and other attributes.

    • findPropertyByName

      public static Property findPropertyByName(PersistentClass associatedClass, String propertyName)
      Retrieve the property by path in a recursive way, including IdentifierProperty in the loop If propertyName is null or empty, the IdentifierProperty is returned

    • findPropertyByName

      public static Property findPropertyByName(Component component, String propertyName)
      Retrieve the property by path in a recursive way

    • getRelativePath

      public static String getRelativePath(PropertyHolder propertyHolder, String propertyName)

    • findReferencedColumnOwner

      public static AttributeContainer findReferencedColumnOwner(PersistentClass persistentClass, AnnotatedJoinColumn joinColumn, MetadataBuildingContext context)

    • findColumnOwner

      public static AttributeContainer findColumnOwner(PersistentClass persistentClass, String columnName, MetadataBuildingContext context)
      Find the column owner (ie PersistentClass or Join) of columnName. If columnName is null or empty, persistentClass is returned

    • buildAnyValue

      public static Any buildAnyValue(Column discriminatorColumn, Formula discriminatorFormula, AnnotatedJoinColumns keyColumns, PropertyData inferredData, OnDeleteAction onDeleteAction, boolean lazy, Nullability nullability, PropertyHolder propertyHolder, EntityBinder entityBinder, boolean optional, MetadataBuildingContext context)

    • getMappedSuperclassOrNull

      public static MappedSuperclass getMappedSuperclassOrNull(org.hibernate.annotations.common.reflection.XClass declaringClass, Map<org.hibernate.annotations.common.reflection.XClass,InheritanceState> inheritanceStatePerClass, MetadataBuildingContext context)

    • getPath

      public static String getPath(PropertyHolder holder, PropertyData property)

    • toAliasTableMap

      public static Map<String,String> toAliasTableMap(SqlFragmentAlias[] aliases)

    • toAliasEntityMap

      public static Map<String,String> toAliasEntityMap(SqlFragmentAlias[] aliases)

    • hasToOneAnnotation

      public static boolean hasToOneAnnotation(org.hibernate.annotations.common.reflection.XAnnotatedElement property)

    • getOverridableAnnotation

      public static <T extends Annotation> T getOverridableAnnotation(org.hibernate.annotations.common.reflection.XAnnotatedElement element, Class<T> annotationType, MetadataBuildingContext context)

    • getFetchMode

      public static FetchMode getFetchMode(FetchType fetch)

    • getCascadeStrategy

      public static String getCascadeStrategy(CascadeType[] ejbCascades, Cascade hibernateCascadeAnnotation, boolean orphanRemoval, boolean forcePersist)

    • isDefault

      public static boolean isDefault(org.hibernate.annotations.common.reflection.XClass clazz, MetadataBuildingContext context)

    • checkMappedByType

      public static void checkMappedByType(String mappedBy, Value targetValue, String propertyName, PropertyHolder propertyHolder, Map<String,PersistentClass> persistentClasses)

    • noConstraint

      public static boolean noConstraint(ForeignKey foreignKey, boolean noConstraintByDefault)

    • extractFromPackage

      public static <A extends Annotation> A extractFromPackage(Class<A> annotationType, org.hibernate.annotations.common.reflection.XClass xClass, MetadataBuildingContext context)
      Extract an annotation from the package-info for the package the given class is defined in
      Parameters:
      annotationType - The type of annotation to return
      xClass - The class in the package
      context - The processing context
      Returns:
      The annotation or null