Examples with SubqueryExpression com.blazebit.persistence.parser.expression.SubqueryExpression used on opensource projects

Example 1 with SubqueryExpression

use of com.blazebit.persistence.parser.expression.SubqueryExpression in project blaze-persistence by Blazebit.

the class JoinVisitor method visit.

@Override
public void visit(JoinNode node) {
    if (node.getOnPredicate() != null) {
        currentJoinNode = node;
        try {
            node.getOnPredicate().accept(this);
            if (!correlationPathReplacementVisitor.getPathsToCorrelate().isEmpty()) {
                // We rewrite the predicate to use correlated subqueries for implicit joins
                SubqueryInitiatorImpl<Object> subqueryInitiator = (SubqueryInitiatorImpl<Object>) joinManager.getSubqueryInitFactory().createSubqueryInitiator(null, this, true, fromClause);
                SubqueryBuilderImpl<?> subqueryBuilder = null;
                List<Predicate> additionalPredicates = new ArrayList<>(correlationPathReplacementVisitor.getRootsToCorrelate().size());
                for (ImplicitJoinCorrelationPathReplacementVisitor.RootCorrelationEntry entry : correlationPathReplacementVisitor.getRootsToCorrelate()) {
                    if (subqueryBuilder == null) {
                        subqueryBuilder = (SubqueryBuilderImpl<?>) subqueryInitiator.from(entry.getEntityClass(), entry.getAlias());
                    } else {
                        subqueryBuilder.from(entry.getEntityClass(), entry.getAlias());
                    }
                    additionalPredicates.add(entry.getAdditionalPredicate());
                }
                for (ImplicitJoinCorrelationPathReplacementVisitor.CorrelationTransformEntry correlationTransformEntry : correlationPathReplacementVisitor.getPathsToCorrelate()) {
                    String alias = correlationTransformEntry.getAlias();
                    String correlationExpression = correlationTransformEntry.getCorrelationExpression();
                    if (correlationTransformEntry.isInConjunction()) {
                        if (subqueryBuilder == null) {
                            subqueryBuilder = (SubqueryBuilderImpl<?>) subqueryInitiator.from(correlationExpression, alias);
                        } else {
                            subqueryBuilder.from(correlationExpression, alias);
                        }
                    } else {
                        subqueryBuilder.leftJoinDefault(correlationExpression, alias);
                    }
                }
                subqueryBuilder.whereManager.restrictSetExpression(correlationPathReplacementVisitor.rewritePredicate(node.getOnPredicate()));
                for (Predicate additionalPredicate : additionalPredicates) {
                    subqueryBuilder.whereManager.restrictExpression(additionalPredicate);
                }
                node.setOnPredicate(new CompoundPredicate(CompoundPredicate.BooleanOperator.AND, new ExistsPredicate(new SubqueryExpression(subqueryBuilder), false)));
                node.getOnPredicate().accept(this);
            }
        } finally {
            currentJoinNode = null;
        }
    }
    node.registerDependencies();
    if (node.isFetch()) {
        fetchableNodes.add(node);
    }
}

Example 2 with SubqueryExpression

use of com.blazebit.persistence.parser.expression.SubqueryExpression in project blaze-persistence by Blazebit.

the class JpaUtils method expandBindings.

public static void expandBindings(Map<String, Integer> bindingMap, Map<String, String> columnBindingMap, Map<String, ExtendedAttribute<?, ?>> attributeEntries, ClauseType clause, AbstractCommonQueryBuilder<?, ?, ?, ?, ?> queryBuilder, String keyFunctionExpression, boolean enableElementCollectionIdCutoff) {
    SelectManager<?> selectManager = queryBuilder.selectManager;
    JoinManager joinManager = queryBuilder.joinManager;
    ParameterManager parameterManager = queryBuilder.parameterManager;
    JpaProvider jpaProvider = queryBuilder.mainQuery.jpaProvider;
    EntityMetamodelImpl metamodel = queryBuilder.mainQuery.metamodel;
    boolean requiresNullCast = queryBuilder.mainQuery.dbmsDialect.requiresNullCast();
    boolean needsCastParameters = queryBuilder.mainQuery.dbmsDialect.needsCastParameters();
    JpaMetamodelAccessor jpaMetamodelAccessor = jpaProvider.getJpaMetamodelAccessor();
    boolean needsElementCollectionIdCutoff = enableElementCollectionIdCutoff && jpaProvider.needsElementCollectionIdCutoff();
    final Queue<String> attributeQueue = new ArrayDeque<>(bindingMap.keySet());
    while (!attributeQueue.isEmpty()) {
        final String attributeName = attributeQueue.remove();
        Integer tupleIndex = bindingMap.get(attributeName);
        Class<?> elementType;
        String columnType;
        boolean splitExpression;
        ExtendedAttribute<?, ?> attributeEntry = attributeEntries.get(attributeName);
        if (attributeEntry == null) {
            if (!attributeName.equalsIgnoreCase(keyFunctionExpression)) {
                continue;
            }
            String realAttributeName = attributeName.substring(attributeName.indexOf('(') + 1, attributeName.length() - 1);
            attributeEntry = attributeEntries.get(realAttributeName);
            if (attributeEntry.getAttribute() instanceof ListAttribute<?, ?>) {
                elementType = Integer.class;
                columnType = queryBuilder.mainQuery.dbmsDialect.getSqlType(Integer.class);
            } else {
                MapAttribute<?, ?, ?> mapAttribute = (MapAttribute<?, ?, ?>) attributeEntry.getAttribute();
                elementType = mapAttribute.getKeyJavaType();
                columnType = attributeEntry.getJoinTable() != null && attributeEntry.getJoinTable().getKeyColumnTypes() != null && attributeEntry.getJoinTable().getKeyColumnTypes().size() == 1 ? attributeEntry.getJoinTable().getKeyColumnTypes().values().iterator().next() : null;
            }
            splitExpression = false;
        } else {
            elementType = attributeEntry.getElementClass();
            columnType = attributeEntry.getColumnTypes().length == 0 ? null : attributeEntry.getColumnTypes()[0];
            final List<Attribute<?, ?>> attributePath = attributeEntry.getAttributePath();
            final Attribute<?, ?> lastAttribute = attributePath.get(attributePath.size() - 1);
            splitExpression = lastAttribute.getPersistentAttributeType() == Attribute.PersistentAttributeType.EMBEDDED;
            if (!splitExpression) {
                if ((clause != ClauseType.SET || jpaProvider.supportsUpdateSetAssociationId()) && jpaMetamodelAccessor.isJoinable(lastAttribute) && !isBasicElementType(lastAttribute)) {
                    splitExpression = true;
                    if (needsElementCollectionIdCutoff) {
                        OUTER: for (int i = 0; i < attributePath.size() - 1; i++) {
                            Attribute<?, ?> attribute = attributePath.get(i);
                            if (attribute.getPersistentAttributeType() == Attribute.PersistentAttributeType.ELEMENT_COLLECTION) {
                                // This is a special case, when an embeddable is between an element collection and the association, we still need to split the expression
                                for (int j = i + 1; j < attributePath.size() - 1; j++) {
                                    attribute = attributePath.get(j);
                                    if (attribute.getPersistentAttributeType() == Attribute.PersistentAttributeType.EMBEDDED) {
                                        break OUTER;
                                    }
                                }
                                splitExpression = false;
                                break;
                            }
                        }
                    }
                }
            }
        }
        SelectInfo selectInfo = selectManager.getSelectInfos().get(tupleIndex);
        final Expression selectExpression = selectInfo.getExpression();
        if (splitExpression) {
            // TODO: Maybe also allow Treat, Case-When, Array?
            if (selectExpression instanceof NullExpression) {
                final Collection<String> embeddedPropertyNames = getEmbeddedPropertyPaths(attributeEntries, attributeName, needsElementCollectionIdCutoff, false);
                if (embeddedPropertyNames.size() > 0) {
                    selectManager.getSelectInfos().remove(tupleIndex.intValue());
                    bindingMap.remove(attributeName);
                    // We are going to insert the expanded attributes as new select items and shift existing ones
                    int delta = embeddedPropertyNames.size() - 1;
                    if (delta > 0) {
                        for (Map.Entry<String, Integer> entry : bindingMap.entrySet()) {
                            if (entry.getValue() > tupleIndex) {
                                entry.setValue(entry.getValue() + delta);
                            }
                        }
                    }
                    int offset = 0;
                    for (String embeddedPropertyName : embeddedPropertyNames) {
                        String nestedAttributePath = attributeName + "." + embeddedPropertyName;
                        ExtendedAttribute<?, ?> nestedAttributeEntry = attributeEntries.get(nestedAttributePath);
                        // Process the nested attribute path recursively
                        attributeQueue.add(nestedAttributePath);
                        // Replace this binding in the binding map, additional selects need an updated index
                        bindingMap.put(nestedAttributePath, tupleIndex + offset);
                        selectManager.select(offset == 0 ? selectExpression : selectExpression.copy(ExpressionCopyContext.EMPTY), null, tupleIndex + offset);
                        if (columnBindingMap != null) {
                            for (String column : nestedAttributeEntry.getColumnNames()) {
                                columnBindingMap.put(column, nestedAttributePath);
                            }
                        }
                        offset++;
                    }
                }
            } else if (selectExpression instanceof PathExpression) {
                boolean firstBinding = true;
                final Collection<String> embeddedPropertyNames = getEmbeddedPropertyPaths(attributeEntries, attributeName, needsElementCollectionIdCutoff, false);
                PathExpression baseExpression = embeddedPropertyNames.size() > 1 ? ((PathExpression) selectExpression).copy(ExpressionCopyContext.EMPTY) : ((PathExpression) selectExpression);
                joinManager.implicitJoin(baseExpression, true, true, true, null, ClauseType.SELECT, new HashSet<String>(), false, false, false, false);
                if (elementType != baseExpression.getPathReference().getType().getJavaType()) {
                    throw new IllegalStateException("An association should be bound to its association type and not its identifier type");
                }
                if (embeddedPropertyNames.size() > 0) {
                    bindingMap.remove(attributeName);
                    // We are going to insert the expanded attributes as new select items and shift existing ones
                    int delta = embeddedPropertyNames.size() - 1;
                    if (delta > 0) {
                        for (Map.Entry<String, Integer> entry : bindingMap.entrySet()) {
                            if (entry.getValue() > tupleIndex) {
                                entry.setValue(entry.getValue() + delta);
                            }
                        }
                    }
                    int offset = 0;
                    for (String embeddedPropertyName : embeddedPropertyNames) {
                        PathExpression pathExpression = firstBinding ? ((PathExpression) selectExpression) : baseExpression.copy(ExpressionCopyContext.EMPTY);
                        for (String propertyNamePart : embeddedPropertyName.split("\\.")) {
                            pathExpression.getExpressions().add(new PropertyExpression(propertyNamePart));
                        }
                        String nestedAttributePath = attributeName + "." + embeddedPropertyName;
                        ExtendedAttribute<?, ?> nestedAttributeEntry = attributeEntries.get(nestedAttributePath);
                        // Process the nested attribute path recursively
                        attributeQueue.add(nestedAttributePath);
                        // Replace this binding in the binding map, additional selects need an updated index
                        bindingMap.put(nestedAttributePath, firstBinding ? tupleIndex : tupleIndex + offset);
                        if (!firstBinding) {
                            selectManager.select(pathExpression, null, tupleIndex + offset);
                        } else {
                            firstBinding = false;
                        }
                        if (columnBindingMap != null) {
                            for (String column : nestedAttributeEntry.getColumnNames()) {
                                columnBindingMap.put(column, nestedAttributePath);
                            }
                        }
                        offset++;
                    }
                }
            } else if (selectExpression instanceof ParameterExpression) {
                final Collection<String> embeddedPropertyNames = getEmbeddedPropertyPaths(attributeEntries, attributeName, jpaProvider.needsElementCollectionIdCutoff(), false);
                if (embeddedPropertyNames.size() > 0) {
                    ParameterExpression parameterExpression = (ParameterExpression) selectExpression;
                    String parameterName = parameterExpression.getName();
                    Map<String, List<String>> parameterAccessPaths = new HashMap<>(embeddedPropertyNames.size());
                    ParameterValueTransformer tranformer = parameterManager.getParameter(parameterName).getTransformer();
                    if (tranformer instanceof SplittingParameterTransformer) {
                        for (String name : ((SplittingParameterTransformer) tranformer).getParameterNames()) {
                            parameterManager.unregisterParameterName(name, clause, queryBuilder);
                        }
                    }
                    selectManager.getSelectInfos().remove(tupleIndex.intValue());
                    bindingMap.remove(attributeName);
                    // We are going to insert the expanded attributes as new select items and shift existing ones
                    int delta = embeddedPropertyNames.size() - 1;
                    if (delta > 0) {
                        for (Map.Entry<String, Integer> entry : bindingMap.entrySet()) {
                            if (entry.getValue() > tupleIndex) {
                                entry.setValue(entry.getValue() + delta);
                            }
                        }
                    }
                    int offset = 0;
                    for (String embeddedPropertyName : embeddedPropertyNames) {
                        String subParamName = "_" + parameterName + "_" + embeddedPropertyName.replace('.', '_');
                        parameterManager.registerParameterName(subParamName, false, clause, queryBuilder);
                        parameterAccessPaths.put(subParamName, Arrays.asList(embeddedPropertyName.split("\\.")));
                        String nestedAttributePath = attributeName + "." + embeddedPropertyName;
                        ExtendedAttribute<?, ?> nestedAttributeEntry = attributeEntries.get(nestedAttributePath);
                        // Process the nested attribute path recursively
                        attributeQueue.add(nestedAttributePath);
                        // Replace this binding in the binding map, additional selects need an updated index
                        bindingMap.put(nestedAttributePath, tupleIndex + offset);
                        selectManager.select(new ParameterExpression(subParamName), null, tupleIndex + offset);
                        if (columnBindingMap != null) {
                            for (String column : nestedAttributeEntry.getColumnNames()) {
                                columnBindingMap.put(column, nestedAttributePath);
                            }
                        }
                        offset++;
                    }
                    parameterManager.getParameter(parameterName).setTransformer(new SplittingParameterTransformer(parameterManager, metamodel, elementType, parameterAccessPaths));
                }
            } else {
                throw new IllegalArgumentException("Illegal expression '" + selectExpression.toString() + "' for binding relation '" + attributeName + "'!");
            }
        } else if (requiresNullCast && selectExpression instanceof NullExpression) {
            if (BasicCastTypes.TYPES.contains(elementType) && queryBuilder.statementType != DbmsStatementType.INSERT) {
                // We also need a cast for parameter expressions except in the SET clause
                List<Expression> arguments = new ArrayList<>(2);
                arguments.add(selectExpression);
                if (columnType != null) {
                    arguments.add(new StringLiteral(columnType));
                }
                selectInfo.set(new FunctionExpression("CAST_" + elementType.getSimpleName(), arguments, selectExpression));
            } else {
                final EntityMetamodelImpl.AttributeExample attributeExample = metamodel.getBasicTypeExampleAttributes().get(elementType);
                if (attributeExample != null) {
                    List<Expression> arguments = new ArrayList<>(2);
                    arguments.add(new SubqueryExpression(new Subquery() {

                        @Override
                        public String getQueryString() {
                            return attributeExample.getExampleJpql() + selectExpression;
                        }
                    }));
                    if (queryBuilder.statementType != DbmsStatementType.INSERT && needsCastParameters) {
                        arguments.add(new StringLiteral(attributeExample.getAttribute().getColumnTypes()[0]));
                    }
                    selectInfo.set(new FunctionExpression(NullfnFunction.FUNCTION_NAME, arguments, selectExpression));
                }
            }
        } else if (selectExpression instanceof ParameterExpression && clause != ClauseType.SET) {
            if (BasicCastTypes.TYPES.contains(elementType) && queryBuilder.statementType != DbmsStatementType.INSERT) {
                // We also need a cast for parameter expressions except in the SET clause
                List<Expression> arguments = new ArrayList<>(2);
                arguments.add(selectExpression);
                if (columnType != null) {
                    arguments.add(new StringLiteral(columnType));
                }
                selectInfo.set(new FunctionExpression("CAST_" + elementType.getSimpleName(), arguments, selectExpression));
            } else {
                final EntityMetamodelImpl.AttributeExample attributeExample = metamodel.getBasicTypeExampleAttributes().get(elementType);
                if (attributeExample != null) {
                    List<Expression> arguments = new ArrayList<>(2);
                    arguments.add(new SubqueryExpression(new Subquery() {

                        @Override
                        public String getQueryString() {
                            return attributeExample.getExampleJpql() + selectExpression;
                        }
                    }));
                    if (queryBuilder.statementType != DbmsStatementType.INSERT && needsCastParameters) {
                        arguments.add(new StringLiteral(attributeExample.getAttribute().getColumnTypes()[0]));
                    }
                    selectInfo.set(new FunctionExpression(ParamFunction.FUNCTION_NAME, arguments, selectExpression));
                }
            }
        }
    }
}

Example 3 with SubqueryExpression

use of com.blazebit.persistence.parser.expression.SubqueryExpression in project blaze-persistence by Blazebit.

the class ResolvingQueryGenerator method visit.

@Override
public void visit(ExistsPredicate predicate) {
    SubqueryExpression subqueryExpression;
    if (predicate.getExpression() instanceof SubqueryExpression && !isSimpleSubquery(subqueryExpression = (SubqueryExpression) predicate.getExpression())) {
        if (externalRepresentation) {
            if (predicate.isNegated()) {
                sb.append("NOT EXISTS ");
            } else {
                sb.append("EXISTS ");
            }
            sb.append('(');
            predicate.getExpression().accept(this);
            sb.append(')');
        } else {
            sb.append("1 = ");
            sb.append(jpaProvider.getCustomFunctionInvocation(ExistFunction.FUNCTION_NAME, 1));
            subqueryExpression.accept(this);
            if (predicate.isNegated()) {
                sb.append(",1");
            }
            sb.append(")");
        }
    } else {
        super.visit(predicate);
    }
}

Example 4 with SubqueryExpression

use of com.blazebit.persistence.parser.expression.SubqueryExpression in project blaze-persistence by Blazebit.

the class SelectManager method wrapPlainParameters.

public void wrapPlainParameters() {
    boolean needsCastParameters = queryBuilder.mainQuery.dbmsDialect.needsCastParameters();
    for (int i = 0; i < selectInfos.size(); i++) {
        SelectInfo selectInfo = selectInfos.get(i);
        final Expression expression = selectInfo.getExpression();
        if (expression instanceof ParameterExpression) {
            String parameterName = ((ParameterExpression) expression).getName();
            ParameterManager.ParameterImpl<?> parameter = parameterManager.getParameter(parameterName);
            Object boundValue = parameter.getValue();
            Class<?> elementType;
            if (parameter.getParameterType() == null) {
                if (boundValue == null) {
                    throw new IllegalArgumentException("Can't use the parameter with name '" + parameterName + "' as plain SELECT item with a null value!");
                }
                ParameterManager.ParameterValue parameterValue = parameter.getParameterValue();
                if (parameterValue == null) {
                    elementType = boundValue.getClass();
                } else {
                    elementType = parameterValue.getValueType();
                }
            } else {
                elementType = parameter.getParameterType();
            }
            if (BasicCastTypes.TYPES.contains(elementType) && needsCastParameters) {
                // We also need a cast for parameter expressions except in the SET clause
                List<Expression> arguments = new ArrayList<>(2);
                arguments.add(expression);
                arguments.add(new StringLiteral(mainQuery.dbmsDialect.getSqlType(elementType)));
                selectInfo.set(new FunctionExpression("CAST_" + elementType.getSimpleName(), arguments, expression));
            } else {
                final EntityMetamodelImpl.AttributeExample attributeExample = mainQuery.metamodel.getBasicTypeExampleAttributes().get(elementType);
                if (attributeExample == null) {
                    throw new IllegalArgumentException("Can't use the parameter with name '" + parameterName + "', type '" + elementType.getName() + "' and value '" + boundValue + "' as plain SELECT item because there is no example attribute with that type in the JPA model providing the SQL type!");
                }
                List<Expression> arguments = new ArrayList<>(2);
                arguments.add(new SubqueryExpression(new Subquery() {

                    @Override
                    public String getQueryString() {
                        return attributeExample.getExampleJpql() + expression;
                    }
                }));
                if (needsCastParameters && attributeExample.getAttribute().getColumnTypes().length != 0) {
                    arguments.add(new StringLiteral(attributeExample.getAttribute().getColumnTypes()[0]));
                }
                selectInfo.set(new FunctionExpression(ParamFunction.FUNCTION_NAME, arguments, expression));
            }
        }
    }
}

Example 5 with SubqueryExpression

use of com.blazebit.persistence.parser.expression.SubqueryExpression in project blaze-persistence by Blazebit.

the class SelectManager method addJpqlFunctionProcessor.

private void addJpqlFunctionProcessor(Expression expr, int index) {
    if (expr instanceof FunctionExpression) {
        String functionName = ((FunctionExpression) expr).getFunctionName().toLowerCase();
        JpqlFunction jpqlFunction = mainQuery.cbf.getRegisteredFunctions().get(functionName);
        if (jpqlFunction instanceof JpqlFunctionProcessor<?>) {
            jpqlFunctionProcessors.put(index, (JpqlFunctionProcessor<?>) jpqlFunction);
            if ("to_multiset".equals(functionName)) {
                Subquery subquery = ((SubqueryExpression) ((FunctionExpression) expr).getExpressions().get(0)).getSubquery();
                if (subquery instanceof SubqueryInternalBuilder<?>) {
                    SubqueryInternalBuilder<?> subqueryInternalBuilder = (SubqueryInternalBuilder<?>) subquery;
                    jpqlFunctionProcessors.put(index, new NestedToMultisetJpqlFunctionProcessor((JpqlFunctionProcessor<?>) jpqlFunction, subqueryInternalBuilder.getJpqlFunctionProcessors(), subqueryInternalBuilder.getSelectExpressions()));
                }
            }
        }
    } else if (expr instanceof SubqueryExpression) {
        Subquery subquery = ((SubqueryExpression) expr).getSubquery();
        if (subquery instanceof SubqueryInternalBuilder<?>) {
            SubqueryInternalBuilder<?> subqueryInternalBuilder = (SubqueryInternalBuilder<?>) subquery;
            if (!subqueryInternalBuilder.getJpqlFunctionProcessors().isEmpty()) {
                jpqlFunctionProcessors.put(index, subqueryInternalBuilder.getJpqlFunctionProcessors().get(0));
            }
        }
    }
}