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

Example 16 with ForeignKeyDescriptor

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

the class MappingModelCreationHelper method interpretToOneKeyDescriptor.

/**
 * Tries to {@link ToOneAttributeMapping#setForeignKeyDescriptor}
 * to the given attribute {@code attributeMapping}.
 *
 * @param attributeMapping The attribute for which we try to set the foreign key
 * @param bootProperty The property
 * @param bootValueMapping The value mapping
 * @param inversePropertyAccess Access to the inverse property
 * @param dialect Current dialect
 * @param creationProcess Current creation process
 * @return true if the foreign key is actually set
 */
public static boolean interpretToOneKeyDescriptor(ToOneAttributeMapping attributeMapping, Property bootProperty, ToOne bootValueMapping, PropertyAccess inversePropertyAccess, Dialect dialect, MappingModelCreationProcess creationProcess) {
    if (attributeMapping.getForeignKeyDescriptor() != null) {
        // already built/known
        return true;
    }
    final String tableName = getTableIdentifierExpression(bootValueMapping.getTable(), creationProcess);
    attributeMapping.setIdentifyingColumnsTableExpression(tableName);
    final EntityPersister referencedEntityDescriptor = creationProcess.getEntityPersister(bootValueMapping.getReferencedEntityName());
    String referencedPropertyName;
    boolean swapDirection = false;
    if (bootValueMapping instanceof OneToOne) {
        OneToOne oneToOne = (OneToOne) bootValueMapping;
        swapDirection = oneToOne.getForeignKeyType() == ForeignKeyDirection.TO_PARENT;
        referencedPropertyName = oneToOne.getMappedByProperty();
        if (referencedPropertyName == null) {
            referencedPropertyName = oneToOne.getReferencedPropertyName();
        }
    } else {
        referencedPropertyName = null;
    }
    if (referencedPropertyName != null) {
        if (referencedPropertyName.indexOf(".") > 0) {
            return interpretNestedToOneKeyDescriptor(referencedEntityDescriptor, referencedPropertyName, attributeMapping);
        }
        final ModelPart modelPart = referencedEntityDescriptor.findByPath(referencedPropertyName);
        if (modelPart instanceof ToOneAttributeMapping) {
            setReferencedAttributeForeignKeyDescriptor(attributeMapping, (ToOneAttributeMapping) modelPart, referencedEntityDescriptor, referencedPropertyName, dialect, creationProcess);
        } else if (modelPart instanceof EmbeddableValuedModelPart) {
            final EmbeddedForeignKeyDescriptor embeddedForeignKeyDescriptor = buildEmbeddableForeignKeyDescriptor((EmbeddableValuedModelPart) modelPart, bootValueMapping, attributeMapping.getDeclaringType(), attributeMapping.findContainingEntityMapping(), true, dialect, creationProcess);
            attributeMapping.setForeignKeyDescriptor(embeddedForeignKeyDescriptor);
        } else if (modelPart == null) {
            throw new IllegalArgumentException("Unable to find attribute " + bootProperty.getPersistentClass().getEntityName() + " -> " + bootProperty.getName());
        } else {
            throw new NotYetImplementedFor6Exception("Support for foreign-keys based on `" + modelPart + "` not yet implemented: " + bootProperty.getPersistentClass().getEntityName() + " -> " + bootProperty.getName());
        }
        return true;
    }
    final ModelPart fkTarget;
    if (bootValueMapping.isReferenceToPrimaryKey()) {
        fkTarget = referencedEntityDescriptor.getIdentifierMapping();
    } else {
        fkTarget = referencedEntityDescriptor.findByPath(bootValueMapping.getReferencedPropertyName());
    }
    if (fkTarget instanceof BasicValuedModelPart) {
        final BasicValuedModelPart simpleFkTarget = (BasicValuedModelPart) fkTarget;
        final Iterator<Selectable> columnIterator = bootValueMapping.getColumnIterator();
        final Table table = bootValueMapping.getTable();
        final String tableExpression = getTableIdentifierExpression(table, creationProcess);
        final BasicValuedModelPart declaringKeyPart;
        final PropertyAccess declaringKeyPropertyAccess;
        if (inversePropertyAccess == null) {
            // So far, OneToOne mappings are only supported based on the owner's PK
            if (bootValueMapping instanceof OneToOne) {
                declaringKeyPart = simpleFkTarget;
                final EntityIdentifierMapping identifierMapping = attributeMapping.findContainingEntityMapping().getIdentifierMapping();
                declaringKeyPropertyAccess = ((PropertyBasedMapping) identifierMapping).getPropertyAccess();
            } else {
                declaringKeyPart = simpleFkTarget;
                // declaringKeyPropertyAccess = ( (PropertyBasedMapping) declaringKeyPart ).getPropertyAccess();
                declaringKeyPropertyAccess = new ChainedPropertyAccessImpl(attributeMapping.getPropertyAccess(), ((PropertyBasedMapping) declaringKeyPart).getPropertyAccess());
            }
        } else {
            declaringKeyPart = simpleFkTarget;
            declaringKeyPropertyAccess = new ChainedPropertyAccessImpl(inversePropertyAccess, ((PropertyBasedMapping) simpleFkTarget).getPropertyAccess());
        }
        final SelectableMapping keySelectableMapping;
        if (columnIterator.hasNext()) {
            keySelectableMapping = SelectableMappingImpl.from(tableExpression, columnIterator.next(), simpleFkTarget.getJdbcMapping(), dialect, creationProcess.getSqmFunctionRegistry());
        } else {
            // case of ToOne with @PrimaryKeyJoinColumn
            keySelectableMapping = SelectableMappingImpl.from(tableExpression, table.getColumn(0), simpleFkTarget.getJdbcMapping(), dialect, creationProcess.getSqmFunctionRegistry());
        }
        final ForeignKeyDescriptor foreignKeyDescriptor = new SimpleForeignKeyDescriptor(attributeMapping.getDeclaringType(), declaringKeyPart, declaringKeyPropertyAccess, keySelectableMapping, simpleFkTarget, bootValueMapping.isReferenceToPrimaryKey(), bootValueMapping.isConstrained(), swapDirection);
        attributeMapping.setForeignKeyDescriptor(foreignKeyDescriptor);
    } else if (fkTarget instanceof EmbeddableValuedModelPart) {
        final EmbeddedForeignKeyDescriptor embeddedForeignKeyDescriptor = buildEmbeddableForeignKeyDescriptor((EmbeddableValuedModelPart) fkTarget, bootValueMapping, attributeMapping.getDeclaringType(), attributeMapping.findContainingEntityMapping(), swapDirection, dialect, creationProcess);
        attributeMapping.setForeignKeyDescriptor(embeddedForeignKeyDescriptor);
    } else {
        throw new NotYetImplementedFor6Exception("Support for " + fkTarget.getClass() + " foreign-keys not yet implemented: " + bootProperty.getPersistentClass().getEntityName() + " -> " + bootProperty.getName());
    }
    return true;
}

Example 17 with ForeignKeyDescriptor

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

the class DomainResultCreationStateImpl method visitFetches.

@Override
public List<Fetch> visitFetches(FetchParent fetchParent) {
    final FetchableContainer fetchableContainer = fetchParent.getReferencedMappingContainer();
    final List<Fetch> fetches = CollectionHelper.arrayList(fetchableContainer.getNumberOfFetchables());
    final Consumer<Fetchable> fetchableConsumer = fetchable -> {
        final String fetchableName = fetchable.getFetchableName();
        Map.Entry<String, NavigablePath> currentEntry;
        if (relativePathStack.isEmpty()) {
            currentEntry = new AbstractMap.SimpleEntry<>(getRelativePath("", fetchable, fetchableContainer), new NavigablePath(fetchableName));
        } else {
            final Map.Entry<String, NavigablePath> oldEntry = relativePathStack.getCurrent();
            final String key = oldEntry.getKey();
            currentEntry = new AbstractMap.SimpleEntry<>(getRelativePath(key, fetchable, fetchableContainer), oldEntry.getValue().append(fetchableName));
        }
        // todo (6.0): figure out if we can somehow create the navigable paths in a better way
        final String fullPath = currentEntry.getKey();
        FetchBuilder explicitFetchBuilder = fetchBuilderResolverStack.getCurrent().apply(fullPath);
        DynamicFetchBuilderLegacy fetchBuilderLegacy;
        if (explicitFetchBuilder == null) {
            fetchBuilderLegacy = legacyFetchResolver.resolve(fromClauseAccess.findTableGroup(fetchParent.getNavigablePath()).getPrimaryTableReference().getIdentificationVariable(), fetchableName);
        } else {
            fetchBuilderLegacy = null;
        }
        if (fetchable instanceof Association && fetchable.getMappedFetchOptions().getTiming() == FetchTiming.DELAYED) {
            final Association association = (Association) fetchable;
            final ForeignKeyDescriptor foreignKeyDescriptor = association.getForeignKeyDescriptor();
            final String partName = attributeName(foreignKeyDescriptor.getSide(association.getSideNature().inverse()).getModelPart());
            // If there are no fetch builders for this association, we only want to fetch the FK
            if (explicitFetchBuilder == null && fetchBuilderLegacy == null && partName != null) {
                currentEntry = new AbstractMap.SimpleEntry<>(currentEntry.getKey() + "." + partName, currentEntry.getValue().append(partName));
                explicitFetchBuilder = fetchBuilderResolverStack.getCurrent().apply(currentEntry.getKey());
                if (explicitFetchBuilder == null) {
                    fetchBuilderLegacy = legacyFetchResolver.resolve(fromClauseAccess.findTableGroup(fetchParent.getNavigablePath()).getPrimaryTableReference().getIdentificationVariable(), fetchableName);
                }
            }
        }
        relativePathStack.push(currentEntry);
        try {
            final NavigablePath fetchPath = fetchParent.resolveNavigablePath(fetchable);
            final FetchBuilder fetchBuilder;
            if (explicitFetchBuilder != null) {
                fetchBuilder = explicitFetchBuilder;
            } else {
                if (fetchBuilderLegacy == null) {
                    fetchBuilder = Builders.implicitFetchBuilder(fetchPath, fetchable, this);
                } else {
                    fetchBuilder = fetchBuilderLegacy;
                }
            }
            final Fetch fetch = fetchBuilder.buildFetch(fetchParent, fetchPath, jdbcResultsMetadata, (s, s2) -> {
                throw new UnsupportedOperationException();
            }, this);
            fetches.add(fetch);
        } finally {
            relativePathStack.pop();
        }
    };
    boolean previous = this.processingKeyFetches;
    this.processingKeyFetches = true;
    if (fetchableContainer instanceof EntityValuedModelPart) {
        final EntityValuedModelPart entityValuedFetchable = (EntityValuedModelPart) fetchableContainer;
        final EntityIdentifierMapping identifierMapping = entityValuedFetchable.getEntityMappingType().getIdentifierMapping();
        final boolean idClass = identifierMapping instanceof NonAggregatedIdentifierMapping;
        final String identifierAttributeName = attributeName(identifierMapping);
        if (idClass) {
            final Map.Entry<String, NavigablePath> oldEntry = relativePathStack.getCurrent();
            relativePathStack.push(new AbstractMap.SimpleEntry<>(oldEntry == null ? "" : oldEntry.getKey(), new EntityIdentifierNavigablePath(oldEntry == null ? fetchParent.getNavigablePath() : oldEntry.getValue(), identifierAttributeName)));
        } else if (identifierMapping instanceof CompositeIdentifierMapping) {
            final Map.Entry<String, NavigablePath> oldEntry = relativePathStack.getCurrent();
            relativePathStack.push(new AbstractMap.SimpleEntry<>(oldEntry == null ? identifierAttributeName : oldEntry.getKey() + "." + identifierAttributeName, new EntityIdentifierNavigablePath(oldEntry == null ? fetchParent.getNavigablePath() : oldEntry.getValue(), identifierAttributeName)));
        }
        try {
            if (identifierMapping instanceof FetchableContainer) {
                // essentially means the entity has a composite id - ask the embeddable to visit its fetchables
                ((FetchableContainer) identifierMapping).visitFetchables(fetchableConsumer, null);
            } else {
                fetchableConsumer.accept((Fetchable) identifierMapping);
            }
        } finally {
            this.processingKeyFetches = previous;
            if (idClass) {
                this.relativePathStack.pop();
            }
        }
    }
    fetchableContainer.visitKeyFetchables(fetchableConsumer, null);
    fetchableContainer.visitFetchables(fetchableConsumer, null);
    return fetches;
}

Example 18 with ForeignKeyDescriptor

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

the class DynamicFetchBuilderLegacy method buildFetch.

@Override
public Fetch buildFetch(FetchParent parent, NavigablePath fetchPath, JdbcValuesMetadata jdbcResultsMetadata, BiFunction<String, String, DynamicFetchBuilderLegacy> legacyFetchResolver, DomainResultCreationState domainResultCreationState) {
    final DomainResultCreationStateImpl creationState = ResultsHelper.impl(domainResultCreationState);
    final TableGroup ownerTableGroup = creationState.getFromClauseAccess().findByAlias(ownerTableAlias);
    final AttributeMapping attributeMapping = parent.getReferencedMappingContainer().findContainingEntityMapping().findDeclaredAttributeMapping(fetchableName);
    final TableGroup tableGroup;
    if (attributeMapping instanceof TableGroupJoinProducer) {
        final SqlAliasBase sqlAliasBase = new SqlAliasBaseConstant(tableAlias);
        final TableGroupJoin tableGroupJoin = ((TableGroupJoinProducer) attributeMapping).createTableGroupJoin(fetchPath, ownerTableGroup, tableAlias, SqlAstJoinType.INNER, true, false, s -> sqlAliasBase, creationState.getSqlExpressionResolver(), creationState.getFromClauseAccess(), creationState.getCreationContext());
        ownerTableGroup.addTableGroupJoin(tableGroupJoin);
        creationState.getFromClauseAccess().registerTableGroup(fetchPath, tableGroup = tableGroupJoin.getJoinedGroup());
    } else {
        tableGroup = ownerTableGroup;
    }
    if (columnNames != null) {
        final ForeignKeyDescriptor keyDescriptor;
        if (attributeMapping instanceof PluralAttributeMapping) {
            final PluralAttributeMapping pluralAttributeMapping = (PluralAttributeMapping) attributeMapping;
            keyDescriptor = pluralAttributeMapping.getKeyDescriptor();
        } else {
            // Not sure if this fetch builder can also be used with other attribute mappings
            assert attributeMapping instanceof ToOneAttributeMapping;
            final ToOneAttributeMapping toOneAttributeMapping = (ToOneAttributeMapping) attributeMapping;
            keyDescriptor = toOneAttributeMapping.getForeignKeyDescriptor();
        }
        if (!columnNames.isEmpty()) {
            keyDescriptor.forEachSelectable((selectionIndex, selectableMapping) -> {
                resolveSqlSelection(columnNames.get(selectionIndex), createColumnReferenceKey(tableGroup.resolveTableReference(selectableMapping.getContainingTableExpression()), selectableMapping.getSelectionExpression()), selectableMapping.getJdbcMapping(), jdbcResultsMetadata, domainResultCreationState);
            });
        }
        // We process the fetch builder such that it contains a resultBuilderEntity before calling this method in ResultSetMappingProcessor
        if (resultBuilderEntity != null) {
            return resultBuilderEntity.buildFetch(parent, attributeMapping, jdbcResultsMetadata, creationState);
        }
    }
    try {
        final NavigablePath currentRelativePath = creationState.getCurrentRelativePath();
        final String prefix;
        if (currentRelativePath == null) {
            prefix = "";
        } else {
            prefix = currentRelativePath.getFullPath().replace(ELEMENT_PREFIX, "").replace(INDEX_PREFIX, "") + ".";
        }
        creationState.pushExplicitFetchMementoResolver(relativePath -> {
            if (relativePath.startsWith(prefix)) {
                return findFetchBuilder(relativePath.substring(prefix.length()));
            }
            return null;
        });
        return parent.generateFetchableFetch(attributeMapping, parent.resolveNavigablePath(attributeMapping), FetchTiming.IMMEDIATE, true, null, domainResultCreationState);
    } finally {
        creationState.popExplicitFetchMementoResolver();
    }
}

Example 19 with ForeignKeyDescriptor

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

the class BaseSqmToSqlAstConverter method visitLiteral.

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// General expressions
@Override
public Expression visitLiteral(SqmLiteral<?> literal) {
    if (literal instanceof SqmLiteralNull) {
        MappingModelExpressible<?> mappingModelExpressible = resolveInferredType();
        if (mappingModelExpressible == null) {
            mappingModelExpressible = determineCurrentExpressible(literal);
        }
        if (mappingModelExpressible instanceof BasicValuedMapping) {
            return new QueryLiteral<>(null, (BasicValuedMapping) mappingModelExpressible);
        }
        final MappingModelExpressible<?> keyExpressible = getKeyExpressible(mappingModelExpressible);
        if (keyExpressible == null) {
            // Default to the Object type
            return new QueryLiteral<>(null, basicType(Object.class));
        }
        final List<Expression> expressions = new ArrayList<>(keyExpressible.getJdbcTypeCount());
        keyExpressible.forEachJdbcType((index, jdbcMapping) -> expressions.add(new QueryLiteral<>(null, (BasicValuedMapping) jdbcMapping)));
        return new SqlTuple(expressions, mappingModelExpressible);
    }
    final MappingModelExpressible<?> inferableExpressible = resolveInferredType();
    if (inferableExpressible instanceof ConvertibleModelPart) {
        final ConvertibleModelPart convertibleModelPart = (ConvertibleModelPart) inferableExpressible;
        if (convertibleModelPart.getValueConverter() != null) {
            return new QueryLiteral<>(literal.getLiteralValue(), convertibleModelPart);
        }
    } else // Special case for when we create an entity literal through the JPA CriteriaBuilder.literal API
    if (inferableExpressible instanceof EntityDiscriminatorMapping) {
        final EntityDiscriminatorMapping discriminatorMapping = (EntityDiscriminatorMapping) inferableExpressible;
        final Object literalValue = literal.getLiteralValue();
        final EntityPersister mappingDescriptor;
        if (literalValue instanceof Class<?>) {
            mappingDescriptor = creationContext.getSessionFactory().getRuntimeMetamodels().getMappingMetamodel().getEntityDescriptor((Class<?>) literalValue);
        } else {
            final JavaType<?> javaType = discriminatorMapping.getJdbcMapping().getJavaTypeDescriptor();
            final Object discriminatorValue;
            if (javaType.getJavaTypeClass().isInstance(literalValue)) {
                discriminatorValue = literalValue;
            } else if (literalValue instanceof CharSequence) {
                discriminatorValue = javaType.fromString((CharSequence) literalValue);
            } else if (creationContext.getSessionFactory().getJpaMetamodel().getJpaCompliance().isLoadByIdComplianceEnabled()) {
                discriminatorValue = literalValue;
            } else {
                discriminatorValue = javaType.coerce(literalValue, null);
            }
            final String entityName = discriminatorMapping.getConcreteEntityNameForDiscriminatorValue(discriminatorValue);
            mappingDescriptor = creationContext.getSessionFactory().getRuntimeMetamodels().getMappingMetamodel().getEntityDescriptor(entityName);
        }
        return new EntityTypeLiteral(mappingDescriptor);
    }
    final MappingModelExpressible<?> expressible;
    final MappingModelExpressible<?> localExpressible = SqmMappingModelHelper.resolveMappingModelExpressible(literal, creationContext.getSessionFactory().getRuntimeMetamodels().getMappingMetamodel(), getFromClauseAccess()::findTableGroup);
    if (localExpressible == null) {
        expressible = getElementExpressible(inferableExpressible);
    } else {
        final MappingModelExpressible<?> elementExpressible = getElementExpressible(localExpressible);
        if (elementExpressible instanceof BasicType) {
            expressible = InferredBasicValueResolver.resolveSqlTypeIndicators(this, (BasicType) elementExpressible, literal.getJavaTypeDescriptor());
        } else {
            expressible = elementExpressible;
        }
    }
    if (expressible instanceof EntityIdentifierMapping && literal.getNodeType() instanceof EntityTypeImpl) {
        return new QueryLiteral<>(((EntityIdentifierMapping) expressible).getIdentifier(literal.getLiteralValue()), (BasicValuedMapping) expressible);
    }
    if (expressible instanceof BasicValuedMapping) {
        return new QueryLiteral<>(literal.getLiteralValue(), (BasicValuedMapping) expressible);
    }
    // Handling other values might seem unnecessary, but with JPA Criteria it is totally possible to have such literals
    if (expressible instanceof EmbeddableValuedModelPart) {
        final EmbeddableValuedModelPart embeddableValuedModelPart = (EmbeddableValuedModelPart) expressible;
        final List<Expression> list = new ArrayList<>(embeddableValuedModelPart.getJdbcTypeCount());
        embeddableValuedModelPart.forEachJdbcValue(literal.getLiteralValue(), null, (selectionIndex, value, jdbcMapping) -> list.add(new QueryLiteral<>(value, (BasicValuedMapping) jdbcMapping)), null);
        return new SqlTuple(list, expressible);
    } else if (expressible instanceof EntityValuedModelPart) {
        final EntityValuedModelPart entityValuedModelPart = (EntityValuedModelPart) expressible;
        final Object associationKey;
        final ModelPart associationKeyPart;
        if (entityValuedModelPart instanceof Association) {
            final Association association = (Association) entityValuedModelPart;
            final ForeignKeyDescriptor foreignKeyDescriptor = association.getForeignKeyDescriptor();
            associationKey = foreignKeyDescriptor.getAssociationKeyFromSide(literal.getLiteralValue(), association.getSideNature().inverse(), null);
            associationKeyPart = foreignKeyDescriptor.getPart(association.getSideNature());
        } else {
            final EntityIdentifierMapping identifierMapping = entityValuedModelPart.getEntityMappingType().getIdentifierMapping();
            associationKeyPart = identifierMapping;
            associationKey = identifierMapping.getIdentifier(literal.getLiteralValue(), null);
        }
        if (associationKeyPart instanceof BasicValuedMapping) {
            return new QueryLiteral<>(associationKey, (BasicValuedMapping) associationKeyPart);
        } else {
            final List<Expression> list = new ArrayList<>(associationKeyPart.getJdbcTypeCount());
            associationKeyPart.forEachJdbcValue(associationKey, null, (selectionIndex, value, jdbcMapping) -> list.add(new QueryLiteral<>(value, (BasicValuedMapping) jdbcMapping)), null);
            return new SqlTuple(list, associationKeyPart);
        }
    } else {
        return new QueryLiteral<>(literal.getLiteralValue(), creationContext.getSessionFactory().getTypeConfiguration().getBasicTypeRegistry().getRegisteredType(((BasicSqmPathSource<?>) literal.getNodeType()).getSqmPathType().getJavaType().getName()));
    }
}

Example 20 with ForeignKeyDescriptor

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

the class ManyToOneJoinTableTest method basicTest.

@Test
public void basicTest(SessionFactoryScope scope) {
    final EntityPersister otherDescriptor = scope.getSessionFactory().getMappingMetamodel().findEntityDescriptor(OtherEntity.class);
    final ModelPart simpleEntityAssociation = otherDescriptor.findSubPart("simpleEntity");
    assertThat(simpleEntityAssociation, instanceOf(ToOneAttributeMapping.class));
    final ToOneAttributeMapping simpleAttributeMapping = (ToOneAttributeMapping) simpleEntityAssociation;
    ForeignKeyDescriptor foreignKeyDescriptor = simpleAttributeMapping.getForeignKeyDescriptor();
    foreignKeyDescriptor.visitKeySelectables((columnIndex, selection) -> {
        assertThat(selection.getContainingTableExpression(), is("other_simple"));
        assertThat(selection.getSelectionExpression(), is("RHS_ID"));
    });
    foreignKeyDescriptor.visitTargetSelectables((columnIndex, selection) -> {
        assertThat(selection.getContainingTableExpression(), is("simple_entity"));
        assertThat(selection.getSelectionExpression(), is("id"));
    });
    final ModelPart anotherEntityAssociation = otherDescriptor.findSubPart("anotherEntity");
    assertThat(anotherEntityAssociation, instanceOf(ToOneAttributeMapping.class));
    final ToOneAttributeMapping anotherAttributeMapping = (ToOneAttributeMapping) anotherEntityAssociation;
    foreignKeyDescriptor = anotherAttributeMapping.getForeignKeyDescriptor();
    foreignKeyDescriptor.visitKeySelectables((columnIndex, selection) -> {
        assertThat(selection.getContainingTableExpression(), is("other_another"));
        assertThat(selection.getSelectionExpression(), is("RHS_ID"));
    });
    foreignKeyDescriptor.visitTargetSelectables((columnIndex, selection) -> {
        assertThat(selection.getContainingTableExpression(), is("another_entity"));
        assertThat(selection.getSelectionExpression(), is("id"));
    });
    final EntityPersister simpleDescriptor = scope.getSessionFactory().getMappingMetamodel().findEntityDescriptor(SimpleEntity.class);
    ModelPart otherEntityEntityAssociation = simpleDescriptor.findSubPart("other");
    assertThat(otherEntityEntityAssociation, instanceOf(ToOneAttributeMapping.class));
    ToOneAttributeMapping otherAttributeMapping = (ToOneAttributeMapping) otherEntityEntityAssociation;
    foreignKeyDescriptor = otherAttributeMapping.getForeignKeyDescriptor();
    foreignKeyDescriptor.visitKeySelectables((columnIndex, selection) -> {
        assertThat(selection.getContainingTableExpression(), is("other_simple"));
        assertThat(selection.getSelectionExpression(), is("LHS_ID"));
    });
    foreignKeyDescriptor.visitTargetSelectables((columnIndex, selection) -> {
        assertThat(selection.getContainingTableExpression(), is("other_entity"));
        assertThat(selection.getSelectionExpression(), is("id"));
    });
    final EntityPersister anotherDescriptor = scope.getSessionFactory().getMappingMetamodel().findEntityDescriptor(AnotherEntity.class);
    otherEntityEntityAssociation = anotherDescriptor.findSubPart("other");
    assertThat(otherEntityEntityAssociation, instanceOf(ToOneAttributeMapping.class));
    otherAttributeMapping = (ToOneAttributeMapping) otherEntityEntityAssociation;
    foreignKeyDescriptor = otherAttributeMapping.getForeignKeyDescriptor();
    foreignKeyDescriptor.visitKeySelectables((columnIndex, selection) -> {
        assertThat(selection.getContainingTableExpression(), is("another_entity"));
        assertThat(selection.getSelectionExpression(), is("other_id"));
    });
    foreignKeyDescriptor.visitTargetSelectables((columnIndex, selection) -> {
        assertThat(selection.getContainingTableExpression(), is("other_entity"));
        assertThat(selection.getSelectionExpression(), is("id"));
    });
}