Examples with GraphSchema com.alibaba.maxgraph.compiler.api.schema.GraphSchema used on opensource projects

Example 11 with GraphSchema

use of com.alibaba.maxgraph.compiler.api.schema.GraphSchema 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());
            }
        }
    }
}

Example 12 with GraphSchema

use of com.alibaba.maxgraph.compiler.api.schema.GraphSchema in project GraphScope by alibaba.

the class CostDataStatistics method getOutERatio.

/**
 * Compute outE scale ratio with start vertex label list and edge list
 *
 * @param input The given start vertex label list
 * @param edgeList The given edge label list
 * @return The result ratio
 */
public NodeStatistics getOutERatio(NodeStatistics input, Set<String> edgeList) {
    GraphSchema schema = schemaFetcher.getSchemaSnapshotPair().getLeft();
    NodeStatistics nodeStatistics = new NodeStatistics(schema);
    Map<String, Double> inputVertexCountList = input.getVertexCountList();
    for (String edgeLabel : edgeList) {
        try {
            GraphEdge edge = (GraphEdge) schema.getElement(edgeLabel);
            List<EdgeRelation> relationList = edge.getRelationList();
            if (relationList.size() > 0) {
                double avgRelationRatio = 1.0 / edge.getRelationList().size();
                relationList.stream().filter(v -> inputVertexCountList.containsKey(v.getSource().getLabel())).forEach(v -> {
                    double sourceVertexCount = inputVertexCountList.getOrDefault(v.getSource().getLabel(), INIT_VERTEX_COUNT);
                    double currEdgeCount = (this.edgeCountList.getOrDefault(edge.getLabel(), INIT_EDGE_COUNT) * avgRelationRatio / this.vertexCountList.getOrDefault(v.getSource().getLabel(), INIT_VERTEX_COUNT)) * sourceVertexCount;
                    nodeStatistics.addEdgeCount(edgeLabel, currEdgeCount);
                });
            }
        } catch (Exception ignored) {
        }
    }
    return nodeStatistics;
}

Example 13 with GraphSchema

use of com.alibaba.maxgraph.compiler.api.schema.GraphSchema in project GraphScope by alibaba.

the class CostDataStatistics method vertexQueryList.

public Map<String, String> vertexQueryList() {
    GraphSchema schema = schemaFetcher.getSchemaSnapshotPair().getLeft();
    Map<String, String> queryList = Maps.newHashMap();
    schema.getVertexList().forEach(v -> {
        queryList.put(v.getLabel(), String.format(VERTEX_QUERY, v.getLabel()));
    });
    return queryList;
}

Example 14 with GraphSchema

use of com.alibaba.maxgraph.compiler.api.schema.GraphSchema in project GraphScope by alibaba.

the class CostDataStatistics method computeStepCount.

/**
 * Compute step count with given node and node label
 *
 * @param inputStatistics The given input statistics
 * @param treeNode The given tree node
 * @param currNodeLabel The given current node label
 * @return The result step count
 */
private NodeStatistics computeStepCount(NodeStatistics inputStatistics, TreeNode treeNode, NodeLabelList currNodeLabel) {
    GraphSchema schema = schemaFetcher.getSchemaSnapshotPair().getLeft();
    NodeStatistics nodeStatistics = new NodeStatistics(schema);
    if (null == inputStatistics) {
        if (currNodeLabel.isUnknownFlag()) {
            for (Map.Entry<String, Double> entry : vertexCountList.entrySet()) {
                nodeStatistics.addVertexCount(entry.getKey(), entry.getValue());
            }
        } else {
            SourceTreeNode sourceTreeNode = (SourceTreeNode) treeNode;
            Object[] ids = sourceTreeNode.getIds();
            Set<String> vertexLabelList = currNodeLabel.getVertexLabelList();
            for (String vertexLabel : vertexLabelList) {
                double vertexCount = null == ids ? vertexCountList.getOrDefault(vertexLabel, INIT_VERTEX_COUNT) : (ids.length * 1.0 / vertexLabelList.size());
                nodeStatistics.addVertexCount(vertexLabel, vertexCount);
            }
            Set<String> edgeLabelList = currNodeLabel.getEdgeLabelList();
            for (String edgeLabel : currNodeLabel.getEdgeLabelList()) {
                double edgeCount = null == ids ? edgeCountList.getOrDefault(edgeLabel, INIT_EDGE_COUNT) : (ids.length * 1.0 / edgeLabelList.size());
                nodeStatistics.addEdgeCount(edgeLabel, edgeCount);
            }
        }
    } else {
        if (treeNode instanceof VertexTreeNode) {
            VertexTreeNode vertexTreeNode = (VertexTreeNode) treeNode;
            Direction direction = vertexTreeNode.getDirection();
            Set<String> edgeLabelList;
            if (null == vertexTreeNode.getEdgeLabels()) {
                edgeLabelList = Sets.newHashSet();
            } else {
                edgeLabelList = Sets.newHashSet(vertexTreeNode.getEdgeLabels());
            }
            switch(direction) {
                case OUT:
                    {
                        nodeStatistics.merge(getOutRatio(inputStatistics, edgeLabelList));
                        break;
                    }
                case IN:
                    {
                        nodeStatistics.merge(getInRatio(inputStatistics, edgeLabelList));
                        break;
                    }
                case BOTH:
                    {
                        nodeStatistics.merge(getOutRatio(inputStatistics, edgeLabelList));
                        nodeStatistics.merge(getInRatio(inputStatistics, edgeLabelList));
                        break;
                    }
            }
        } else if (treeNode instanceof EdgeTreeNode) {
            Set<String> edgeLabelList = currNodeLabel.getEdgeLabelList();
            Direction direction = ((EdgeTreeNode) treeNode).getDirection();
            switch(direction) {
                case OUT:
                    {
                        nodeStatistics.merge(getOutERatio(inputStatistics, edgeLabelList));
                        break;
                    }
                case IN:
                    {
                        nodeStatistics.merge(getInERatio(inputStatistics, edgeLabelList));
                        break;
                    }
                case BOTH:
                    {
                        nodeStatistics.merge(getOutERatio(inputStatistics, edgeLabelList));
                        nodeStatistics.merge(getInERatio(inputStatistics, edgeLabelList));
                        break;
                    }
            }
        } else if (treeNode instanceof EdgeVertexTreeNode) {
            Map<String, Double> edgeCountList = inputStatistics.getEdgeCountList();
            Direction direction = ((EdgeVertexTreeNode) treeNode).getDirection();
            edgeCountList.keySet().stream().map(v -> {
                try {
                    return schema.getElement(v);
                } catch (Exception ignored) {
                    return null;
                }
            }).filter(v -> null != v && v instanceof GraphEdge).map(v -> (GraphEdge) v).forEach(v -> {
                v.getRelationList().forEach(vv -> {
                    double currEdgeCount = edgeCountList.get(v.getLabel());
                    if (direction == Direction.OUT || direction == Direction.BOTH) {
                        List<String> resultVertexLabelList = Lists.newArrayList();
                        if (currNodeLabel.getVertexLabelList().contains(vv.getSource().getLabel())) {
                            resultVertexLabelList.add(vv.getSource().getLabel());
                        }
                        double avgVertexCount = currEdgeCount / resultVertexLabelList.size();
                        for (String vertexLabel : resultVertexLabelList) {
                            nodeStatistics.addVertexCount(vertexLabel, avgVertexCount);
                        }
                    }
                    if (direction == Direction.IN || direction == Direction.BOTH) {
                        List<String> resultVertexLabelList = Lists.newArrayList();
                        if (currNodeLabel.getVertexLabelList().contains(vv.getTarget().getLabel())) {
                            resultVertexLabelList.add(vv.getTarget().getLabel());
                        }
                        double avgVertexCount = currEdgeCount / resultVertexLabelList.size();
                        for (String vertexLabel : resultVertexLabelList) {
                            nodeStatistics.addVertexCount(vertexLabel, avgVertexCount);
                        }
                    }
                });
            });
        } else if (treeNode instanceof EdgeOtherVertexTreeNode) {
            Set<String> vertexLabelList = currNodeLabel.getVertexLabelList();
            double avgVertexCount = inputStatistics.totalCount() / vertexLabelList.size();
            vertexLabelList.forEach(v -> nodeStatistics.addVertexCount(v, avgVertexCount));
        } else {
            NodeType nodeType = treeNode.getNodeType();
            if (NodeType.MAP == nodeType) {
                nodeStatistics.addElementCount(inputStatistics.totalCount());
            } else if (NodeType.FILTER == nodeType) {
                nodeStatistics.merge(inputStatistics, FILTER_RATIO);
            } else if (NodeType.FLATMAP == nodeType) {
                nodeStatistics.addElementCount(inputStatistics.totalCount() * FLATMAP_RATIO);
            } else if (NodeType.AGGREGATE == nodeType) {
                nodeStatistics.addElementCount(1);
            } else {
                nodeStatistics.merge(inputStatistics);
            }
        }
    }
    return nodeStatistics;
}

Example 15 with GraphSchema

use of com.alibaba.maxgraph.compiler.api.schema.GraphSchema in project GraphScope by alibaba.

the class MaxTestGraph method dropData.

private void dropData() {
    CompletableFuture<GraphSchema> future = new CompletableFuture<>();
    this.clientService.dropSchema(DropSchemaRequest.newBuilder().build(), new StreamObserver<DropSchemaResponse>() {

        @Override
        public void onNext(DropSchemaResponse value) {
            future.complete(GraphDef.parseProto(value.getGraphDef()));
        }

        @Override
        public void onError(Throwable t) {
            future.completeExceptionally(t);
        }

        @Override
        public void onCompleted() {
        }
    });
    GraphSchema schema;
    try {
        schema = future.get();
    } catch (Exception e) {
        throw new MaxGraphException(e);
    }
    logger.info("drop schema: " + ((GraphDef) schema).toProto().toString());
}