예제 #1
0
 private EntityMetamodel getDeclarerEntityMetamodel(IdentifiableType<?> ownerType) {
   final Type.PersistenceType persistenceType = ownerType.getPersistenceType();
   if (persistenceType == Type.PersistenceType.ENTITY) {
     return context
         .getSessionFactory()
         .getEntityPersister(ownerType.getJavaType().getName())
         .getEntityMetamodel();
   } else if (persistenceType == Type.PersistenceType.MAPPED_SUPERCLASS) {
     PersistentClass persistentClass =
         context.getPersistentClassHostingProperties((MappedSuperclassTypeImpl<?>) ownerType);
     return context
         .getSessionFactory()
         .getEntityPersister(persistentClass.getClassName())
         .getEntityMetamodel();
   } else {
     throw new AssertionFailure(
         "Cannot get the metamodel for PersistenceType: " + persistenceType);
   }
 }
예제 #2
0
 @SuppressWarnings("unchecked")
 private <Y> Type<Y> getMetaModelType(ValueContext typeContext) {
   switch (typeContext.getValueClassification()) {
     case BASIC:
       {
         return new BasicTypeImpl<Y>(typeContext.getBindableType(), Type.PersistenceType.BASIC);
       }
     case ENTITY:
       {
         final org.hibernate.type.EntityType type = (EntityType) typeContext.getValue().getType();
         return (Type<Y>) context.locateEntityType(type.getAssociatedEntityName());
       }
     case EMBEDDABLE:
       {
         final Component component = (Component) typeContext.getValue();
         final EmbeddableTypeImpl<Y> embeddableType =
             new EmbeddableTypeImpl<Y>(
                 typeContext.getBindableType(),
                 typeContext.getAttributeMetadata().getOwnerType(),
                 (ComponentType) typeContext.getValue().getType());
         context.registerEmbeddedableType(embeddableType);
         final Iterator<Property> subProperties = component.getPropertyIterator();
         while (subProperties.hasNext()) {
           final Property property = subProperties.next();
           final AttributeImplementor<Y, Object> attribute =
               buildAttribute(embeddableType, property);
           if (attribute != null) {
             embeddableType.getBuilder().addAttribute(attribute);
           }
         }
         embeddableType.lock();
         return embeddableType;
       }
     default:
       {
         throw new AssertionFailure("Unknown type : " + typeContext.getValueClassification());
       }
   }
 }
예제 #3
0
  /**
   * Here is most of the nuts and bolts of this factory, where we interpret the known JPA metadata
   * against the known Hibernate metadata and build a descriptor for the attribute.
   *
   * @param attributeContext The attribute to be described
   * @param memberResolver Strategy for how to resolve the member defining the attribute.
   * @param <X> The owner type
   * @param <Y> The attribute type
   * @return The attribute description
   */
  @SuppressWarnings({"unchecked"})
  private <X, Y> AttributeMetadata<X, Y> determineAttributeMetadata(
      AttributeContext<X> attributeContext, MemberResolver memberResolver) {
    LOG.trace(
        "Starting attribute metadata determination ["
            + attributeContext.getPropertyMapping().getName()
            + "]");
    final Member member = memberResolver.resolveMember(attributeContext);
    LOG.trace("    Determined member [" + member + "]");

    final Value value = attributeContext.getPropertyMapping().getValue();
    final org.hibernate.type.Type type = value.getType();
    LOG.trace(
        "    Determined type [name="
            + type.getName()
            + ", class="
            + type.getClass().getName()
            + "]");

    if (type.isAnyType()) {
      // ANY mappings are currently not supported in the JPA metamodel; see HHH-6589
      if (context.isIgnoreUnsupported()) {
        return null;
      } else {
        throw new UnsupportedOperationException("ANY not supported");
      }
    } else if (type.isAssociationType()) {
      // collection or entity
      if (type.isEntityType()) {
        // entity
        return new SingularAttributeMetadataImpl<X, Y>(
            attributeContext.getPropertyMapping(),
            attributeContext.getOwnerType(),
            member,
            determineSingularAssociationAttributeType(member));
      }
      // collection
      if (value instanceof Collection) {
        final Collection collValue = (Collection) value;
        final Value elementValue = collValue.getElement();
        final org.hibernate.type.Type elementType = elementValue.getType();

        // First, determine the type of the elements and use that to help determine the
        // collection type)
        final Attribute.PersistentAttributeType elementPersistentAttributeType;
        final Attribute.PersistentAttributeType persistentAttributeType;
        if (elementType.isAnyType()) {
          throw new UnsupportedOperationException("collection of any not supported yet");
        }
        final boolean isManyToMany = isManyToMany(member);
        if (elementValue instanceof Component) {
          elementPersistentAttributeType = Attribute.PersistentAttributeType.EMBEDDED;
          persistentAttributeType = Attribute.PersistentAttributeType.ELEMENT_COLLECTION;
        } else if (elementType.isAssociationType()) {
          elementPersistentAttributeType =
              isManyToMany
                  ? Attribute.PersistentAttributeType.MANY_TO_MANY
                  : Attribute.PersistentAttributeType.ONE_TO_MANY;
          persistentAttributeType = elementPersistentAttributeType;
        } else {
          elementPersistentAttributeType = Attribute.PersistentAttributeType.BASIC;
          persistentAttributeType = Attribute.PersistentAttributeType.ELEMENT_COLLECTION;
        }

        final Attribute.PersistentAttributeType keyPersistentAttributeType;

        // Finally, we determine the type of the map key (if needed)
        if (value instanceof Map) {
          final Value keyValue = ((Map) value).getIndex();
          final org.hibernate.type.Type keyType = keyValue.getType();

          if (keyType.isAnyType())
            throw new UnsupportedOperationException("collection of any not supported yet");
          if (keyValue instanceof Component)
            keyPersistentAttributeType = Attribute.PersistentAttributeType.EMBEDDED;
          else if (keyType.isAssociationType())
            keyPersistentAttributeType = Attribute.PersistentAttributeType.MANY_TO_ONE;
          else keyPersistentAttributeType = Attribute.PersistentAttributeType.BASIC;
        } else keyPersistentAttributeType = null;
        return new PluralAttributeMetadataImpl(
            attributeContext.getPropertyMapping(),
            attributeContext.getOwnerType(),
            member,
            persistentAttributeType,
            elementPersistentAttributeType,
            keyPersistentAttributeType);
      } else if (value instanceof OneToMany) {
        // TODO : is this even possible??? Really OneToMany should be describing the
        // element value within a o.h.mapping.Collection (see logic branch above)
        throw new IllegalArgumentException("HUH???");
        //					final boolean isManyToMany = isManyToMany( member );
        //					//one to many with FK => entity
        //					return new PluralAttributeMetadataImpl(
        //							attributeContext.getPropertyMapping(),
        //							attributeContext.getOwnerType(),
        //							member,
        //							isManyToMany
        //									? Attribute.PersistentAttributeType.MANY_TO_MANY
        //									: Attribute.PersistentAttributeType.ONE_TO_MANY
        //							value,
        //							AttributeContext.TypeStatus.ENTITY,
        //							Attribute.PersistentAttributeType.ONE_TO_MANY,
        //							null, null, null
        //					);
      }
    } else if (attributeContext.getPropertyMapping().isComposite()) {
      // component
      return new SingularAttributeMetadataImpl<X, Y>(
          attributeContext.getPropertyMapping(),
          attributeContext.getOwnerType(),
          member,
          Attribute.PersistentAttributeType.EMBEDDED);
    } else {
      // basic type
      return new SingularAttributeMetadataImpl<X, Y>(
          attributeContext.getPropertyMapping(),
          attributeContext.getOwnerType(),
          member,
          Attribute.PersistentAttributeType.BASIC);
    }
    throw new UnsupportedOperationException(
        "oops, we are missing something: " + attributeContext.getPropertyMapping());
  }