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

Example 1 with PathElementExpression

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

the class JoinManager method implicitJoin.

private JoinResult implicitJoin(JoinNode current, List<String> resultFields, PathExpression pathExpression, ClauseType fromClause, JoinType joinType, JoinNode currentJoinNode, Set<String> currentlyResolvingAliases, int start, int end, boolean allowParentAliases, boolean joinAllowed, boolean singularJoinAllowed, boolean idRemovable) {
    List<PathElementExpression> pathElements = pathExpression.getExpressions();
    PathElementExpression elementExpr;
    int singleValuedAssociationNameStartIndex = -1;
    int singleValuedAssociationNameEndIndex = -1;
    for (int i = start; i < end; i++) {
        AliasInfo aliasInfo;
        elementExpr = pathElements.get(i);
        if (elementExpr instanceof ArrayExpression) {
            ArrayExpression arrayExpr = (ArrayExpression) elementExpr;
            String joinRelationName;
            List<String> joinRelationAttributes;
            if (!resultFields.isEmpty()) {
                resultFields.add(arrayExpr.getBase().toString());
                joinRelationAttributes = resultFields;
                resultFields = new ArrayList<>();
                joinRelationName = StringUtils.join(".", joinRelationAttributes);
            } else {
                joinRelationName = arrayExpr.getBase().toString();
                joinRelationAttributes = Arrays.asList(joinRelationName);
            }
            current = current == null ? getRootNodeOrFail("Ambiguous join path [", joinRelationName, "] because of multiple root nodes!") : current;
            implicitJoinIndex(arrayExpr);
            // Find a node by a predicate match
            JoinNode matchingNode = findNode(current, joinRelationName, arrayExpr);
            if (matchingNode != null) {
                current = matchingNode;
            } else if (i == 0 && (aliasInfo = aliasManager.getAliasInfoForBottomLevel(joinRelationName)) != null) {
                // The first node is allowed to be a join alias
                if (aliasInfo instanceof SelectInfo) {
                    throw new IllegalArgumentException("Illegal reference to the select alias '" + joinRelationName + "'");
                }
                current = ((JoinAliasInfo) aliasInfo).getJoinNode();
                generateAndApplyOnPredicate(current, arrayExpr);
            } else {
                String joinAlias = getJoinAlias(arrayExpr);
                if (arrayExpr.getBase() instanceof PropertyExpression) {
                    final JoinResult result = createOrUpdateNode(current, joinRelationAttributes, null, joinAlias, joinType, currentJoinNode, true, false, joinAllowed, singularJoinAllowed);
                    current = result.baseNode;
                    resultFields = result.addToList(resultFields);
                } else {
                    joinAlias = aliasManager.generateJoinAlias(joinAlias);
                    Class<?> entityClass = ((EntityLiteral) arrayExpr.getBase()).getValue();
                    joinOn(null, current.getAlias(), entityClass, joinAlias, JoinType.LEFT, false).end();
                    current = ((JoinAliasInfo) aliasManager.getAliasInfo(joinAlias)).getJoinNode();
                }
                generateAndApplyOnPredicate(current, arrayExpr);
            }
        } else if (elementExpr instanceof TreatExpression) {
            if (i != 0 || current != null) {
                throw new IllegalArgumentException("A treat expression should be the first element in a path!");
            }
            TreatExpression treatExpression = (TreatExpression) elementExpr;
            boolean fromSubquery = false;
            boolean fromSelectAlias = false;
            boolean joinRequired = false;
            boolean fetch = false;
            current = implicitJoinTreatExpression((TreatExpression) elementExpr, joinAllowed, singularJoinAllowed, fromClause, joinType, currentJoinNode, currentlyResolvingAliases, fromSubquery, fromSelectAlias, true, false, fetch, false);
        } else if (elementExpr instanceof MapKeyExpression) {
            MapKeyExpression mapKeyExpression = (MapKeyExpression) elementExpr;
            boolean fromSubquery = false;
            boolean fromSelectAlias = false;
            boolean joinRequired = true;
            boolean fetch = false;
            current = joinMapKey(mapKeyExpression, null, fromClause, currentlyResolvingAliases, fromSubquery, fromSelectAlias, joinRequired, fetch, true, true);
        } else if (elementExpr instanceof MapValueExpression) {
            MapValueExpression mapValueExpression = (MapValueExpression) elementExpr;
            boolean fromSubquery = false;
            boolean fromSelectAlias = false;
            boolean joinRequired = true;
            boolean fetch = false;
            implicitJoin(mapValueExpression.getPath(), joinAllowed, singularJoinAllowed, true, null, fromClause, currentlyResolvingAliases, fromSubquery, fromSelectAlias, joinRequired, fetch);
            current = (JoinNode) mapValueExpression.getPath().getBaseNode();
        } else if (pathElements.size() == 1 && (aliasInfo = aliasManager.getAliasInfoForBottomLevel(elementExpr.toString())) != null) {
            if (aliasInfo instanceof SelectInfo) {
                throw new IllegalArgumentException("Can't dereference a select alias");
            } else {
                // Join alias usage like in "joinAlias.relationName"
                current = ((JoinAliasInfo) aliasInfo).getJoinNode();
            }
        } else {
            String elementExpressionString = elementExpr.toString();
            if (current == null) {
                // When no base is given, check if the attribute name is an alias
                aliasInfo = allowParentAliases ? aliasManager.getAliasInfo(elementExpressionString) : aliasManager.getAliasInfoForBottomLevel(elementExpressionString);
                if (aliasInfo instanceof JoinAliasInfo) {
                    current = ((JoinAliasInfo) aliasInfo).getJoinNode();
                    // We can only "consider" this path a single valued association id when we are about to "remove" the id part
                    if (idRemovable && current.getNodeType() instanceof ManagedType<?> && pathElements.size() == i + 2) {
                        ExtendedManagedType<?> managedType = metamodel.getManagedType(ExtendedManagedType.class, current.getManagedType());
                        if (contains(managedType.getIdAttributes(), pathElements.get(i + 1))) {
                            singleValuedAssociationNameStartIndex = 0;
                            singleValuedAssociationNameEndIndex = 0;
                            break;
                        }
                    }
                    continue;
                } else {
                    current = getRootNodeOrFail("Ambiguous join path [", elementExpressionString, "] because of multiple root nodes!");
                }
            }
            int pathElementsSize = pathElements.size();
            if (joinType != JoinType.INNER && (idRemovable || mainQuery.jpaProvider.supportsSingleValuedAssociationIdExpressions()) && (current.getManagedType().getPersistenceType() != Type.PersistenceType.EMBEDDABLE || current.getValuesLikeAttribute() != null) && i + 1 < pathElementsSize) {
                // If the current type is not an embeddable, we check if the path elements access a singular association id
                List<PathElementExpression> pathElementExpressions = new ArrayList<>(pathElementsSize - i);
                for (int j = i; j < pathElementsSize; j++) {
                    PathElementExpression pathElementExpression = pathElements.get(j);
                    if (!(pathElementExpression instanceof PropertyExpression)) {
                        break;
                    }
                    pathElementExpressions.add(pathElementExpression);
                }
                ExtendedManagedType<?> extendedManagedType = metamodel.getManagedType(ExtendedManagedType.class, current.getManagedType());
                // We collect and check if we have only property expressions
                if (pathElementExpressions.size() == pathElementsSize - i) {
                    // Only if all path elements are property expressions, we check if this is single valued association id
                    PathExpression pathRestExpression = new PathExpression(pathElementExpressions);
                    String pathRestString = pathRestExpression.toString();
                    int idx = 0;
                    ExtendedAttribute<?, ?> extendedAttribute;
                    if (current.getValuesLikeAttribute() == null) {
                        extendedAttribute = extendedManagedType.getOwnedSingularAttributes().get(pathRestString);
                    } else {
                        extendedAttribute = extendedManagedType.getAttributes().get(pathRestString);
                    }
                    if (extendedAttribute != null && !JpaMetamodelUtils.isAssociation(extendedAttribute.getAttribute())) {
                        ExtendedAttribute<?, ?> associationAttribute = null;
                        ExtendedAttribute<?, ?> attr;
                        singleValuedAssociationNameStartIndex = i;
                        List<String> newResultFields = new ArrayList<>();
                        for (int j = i; j < end; j++) {
                            idx = pathRestString.indexOf('.', idx + 1);
                            if (idx != -1 && JpaMetamodelUtils.isAssociation((attr = extendedManagedType.getAttribute(pathRestString.substring(0, idx))).getAttribute())) {
                                associationAttribute = attr;
                                singleValuedAssociationNameEndIndex = j;
                            }
                            newResultFields.add(pathElements.get(j).toString());
                        }
                        if (singleValuedAssociationNameEndIndex == -1) {
                            // The expression ends at an association, so this can't be a single valued association id expression
                            singleValuedAssociationNameStartIndex = -1;
                        } else if (current.getValueType() == null && mainQuery.jpaProvider.isForeignJoinColumn((EntityType<?>) current.getManagedType(), new PathExpression(pathElements.subList(singleValuedAssociationNameStartIndex, singleValuedAssociationNameEndIndex + 1)).toString()) || current.getValueType() != null && mainQuery.jpaProvider.isForeignJoinColumn(current.getValueType(), current.getValuesLikeAttribute() + "." + new PathExpression(pathElements.subList(singleValuedAssociationNameStartIndex, singleValuedAssociationNameEndIndex + 1)).toString())) {
                            // If the column is "foreign", we can't do any optimizations
                            singleValuedAssociationNameStartIndex = -1;
                        } else if (!mainQuery.jpaProvider.supportsSingleValuedAssociationNaturalIdExpressions() && !contains(metamodel.getManagedType(ExtendedManagedType.class, associationAttribute.getElementClass()), new PathExpression(pathElements.subList(singleValuedAssociationNameEndIndex + 1, pathElementsSize)))) {
                            // If the jpa provider doesn't support any optimizations, we are done
                            singleValuedAssociationNameStartIndex = -1;
                        } else {
                            resultFields.addAll(newResultFields);
                            break;
                        }
                    }
                }
            }
            if (resultFields.isEmpty()) {
                final JoinResult result = implicitJoinSingle(current, elementExpressionString, null, joinType, currentJoinNode, allowParentAliases, joinAllowed, singularJoinAllowed);
                if (current != result.baseNode) {
                    current = result.baseNode;
                }
                resultFields = result.addToList(resultFields);
            } else {
                resultFields.add(elementExpressionString);
                JoinResult currentResult = createOrUpdateNode(current, resultFields, null, null, joinType, currentJoinNode, true, true, joinAllowed, singularJoinAllowed);
                current = currentResult.baseNode;
                if (!currentResult.hasField()) {
                    resultFields.clear();
                }
            }
        }
    }
    if (resultFields.isEmpty()) {
        return new JoinResult(current, null, current == null ? null : current.getNodeType(), singleValuedAssociationNameStartIndex, singleValuedAssociationNameEndIndex);
    } else {
        List<PathElementExpression> pathElementExpressions = new ArrayList<>(resultFields.size());
        for (int i = 0; i < resultFields.size(); i++) {
            pathElementExpressions.add(new PropertyExpression(resultFields.get(i)));
        }
        Expression expression = new PathExpression(pathElementExpressions);
        Type<?> type = JpaUtils.getAttributeForJoining(metamodel, current.getNodeType(), expression, null).getAttributeType();
        return new JoinResult(current, resultFields, type, singleValuedAssociationNameStartIndex, singleValuedAssociationNameEndIndex);
    }
}

Example 2 with PathElementExpression

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

the class JoinManager method getCorrelatedAttribute.

private String getCorrelatedAttribute(PathExpression correlatedAttributeExpr) {
    StringBuilder sb = new StringBuilder();
    List<PathElementExpression> expressions = correlatedAttributeExpr.getExpressions();
    for (int i = 0; i < expressions.size(); i++) {
        if (i != 0) {
            sb.append('.');
        }
        PathElementExpression expr = expressions.get(i);
        if (expr instanceof ArrayExpression) {
            sb.append(((ArrayExpression) expr).getBase());
        } else {
            sb.append(expr);
        }
    }
    return sb.toString();
}

Example 3 with PathElementExpression

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

the class JoinManager method join.

JoinNode join(Expression expr, String alias, JoinType type, boolean fetch, boolean defaultJoin, String deReferenceFunction) {
    PathElementExpression elementExpr;
    String treatType = null;
    JoinResult result;
    JoinNode current;
    if (type == JoinType.FULL) {
        hasFullJoin = true;
    }
    if (expr instanceof PathExpression) {
        PathExpression pathExpression = (PathExpression) expr;
        if (isExternal(pathExpression) || isJoinableSelectAlias(pathExpression, false, false)) {
            throw new IllegalArgumentException("No external path or select alias allowed in join path");
        }
        List<PathElementExpression> pathElements = pathExpression.getExpressions();
        elementExpr = pathElements.get(pathElements.size() - 1);
        result = implicitJoin(null, pathExpression, null, null, null, new HashSet<String>(), 0, pathElements.size() - 1, false, true, true, false);
        current = result.baseNode;
    } else if (expr instanceof QualifiedExpression) {
        elementExpr = (PathElementExpression) expr;
        result = null;
        current = null;
    } else if (expr instanceof TreatExpression) {
        TreatExpression treatExpression = (TreatExpression) expr;
        if (isExternal(treatExpression)) {
            throw new IllegalArgumentException("No external path or select alias allowed in join path");
        }
        Expression expression = treatExpression.getExpression();
        if (expression instanceof PathExpression) {
            PathExpression pathExpression = (PathExpression) expression;
            List<PathElementExpression> pathElements = pathExpression.getExpressions();
            elementExpr = pathElements.get(pathElements.size() - 1);
            result = implicitJoin(null, pathExpression, null, null, null, new HashSet<String>(), 0, pathElements.size() - 1, false, true, true, false);
            current = result.baseNode;
            treatType = treatExpression.getType();
        } else {
            throw new IllegalArgumentException("Unexpected expression type[" + expression.getClass().getSimpleName() + "] in treat expression: " + treatExpression);
        }
    } else {
        throw new IllegalArgumentException("Join path [" + expr + "] is not a path");
    }
    if (elementExpr instanceof ArrayExpression) {
        ArrayExpression arrayExpr = (ArrayExpression) elementExpr;
        implicitJoinIndex(arrayExpr);
        if (arrayExpr.getBase() instanceof PropertyExpression) {
            List<String> resultFields = result.addToList(new ArrayList<String>());
            current = current == null ? getRootNodeOrFail("Could not join path [", expr, "] because it did not use an absolute path but multiple root nodes are available!") : current;
            resultFields.add(arrayExpr.getBase().toString());
            result = createOrUpdateNode(current, resultFields, treatType, alias, type, null, false, defaultJoin, true, true);
        } else {
            Class<?> entityClass = ((EntityLiteral) arrayExpr.getBase()).getValue();
            joinOn(null, rootNodes.get(0).getAlias(), entityClass, alias, JoinType.LEFT, false).end();
            result = new JoinResult(((JoinAliasInfo) aliasManager.getAliasInfo(alias)).getJoinNode());
        }
        generateAndApplyOnPredicate(result.baseNode, arrayExpr);
    } else if (elementExpr instanceof MapKeyExpression) {
        MapKeyExpression mapKeyExpression = (MapKeyExpression) elementExpr;
        boolean fromSubquery = false;
        boolean fromSelectAlias = false;
        boolean joinRequired = true;
        current = joinMapKey(mapKeyExpression, alias, null, new HashSet<String>(), fromSubquery, fromSelectAlias, joinRequired, fetch, false, defaultJoin);
        result = new JoinResult(current);
    } else {
        List<String> joinRelationAttributes = result.addToList(new ArrayList<String>());
        joinRelationAttributes.add(elementExpr.toString());
        current = current == null ? getRootNodeOrFail("Could not join path [", expr, "] because it did not use an absolute path but multiple root nodes are available!") : current;
        result = createOrUpdateNode(current, joinRelationAttributes, treatType, alias, type, null, false, defaultJoin, true, true);
    }
    result.baseNode.setDeReferenceFunction(deReferenceFunction);
    if (fetch) {
        fetchPath(result.baseNode);
    }
    return result.baseNode;
}

Example 4 with PathElementExpression

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

the class JoinManager method implicitJoinIndex.

private void implicitJoinIndex(ArrayExpression arrayExpr) {
    // Array expression predicates get a different root, normal expressions not
    if (arrayExpr.getIndex() instanceof Predicate) {
        // So we have to prefix relative expressions with ArrayExpression.ELEMENT_NAME
        PathElementExpression old = joinVisitor.getRelativeExpressionPrefix();
        try {
            joinVisitor.setRelativeExpressionPrefix(new PropertyExpression(ArrayExpression.ELEMENT_NAME));
            arrayExpr.getIndex().accept(joinVisitor);
        } finally {
            joinVisitor.setRelativeExpressionPrefix(old);
        }
    } else {
        arrayExpr.getIndex().accept(joinVisitor);
    }
}

Example 5 with PathElementExpression

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

the class JoinManager method getArrayExpressionPredicate.

private Predicate getArrayExpressionPredicate(JoinNode joinNode, ArrayExpression arrayExpr) {
    if (arrayExpr.getIndex() instanceof Predicate) {
        return (Predicate) arrayExpr.getIndex();
    } else {
        PathExpression keyPath = new PathExpression(new ArrayList<PathElementExpression>(), true);
        keyPath.getExpressions().add(new PropertyExpression(joinNode.getAliasInfo().getAlias()));
        keyPath.setPathReference(new SimplePathReference(joinNode, null, joinNode.getNodeType()));
        Attribute<?, ?> arrayBaseAttribute = joinNode.getParentTreeNode().getAttribute();
        Expression keyExpression;
        if (arrayBaseAttribute instanceof ListAttribute<?, ?>) {
            keyExpression = new ListIndexExpression(keyPath);
        } else {
            keyExpression = new MapKeyExpression(keyPath);
        }
        return new EqPredicate(keyExpression, arrayExpr.getIndex());
    }
}