Class BinderHelper

  • public class BinderHelper
    extends Object
    • Field Detail


        public static final Set<String> PRIMITIVE_NAMES
    • Method Detail

      • 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 using 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
      • findColumnOwner

        public static Object 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
      • getMappedSuperclassOrNull

        public static MappedSuperclass getMappedSuperclassOrNull​(org.hibernate.annotations.common.reflection.XClass declaringClass,
                                                                 Map<org.hibernate.annotations.common.reflection.XClass,​InheritanceState> inheritanceStatePerClass,
                                                                 MetadataBuildingContext context)
      • 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​(jakarta.persistence.FetchType fetch)
      • getCascadeStrategy

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