Examples with LogicalVertex com.alibaba.maxgraph.compiler.logical.LogicalVertex used on opensource projects

Example 1 with LogicalVertex

use of com.alibaba.maxgraph.compiler.logical.LogicalVertex in project GraphScope by alibaba.

the class OptionalTreeNode method buildLogicalQueryPlan.

@Override
public LogicalSubQueryPlan buildLogicalQueryPlan(ContextManager contextManager) {
    LogicalSubQueryPlan logicalQueryPlan = new LogicalSubQueryPlan(contextManager);
    LogicalVertex sourceVertex = getInputNode().getOutputVertex();
    logicalQueryPlan.addLogicalVertex(sourceVertex);
    LogicalVertex trueVertex = TreeNodeUtils.buildFilterTreeNode(this.branchTreeNode, contextManager, logicalQueryPlan, sourceVertex, schema);
    ProcessorFunction joinFilterRightFunction = new ProcessorFunction(QueryFlowOuterClass.OperatorType.JOIN_DIRECT_FILTER_NEGATE);
    LogicalEdge leftEdge = getInputNode().isPropLocalFlag() ? new LogicalEdge(EdgeShuffleType.FORWARD) : new LogicalEdge(EdgeShuffleType.SHUFFLE_BY_KEY);
    LogicalBinaryVertex falseVertex = new LogicalBinaryVertex(contextManager.getVertexIdManager().getId(), joinFilterRightFunction, getInputNode().isPropLocalFlag(), sourceVertex, trueVertex);
    logicalQueryPlan.addLogicalVertex(falseVertex);
    logicalQueryPlan.addLogicalEdge(sourceVertex, falseVertex, leftEdge);
    logicalQueryPlan.addLogicalEdge(trueVertex, falseVertex, new LogicalEdge(EdgeShuffleType.SHUFFLE_BY_KEY));
    LogicalQueryPlan truePlan = TreeNodeUtils.buildSubQueryPlan(this.trueNode, trueVertex, contextManager);
    LogicalVertex trueOutputVertex = truePlan.getOutputVertex();
    LogicalQueryPlan falsePlan = TreeNodeUtils.buildSubQueryPlan(this.falseNode, falseVertex, contextManager);
    LogicalVertex falseOutputVertex = falsePlan.getOutputVertex();
    logicalQueryPlan.mergeLogicalQueryPlan(truePlan);
    logicalQueryPlan.mergeLogicalQueryPlan(falsePlan);
    LogicalBinaryVertex unionVertex = new LogicalBinaryVertex(contextManager.getVertexIdManager().getId(), new ProcessorFunction(QueryFlowOuterClass.OperatorType.UNION), false, trueOutputVertex, falseOutputVertex);
    logicalQueryPlan.addLogicalVertex(unionVertex);
    logicalQueryPlan.addLogicalEdge(trueOutputVertex, unionVertex, new LogicalEdge(EdgeShuffleType.FORWARD));
    logicalQueryPlan.addLogicalEdge(falseOutputVertex, unionVertex, new LogicalEdge(EdgeShuffleType.FORWARD));
    setFinishVertex(unionVertex, contextManager.getTreeNodeLabelManager());
    addUsedLabelAndRequirement(unionVertex, contextManager.getTreeNodeLabelManager());
    return logicalQueryPlan;
}

Example 2 with LogicalVertex

use of com.alibaba.maxgraph.compiler.logical.LogicalVertex in project GraphScope by alibaba.

the class OrderGlobalTreeNode method buildLogicalQueryPlan.

@Override
public LogicalSubQueryPlan buildLogicalQueryPlan(ContextManager contextManager) {
    LogicalSubQueryPlan logicalSubQueryPlan = new LogicalSubQueryPlan(contextManager);
    LogicalVertex delegateSourceVertex = getInputNode().getOutputVertex();
    logicalSubQueryPlan.addLogicalVertex(delegateSourceVertex);
    TreeNodeLabelManager labelManager = contextManager.getTreeNodeLabelManager();
    VertexIdManager vertexIdManager = contextManager.getVertexIdManager();
    Message.OrderComparatorList.Builder comparatorList = Message.OrderComparatorList.newBuilder();
    Set<String> propFillList = Sets.newHashSet();
    Set<Integer> usedLabelIdList = Sets.newHashSet();
    LogicalVertex lastJoinVertex = null;
    LogicalVertex inputVertex = delegateSourceVertex;
    for (int i = 0; i < treeNodeOrderList.size(); i++) {
        Pair<TreeNode, Order> orderPair = treeNodeOrderList.get(i);
        if (orderPair.getLeft() instanceof SourceDelegateNode) {
            comparatorList.addOrderComparator(Message.OrderComparator.newBuilder().setPropId(0).setOrderType(Message.OrderType.valueOf(StringUtils.upperCase(orderPair.getRight().name()))).build());
        } else {
            UnaryTreeNode unaryTreeNode = UnaryTreeNode.class.cast(orderPair.getLeft());
            if (unaryTreeNode.getInputNode() instanceof SourceDelegateNode && ((unaryTreeNode instanceof SelectOneTreeNode && SelectOneTreeNode.class.cast(unaryTreeNode).getTraversalTreeNode() == null) || (unaryTreeNode instanceof ElementValueTreeNode && ElementValueTreeNode.class.cast(unaryTreeNode).getByPassTraversal() == null) || unaryTreeNode instanceof TokenTreeNode || (unaryTreeNode instanceof TraversalMapTreeNode && ((TraversalMapTreeNode) unaryTreeNode).getTraversalNode() instanceof ColumnTreeNode && ((ColumnTreeNode) ((TraversalMapTreeNode) unaryTreeNode).getTraversalNode()).getInputNode() instanceof SourceDelegateNode))) {
                if (unaryTreeNode instanceof SelectOneTreeNode) {
                    int labelId = labelManager.getLabelIndex(SelectOneTreeNode.class.cast(unaryTreeNode).getSelectLabel());
                    comparatorList.addOrderComparator(Message.OrderComparator.newBuilder().setPropId(labelId).setOrderType(Message.OrderType.valueOf(StringUtils.upperCase(orderPair.getRight().name()))).build());
                    usedLabelIdList.add(labelId);
                } else if (unaryTreeNode instanceof TokenTreeNode) {
                    int labelId = labelManager.getLabelIndex(TokenTreeNode.class.cast(unaryTreeNode).getToken().getAccessor());
                    comparatorList.addOrderComparator(Message.OrderComparator.newBuilder().setPropId(labelId).setOrderType(Message.OrderType.valueOf(StringUtils.upperCase(orderPair.getRight().name()))).build());
                } else if (unaryTreeNode instanceof ElementValueTreeNode) {
                    String propKey = ElementValueTreeNode.class.cast(unaryTreeNode).getPropKeyList().iterator().next();
                    propFillList.add(propKey);
                    comparatorList.addOrderComparator(Message.OrderComparator.newBuilder().setPropId(CompilerUtils.getPropertyId(schema, propKey)).setOrderType(Message.OrderType.valueOf(StringUtils.upperCase(orderPair.getRight().name()))).build());
                } else {
                    TraversalMapTreeNode traversalMapTreeNode = TraversalMapTreeNode.class.cast(unaryTreeNode);
                    ColumnTreeNode columnTreeNode = (ColumnTreeNode) traversalMapTreeNode.getTraversalNode();
                    comparatorList.addOrderComparator(Message.OrderComparator.newBuilder().setPropId(labelManager.getLabelIndex(columnTreeNode.getColumn().name())).setOrderType(Message.OrderType.valueOf(StringUtils.upperCase(orderPair.getRight().name()))).build());
                }
            } else {
                TreeNode compareTreeNode = TreeNodeUtils.buildSingleOutputNode(orderPair.getLeft(), schema);
                Pair<LogicalQueryPlan, Integer> planLabelPair = TreeNodeUtils.buildSubQueryWithLabel(compareTreeNode, inputVertex, contextManager);
                inputVertex = planLabelPair.getLeft().getOutputVertex();
                logicalSubQueryPlan.mergeLogicalQueryPlan(planLabelPair.getLeft());
                comparatorList.addOrderComparator(Message.OrderComparator.newBuilder().setPropId(planLabelPair.getRight()).setOrderType(Message.OrderType.valueOf(StringUtils.upperCase(orderPair.getRight().name()))).build());
                usedLabelIdList.add(planLabelPair.getRight());
            }
        }
    }
    if (!propFillList.isEmpty() && getInputNode().getOutputValueType() instanceof VertexValueType) {
        LogicalVertex propFillInputVertex = logicalSubQueryPlan.getOutputVertex();
        ProcessorFunction propFillFunction = new ProcessorFunction(QueryFlowOuterClass.OperatorType.PROP_FILL, Message.Value.newBuilder().addAllIntValueList(propFillList.stream().map(v -> CompilerUtils.getPropertyId(schema, v)).collect(Collectors.toSet())));
        LogicalVertex propFillVertex = new LogicalUnaryVertex(vertexIdManager.getId(), propFillFunction, true, propFillInputVertex);
        LogicalEdge logicalEdge;
        if (propFillInputVertex.isPropLocalFlag()) {
            logicalEdge = new LogicalEdge(EdgeShuffleType.FORWARD);
        } else {
            logicalEdge = new LogicalEdge(EdgeShuffleType.SHUFFLE_BY_KEY);
        }
        logicalSubQueryPlan.addLogicalVertex(propFillVertex);
        logicalSubQueryPlan.addLogicalEdge(propFillInputVertex, propFillVertex, logicalEdge);
    }
    Message.Value.Builder argumentBuilder = Message.Value.newBuilder().setPayload(comparatorList.build().toByteString());
    if (orderFlag) {
        argumentBuilder.setBoolValue(true).setIntValue(labelManager.getLabelIndex(orderFlagLabel));
    }
    argumentBuilder.setBoolFlag(partitionIdFlag).setLongValue(SHUFFLE_THRESHOLD).setOrderFlag(orderKeyFlag);
    ProcessorFunction orderFunction = new ProcessorFunction(QueryFlowOuterClass.OperatorType.ORDER, argumentBuilder, rangeLimit);
    orderFunction.getUsedLabelList().addAll(usedLabelIdList);
    LogicalVertex outputVertex = logicalSubQueryPlan.getOutputVertex();
    LogicalVertex orderVertex = new LogicalUnaryVertex(vertexIdManager.getId(), orderFunction, false, outputVertex);
    logicalSubQueryPlan.addLogicalVertex(orderVertex);
    logicalSubQueryPlan.addLogicalEdge(outputVertex, orderVertex, new LogicalEdge());
    addUsedLabelAndRequirement(orderVertex, labelManager);
    setFinishVertex(orderVertex, labelManager);
    return logicalSubQueryPlan;
}

Example 3 with LogicalVertex

use of com.alibaba.maxgraph.compiler.logical.LogicalVertex in project GraphScope by alibaba.

the class OutputTreeNode method buildLogicalQueryPlan.

@Override
public LogicalSubQueryPlan buildLogicalQueryPlan(ContextManager contextManager) {
    TreeNodeLabelManager labelManager = contextManager.getTreeNodeLabelManager();
    VertexIdManager vertexIdManager = contextManager.getVertexIdManager();
    Builder odpsConfigBuilder = buildArg();
    for (String propName : properties) {
        odpsConfigBuilder.addPropId(SchemaUtils.getPropId(propName, schema));
    }
    Message.Value.Builder argumentBuilder = Message.Value.newBuilder().setPayload(odpsConfigBuilder.build().toByteString());
    ProcessorFunction processorFunction = new ProcessorFunction(QueryFlowOuterClass.OperatorType.WRITE_ODPS, argumentBuilder);
    LogicalSubQueryPlan logicalSubQueryPlan = parseSingleUnaryVertex(vertexIdManager, labelManager, processorFunction, contextManager);
    LogicalVertex outputVertex = logicalSubQueryPlan.getOutputVertex();
    ProcessorFunction sumFunction = new ProcessorFunction(QueryFlowOuterClass.OperatorType.SUM, Message.Value.newBuilder().setValueType(Message.VariantType.VT_LONG));
    LogicalVertex sumVertex = new LogicalUnaryVertex(vertexIdManager.getId(), sumFunction, true, outputVertex);
    logicalSubQueryPlan.addLogicalVertex(sumVertex);
    logicalSubQueryPlan.addLogicalEdge(outputVertex, sumVertex, new LogicalEdge(EdgeShuffleType.SHUFFLE_BY_CONST));
    addUsedLabelAndRequirement(sumVertex, labelManager);
    setFinishVertex(sumVertex, labelManager);
    return logicalSubQueryPlan;
}

Example 4 with LogicalVertex

use of com.alibaba.maxgraph.compiler.logical.LogicalVertex in project GraphScope by alibaba.

the class CountGlobalTreeNode method buildLogicalQueryPlan.

@Override
public LogicalSubQueryPlan buildLogicalQueryPlan(ContextManager contextManager) {
    LogicalSubQueryPlan logicalSubQueryPlan = new LogicalSubQueryPlan(contextManager);
    LogicalVertex sourceVertex = getInputNode().getOutputVertex();
    logicalSubQueryPlan.addLogicalVertex(sourceVertex);
    QueryFlowOuterClass.OperatorType operatorType = getUseKeyOperator(QueryFlowOuterClass.OperatorType.COUNT);
    QueryFlowOuterClass.CountArgumentProto countArgument = QueryFlowOuterClass.CountArgumentProto.newBuilder().setLimitFlag(limitFlag).setLimitCount(limitCount).build();
    ProcessorFunction countFunction = new ProcessorFunction(operatorType, Message.Value.newBuilder().setPayload(countArgument.toByteString()));
    LogicalUnaryVertex countVertex = new LogicalUnaryVertex(contextManager.getVertexIdManager().getId(), countFunction, false, sourceVertex);
    logicalSubQueryPlan.addLogicalVertex(countVertex);
    logicalSubQueryPlan.addLogicalEdge(sourceVertex, countVertex, new LogicalEdge());
    LogicalVertex outputVertex = processJoinZeroVertex(contextManager.getVertexIdManager(), logicalSubQueryPlan, countVertex, isJoinZeroFlag());
    setFinishVertex(outputVertex, contextManager.getTreeNodeLabelManager());
    return logicalSubQueryPlan;
}

Example 5 with LogicalVertex

use of com.alibaba.maxgraph.compiler.logical.LogicalVertex in project GraphScope by alibaba.

the class DedupGlobalTreeNode method buildLogicalQueryPlan.

@Override
public LogicalSubQueryPlan buildLogicalQueryPlan(ContextManager contextManager) {
    LogicalSubQueryPlan logicalSubQueryPlan = new LogicalSubQueryPlan(contextManager);
    LogicalVertex sourceVertex = getInputNode().getOutputVertex();
    logicalSubQueryPlan.addLogicalVertex(sourceVertex);
    QueryFlowOuterClass.OperatorType dedupType = getUseKeyOperator(QueryFlowOuterClass.OperatorType.DEDUP);
    if (null == dedupTreeNode || dedupTreeNode instanceof SourceDelegateNode) {
        ProcessorFunction dedupFunction = new ProcessorFunction(dedupType);
        LogicalVertex dedupVertex = new LogicalUnaryVertex(contextManager.getVertexIdManager().getId(), dedupFunction, isPropLocalFlag(), sourceVertex);
        logicalSubQueryPlan.addLogicalVertex(dedupVertex);
        logicalSubQueryPlan.addLogicalEdge(sourceVertex, dedupVertex, new LogicalEdge());
    } else {
        UnaryTreeNode unaryDedupTreeNode = UnaryTreeNode.class.cast(dedupTreeNode);
        if (unaryDedupTreeNode.getInputNode() instanceof SourceDelegateNode && ((unaryDedupTreeNode instanceof ElementValueTreeNode && ElementValueTreeNode.class.cast(unaryDedupTreeNode).getByPassTraversal() == null) || unaryDedupTreeNode instanceof SelectOneTreeNode || unaryDedupTreeNode instanceof TokenTreeNode)) {
            // id()/label() has been converted to select one tree node
            Message.Value.Builder argumentBuilder = Message.Value.newBuilder();
            Set<Integer> usedLabelList = Sets.newHashSet();
            if (unaryDedupTreeNode instanceof ElementValueTreeNode) {
                String propKey = ((ElementValueTreeNode) unaryDedupTreeNode).getPropKeyList().iterator().next();
                int propId = SchemaUtils.getPropId(propKey, schema);
                argumentBuilder.setIntValue(propId);
            } else if (unaryDedupTreeNode instanceof TokenTreeNode) {
                T token = ((TokenTreeNode) unaryDedupTreeNode).getToken();
                argumentBuilder.setIntValue(contextManager.getTreeNodeLabelManager().getLabelIndex(token.getAccessor()));
            } else {
                String label = ((SelectOneTreeNode) unaryDedupTreeNode).getSelectLabel();
                argumentBuilder.setIntValue(contextManager.getTreeNodeLabelManager().getLabelIndex(label));
                usedLabelList.add(contextManager.getTreeNodeLabelManager().getLabelIndex(label));
            }
            ProcessorFunction dedupFunction = new ProcessorFunction(dedupType, argumentBuilder);
            LogicalVertex dedupVertex = new LogicalUnaryVertex(contextManager.getVertexIdManager().getId(), dedupFunction, isPropLocalFlag(), sourceVertex);
            logicalSubQueryPlan.addLogicalVertex(dedupVertex);
            logicalSubQueryPlan.addLogicalEdge(sourceVertex, dedupVertex, new LogicalEdge());
        } else {
            TreeNode currentDedupNode = TreeNodeUtils.buildSingleOutputNode(dedupTreeNode, schema);
            Pair<LogicalQueryPlan, Integer> planLabelPair = TreeNodeUtils.buildSubQueryWithLabel(currentDedupNode, sourceVertex, contextManager);
            logicalSubQueryPlan.mergeLogicalQueryPlan(planLabelPair.getLeft());
            LogicalVertex dedupInputVertex = logicalSubQueryPlan.getOutputVertex();
            ProcessorFunction dedupFunction = new ProcessorFunction(dedupType, Message.Value.newBuilder().setIntValue(planLabelPair.getRight()));
            dedupFunction.getUsedLabelList().add(planLabelPair.getRight());
            LogicalVertex dedupVertex = new LogicalUnaryVertex(contextManager.getVertexIdManager().getId(), dedupFunction, isPropLocalFlag(), dedupInputVertex);
            logicalSubQueryPlan.addLogicalVertex(dedupVertex);
            logicalSubQueryPlan.addLogicalEdge(dedupInputVertex, dedupVertex, new LogicalEdge());
        }
    }
    LogicalVertex dedupVertex = logicalSubQueryPlan.getOutputVertex();
    addUsedLabelAndRequirement(dedupVertex, contextManager.getTreeNodeLabelManager());
    setFinishVertex(dedupVertex, contextManager.getTreeNodeLabelManager());
    return logicalSubQueryPlan;
}