Examples with EmbeddableMappingType org.hibernate.metamodel.mapping.EmbeddableMappingType used on opensource projects

Example 1 with EmbeddableMappingType

use of org.hibernate.metamodel.mapping.EmbeddableMappingType in project hibernate-orm by hibernate.

the class EmbeddedIdentifierMappingImpl method disassemble.

@Override
public Object disassemble(Object value, SharedSessionContractImplementor session) {
    final EmbeddableMappingType embeddableTypeDescriptor = getEmbeddableTypeDescriptor();
    final Object[] result = new Object[embeddableTypeDescriptor.getNumberOfAttributeMappings()];
    embeddableTypeDescriptor.forEachAttributeMapping((i, mapping) -> {
        Object o = mapping.getPropertyAccess().getGetter().get(value);
        result[i] = mapping.disassemble(o, session);
    });
    return result;
}

Example 2 with EmbeddableMappingType

use of org.hibernate.metamodel.mapping.EmbeddableMappingType in project hibernate-orm by hibernate.

the class MappingModelCreationHelper method buildBasicAttributeMapping.

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Non-identifier attributes
@SuppressWarnings("rawtypes")
public static BasicAttributeMapping buildBasicAttributeMapping(String attrName, NavigableRole navigableRole, int stateArrayPosition, Property bootProperty, ManagedMappingType declaringType, BasicType attrType, String tableExpression, String attrColumnName, boolean isAttrFormula, String readExpr, String writeExpr, String columnDefinition, Long length, Integer precision, Integer scale, PropertyAccess propertyAccess, CascadeStyle cascadeStyle, MappingModelCreationProcess creationProcess) {
    final Value value = bootProperty.getValue();
    final BasicValue.Resolution<?> resolution = ((Resolvable) value).resolve();
    final BasicValueConverter<?, ?> valueConverter = resolution.getValueConverter();
    final StateArrayContributorMetadataAccess attributeMetadataAccess = entityMappingType -> new StateArrayContributorMetadata() {

        private final MutabilityPlan mutabilityPlan = resolution.getMutabilityPlan();

        private final boolean nullable = value.isNullable();

        private final boolean insertable = bootProperty.isInsertable();

        private final boolean updateable = bootProperty.isUpdateable();

        private final boolean includeInOptimisticLocking = bootProperty.isOptimisticLocked();

        @Override
        public PropertyAccess getPropertyAccess() {
            return propertyAccess;
        }

        @Override
        public MutabilityPlan getMutabilityPlan() {
            return mutabilityPlan;
        }

        @Override
        public boolean isNullable() {
            return nullable;
        }

        @Override
        public boolean isInsertable() {
            return insertable;
        }

        @Override
        public boolean isUpdatable() {
            return updateable;
        }

        @Override
        public boolean isIncludedInDirtyChecking() {
            // todo (6.0) : do not believe this is correct
            return updateable;
        }

        @Override
        public boolean isIncludedInOptimisticLocking() {
            return includeInOptimisticLocking;
        }

        @Override
        public CascadeStyle getCascadeStyle() {
            return cascadeStyle;
        }
    };
    final FetchTiming fetchTiming;
    final FetchStyle fetchStyle;
    if (declaringType instanceof EmbeddableMappingType) {
        if (bootProperty.isLazy()) {
            LOGGER.debugf("Attribute was declared lazy, but is part of an embeddable - `%s#%s` - LAZY will be ignored", declaringType.getNavigableRole().getFullPath(), bootProperty.getName());
        }
        fetchTiming = FetchTiming.IMMEDIATE;
        fetchStyle = FetchStyle.JOIN;
    } else {
        fetchTiming = bootProperty.isLazy() ? FetchTiming.DELAYED : FetchTiming.IMMEDIATE;
        fetchStyle = bootProperty.isLazy() ? FetchStyle.SELECT : FetchStyle.JOIN;
    }
    final ValueGeneration valueGeneration = bootProperty.getValueGenerationStrategy();
    if (valueConverter != null) {
        // we want to "decompose" the "type" into its various pieces as expected by the mapping
        assert valueConverter.getRelationalJavaType() == resolution.getRelationalJavaType();
        final BasicType<?> mappingBasicType = creationProcess.getCreationContext().getDomainModel().getTypeConfiguration().getBasicTypeRegistry().resolve(valueConverter.getRelationalJavaType(), resolution.getJdbcType());
        return new BasicAttributeMapping(attrName, navigableRole, stateArrayPosition, attributeMetadataAccess, fetchTiming, fetchStyle, tableExpression, attrColumnName, isAttrFormula, null, null, columnDefinition, length, precision, scale, valueConverter, mappingBasicType.getJdbcMapping(), declaringType, propertyAccess, valueGeneration);
    } else {
        return new BasicAttributeMapping(attrName, navigableRole, stateArrayPosition, attributeMetadataAccess, fetchTiming, fetchStyle, tableExpression, attrColumnName, isAttrFormula, readExpr, writeExpr, columnDefinition, length, precision, scale, null, attrType, declaringType, propertyAccess, valueGeneration);
    }
}

Example 3 with EmbeddableMappingType

use of org.hibernate.metamodel.mapping.EmbeddableMappingType in project hibernate-orm by hibernate.

the class EmbeddableInstantiatorDynamicMap method instantiate.

@Override
public Object instantiate(ValueAccess valuesAccess, SessionFactoryImplementor sessionFactory) {
    final Map<?, ?> dataMap = generateDataMap();
    Object[] values = valuesAccess == null ? null : valuesAccess.getValues();
    if (values != null) {
        final EmbeddableMappingType mappingType = runtimeDescriptorAccess.get();
        mappingType.setValues(dataMap, values);
    }
    return dataMap;
}

Example 4 with EmbeddableMappingType

use of org.hibernate.metamodel.mapping.EmbeddableMappingType in project hibernate-orm by hibernate.

the class AttributeOrderingTests method verifyRuntimeEntityMapping.

public void verifyRuntimeEntityMapping(EntityMappingType entityMappingType) {
    final NaturalIdMapping naturalIdMapping = entityMappingType.getNaturalIdMapping();
    assertThat(naturalIdMapping, notNullValue());
    assertThat(naturalIdMapping.getNaturalIdAttributes().size(), is(2));
    assertThat(naturalIdMapping.getNaturalIdAttributes().get(0).getAttributeName(), is("assignment"));
    assertThat(naturalIdMapping.getNaturalIdAttributes().get(1).getAttributeName(), is("userCode"));
    final ArrayList<AttributeMapping> attributeMappings = new ArrayList<>(entityMappingType.getAttributeMappings());
    assertThat(attributeMappings.size(), is(5));
    assertThat(attributeMappings.get(0).getAttributeName(), is("assignment"));
    assertThat(entityMappingType.getEntityPersister().getPropertyNames()[0], is("assignment"));
    assertThat(attributeMappings.get(1).getAttributeName(), is("name"));
    assertThat(entityMappingType.getEntityPersister().getPropertyNames()[1], is("name"));
    final EmbeddedAttributeMapping theComponentAttrMapping = (EmbeddedAttributeMapping) attributeMappings.get(2);
    assertThat(theComponentAttrMapping.getAttributeName(), is("theComponent"));
    assertThat(entityMappingType.getEntityPersister().getPropertyNames()[2], is("theComponent"));
    final EmbeddableMappingType embeddable = theComponentAttrMapping.getMappedType();
    final ArrayList<AttributeMapping> embeddableAttributeMappings = new ArrayList<>(embeddable.getAttributeMappings());
    assertThat(embeddableAttributeMappings.get(0).getAttributeName(), is("nestedAnything"));
    assertThat(embeddableAttributeMappings.get(1).getAttributeName(), is("nestedName"));
    assertThat(attributeMappings.get(3).getAttributeName(), is("theComponents"));
    assertThat(entityMappingType.getEntityPersister().getPropertyNames()[3], is("theComponents"));
    assertThat(attributeMappings.get(4).getAttributeName(), is("userCode"));
    assertThat(entityMappingType.getEntityPersister().getPropertyNames()[4], is("userCode"));
}

Example 5 with EmbeddableMappingType

use of org.hibernate.metamodel.mapping.EmbeddableMappingType in project hibernate-orm by hibernate.

the class DomainPathContinuation method resolvePathPart.

@Override
public SequencePart resolvePathPart(String name, String identifier, boolean isTerminal, TranslationContext translationContext) {
    if (referencedModelPart instanceof EmbeddableValuedModelPart) {
        final EmbeddableMappingType embeddableMappingType = (EmbeddableMappingType) referencedModelPart.getPartMappingType();
        final ModelPart subPart = embeddableMappingType.findSubPart(name, null);
        if (subPart == null) {
            throw new PathResolutionException("Could not resolve path token : " + referencedModelPart + " -> " + name);
        }
        return new DomainPathContinuation(navigablePath.append(name), this, subPart);
    }
    throw new PathResolutionException("Domain path of type `" + referencedModelPart.getPartMappingType() + "` -> `" + name + "`");
}