@Override public ParameterValueTransformer getToEntityTranformer(Class<?> entityType) { IdentifiableType<?> managedType = (IdentifiableType<?>) metamodel.getManagedType(entityType); Attribute<?, ?> idAttribute = JpaMetamodelUtils.getSingleIdAttribute(managedType); return AssociationFromIdParameterTransformer.getInstance(entityType, idAttribute); }
private Class<?> getCorrelationBasisEntityType(Class<?> entityClazz) { EntityMetamodel entityMetamodel = evm.getMetamodel().getEntityMetamodel(); ManagedType<?> managedType = entityMetamodel.getManagedType(entityClazz); // Return the class if it is identifiable, otherwise return null. When null, it will use fromIdentifiableValues in correlation builders to correlate values if (JpaMetamodelUtils.isIdentifiable(managedType)) { return entityClazz; } return null; }
protected Set<Type<?>> determinePersistSubtypeSet(Type<?> superType, Set<ManagedViewTypeImplementor<?>> subtypes1, Set<ManagedViewTypeImplementor<?>> subtypes2, MetamodelBuildingContext context) { Class<?> superTypeClass = superType.getJavaType(); Set<Type<?>> set = new HashSet<>(subtypes1.size() + subtypes2.size()); if (superType.getMappingType() == Type.MappingType.BASIC && context.getEntityMetamodel().getManagedType(superType.getJavaType()) != null || superType.getMappingType() != Type.MappingType.BASIC && ((ManagedViewType<?>) superType).isCreatable()) { set.add(superType); } addToPersistSubtypeSet(set, superTypeClass, subtypes1, context, false); addToPersistSubtypeSet(set, superTypeClass, subtypes2, context, true); return Collections.unmodifiableSet(set); }
private String getIdAttribute(Class<?> entityClass) { return cbf.getService(EntityMetamodel.class) .getManagedType(ExtendedManagedType.class, entityClass) .getIdAttribute() .getName(); }
public static Map<String, ExtendedAttribute<?, ?>> getCollectionAttributeEntries(EntityMetamodel metamodel, EntityType<?> entityType, ExtendedAttribute<?, ?> attribute) { Map<String, ExtendedAttribute<?, ?>> collectionAttributeEntries = new HashMap<>(); JoinTable joinTable = attribute.getJoinTable(); if (joinTable == null) { throw new IllegalArgumentException("No support for inserting into inverse collection via DML API yet!"); } ExtendedManagedType<?> extendedManagedType = metamodel.getManagedType(ExtendedManagedType.class, entityType); for (String idAttributeName : joinTable.getIdAttributeNames()) { collectionAttributeEntries.put(idAttributeName, extendedManagedType.getAttribute(idAttributeName)); } if (((PluralAttribute<?, ?, ?>) attribute.getAttribute()).getElementType() instanceof ManagedType<?>) { String prefix = attribute.getAttributePathString() + "."; for (Map.Entry<String, ? extends ExtendedAttribute<?, ?>> entry : extendedManagedType.getAttributes().entrySet()) { if (entry.getKey().startsWith(prefix)) { collectionAttributeEntries.put(entry.getKey(), entry.getValue()); } } } collectionAttributeEntries.put(attribute.getAttributePathString(), attribute); return collectionAttributeEntries; }
private String getIdAttribute(Class<?> entityClass) { return cbf.getService(EntityMetamodel.class) .getManagedType(ExtendedManagedType.class, entityClass) .getIdAttribute() .getName(); }
ManagedType<?> t = metamodel.getManagedType(parameterType); fields[i] = new Field[accessPath.size()]; getters[i] = new Method[accessPath.size()]; throw new IllegalArgumentException("Unsupported attribute member type [" + member + "] for attribute [" + attribute.getName() + "] of class [" + t.getJavaType().getName() + "]"); t = metamodel.getManagedType(JpaMetamodelUtils.resolveFieldClass(t.getJavaType(), attribute));
private String getMapping(String prefixParts, String mapping, Class<?> expressionType) { if (expressionType == null) { return getMapping(prefixParts, mapping); } ManagedType<?> managedType = metamodel.getManagedType(expressionType); Set<SingularAttribute<?, ?>> idAttributes; if (managedType == null || !JpaMetamodelUtils.isIdentifiable(managedType) || (idAttributes = JpaMetamodelUtils.getIdAttributes((IdentifiableType<?>) managedType)).size() > 1) { return getMapping(prefixParts, mapping); } javax.persistence.metamodel.SingularAttribute<?, ?> idAttr = idAttributes.iterator().next(); if (mapping.isEmpty()) { return getMapping(prefixParts, idAttr.getName()); } else { return getMapping(prefixParts, mapping + '.' + idAttr.getName()); } }
public UnmappedBasicAttributeCascadeDeleter(EntityViewManagerImpl evm, String attributeName, ExtendedAttribute<?, ?> attribute, String ownerIdAttributeName, boolean disallowCycle) { super(evm, attributeName, attribute); EntityMetamodel entityMetamodel = evm.getMetamodel().getEntityMetamodel(); ExtendedManagedType extendedManagedType = entityMetamodel.getManagedType(ExtendedManagedType.class, elementEntityClass); EntityType<?> entityType = (EntityType<?>) extendedManagedType.getType(); this.requiresDeleteCascadeAfterRemove = !attribute.isForeignJoinColumn();
t = metamodel.getManagedType(JpaMetamodelUtils.resolveFieldClass(t.getJavaType(), jpaAttribute)); if (jpaAttribute instanceof PluralAttribute<?, ?, ?>) { paths.add(sb.toString());
return false; ExtendedManagedType<?> managedType = evm.getMetamodel().getEntityMetamodel().getManagedType(ExtendedManagedType.class, managedTypeClass); ExtendedManagedType<?> correlationBasisManagedType = evm.getMetamodel().getEntityMetamodel().getManagedType(ExtendedManagedType.class, correlationBasisEntity);
public static List<UnmappedAttributeCascadeDeleter> createUnmappedCascadeDeleters(EntityViewManagerImpl evm, Class<?> entityClass, String ownerIdAttributeName) { EntityMetamodel entityMetamodel = evm.getMetamodel().getEntityMetamodel(); ExtendedManagedType<?> extendedManagedType = entityMetamodel.getManagedType(ExtendedManagedType.class, entityClass); Map<String, ? extends ExtendedAttribute<?, ?>> attributes = extendedManagedType.getOwnedAttributes(); List<UnmappedAttributeCascadeDeleter> deleters = new ArrayList<>(attributes.size());
ExtendedAttribute<?, ?> extendedAttribute = (ExtendedAttribute<?, ?>) metamodel.getManagedType(ExtendedManagedType.class, ownerType).getAttributes().get(fieldPrefix + attributeName); if (extendedAttribute != null && StringUtils.isEmpty(extendedAttribute.getMappedBy())) { ExtendedManagedType<?> managedType = metamodel.getManagedType(ExtendedManagedType.class, (ManagedType<?>) singularAttribute.getType()); for (String attrName : attributeNames) { addAttributes(ownerType, elementCollectionPath, fieldPrefix, newPrefix, (SingularAttribute<?, ?>) managedType.getAttributes().get(attrName).getAttribute(), orderedAttributes);
public AbstractUnmappedAttributeCascadeDeleter(EntityViewManagerImpl evm, String attributeName, ExtendedAttribute<?, ?> attribute) { EntityMetamodel entityMetamodel = evm.getMetamodel().getEntityMetamodel(); this.elementEntityClass = attribute.getElementClass(); this.attributeName = attributeName; if (entityMetamodel.getEntity(elementEntityClass) == null) { this.elementIdAttributeName = null; this.attributeValuePath = attributeName; this.cascadeDeleteElement = false; } else { ExtendedManagedType extendedManagedType = entityMetamodel.getManagedType(ExtendedManagedType.class, elementEntityClass); this.elementIdAttributeName = extendedManagedType.getIdAttribute().getName(); this.attributeValuePath = attributeName + "." + elementIdAttributeName; this.cascadeDeleteElement = attribute.isDeleteCascaded(); } }
ExtendedManagedType<?> extendedManagedType = m.getManagedType(ExtendedManagedType.class, entityType); Set<String> attributePaths; if (rootNode.getValuesIdNames() != null && !rootNode.getValuesIdNames().isEmpty()) {
public AbstractMethodListAttribute(ManagedViewTypeImplementor<X> viewType, MethodAttributeMapping mapping, MetamodelBuildingContext context, int attributeIndex, int dirtyStateIndex, EmbeddableOwner embeddableMapping) { super(viewType, mapping, context, attributeIndex, dirtyStateIndex, embeddableMapping); this.isIndexed = mapping.determineIndexed(context, context.getEntityMetamodel().getManagedType(viewType.getEntityClass())); this.collectionInstantiator = createCollectionInstantiator(context, createCollectionFactory(context), isIndexed(), isSorted(), isOrdered(), getComparator()); }
public AbstractParameterListAttribute(MappingConstructorImpl<X> mappingConstructor, ParameterAttributeMapping mapping, MetamodelBuildingContext context, EmbeddableOwner embeddableMapping) { super(mappingConstructor, mapping, context, embeddableMapping); this.isIndexed = mapping.determineIndexed(context, context.getEntityMetamodel().getManagedType(mappingConstructor.getDeclaringType().getEntityClass())); this.collectionInstantiator = createCollectionInstantiator(context, null, isIndexed(), isSorted(), isOrdered(), getComparator()); }
ExtendedManagedType extendedManagedType = metamodel.getManagedType(ExtendedManagedType.class, JpaMetamodelUtils.getTypeName(managedType)); Attribute<?, ?> attr = extendedManagedType.getAttribute(expr.getField()).getAttribute();
protected boolean determineForcedUnique(MetamodelBuildingContext context) { if (isCollection() && getMapping() != null && getMapping().indexOf('.') == -1) { ExtendedManagedType<?> managedType = context.getEntityMetamodel().getManagedType(ExtendedManagedType.class, getDeclaringType().getJpaManagedType()); ExtendedAttribute<?, ?> attribute = managedType.getOwnedAttributes().get(getMapping()); if (attribute != null && attribute.getAttribute() instanceof javax.persistence.metamodel.PluralAttribute<?, ?, ?>) { // TODO: we should add that information to ExtendedAttribute return (((javax.persistence.metamodel.PluralAttribute<?, ?, ?>) attribute.getAttribute()).getCollectionType() != javax.persistence.metamodel.PluralAttribute.CollectionType.MAP) && (!StringUtils.isEmpty(attribute.getMappedBy()) || !attribute.isBag()) && (attribute.getJoinTable() == null || attribute.getJoinTable().getKeyColumnMappings() == null) && !MetamodelUtils.isIndexedList(context.getEntityMetamodel(), context.getExpressionFactory(), managedType.getType().getJavaType(), getMapping()); } } return false; }
ExtendedManagedType<?> managedType = metamodel.getManagedType(ExtendedManagedType.class, baseNode.getJavaType()); attr = managedType.getAttribute(pathReference.getField()).getAttribute();