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

Example 1 with EntityLiteral

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

the class JoinManager method findNode.

private JoinNode findNode(JoinNode baseNode, String joinRelationName, final ArrayExpression arrayExpression) {
    if (arrayExpression.getBase() instanceof PropertyExpression) {
        if (baseNode == null) {
            for (JoinNode node : rootNodes) {
                Predicate pred = getArrayExpressionPredicate(node, arrayExpression);
                CompoundPredicate compoundPredicate = node.getOnPredicate();
                if (findPredicate(compoundPredicate, pred, node.getAlias())) {
                    return node;
                }
            }
        } else {
            JoinTreeNode treeNode = baseNode.getNodes().get(joinRelationName);
            if (treeNode == null) {
                return null;
            }
            for (JoinNode node : treeNode.getJoinNodes().values()) {
                Predicate pred = getArrayExpressionPredicate(node, arrayExpression);
                CompoundPredicate compoundPredicate = node.getOnPredicate();
                if (findPredicate(compoundPredicate, pred, node.getAlias())) {
                    return node;
                }
            }
        }
    } else {
        final Class<?> entityType = ((EntityLiteral) arrayExpression.getBase()).getValue();
        JoinNode node = null;
        AbortableResultJoinNodeVisitor<Object> visitor = new AbortableResultJoinNodeVisitor<Object>() {

            @Override
            public Object getStopValue() {
                return this;
            }

            @Override
            public Object visit(JoinNode node) {
                if (node.isEntityJoinNode() && entityType == node.getNodeType().getJavaType()) {
                    Predicate pred = getArrayExpressionPredicate(node, arrayExpression);
                    CompoundPredicate compoundPredicate = node.getOnPredicate();
                    if (findPredicate(compoundPredicate, pred, node.getAlias())) {
                        return node;
                    }
                }
                return null;
            }

            @Override
            public int hashCode() {
                return 0;
            }

            // This is a fake implementation for the stopValue
            @Override
            public boolean equals(Object obj) {
                return obj != null;
            }
        };
        for (int i = 0; i < rootNodes.size(); i++) {
            node = (JoinNode) rootNodes.get(i).accept(visitor);
            if (node != null) {
                break;
            }
        }
        return node;
    }
    return null;
}

Example 2 with EntityLiteral

use of com.blazebit.persistence.parser.expression.EntityLiteral 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 3 with EntityLiteral

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

the class TestLiterals method testEntityLiteral1.

@Test
public void testEntityLiteral1() {
    entityTypes.put("Entity", Entity.class);
    entityTypes.put(Entity.class.getName(), Entity.class);
    EntityLiteral result = (EntityLiteral) parse("Entity");
    assertEquals(_entity(Entity.class), result);
}

Example 4 with EntityLiteral

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

the class TestLiterals method testEntityLiteral2.

@Test
public void testEntityLiteral2() {
    entityTypes.put("Entity", Entity.class);
    entityTypes.put(Entity.class.getName(), Entity.class);
    EntityLiteral result = (EntityLiteral) parse(Entity.class.getName());
    assertEquals(_entity(Entity.class), result);
}

Example 5 with EntityLiteral

use of com.blazebit.persistence.parser.expression.EntityLiteral 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;
}