Examples with TreeNodeLabelManager com.alibaba.maxgraph.compiler.tree.TreeNodeLabelManager used on opensource projects

Example 1 with TreeNodeLabelManager

use of com.alibaba.maxgraph.compiler.tree.TreeNodeLabelManager in project GraphScope by alibaba.

the class LogicalPlanBuilder method processCostModel.

private void processCostModel(TreeNode currentNode, LogicalQueryPlan queryPlan, ContextManager contextManager, GraphSchema schema, Set<Integer> labelIdList) {
    CostModelManager costModelManager = contextManager.getCostModelManager();
    TreeNodeLabelManager treeNodeLabelManager = contextManager.getTreeNodeLabelManager();
    VertexIdManager vertexIdManager = contextManager.getVertexIdManager();
    if (costModelManager.hasBestPath()) {
        CostMappingManager costMappingManager = costModelManager.getCostMappingManager();
        RowFieldManager rowFieldManager = costModelManager.getPathFieldManager();
        if (null == rowFieldManager) {
            return;
        }
        RowField rowField = rowFieldManager.getRowField();
        Set<String> birthFieldList = rowFieldManager.getBirthFieldList();
        Set<String> fieldList = rowField.getFieldList();
        for (String field : fieldList) {
            LogicalVertex outputVertex = queryPlan.getOutputVertex();
            if (birthFieldList.contains(field)) {
                buildLabelValuePlan(queryPlan, contextManager, schema, outputVertex, treeNodeLabelManager, vertexIdManager, costMappingManager, field, currentNode);
            } else {
                RowFieldManager parentFieldManager = rowFieldManager.getParent();
                if (!parentFieldManager.getRowField().getFieldList().contains(field)) {
                    buildLabelValuePlan(queryPlan, contextManager, schema, outputVertex, treeNodeLabelManager, vertexIdManager, costMappingManager, field, currentNode);
                }
            }
        }
        currentNode.setFinishVertex(queryPlan.getOutputVertex(), null);
    }
    List<LogicalVertex> logicalVertexList = queryPlan.getLogicalVertexList();
    for (LogicalVertex vertex : logicalVertexList) {
        if (vertex.getProcessorFunction() != null && vertex.getProcessorFunction().getOperatorType() == QueryFlowOuterClass.OperatorType.LABEL_VALUE) {
            if (vertex.getProcessorFunction().getArgumentBuilder().getIntValue() != 0) {
                labelIdList.add(vertex.getProcessorFunction().getArgumentBuilder().getIntValue());
            }
        } else {
            vertex.getBeforeRequirementList().removeIf(vv -> {
                if (vv.getReqType() == QueryFlowOuterClass.RequirementType.LABEL_START) {
                    List<Integer> intValueList = Lists.newArrayList(vv.getReqArgument().getIntValueListList());
                    intValueList.removeIf(labelIdList::contains);
                    if (intValueList.isEmpty()) {
                        return true;
                    }
                    vv.getReqArgumentBuilder().clearIntValueList().addAllIntValueList(intValueList);
                }
                return false;
            });
        }
    }
}

Example 2 with TreeNodeLabelManager

use of com.alibaba.maxgraph.compiler.tree.TreeNodeLabelManager in project GraphScope by alibaba.

the class TreeNodeUtils method buildFilterTreeNode.

/**
 * Build logical plan with filter tree node and output the input value
 */
public static LogicalVertex buildFilterTreeNode(TreeNode treeNode, ContextManager contextManager, LogicalQueryPlan logicalQueryPlan, LogicalVertex sourceVertex, GraphSchema schema) {
    TreeNodeLabelManager labelManager = contextManager.getTreeNodeLabelManager();
    VertexIdManager vertexIdManager = contextManager.getVertexIdManager();
    TreeNode filterTreeNode = TreeNodeUtils.optimizeSubFilterNode(treeNode);
    UnaryTreeNode unaryTreeNode = UnaryTreeNode.class.cast(filterTreeNode);
    LogicalVertex outputVertex;
    if (unaryTreeNode.getInputNode() instanceof SourceTreeNode && (unaryTreeNode instanceof SelectOneTreeNode || unaryTreeNode instanceof PropertyNode)) {
        // optimize traversal filter to filter operator
        int propId;
        if (unaryTreeNode instanceof SelectOneTreeNode) {
            propId = labelManager.getLabelIndex(SelectOneTreeNode.class.cast(unaryTreeNode).getSelectLabel());
        } else {
            propId = SchemaUtils.getPropId(PropertyNode.class.cast(unaryTreeNode).getPropKeyList().iterator().next(), schema);
        }
        Message.LogicalCompare logicalCompare = Message.LogicalCompare.newBuilder().setCompare(Message.CompareType.EXIST).setPropId(propId).build();
        ProcessorFilterFunction processorFunction = new ProcessorFilterFunction(QueryFlowOuterClass.OperatorType.HAS);
        if (propId < 0) {
            processorFunction.getUsedLabelList().add(propId);
        }
        processorFunction.getLogicalCompareList().add(logicalCompare);
        outputVertex = new LogicalUnaryVertex(vertexIdManager.getId(), processorFunction, false, sourceVertex);
        logicalQueryPlan.addLogicalVertex(outputVertex);
        logicalQueryPlan.addLogicalEdge(sourceVertex, outputVertex, new LogicalEdge());
    } else {
        TreeNode currentFilterTreeNode = TreeNodeUtils.buildSingleOutputNode(filterTreeNode, schema);
        // build filter plan, and use join direct filter vertex to filter left stream
        LogicalSubQueryPlan filterPlan = TreeNodeUtils.buildSubQueryPlan(currentFilterTreeNode, sourceVertex, contextManager);
        TreeNode filterSourceNode = TreeNodeUtils.getSourceTreeNode(currentFilterTreeNode);
        sourceVertex = filterSourceNode.getOutputVertex();
        LogicalVertex rightVertex = filterPlan.getOutputVertex();
        logicalQueryPlan.mergeLogicalQueryPlan(filterPlan);
        if (TreeNodeUtils.checkJoinSourceFlag(currentFilterTreeNode)) {
            LogicalBinaryVertex filterJoinVertex = new LogicalBinaryVertex(vertexIdManager.getId(), new ProcessorFunction(QueryFlowOuterClass.OperatorType.JOIN_DIRECT_FILTER), false, sourceVertex, rightVertex);
            logicalQueryPlan.addLogicalVertex(filterJoinVertex);
            logicalQueryPlan.addLogicalEdge(sourceVertex, filterJoinVertex, new LogicalEdge());
            logicalQueryPlan.addLogicalEdge(rightVertex, filterJoinVertex, new LogicalEdge());
            outputVertex = filterJoinVertex;
        } else if (TreeNodeUtils.checkSelectFlag(currentFilterTreeNode)) {
            String inputLabel = labelManager.createSysLabelStart(sourceVertex, "input");
            ProcessorFunction selectFunction = createSelectOneFunction(inputLabel, Pop.last, labelManager.getLabelIndexList());
            LogicalUnaryVertex selectVertex = new LogicalUnaryVertex(vertexIdManager.getId(), selectFunction, false, rightVertex);
            logicalQueryPlan.addLogicalVertex(selectVertex);
            logicalQueryPlan.addLogicalEdge(rightVertex, selectVertex, new LogicalEdge());
            outputVertex = logicalQueryPlan.getOutputVertex();
        } else {
            outputVertex = logicalQueryPlan.getOutputVertex();
        }
    }
    return outputVertex;
}

Example 3 with TreeNodeLabelManager

use of com.alibaba.maxgraph.compiler.tree.TreeNodeLabelManager in project GraphScope by alibaba.

the class SourceVertexTreeNode method buildLogicalQueryPlan.

@Override
public LogicalSubQueryPlan buildLogicalQueryPlan(ContextManager contextManager) {
    LogicalSubQueryPlan logicalQueryPlan = new LogicalSubQueryPlan(contextManager);
    logicalQueryPlan.setDelegateSourceFlag(false);
    Message.Value.Builder argumentBuilder = Message.Value.newBuilder();
    processLabelArgument(argumentBuilder, true);
    processIdArgument(argumentBuilder, true);
    Map<String, List<Integer>> primaryKeyLabelIdList = Maps.newHashMap();
    for (GraphVertex vertexType : this.schema.getVertexList()) {
        List<GraphProperty> primaryKeyList = vertexType.getPrimaryKeyList();
        if (null != primaryKeyList && primaryKeyList.size() == 1) {
            String propertyName = primaryKeyList.get(0).getName();
            List<Integer> labelIdList = primaryKeyLabelIdList.computeIfAbsent(propertyName, k -> Lists.newArrayList());
            labelIdList.add(vertexType.getLabelId());
        }
    }
    QueryFlowOuterClass.VertexPrimaryKeyListProto.Builder primaryKeyBuilder = QueryFlowOuterClass.VertexPrimaryKeyListProto.newBuilder();
    for (HasContainer container : this.hasContainerList) {
        String key = container.getKey();
        List<Integer> labelIdList = primaryKeyLabelIdList.get(key);
        if (null != labelIdList) {
            for (Integer labelId : labelIdList) {
                if (container.getBiPredicate() instanceof Compare && container.getBiPredicate() == Compare.eq) {
                    primaryKeyBuilder.addPrimaryKeys(QueryFlowOuterClass.VertexPrimaryKeyProto.newBuilder().setLabelId(labelId).setPrimaryKeyValue(container.getValue().toString()));
                } else if (container.getBiPredicate() instanceof Contains && container.getBiPredicate() == Contains.within) {
                    for (Object val : (Collection<Object>) container.getValue()) {
                        primaryKeyBuilder.addPrimaryKeys(QueryFlowOuterClass.VertexPrimaryKeyProto.newBuilder().setLabelId(labelId).setPrimaryKeyValue(val.toString()));
                    }
                }
            }
        }
    }
    argumentBuilder.setPayload(primaryKeyBuilder.build().toByteString()).setBoolFlag(isPartitionIdFlag());
    ProcessorSourceFunction processorSourceFunction = new ProcessorSourceFunction(getCountOperator(QueryFlowOuterClass.OperatorType.V), argumentBuilder, rangeLimit);
    VertexIdManager vertexIdManager = contextManager.getVertexIdManager();
    TreeNodeLabelManager treeNodeLabelManager = contextManager.getTreeNodeLabelManager();
    LogicalSourceVertex logicalSourceVertex = new LogicalSourceVertex(vertexIdManager.getId(), processorSourceFunction);
    logicalSourceVertex.getBeforeRequirementList().addAll(buildBeforeRequirementList(treeNodeLabelManager));
    logicalSourceVertex.getAfterRequirementList().addAll(buildAfterRequirementList(treeNodeLabelManager));
    getUsedLabelList().forEach(v -> processorSourceFunction.getUsedLabelList().add(treeNodeLabelManager.getLabelIndex(v)));
    logicalQueryPlan.addLogicalVertex(logicalSourceVertex);
    setFinishVertex(logicalQueryPlan.getOutputVertex(), treeNodeLabelManager);
    return logicalQueryPlan;
}

Example 4 with TreeNodeLabelManager

use of com.alibaba.maxgraph.compiler.tree.TreeNodeLabelManager in project GraphScope by alibaba.

the class LogicalPlanBuilder method build.

/**
 * Build logical plan from tree manager
 *
 * @param treeManager The given tree manager
 * @return The result logical plan
 */
public LogicalQueryPlan build(TreeManager treeManager) {
    CostModelManager costModelManager = treeManager.optimizeCostModel();
    TreeNodeLabelManager labelManager = treeManager.getLabelManager();
    VertexIdManager vertexIdManager = VertexIdManager.createVertexIdManager();
    ContextManager contextManager = new ContextManager(costModelManager, treeManager.getQueryConfig(), vertexIdManager, labelManager);
    TreeNode leafNode = treeManager.getTreeLeaf();
    return buildPlan(leafNode, contextManager, treeManager.getSchema());
}

Example 5 with TreeNodeLabelManager

use of com.alibaba.maxgraph.compiler.tree.TreeNodeLabelManager in project GraphScope by alibaba.

the class LogicalPlanBuilder method buildLabelValuePlan.

private void buildLabelValuePlan(LogicalQueryPlan queryPlan, ContextManager contextManager, GraphSchema schema, LogicalVertex outputVertex, TreeNodeLabelManager treeNodeLabelManager, VertexIdManager vertexIdManager, CostMappingManager costMappingManager, String field, TreeNode currNode) {
    // Create field value here
    String parentField = costMappingManager.getValueParent(field);
    if (!StringUtils.isEmpty(parentField)) {
        BaseTreeNode nextNode = (BaseTreeNode) currNode.getOutputNode();
        nextNode.removeBeforeLabel(parentField);
        // If the field is value field, process it and remove the label requirement in vertex
        int labelIndex = treeNodeLabelManager.getLabelIndex(parentField);
        TreeNode fieldValueTreeNode = costMappingManager.getComputeTreeByValue(parentField);
        if (!(fieldValueTreeNode instanceof SourceTreeNode)) {
            for (QueryFlowOuterClass.RequirementValue.Builder reqValue : outputVertex.getAfterRequirementList()) {
                if (reqValue.getReqType() == QueryFlowOuterClass.RequirementType.LABEL_START) {
                    List<Integer> labelIndexList = reqValue.getReqArgumentBuilder().getIntValueListList().stream().filter(v -> v != labelIndex).collect(Collectors.toList());
                    reqValue.getReqArgumentBuilder().clearIntValueList().addAllIntValueList(labelIndexList);
                }
            }
            TreeNode currentFilterTreeNode = TreeNodeUtils.buildSingleOutputNode(fieldValueTreeNode, schema);
            // build filter plan, and use join direct filter vertex to filter left stream
            LogicalSubQueryPlan fieldValuePlan = TreeNodeUtils.buildSubQueryPlan(currentFilterTreeNode, outputVertex, contextManager);
            List<LogicalVertex> fieldValueVertexList = fieldValuePlan.getLogicalVertexList();
            if (fieldValueVertexList.size() == 2) {
                LogicalVertex fieldValueVertex = fieldValueVertexList.get(1);
                ProcessorLabelValueFunction labelValueFunction = new ProcessorLabelValueFunction(labelIndex, fieldValueVertex);
                LogicalVertex labelValueVertex = new LogicalUnaryVertex(vertexIdManager.getId(), labelValueFunction, outputVertex);
                queryPlan.addLogicalVertex(labelValueVertex);
                queryPlan.addLogicalEdge(outputVertex, labelValueVertex, LogicalEdge.shuffleByKey(labelIndex));
            } else {
                LogicalVertex fieldValueVertex = fieldValuePlan.getOutputVertex();
                fieldValueVertex.getAfterRequirementList().add(QueryFlowOuterClass.RequirementValue.newBuilder().setReqType(QueryFlowOuterClass.RequirementType.LABEL_START).setReqArgument(Message.Value.newBuilder().addIntValueList(labelIndex)));
                queryPlan.mergeLogicalQueryPlan(fieldValuePlan);
                LogicalVertex outputKeyVertex = new LogicalUnaryVertex(vertexIdManager.getId(), new ProcessorFunction(QueryFlowOuterClass.OperatorType.KEY_MESSAGE), fieldValueVertex);
                queryPlan.addLogicalVertex(outputKeyVertex);
                queryPlan.addLogicalEdge(fieldValueVertex, outputKeyVertex, LogicalEdge.forwardEdge());
            }
        }
    }
}