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

Example 16 with PluralAttributeMapping

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

the class TemporaryTable method createIdTable.

public static TemporaryTable createIdTable(EntityMappingType entityDescriptor, Function<String, String> temporaryTableNameAdjuster, Dialect dialect, RuntimeModelCreationContext runtimeModelCreationContext) {
    return new TemporaryTable(entityDescriptor, temporaryTableNameAdjuster, dialect, temporaryTable -> {
        final List<TemporaryTableColumn> columns = new ArrayList<>();
        final PersistentClass entityBinding = runtimeModelCreationContext.getBootModel().getEntityBinding(entityDescriptor.getEntityName());
        final Iterator<JdbcMapping> jdbcMappings = entityDescriptor.getIdentifierMapping().getJdbcMappings().iterator();
        for (Column column : entityBinding.getKey().getColumns()) {
            final JdbcMapping jdbcMapping = jdbcMappings.next();
            columns.add(new TemporaryTableColumn(temporaryTable, column.getText(dialect), jdbcMapping, column.getSqlType(dialect, runtimeModelCreationContext.getMetadata()), column.isNullable(), true));
        }
        entityDescriptor.visitSubTypeAttributeMappings(attribute -> {
            if (attribute instanceof PluralAttributeMapping) {
                final PluralAttributeMapping pluralAttribute = (PluralAttributeMapping) attribute;
                if (pluralAttribute.getSeparateCollectionTable() != null) {
                    // Ensure that the FK target columns are available
                    ForeignKeyDescriptor keyDescriptor = pluralAttribute.getKeyDescriptor();
                    if (keyDescriptor == null) {
                        // and the callback is re-queued.
                        throw new IllegalStateException("Not yet ready: " + pluralAttribute);
                    }
                    final ModelPart fkTarget = keyDescriptor.getTargetPart();
                    if (!(fkTarget instanceof EntityIdentifierMapping)) {
                        final Value value = entityBinding.getSubclassProperty(pluralAttribute.getAttributeName()).getValue();
                        final Iterator<Selectable> columnIterator = ((Collection) value).getKey().getColumnIterator();
                        fkTarget.forEachSelectable((columnIndex, selection) -> {
                            final Selectable selectable = columnIterator.next();
                            if (selectable instanceof Column) {
                                final Column column = (Column) selectable;
                                columns.add(new TemporaryTableColumn(temporaryTable, selectable.getText(dialect), selection.getJdbcMapping(), column.getSqlType(dialect, runtimeModelCreationContext.getMetadata()), column.isNullable()));
                            }
                        });
                    }
                }
            }
        });
        return columns;
    });
}

Example 17 with PluralAttributeMapping

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

the class BaseSqmToSqlAstConverter method visitTableGroup.

private Expression visitTableGroup(TableGroup tableGroup, SqmFrom<?, ?> path) {
    final ModelPartContainer modelPart;
    final MappingModelExpressible<?> inferredValueMapping = getInferredValueMapping();
    // For plain SqmFrom node uses, prefer the mapping type from the context if possible
    if (!(inferredValueMapping instanceof ModelPartContainer)) {
        modelPart = tableGroup.getModelPart();
    } else {
        modelPart = (ModelPartContainer) inferredValueMapping;
    }
    final ModelPart resultModelPart;
    final ModelPart interpretationModelPart;
    final TableGroup parentGroupToUse;
    if (modelPart instanceof ToOneAttributeMapping) {
        final ToOneAttributeMapping toOneAttributeMapping = (ToOneAttributeMapping) modelPart;
        final ModelPart targetPart = toOneAttributeMapping.getForeignKeyDescriptor().getPart(toOneAttributeMapping.getSideNature().inverse());
        if (tableGroup.getModelPart().getPartMappingType() == modelPart.getPartMappingType()) {
            resultModelPart = targetPart;
        } else {
            // If the table group is for a different mapping type i.e. an inheritance subtype,
            // lookup the target part on that mapping type
            resultModelPart = tableGroup.getModelPart().findSubPart(targetPart.getPartName(), null);
        }
        interpretationModelPart = modelPart;
        parentGroupToUse = null;
    } else if (modelPart instanceof PluralAttributeMapping) {
        final PluralAttributeMapping pluralAttributeMapping = (PluralAttributeMapping) modelPart;
        final CollectionPart elementDescriptor = pluralAttributeMapping.getElementDescriptor();
        if (elementDescriptor instanceof EntityCollectionPart) {
            // Usually, we need to resolve to the PK for visitTableGroup
            final EntityCollectionPart collectionPart = (EntityCollectionPart) elementDescriptor;
            final ModelPart collectionTargetPart = collectionPart.getForeignKeyDescriptor().getPart(collectionPart.getSideNature().inverse());
            final EntityIdentifierMapping identifierMapping = collectionPart.getEntityMappingType().getIdentifierMapping();
            // If the FK points to the PK, we can use the FK part though, if this is not a root
            if (collectionTargetPart == identifierMapping && !(path instanceof SqmRoot<?>)) {
                resultModelPart = collectionPart.getForeignKeyDescriptor().getPart(collectionPart.getSideNature());
            } else {
                resultModelPart = identifierMapping;
            }
        } else {
            resultModelPart = elementDescriptor;
        }
        interpretationModelPart = elementDescriptor;
        parentGroupToUse = null;
    } else if (modelPart instanceof EntityCollectionPart) {
        // Usually, we need to resolve to the PK for visitTableGroup
        final EntityCollectionPart collectionPart = (EntityCollectionPart) modelPart;
        final ModelPart collectionTargetPart = collectionPart.getForeignKeyDescriptor().getPart(collectionPart.getSideNature().inverse());
        final EntityIdentifierMapping identifierMapping = collectionPart.getEntityMappingType().getIdentifierMapping();
        // If the FK points to the PK, we can use the FK part though, if this is not a root
        if (collectionTargetPart == identifierMapping && !(path instanceof SqmRoot<?>)) {
            resultModelPart = collectionPart.getForeignKeyDescriptor().getPart(collectionPart.getSideNature());
        } else {
            resultModelPart = identifierMapping;
        }
        interpretationModelPart = modelPart;
        parentGroupToUse = findTableGroup(tableGroup.getNavigablePath().getParent());
    } else if (modelPart instanceof EntityMappingType) {
        resultModelPart = ((EntityMappingType) modelPart).getIdentifierMapping();
        interpretationModelPart = modelPart;
        // todo: I think this will always be null anyways because EntityMappingType will only be the model part
        // of a TableGroup if that is a root TableGroup, so check if we can just switch to null
        parentGroupToUse = findTableGroup(tableGroup.getNavigablePath().getParent());
    } else {
        resultModelPart = modelPart;
        interpretationModelPart = modelPart;
        parentGroupToUse = null;
    }
    final NavigablePath navigablePath;
    if (interpretationModelPart == modelPart) {
        navigablePath = tableGroup.getNavigablePath();
    } else {
        navigablePath = tableGroup.getNavigablePath().append(interpretationModelPart.getPartName());
    }
    final Expression result;
    if (interpretationModelPart instanceof EntityValuedModelPart) {
        final boolean expandToAllColumns;
        if (currentClauseStack.getCurrent() == Clause.GROUP) {
            // When the table group is known to be fetched i.e. a fetch join
            // but also when the from clause is part of the select clause
            // we need to expand to all columns, as we also expand this to all columns in the select clause
            expandToAllColumns = tableGroup.isFetched() || selectClauseContains(path);
        } else {
            expandToAllColumns = false;
        }
        final EntityValuedModelPart mapping = (EntityValuedModelPart) interpretationModelPart;
        EntityMappingType mappingType;
        if (path instanceof SqmTreatedPath) {
            mappingType = creationContext.getSessionFactory().getRuntimeMetamodels().getMappingMetamodel().findEntityDescriptor(((SqmTreatedPath<?, ?>) path).getTreatTarget().getHibernateEntityName());
        } else {
            mappingType = mapping.getEntityMappingType();
        }
        result = EntityValuedPathInterpretation.from(navigablePath, parentGroupToUse == null ? tableGroup : parentGroupToUse, expandToAllColumns ? null : resultModelPart, (EntityValuedModelPart) interpretationModelPart, mappingType, this);
    } else if (interpretationModelPart instanceof EmbeddableValuedModelPart) {
        final EmbeddableValuedModelPart mapping = (EmbeddableValuedModelPart) resultModelPart;
        result = new EmbeddableValuedPathInterpretation<>(mapping.toSqlExpression(tableGroup, currentClauseStack.getCurrent(), this, getSqlAstCreationState()), navigablePath, (EmbeddableValuedModelPart) interpretationModelPart, tableGroup);
    } else {
        assert interpretationModelPart instanceof BasicValuedModelPart;
        final BasicValuedModelPart mapping = (BasicValuedModelPart) resultModelPart;
        final TableReference tableReference = tableGroup.resolveTableReference(navigablePath.append(resultModelPart.getPartName()), mapping.getContainingTableExpression());
        final Expression expression = getSqlExpressionResolver().resolveSqlExpression(SqlExpressionResolver.createColumnReferenceKey(tableReference, mapping.getSelectionExpression()), sacs -> new ColumnReference(tableReference.getIdentificationVariable(), mapping, getCreationContext().getSessionFactory()));
        final ColumnReference columnReference;
        if (expression instanceof ColumnReference) {
            columnReference = (ColumnReference) expression;
        } else if (expression instanceof SqlSelectionExpression) {
            final Expression selectedExpression = ((SqlSelectionExpression) expression).getSelection().getExpression();
            assert selectedExpression instanceof ColumnReference;
            columnReference = (ColumnReference) selectedExpression;
        } else {
            throw new UnsupportedOperationException("Unsupported basic-valued path expression : " + expression);
        }
        result = new BasicValuedPathInterpretation<>(columnReference, navigablePath, (BasicValuedModelPart) interpretationModelPart, tableGroup);
    }
    return withTreatRestriction(result, path);
}

Example 18 with PluralAttributeMapping

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

the class BaseSqmToSqlAstConverter method createLateralJoinExpression.

protected Expression createLateralJoinExpression(AbstractSqmSpecificPluralPartPath<?> pluralPartPath, boolean index, String functionName) {
    prepareReusablePath(pluralPartPath.getLhs(), () -> null);
    final PluralAttributeMapping pluralAttributeMapping = (PluralAttributeMapping) determineValueMapping(pluralPartPath.getPluralDomainPath());
    final FromClauseAccess parentFromClauseAccess = getFromClauseAccess();
    final TableGroup parentTableGroup = parentFromClauseAccess.findTableGroup(pluralPartPath.getNavigablePath().getParent());
    final CollectionPart collectionPart = index ? pluralAttributeMapping.getIndexDescriptor() : pluralAttributeMapping.getElementDescriptor();
    final ModelPart modelPart;
    if (collectionPart instanceof EntityAssociationMapping) {
        modelPart = ((EntityAssociationMapping) collectionPart).getKeyTargetMatchPart();
    } else {
        modelPart = collectionPart;
    }
    final int jdbcTypeCount = modelPart.getJdbcTypeCount();
    final String pathName = functionName + (index ? "_index" : "_element");
    final String identifierVariable = parentTableGroup.getPrimaryTableReference().getIdentificationVariable() + "_" + pathName;
    final NavigablePath queryPath = new NavigablePath(parentTableGroup.getNavigablePath(), pathName, identifierVariable);
    TableGroup lateralTableGroup = parentFromClauseAccess.findTableGroup(queryPath);
    if (lateralTableGroup == null) {
        final QuerySpec subQuerySpec = new QuerySpec(false);
        pushProcessingState(new SqlAstQueryPartProcessingStateImpl(subQuerySpec, getCurrentProcessingState(), this, currentClauseStack::getCurrent, false));
        try {
            final TableGroup tableGroup = pluralAttributeMapping.createRootTableGroup(true, pluralPartPath.getNavigablePath(), null, () -> subQuerySpec::applyPredicate, this, creationContext);
            pluralAttributeMapping.applyBaseRestrictions(subQuerySpec::applyPredicate, tableGroup, true, getLoadQueryInfluencers().getEnabledFilters(), null, this);
            getFromClauseAccess().registerTableGroup(pluralPartPath.getNavigablePath(), tableGroup);
            registerPluralTableGroupParts(tableGroup);
            subQuerySpec.getFromClause().addRoot(tableGroup);
            final List<String> columnNames = new ArrayList<>(jdbcTypeCount);
            final List<ColumnReference> resultColumnReferences = new ArrayList<>(jdbcTypeCount);
            final NavigablePath navigablePath = pluralPartPath.getNavigablePath();
            final Boolean max = functionName.equalsIgnoreCase("max") ? Boolean.TRUE : (functionName.equalsIgnoreCase("min") ? Boolean.FALSE : null);
            final AbstractSqmSelfRenderingFunctionDescriptor functionDescriptor = (AbstractSqmSelfRenderingFunctionDescriptor) creationContext.getSessionFactory().getQueryEngine().getSqmFunctionRegistry().findFunctionDescriptor(functionName);
            final List<ColumnReference> subQueryColumns = new ArrayList<>(jdbcTypeCount);
            modelPart.forEachSelectable((selectionIndex, selectionMapping) -> {
                final ColumnReference columnReference = new ColumnReference(tableGroup.resolveTableReference(navigablePath, selectionMapping.getContainingTableExpression()), selectionMapping, creationContext.getSessionFactory());
                final String columnName;
                if (selectionMapping.isFormula()) {
                    columnName = "col" + columnNames.size();
                } else {
                    columnName = selectionMapping.getSelectionExpression();
                }
                columnNames.add(columnName);
                subQueryColumns.add(columnReference);
                if (max != null) {
                    subQuerySpec.addSortSpecification(new SortSpecification(columnReference, max ? SortOrder.DESCENDING : SortOrder.ASCENDING));
                }
            });
            if (max != null) {
                for (int i = 0; i < subQueryColumns.size(); i++) {
                    subQuerySpec.getSelectClause().addSqlSelection(new SqlSelectionImpl(i + 1, i, subQueryColumns.get(i)));
                    resultColumnReferences.add(new ColumnReference(identifierVariable, columnNames.get(i), false, null, null, subQueryColumns.get(i).getJdbcMapping(), creationContext.getSessionFactory()));
                }
                subQuerySpec.setFetchClauseExpression(new QueryLiteral<>(1, basicType(Integer.class)), FetchClauseType.ROWS_ONLY);
            } else {
                final List<? extends SqlAstNode> arguments;
                if (jdbcTypeCount == 1) {
                    arguments = subQueryColumns;
                } else {
                    arguments = Collections.singletonList(new SqlTuple(subQueryColumns, modelPart));
                }
                final Expression expression = new SelfRenderingAggregateFunctionSqlAstExpression(functionDescriptor.getName(), functionDescriptor, arguments, null, (ReturnableType<?>) functionDescriptor.getReturnTypeResolver().resolveFunctionReturnType(() -> null, arguments).getJdbcMapping(), modelPart);
                subQuerySpec.getSelectClause().addSqlSelection(new SqlSelectionImpl(1, 0, expression));
                resultColumnReferences.add(new ColumnReference(identifierVariable, columnNames.get(0), false, null, null, expression.getExpressionType().getJdbcMappings().get(0), creationContext.getSessionFactory()));
            }
            subQuerySpec.applyPredicate(pluralAttributeMapping.getKeyDescriptor().generateJoinPredicate(parentFromClauseAccess.findTableGroup(pluralPartPath.getPluralDomainPath().getNavigablePath().getParent()), tableGroup, getSqlExpressionResolver(), creationContext));
            final String compatibleTableExpression;
            if (modelPart instanceof BasicValuedModelPart) {
                compatibleTableExpression = ((BasicValuedModelPart) modelPart).getContainingTableExpression();
            } else if (modelPart instanceof EmbeddableValuedModelPart) {
                compatibleTableExpression = ((EmbeddableValuedModelPart) modelPart).getContainingTableExpression();
            } else {
                compatibleTableExpression = null;
            }
            lateralTableGroup = new QueryPartTableGroup(queryPath, null, subQuerySpec, identifierVariable, columnNames, compatibleTableExpression, true, false, creationContext.getSessionFactory());
            if (currentlyProcessingJoin == null) {
                parentTableGroup.addTableGroupJoin(new TableGroupJoin(lateralTableGroup.getNavigablePath(), SqlAstJoinType.LEFT, lateralTableGroup));
            } else {
                // In case this is used in the ON condition, we must prepend this lateral join
                final TableGroup targetTableGroup;
                if (currentlyProcessingJoin.getLhs() == null) {
                    targetTableGroup = parentFromClauseAccess.getTableGroup(currentlyProcessingJoin.findRoot().getNavigablePath());
                } else {
                    targetTableGroup = parentFromClauseAccess.getTableGroup(currentlyProcessingJoin.getLhs().getNavigablePath());
                }
                // Many databases would support modelling this as nested table group join,
                // but at least SQL Server doesn't like that, saying that the correlated columns can't be "bound"
                // Since there is no dependency on the currentlyProcessingJoin, we can safely prepend this join
                targetTableGroup.prependTableGroupJoin(currentlyProcessingJoin.getNavigablePath(), new TableGroupJoin(lateralTableGroup.getNavigablePath(), SqlAstJoinType.LEFT, lateralTableGroup));
            }
            parentFromClauseAccess.registerTableGroup(lateralTableGroup.getNavigablePath(), lateralTableGroup);
            if (jdbcTypeCount == 1) {
                return new SelfRenderingFunctionSqlAstExpression(pathName, (sqlAppender, sqlAstArguments, walker) -> {
                    sqlAstArguments.get(0).accept(walker);
                }, resultColumnReferences, (ReturnableType<?>) resultColumnReferences.get(0).getJdbcMapping(), resultColumnReferences.get(0).getJdbcMapping());
            } else {
                return new SqlTuple(resultColumnReferences, modelPart);
            }
        } finally {
            popProcessingStateStack();
        }
    }
    final QueryPartTableReference tableReference = (QueryPartTableReference) lateralTableGroup.getPrimaryTableReference();
    if (jdbcTypeCount == 1) {
        final List<SqlSelection> sqlSelections = tableReference.getQueryPart().getFirstQuerySpec().getSelectClause().getSqlSelections();
        return new SelfRenderingFunctionSqlAstExpression(pathName, (sqlAppender, sqlAstArguments, walker) -> {
            sqlAstArguments.get(0).accept(walker);
        }, Collections.singletonList(new ColumnReference(identifierVariable, tableReference.getColumnNames().get(0), false, null, null, sqlSelections.get(0).getExpressionType().getJdbcMappings().get(0), creationContext.getSessionFactory())), (ReturnableType<?>) sqlSelections.get(0).getExpressionType().getJdbcMappings().get(0), sqlSelections.get(0).getExpressionType());
    } else {
        final List<ColumnReference> resultColumnReferences = new ArrayList<>(jdbcTypeCount);
        modelPart.forEachSelectable((selectionIndex, selectionMapping) -> resultColumnReferences.add(new ColumnReference(identifierVariable, tableReference.getColumnNames().get(selectionIndex), false, null, null, selectionMapping.getJdbcMapping(), creationContext.getSessionFactory())));
        return new SqlTuple(resultColumnReferences, modelPart);
    }
}

Example 19 with PluralAttributeMapping

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

the class BaseSqmToSqlAstConverter method visitMapEntryFunction.

@Override
public Object visitMapEntryFunction(SqmMapEntryReference<?, ?> entryRef) {
    final SqmPath<?> mapPath = entryRef.getMapPath();
    prepareReusablePath(mapPath, () -> null);
    final NavigablePath mapNavigablePath = mapPath.getNavigablePath();
    final TableGroup tableGroup = getFromClauseAccess().resolveTableGroup(mapNavigablePath, (navigablePath) -> {
        final TableGroup parentTableGroup = getFromClauseAccess().getTableGroup(mapNavigablePath.getParent());
        final PluralAttributeMapping mapAttribute = (PluralAttributeMapping) parentTableGroup.getModelPart().findSubPart(mapNavigablePath.getLocalName(), null);
        final TableGroupJoin tableGroupJoin = mapAttribute.createTableGroupJoin(mapNavigablePath, parentTableGroup, null, SqlAstJoinType.INNER, false, false, sqlAliasBaseManager, getSqlExpressionResolver(), this, creationContext);
        parentTableGroup.addTableGroupJoin(tableGroupJoin);
        return tableGroupJoin.getJoinedGroup();
    });
    final PluralAttributeMapping mapDescriptor = (PluralAttributeMapping) tableGroup.getModelPart();
    final CollectionPart indexDescriptor = mapDescriptor.getIndexDescriptor();
    final NavigablePath indexNavigablePath = mapNavigablePath.append(indexDescriptor.getPartName());
    final DomainResult<Object> indexResult = indexDescriptor.createDomainResult(indexNavigablePath, tableGroup, null, this);
    final CollectionPart valueDescriptor = mapDescriptor.getElementDescriptor();
    final NavigablePath valueNavigablePath = mapNavigablePath.append(valueDescriptor.getPartName());
    final DomainResult<Object> valueResult = valueDescriptor.createDomainResult(valueNavigablePath, tableGroup, null, this);
    return new DomainResultProducer<Map.Entry<Object, Object>>() {

        @Override
        public DomainResult<Map.Entry<Object, Object>> createDomainResult(String resultVariable, DomainResultCreationState creationState) {
            final JavaType<Map.Entry<Object, Object>> mapEntryDescriptor = getTypeConfiguration().getJavaTypeRegistry().resolveDescriptor(Map.Entry.class);
            return new SqmMapEntryResult<>(indexResult, valueResult, resultVariable, mapEntryDescriptor);
        }

        @Override
        public void applySqlSelections(DomainResultCreationState creationState) {
            throw new UnsupportedOperationException();
        }
    };
}

Example 20 with PluralAttributeMapping

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

the class BaseSqmToSqlAstConverter method visitMemberOfPredicate.

@Override
public Predicate visitMemberOfPredicate(SqmMemberOfPredicate predicate) {
    final SqmPath<?> pluralPath = predicate.getPluralPath();
    prepareReusablePath(pluralPath, () -> null);
    final PluralAttributeMapping pluralAttributeMapping = (PluralAttributeMapping) determineValueMapping(pluralPath);
    if (pluralAttributeMapping.getElementDescriptor() instanceof EntityCollectionPart) {
        inferrableTypeAccessStack.push(() -> ((EntityCollectionPart) pluralAttributeMapping.getElementDescriptor()).getKeyTargetMatchPart());
    } else if (pluralAttributeMapping.getElementDescriptor() instanceof EmbeddedCollectionPart) {
        inferrableTypeAccessStack.push(pluralAttributeMapping::getElementDescriptor);
    } else {
        inferrableTypeAccessStack.push(() -> pluralAttributeMapping);
    }
    final Expression lhs;
    try {
        lhs = (Expression) predicate.getLeftHandExpression().accept(this);
    } finally {
        inferrableTypeAccessStack.pop();
    }
    final FromClauseAccess parentFromClauseAccess = getFromClauseAccess();
    final QuerySpec subQuerySpec = new QuerySpec(false);
    pushProcessingState(new SqlAstQueryPartProcessingStateImpl(subQuerySpec, getCurrentProcessingState(), this, currentClauseStack::getCurrent, false));
    try {
        final TableGroup tableGroup = pluralAttributeMapping.createRootTableGroup(true, pluralPath.getNavigablePath(), null, () -> subQuerySpec::applyPredicate, this, creationContext);
        pluralAttributeMapping.applyBaseRestrictions(subQuerySpec::applyPredicate, tableGroup, true, getLoadQueryInfluencers().getEnabledFilters(), null, this);
        getFromClauseAccess().registerTableGroup(pluralPath.getNavigablePath(), tableGroup);
        registerPluralTableGroupParts(tableGroup);
        subQuerySpec.getFromClause().addRoot(tableGroup);
        final CollectionPart elementDescriptor = pluralAttributeMapping.getElementDescriptor();
        if (elementDescriptor instanceof EntityCollectionPart) {
            ((EntityCollectionPart) elementDescriptor).getKeyTargetMatchPart().createDomainResult(pluralPath.getNavigablePath(), tableGroup, null, this);
        } else {
            elementDescriptor.createDomainResult(pluralPath.getNavigablePath(), tableGroup, null, this);
        }
        subQuerySpec.applyPredicate(pluralAttributeMapping.getKeyDescriptor().generateJoinPredicate(parentFromClauseAccess.findTableGroup(pluralPath.getNavigablePath().getParent()), tableGroup, getSqlExpressionResolver(), creationContext));
    } finally {
        popProcessingStateStack();
    }
    return new InSubQueryPredicate(lhs, subQuerySpec, predicate.isNegated(), getBooleanType());
}