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

Example 26 with EntityIdentifierMapping

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

the class DynamicResultBuilderEntityStandard method buildResultOrFetch.

private <T> T buildResultOrFetch(Function<TableGroup, T> resultOrFetchBuilder, JdbcValuesMetadata jdbcResultsMetadata, DomainResultCreationState domainResultCreationState) {
    final DomainResultCreationStateImpl creationState = impl(domainResultCreationState);
    final FromClauseAccess fromClauseAccess = domainResultCreationState.getSqlAstCreationState().getFromClauseAccess();
    final TableGroup tableGroup = fromClauseAccess.resolveTableGroup(navigablePath, np -> {
        final TableReference tableReference = entityMapping.createPrimaryTableReference(new SqlAliasBaseConstant(tableAlias), creationState.getSqlExpressionResolver(), creationState.getCreationContext());
        if (lockMode != null) {
            domainResultCreationState.getSqlAstCreationState().registerLockMode(tableAlias, lockMode);
        }
        return new TableGroupImpl(navigablePath, tableAlias, tableReference, entityMapping);
    });
    final TableReference tableReference = tableGroup.getPrimaryTableReference();
    final List<String> idColumnAliases;
    final FetchBuilder idFetchBuilder;
    if (this.idColumnNames != null) {
        idColumnAliases = this.idColumnNames;
    } else if ((idFetchBuilder = findIdFetchBuilder()) != null) {
        idColumnAliases = ((DynamicFetchBuilder) idFetchBuilder).getColumnAliases();
    } else {
        idColumnAliases = null;
    }
    if (idColumnAliases != null) {
        final EntityIdentifierMapping identifierMapping = entityMapping.getIdentifierMapping();
        identifierMapping.forEachSelectable((selectionIndex, selectableMapping) -> {
            resolveSqlSelection(idColumnAliases.get(selectionIndex), createColumnReferenceKey(tableReference, selectableMapping.getSelectionExpression()), selectableMapping.getJdbcMapping(), jdbcResultsMetadata, domainResultCreationState);
        });
    }
    if (discriminatorColumnName != null) {
        resolveSqlSelection(discriminatorColumnName, createColumnReferenceKey(tableReference, entityMapping.getDiscriminatorMapping().getSelectionExpression()), entityMapping.getDiscriminatorMapping().getJdbcMapping(), jdbcResultsMetadata, domainResultCreationState);
    }
    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)) {
                final int startIndex;
                if (relativePath.regionMatches(prefix.length(), ELEMENT_PREFIX, 0, ELEMENT_PREFIX.length())) {
                    startIndex = prefix.length() + ELEMENT_PREFIX.length();
                } else {
                    startIndex = prefix.length();
                }
                return findFetchBuilder(relativePath.substring(startIndex));
            }
            return null;
        });
        return resultOrFetchBuilder.apply(tableGroup);
    } finally {
        creationState.popExplicitFetchMementoResolver();
    }
}

Example 27 with EntityIdentifierMapping

use of org.hibernate.metamodel.mapping.EntityIdentifierMapping 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 28 with EntityIdentifierMapping

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

the class BaseSqmToSqlAstConverter method consumeFromClauseCorrelatedRoot.

protected void consumeFromClauseCorrelatedRoot(SqmRoot<?> sqmRoot) {
    log.tracef("Resolving SqmRoot [%s] to TableGroup", sqmRoot);
    final FromClauseIndex fromClauseIndex = getFromClauseIndex();
    if (fromClauseIndex.isResolved(sqmRoot)) {
        log.tracef("Already resolved SqmRoot [%s] to TableGroup", sqmRoot);
    }
    final QuerySpec currentQuerySpec = currentQuerySpec();
    final TableGroup tableGroup;
    if (!sqmRoot.isCorrelated()) {
        return;
    }
    final SessionFactoryImplementor sessionFactory = creationContext.getSessionFactory();
    if (sqmRoot.containsOnlyInnerJoins()) {
        // If we have just inner joins against a correlated root, we can render the joins as references
        final SqmFrom<?, ?> from;
        // It will always contain just a single correlated join though, which is what is actually correlated
        if (sqmRoot instanceof SqmCorrelatedRootJoin<?>) {
            assert sqmRoot.getSqmJoins().size() == 1;
            assert sqmRoot.getSqmJoins().get(0).isCorrelated();
            from = sqmRoot.getSqmJoins().get(0);
        } else {
            from = sqmRoot;
        }
        final TableGroup parentTableGroup = fromClauseIndex.findTableGroupOnParents(from.getCorrelationParent().getNavigablePath());
        final SqlAliasBase sqlAliasBase = sqlAliasBaseManager.createSqlAliasBase(parentTableGroup.getGroupAlias());
        if (parentTableGroup instanceof PluralTableGroup) {
            final PluralTableGroup pluralTableGroup = (PluralTableGroup) parentTableGroup;
            final CorrelatedPluralTableGroup correlatedPluralTableGroup = new CorrelatedPluralTableGroup(parentTableGroup, sqlAliasBase, currentQuerySpec, predicate -> additionalRestrictions = SqlAstTreeHelper.combinePredicates(additionalRestrictions, predicate), sessionFactory);
            final TableGroup elementTableGroup = pluralTableGroup.getElementTableGroup();
            if (elementTableGroup != null) {
                final TableGroup correlatedElementTableGroup = new CorrelatedTableGroup(elementTableGroup, sqlAliasBase, currentQuerySpec, predicate -> additionalRestrictions = SqlAstTreeHelper.combinePredicates(additionalRestrictions, predicate), sessionFactory);
                final TableGroupJoin tableGroupJoin = new TableGroupJoin(elementTableGroup.getNavigablePath(), SqlAstJoinType.INNER, correlatedElementTableGroup);
                correlatedPluralTableGroup.registerElementTableGroup(tableGroupJoin);
            }
            final TableGroup indexTableGroup = pluralTableGroup.getIndexTableGroup();
            if (indexTableGroup != null) {
                final TableGroup correlatedIndexTableGroup = new CorrelatedTableGroup(indexTableGroup, sqlAliasBase, currentQuerySpec, predicate -> additionalRestrictions = SqlAstTreeHelper.combinePredicates(additionalRestrictions, predicate), sessionFactory);
                final TableGroupJoin tableGroupJoin = new TableGroupJoin(indexTableGroup.getNavigablePath(), SqlAstJoinType.INNER, correlatedIndexTableGroup);
                correlatedPluralTableGroup.registerIndexTableGroup(tableGroupJoin);
            }
            tableGroup = correlatedPluralTableGroup;
        } else {
            tableGroup = new CorrelatedTableGroup(parentTableGroup, sqlAliasBase, currentQuerySpec, predicate -> additionalRestrictions = SqlAstTreeHelper.combinePredicates(additionalRestrictions, predicate), sessionFactory);
        }
        fromClauseIndex.register(from, tableGroup);
        registerPluralTableGroupParts(tableGroup);
        log.tracef("Resolved SqmRoot [%s] to correlated TableGroup [%s]", sqmRoot, tableGroup);
        consumeExplicitJoins(from, tableGroup);
        return;
    } else {
        final EntityPersister entityDescriptor = resolveEntityPersister(sqmRoot.getReferencedPathSource());
        final TableGroup parentTableGroup = fromClauseIndex.findTableGroupOnParents(sqmRoot.getCorrelationParent().getNavigablePath());
        // If we have non-inner joins against a correlated root, we must render the root with a correlation predicate
        tableGroup = entityDescriptor.createRootTableGroup(true, sqmRoot.getNavigablePath(), sqmRoot.getExplicitAlias(), () -> predicate -> {
        }, this, creationContext);
        final EntityIdentifierMapping identifierMapping = entityDescriptor.getIdentifierMapping();
        final NavigablePath navigablePath = sqmRoot.getNavigablePath().append(identifierMapping.getNavigableRole().getNavigableName());
        final int jdbcTypeCount = identifierMapping.getJdbcTypeCount();
        if (jdbcTypeCount == 1) {
            identifierMapping.forEachSelectable((index, selectable) -> additionalRestrictions = SqlAstTreeHelper.combinePredicates(additionalRestrictions, new ComparisonPredicate(new ColumnReference(parentTableGroup.resolveTableReference(navigablePath, selectable.getContainingTableExpression()), selectable, sessionFactory), ComparisonOperator.EQUAL, new ColumnReference(tableGroup.resolveTableReference(navigablePath, selectable.getContainingTableExpression()), selectable, sessionFactory))));
        } else {
            final List<Expression> lhs = new ArrayList<>(jdbcTypeCount);
            final List<Expression> rhs = new ArrayList<>(jdbcTypeCount);
            identifierMapping.forEachSelectable((index, selectable) -> {
                lhs.add(new ColumnReference(parentTableGroup.resolveTableReference(navigablePath, selectable.getContainingTableExpression()), selectable, sessionFactory));
                rhs.add(new ColumnReference(tableGroup.resolveTableReference(navigablePath, selectable.getContainingTableExpression()), selectable, sessionFactory));
            });
            additionalRestrictions = SqlAstTreeHelper.combinePredicates(additionalRestrictions, new ComparisonPredicate(new SqlTuple(lhs, identifierMapping), ComparisonOperator.EQUAL, new SqlTuple(rhs, identifierMapping)));
        }
    }
    log.tracef("Resolved SqmRoot [%s] to new TableGroup [%s]", sqmRoot, tableGroup);
    fromClauseIndex.register(sqmRoot, tableGroup);
    currentQuerySpec.getFromClause().addRoot(tableGroup);
    consumeJoins(sqmRoot, fromClauseIndex, tableGroup);
}

Example 29 with EntityIdentifierMapping

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

the class SqmCteTable method createIdTable.

public static SqmCteTable createIdTable(String cteName, EntityMappingType entityDescriptor) {
    return new SqmCteTable(cteName, sqmCteTable -> {
        final int numberOfColumns = entityDescriptor.getIdentifierMapping().getJdbcTypeCount();
        final List<SqmCteTableColumn> columns = new ArrayList<>(numberOfColumns);
        final EntityIdentifierMapping identifierMapping = entityDescriptor.getIdentifierMapping();
        final String idName;
        if (identifierMapping instanceof SingleAttributeIdentifierMapping) {
            idName = ((SingleAttributeIdentifierMapping) identifierMapping).getAttributeName();
        } else {
            idName = "id";
        }
        columns.add(new SqmCteTableColumn(sqmCteTable, idName, identifierMapping));
        return columns;
    });
}

Example 30 with EntityIdentifierMapping

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

the class SqmCteTable method createEntityTable.

public static SqmCteTable createEntityTable(String cteName, EntityMappingType entityDescriptor) {
    return new SqmCteTable(cteName, sqmCteTable -> {
        final int numberOfColumns = entityDescriptor.getIdentifierMapping().getJdbcTypeCount();
        final List<SqmCteTableColumn> columns = new ArrayList<>(numberOfColumns);
        final EntityIdentifierMapping identifierMapping = entityDescriptor.getIdentifierMapping();
        final String idName;
        if (identifierMapping instanceof SingleAttributeIdentifierMapping) {
            idName = ((SingleAttributeIdentifierMapping) identifierMapping).getAttributeName();
        } else {
            idName = "id";
        }
        columns.add(new SqmCteTableColumn(sqmCteTable, idName, identifierMapping));
        final EntityDiscriminatorMapping discriminatorMapping = entityDescriptor.getDiscriminatorMapping();
        if (discriminatorMapping != null && discriminatorMapping.isPhysical() && !discriminatorMapping.isFormula()) {
            columns.add(new SqmCteTableColumn(sqmCteTable, "class", discriminatorMapping));
        }
        // Collect all columns for all entity subtype attributes
        entityDescriptor.visitSubTypeAttributeMappings(attribute -> {
            if (!(attribute instanceof PluralAttributeMapping)) {
                columns.add(new SqmCteTableColumn(sqmCteTable, attribute.getAttributeName(), attribute));
            }
        });
        // We add a special row number column that we can use to identify and join rows
        columns.add(new SqmCteTableColumn(sqmCteTable, "rn_", entityDescriptor.getEntityPersister().getFactory().getTypeConfiguration().getBasicTypeForJavaType(Integer.class)));
        return columns;
    });
}