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

Example 16 with PathExpression

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

the class SplittingVisitor method visit.

@Override
public Expression visit(PathExpression expression) {
    if (expression.getBaseNode() == null) {
        Expression aliasedExpression = ((SelectInfo) aliasManager.getAliasInfo(expression.toString())).getExpression();
        Expression newExpression = aliasedExpression.accept(this);
        return aliasedExpression == newExpression ? expression : newExpression;
    }
    if (expression == expressionToSplit) {
        List<PathElementExpression> expressions = new ArrayList<>(expression.getExpressions());
        for (String subAttributePart : subAttribute.split("\\.")) {
            expressions.add(new PropertyExpression(subAttributePart));
        }
        String field;
        if (expression.getField() == null) {
            field = subAttribute;
        } else {
            field = expression.getField() + "." + subAttribute;
        }
        JoinNode node = (JoinNode) expression.getBaseNode();
        Class<?> fieldClass = jpaProvider.getJpaMetamodelAccessor().getAttributePath(metamodel, node.getManagedType(), field).getAttributeClass();
        Type<?> fieldType = metamodel.type(fieldClass);
        return new PathExpression(expressions, new SimplePathReference(node, field, fieldType), expression.isUsedInCollectionFunction(), expression.isCollectionQualifiedPath());
    }
    return expression;
}

Example 17 with PathExpression

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

the class AbstractCommonQueryBuilder method getFromByPath.

public JoinNode getFromByPath(String path) {
    if (path == null || path.isEmpty()) {
        JoinNode node = joinManager.getRootNodeOrFail("No or multiple query roots, can't find single root!");
        return node;
    }
    PathExpression pathExpression = expressionFactory.createPathExpression(path);
    joinManager.implicitJoin(pathExpression, true, true, true, null, null, new HashSet<String>(), false, false, true, false);
    // If we expose the path to the outside world, we can't remove it if it is a default select node
    if (pathExpression.getPathReference() != null) {
        selectManager.removeDefaultSelectNode((JoinNode) pathExpression.getBaseNode());
    }
    return (JoinNode) pathExpression.getBaseNode();
}

Example 18 with PathExpression

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

the class SimpleCachingExpressionFactoryTest method testCreateSimpleExpressionCacheWithMacros.

@Test
public void testCreateSimpleExpressionCacheWithMacros() {
    ExpressionFactory ef = new SimpleCachingExpressionFactory(new ExpressionFactoryImpl(new HashMap<String, FunctionKind>(), true, true));
    MacroConfiguration macroConfiguration = MacroConfiguration.of(Collections.singletonMap("my_macro", (MacroFunction) new MacroFunction() {

        @Override
        public Expression apply(List<Expression> expressions) {
            PathExpression p;
            if (expressions.get(0) instanceof PathExpression) {
                p = (PathExpression) expressions.get(0);
            } else {
                p = new PathExpression(new ArrayList<>(Arrays.asList((PathElementExpression) expressions.get(0))));
            }
            p.getExpressions().add(new ArrayExpression(new PropertyExpression("lsls"), new PathExpression(Arrays.<PathElementExpression>asList(new PropertyExpression("a"), new PropertyExpression("b"), new PropertyExpression("c"), new PropertyExpression("d"), new PropertyExpression("e")))));
            return p;
        }

        @Override
        public Object[] getState() {
            return new Object[0];
        }

        @Override
        public boolean supportsCaching() {
            return true;
        }

        @Override
        public int hashCode() {
            return getClass().hashCode();
        }

        @Override
        public boolean equals(Object obj) {
            return obj.getClass() == getClass();
        }
    }));
    String expressionString = "SIZE(my_macro(Hello.world[:hahaha].criteria[1].api)) + SIZE(my_macro(Hello.world[:hahaha].criteria[1].api))";
    Expression expr1 = ef.createSimpleExpression(expressionString, false, true, false, macroConfiguration, null);
    Expression expr2 = ef.createSimpleExpression(expressionString, false, true, false, macroConfiguration, null);
    Assert.assertFalse(expr1 == expr2);
    Assert.assertEquals(expr1, expr2);
}

Example 19 with PathExpression

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

the class CollectionJoinMappingGathererExpressionVisitor method visit.

@Override
public void visit(PathExpression expression) {
    List<PathElementExpression> expressions = expression.getExpressions();
    int size = expressions.size();
    StringBuilder sb = new StringBuilder(size * 10);
    ManagedType<?> t = managedType;
    Attribute<?, ?> jpaAttribute = null;
    for (int i = 0; i < size; i++) {
        String baseName;
        Expression e = expressions.get(i);
        if (e instanceof ArrayExpression) {
            ArrayExpression arrayExpression = (ArrayExpression) e;
            arrayExpression.getIndex().accept(this);
            continue;
        } else {
            baseName = e.toString();
        }
        if (i != 0) {
            sb.append('.');
        }
        sb.append(e.toString());
        try {
            jpaAttribute = t.getAttribute(baseName);
        } catch (IllegalArgumentException ex) {
            // Ignore non existing attributes
            jpaAttribute = null;
        }
        // NOTE: Attribute could be null because this model might contain errors
        if (jpaAttribute != null) {
            t = metamodel.getManagedType(JpaMetamodelUtils.resolveFieldClass(t.getJavaType(), jpaAttribute));
            if (jpaAttribute instanceof PluralAttribute<?, ?, ?>) {
                paths.add(sb.toString());
            }
        }
    }
    if (jpaAttribute instanceof PluralAttribute<?, ?, ?>) {
        paths.add(sb.toString());
    }
}

Example 20 with PathExpression

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

the class JoinManager method addRoot.

String addRoot(String correlationPath, Expression expr, String rootAlias, boolean lateral, boolean implicitCorrelation) {
    PathExpression pathExpression;
    String treatEntityType = null;
    // First we extract the path expression and some parameters from surrounding expressions
    if (expr instanceof PathExpression) {
        pathExpression = (PathExpression) expr;
    } else if (expr instanceof TreatExpression) {
        TreatExpression treatExpression = (TreatExpression) expr;
        Expression expression = treatExpression.getExpression();
        if (expression instanceof PathExpression) {
            pathExpression = (PathExpression) expression;
            treatEntityType = treatExpression.getType();
        } else {
            throw new IllegalArgumentException("Unexpected expression type[" + expression.getClass().getSimpleName() + "] in treat expression: " + treatExpression);
        }
    } else if (expr instanceof FunctionExpression && ExpressionUtils.isOuterFunction((FunctionExpression) expr)) {
        FunctionExpression outerFunctionExpr = (FunctionExpression) expr;
        pathExpression = (PathExpression) outerFunctionExpr.getExpressions().get(0);
    } else {
        throw new IllegalArgumentException("Correlation join path [" + correlationPath + "] is not a valid join path");
    }
    if (isJoinableSelectAlias(pathExpression, false, false)) {
        throw new IllegalArgumentException("No select alias allowed in join path");
    }
    // Correlation is split into 3 phases
    // Phase 1 is determining the correlation basis which must be an alias
    // Phase 2 is determining the correlated attribute which we use in the root node of the subquery
    // Phase 3 is joining the rest of the path and assigning the last join node the given alias
    List<JoinNode> treatedCorrelationNodes = new ArrayList<>();
    List<PathExpression> pathExpressionStack = new ArrayList<>();
    pathExpressionStack.add(pathExpression);
    // Phase 1
    JoinNode correlationParent = null;
    boolean needsCorrelationAttribute = true;
    int start = 0;
    for (int i = 0; i < pathExpressionStack.size(); i++) {
        PathExpression currentPathExpression = pathExpressionStack.get(i);
        List<PathElementExpression> pathElements = currentPathExpression.getExpressions();
        AliasInfo aliasInfo;
        if (pathElements.get(0) instanceof PropertyExpression) {
            if ((aliasInfo = aliasManager.getAliasInfo(pathElements.get(0).toString())) != null) {
                if (aliasInfo instanceof SelectInfo) {
                    if (pathElements.size() != 1) {
                        // We actually allow usage of select aliases in expressions, but JPA doesn't, so we have to resolve them here
                        Expression selectExpr = ((SelectInfo) aliasInfo).getExpression();
                        if (!(selectExpr instanceof PathExpression)) {
                            throw new RuntimeException("The select expression '" + selectExpr.toString() + "' is not a simple path expression! No idea how to implicit join that.");
                        }
                        // join the expression behind a select alias once when it is encountered the first time
                        if (((PathExpression) selectExpr).getBaseNode() == null) {
                            implicitJoin(selectExpr, true, true, true, null, ClauseType.JOIN, null, false, true, true, false);
                        }
                        PathExpression selectPathExpr = (PathExpression) selectExpr;
                        correlationParent = (JoinNode) selectPathExpr.getBaseNode();
                        if (selectPathExpr.getField() != null) {
                            rootAlias += "." + selectPathExpr.getField();
                        }
                        start = 1;
                    } else {
                        // We can't correlate a single select expression
                        return null;
                    }
                } else {
                    correlationParent = ((JoinAliasInfo) aliasInfo).getJoinNode();
                    start = 1;
                }
            } else {
                correlationParent = parent.getRootNodeOrFail("Could not join correlation path [", correlationPath, "] because it did not use an absolute path but multiple root nodes are available!");
            }
        } else if (pathElements.get(0) instanceof TreatExpression) {
            TreatExpression treatExpression = (TreatExpression) pathElements.get(0);
            PathExpression treatExpressionPathExpression = (PathExpression) treatExpression.getExpression();
            if (treatExpressionPathExpression.getExpressions().size() == 1) {
                if ((aliasInfo = aliasManager.getAliasInfo(treatExpressionPathExpression.getExpressions().get(0).toString())) != null) {
                    // Root treat
                    correlationParent = ((JoinAliasInfo) aliasInfo).getJoinNode().getTreatedJoinNode(metamodel.entity(treatExpression.getType()));
                    treatedCorrelationNodes.add(correlationParent);
                    // Use the treated root node as correlation parent
                    start = 1;
                } else {
                    // Treat of an association on a query root
                    correlationParent = parent.getRootNodeOrFail("Could not join correlation path [", correlationPath, "] because it did not use an absolute path but multiple root nodes are available!");
                    pathExpressionStack.add(treatExpressionPathExpression);
                    break;
                }
            } else {
                pathExpressionStack.add(treatExpressionPathExpression);
            }
        } else if (pathElements.get(0) instanceof ArrayExpression && ((ArrayExpression) pathElements.get(0)).getBase() instanceof EntityLiteral) {
            ArrayExpression arrayExpression = (ArrayExpression) pathElements.get(0);
            JoinNode matchingNode = implicitCorrelation ? findNode(null, null, arrayExpression) : null;
            if (matchingNode == null) {
                rootAlias = addRoot(metamodel.entity(((EntityLiteral) arrayExpression.getBase()).getValue()), rootAlias, lateral && pathElements.size() == 1);
                correlationParent = ((JoinAliasInfo) aliasManager.getAliasInfo(rootAlias)).getJoinNode();
                // This is only necessary in the CTE query where the lateral flag is set to false
                if (!lateral) {
                    implicitJoinIndex(arrayExpression);
                    generateAndApplyOnPredicate(correlationParent, arrayExpression);
                }
            } else {
                rootAlias = matchingNode.getAliasExpression();
                correlationParent = matchingNode;
            }
            start = 1;
            needsCorrelationAttribute = false;
        } else if (pathElements.get(0) instanceof ArrayExpression) {
            correlationParent = parent.getRootNodeOrFail("Could not join correlation path [", correlationPath, "] because it did not use an absolute path but multiple root nodes are available!");
        } else {
            throw new IllegalArgumentException("The correlation path '" + correlationPath + "' couldn't be properly analyzed because of an unsupported expression structure!");
        }
    }
    // Phase 2
    PathExpression currentPathExpression = pathExpressionStack.remove(pathExpressionStack.size() - 1);
    List<PathElementExpression> pathElements = currentPathExpression.getExpressions();
    int correlatedAttributeIndex = findCorrelatedAttributeIndex(correlationParent, pathElements, start, pathElements.size());
    if (correlatedAttributeIndex == -1) {
        if (needsCorrelationAttribute) {
            if (!implicitCorrelation) {
                throw new IllegalArgumentException("The correlation path '" + correlationPath + "' does not contain an attribute that can be correlated!");
            } else {
                return null;
            }
        }
        return rootAlias;
    }
    Expression correlatedAttributeExpr;
    String correlatedAttribute;
    if (start == correlatedAttributeIndex) {
        correlatedAttributeExpr = pathElements.get(start);
        correlatedAttribute = getCorrelatedAttribute(new PathExpression(pathElements.subList(start, correlatedAttributeIndex + 1)));
    } else {
        correlatedAttributeExpr = new PathExpression(pathElements.subList(start, correlatedAttributeIndex + 1));
        correlatedAttribute = getCorrelatedAttribute((PathExpression) correlatedAttributeExpr);
        start += correlatedAttributeIndex - start;
    }
    // Phase 3
    final JoinNode rootNode;
    if (pathExpressionStack.isEmpty() && start + 1 == pathElements.size()) {
        // This is a simple path to an association, no deep expression that requires implicit joining
        JoinNode matchingNode = null;
        if (implicitCorrelation) {
            JoinTreeNode existingNode = correlationParent.getNodes().get(correlatedAttribute);
            if (existingNode != null && existingNode.getDefaultNode() != null) {
                matchingNode = existingNode.getDefaultNode();
            }
        }
        if (matchingNode == null) {
            rootNode = correlate(new JoinResult(correlationParent), rootAlias, correlatedAttributeExpr, metamodel.getEntity(treatEntityType), true, lateral, implicitCorrelation).baseNode;
            rootAlias = rootNode.getAliasExpression();
        } else {
            // Try reusing an existing join
            rootNode = matchingNode;
            rootAlias = matchingNode.getAliasExpression();
        }
    } else {
        JoinNode matchingNode = null;
        if (implicitCorrelation) {
            String path;
            if (correlationParent.getAliasInfo() instanceof TreatedJoinAliasInfo) {
                path = ((TreatedJoinAliasInfo) correlationParent.getAliasInfo()).getTreatedJoinNode().getAliasInfo().getAbsolutePath();
            } else {
                path = correlationParent.getAliasInfo().getAbsolutePath();
            }
            String correlationBaseAlias = (path + "_" + correlatedAttribute).replace('.', '_') + "_base";
            for (int i = 0; i < rootNodes.size(); i++) {
                JoinNode node = rootNodes.get(i);
                if (node.getAliasInfo().isImplicit()) {
                    if (node.getCorrelationParent() == correlationParent && correlatedAttribute.equals(node.getCorrelationPath())) {
                        matchingNode = node;
                        break;
                    } else if (node.getOnPredicate() != null && correlationBaseAlias.equals(node.getAlias())) {
                        matchingNode = node;
                        start--;
                        break;
                    }
                }
            }
        }
        if (matchingNode == null) {
            // This is a simple path to an association, no deep expression that requires implicit joining
            JoinTreeNode existingNode = correlationParent.getNodes().get(correlatedAttribute);
            if (!implicitCorrelation || existingNode == null || existingNode.getDefaultNode() == null) {
                if (isSingleValuedAssociationId(correlationParent, currentPathExpression, start)) {
                    return correlationParent.getAliasExpression() + "." + new PathExpression(pathElements.subList(start, pathElements.size()));
                }
                rootNode = correlate(new JoinResult(correlationParent), rootAlias, correlatedAttributeExpr, null, false, lateral, implicitCorrelation).baseNode;
            } else {
                // Try reusing an existing join
                rootNode = existingNode.getDefaultNode();
            }
        } else {
            rootNode = matchingNode;
        }
        // We correlate or reuse a join for the current position, so increment
        start++;
        JoinResult result = new JoinResult(rootNode);
        if (pathExpressionStack.size() > 0) {
            // Implicit join the rest of the current level
            pathExpressionStack.add(currentPathExpression);
            while (pathExpressionStack.size() > 1) {
                currentPathExpression = pathExpressionStack.remove(pathExpressionStack.size() - 1);
                pathElements = currentPathExpression.getExpressions();
                for (; start < pathElements.size(); start++) {
                    PathElementExpression pathElementExpression = pathElements.get(start);
                    if (pathElementExpression instanceof TreatExpression) {
                        TreatExpression treatExpression = (TreatExpression) pathElementExpression;
                        EntityType<?> treatType = metamodel.entity(treatExpression.getType());
                        JoinNode treatedNode = result.baseNode.getTreatedJoinNode(treatType);
                        treatedCorrelationNodes.add(treatedNode);
                        // We just implicit join the rest of the expression
                        result = implicitJoin(treatedNode, currentPathExpression, null, implicitCorrelation ? JoinType.LEFT : JoinType.INNER, null, new HashSet<String>(), start + 1, pathElements.size(), true, true, true, false);
                        start = pathElements.size();
                    } else {
                        JoinTreeNode existingNode = correlationParent.getNodes().get(((PropertyExpression) pathElementExpression).getProperty());
                        if (existingNode == null || existingNode.getDefaultNode() == null) {
                            break;
                        }
                        result = new JoinResult(existingNode.getDefaultNode());
                    }
                }
                if (result.baseNode.getAliasInfo().getAliasOwner() != aliasManager && start + 1 < pathElements.size() - 1) {
                    result = correlate(result, rootAlias, pathElements.get(start), null, false, lateral, implicitCorrelation);
                    start++;
                }
                result = implicitJoin(result.baseNode, currentPathExpression, null, implicitCorrelation ? JoinType.LEFT : JoinType.INNER, null, new HashSet<String>(), start, pathElements.size(), true, true, true, false);
                // Reset start
                start = 0;
            }
            // At the end of treat processing, we are at index 1
            start = 1;
        }
        if (pathExpressionStack.size() > 0) {
            currentPathExpression = pathExpressionStack.remove(0);
            pathElements = currentPathExpression.getExpressions();
            // This can only be a treat expression
            TreatExpression treatExpression = (TreatExpression) pathElements.get(0);
            EntityType<?> treatType = metamodel.entity(treatExpression.getType());
            JoinNode treatedNode = result.baseNode.getTreatedJoinNode(treatType);
            treatedCorrelationNodes.add(treatedNode);
            result = new JoinResult(treatedNode, null, treatType, -1, -1);
            // Reset start
            start = 1;
        }
        pathElements = currentPathExpression.getExpressions();
        Expression elementExpr = pathElements.get(pathElements.size() - 1);
        while (result.baseNode.getAliasInfo().getAliasOwner() != aliasManager && start < pathElements.size() - 1) {
            if (isSingleValuedAssociationId(result.baseNode, currentPathExpression, start)) {
                return result.baseNode.getAliasExpression() + "." + new PathExpression(pathElements.subList(start, pathElements.size()));
            }
            JoinNode defaultJoin = result.baseNode.getDefaultJoin(pathElements, start - result.fieldCount(), start);
            if (defaultJoin == null) {
                result = correlate(result, rootAlias, pathElements.get(start), null, false, lateral, implicitCorrelation);
            } else {
                result = new JoinResult(defaultJoin);
            }
            start++;
        }
        result = implicitJoin(result.baseNode, currentPathExpression, null, implicitCorrelation ? JoinType.LEFT : JoinType.INNER, null, new HashSet<String>(), start, pathElements.size() - 1, true, true, true, false);
        JoinResult finalNode;
        if (pathExpression.isUsedInCollectionFunction()) {
            JoinNode current = result.baseNode;
            List<String> resultFields = result.fields;
            if (result.hasField()) {
                resultFields.add(elementExpr.toString());
                String attributeName = StringUtils.join(".", resultFields);
                finalNode = new JoinResult(current, resultFields, getPathType(current.getNodeType(), attributeName, pathExpression), -1, -1);
            } else {
                String attributeName = elementExpr.toString();
                finalNode = new JoinResult(current, Arrays.asList(attributeName), getPathType(current.getNodeType(), attributeName, pathExpression), -1, -1);
            }
        } else {
            if (result.hasField()) {
                start = pathElements.size() - 1 - result.fields.size();
            } else {
                start = pathElements.size() - 1;
            }
            if (result.baseNode.getAliasInfo().getAliasOwner() != aliasManager) {
                Expression finalExpression;
                if (result.hasField()) {
                    finalExpression = new PathExpression(pathElements.subList(start, pathElements.size()));
                } else {
                    finalExpression = pathElements.get(start);
                }
                if (isJoinable(result, finalExpression)) {
                    finalNode = correlate(result, rootAlias, finalExpression, null, true, lateral, implicitCorrelation);
                } else {
                    finalNode = result.withField(((PropertyExpression) finalExpression).getProperty());
                }
            } else {
                finalNode = implicitJoin(result.baseNode, pathExpression, null, implicitCorrelation ? JoinType.LEFT : JoinType.INNER, null, new HashSet<String>(), start, pathElements.size(), true, true, true, false);
            }
            if (implicitCorrelation) {
                rootAlias = finalNode.baseNode.getAliasExpression();
            } else {
                aliasManager.unregisterAliasInfoForBottomLevel(finalNode.baseNode.getAliasInfo());
                finalNode.baseNode.getAliasInfo().setAlias(rootAlias);
                aliasManager.registerAliasInfo(finalNode.baseNode.getAliasInfo());
            }
        }
        if (treatEntityType != null) {
            treatedCorrelationNodes.add(finalNode.baseNode);
        }
        if (implicitCorrelation) {
            if (finalNode.hasField()) {
                rootAlias = finalNode.baseNode.getAliasExpression() + "." + finalNode.joinFields();
            }
        } else {
            finalNode.baseNode.getAliasInfo().setImplicit(false);
            explicitJoinNodes.add(finalNode.baseNode);
        }
    }
    if (!treatedCorrelationNodes.isEmpty()) {
        rootNode.setJoinNodesNeedingTreatConjunct(treatedCorrelationNodes);
    }
    return rootAlias;
}