Examples with SqmLiteralNull org.hibernate.query.sqm.tree.expression.SqmLiteralNull used on opensource projects

Example 1 with SqmLiteralNull

use of org.hibernate.query.sqm.tree.expression.SqmLiteralNull in project hibernate-orm by hibernate.

the class SqmCriteriaNodeBuilder method nullLiteral.

@Override
public <T> SqmExpression<T> nullLiteral(Class<T> resultClass) {
    final TypeConfiguration typeConfiguration = getTypeConfiguration();
    final BasicType<T> basicTypeForJavaType = typeConfiguration.getBasicTypeForJavaType(resultClass);
    final SqmExpressible<T> sqmExpressible = basicTypeForJavaType == null ? typeConfiguration.getSessionFactory().getJpaMetamodel().managedType(resultClass) : basicTypeForJavaType;
    return new SqmLiteralNull<>(sqmExpressible, this);
}

Example 2 with SqmLiteralNull

use of org.hibernate.query.sqm.tree.expression.SqmLiteralNull in project hibernate-orm by hibernate.

the class SemanticQueryBuilder method visitComparisonPredicate.

@Override
public SqmPredicate visitComparisonPredicate(HqlParser.ComparisonPredicateContext ctx) {
    final ComparisonOperator comparisonOperator = (ComparisonOperator) ctx.getChild(1).accept(this);
    final SqmExpression<?> left;
    final SqmExpression<?> right;
    final HqlParser.ExpressionContext leftExpressionContext = (HqlParser.ExpressionContext) ctx.getChild(0);
    final HqlParser.ExpressionContext rightExpressionContext = (HqlParser.ExpressionContext) ctx.getChild(2);
    switch(comparisonOperator) {
        case EQUAL:
        case NOT_EQUAL:
        case DISTINCT_FROM:
        case NOT_DISTINCT_FROM:
            {
                Map<Class<?>, Enum<?>> possibleEnumValues;
                if ((possibleEnumValues = getPossibleEnumValues(leftExpressionContext)) != null) {
                    right = (SqmExpression<?>) rightExpressionContext.accept(this);
                    left = resolveEnumShorthandLiteral(leftExpressionContext, possibleEnumValues, right.getJavaType());
                    break;
                } else if ((possibleEnumValues = getPossibleEnumValues(rightExpressionContext)) != null) {
                    left = (SqmExpression<?>) leftExpressionContext.accept(this);
                    right = resolveEnumShorthandLiteral(rightExpressionContext, possibleEnumValues, left.getJavaType());
                    break;
                }
                left = (SqmExpression<?>) leftExpressionContext.accept(this);
                right = (SqmExpression<?>) rightExpressionContext.accept(this);
                // This is something that we used to support before 6 which is also used in our testsuite
                if (left instanceof SqmLiteralNull<?>) {
                    return new SqmNullnessPredicate(right, comparisonOperator == ComparisonOperator.NOT_EQUAL || comparisonOperator == ComparisonOperator.DISTINCT_FROM, creationContext.getNodeBuilder());
                } else if (right instanceof SqmLiteralNull<?>) {
                    return new SqmNullnessPredicate(left, comparisonOperator == ComparisonOperator.NOT_EQUAL || comparisonOperator == ComparisonOperator.DISTINCT_FROM, creationContext.getNodeBuilder());
                }
                break;
            }
        default:
            {
                left = (SqmExpression<?>) leftExpressionContext.accept(this);
                right = (SqmExpression<?>) rightExpressionContext.accept(this);
                break;
            }
    }
    return new SqmComparisonPredicate(left, comparisonOperator, right, creationContext.getNodeBuilder());
}

Example 3 with SqmLiteralNull

use of org.hibernate.query.sqm.tree.expression.SqmLiteralNull 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()));
    }
}