private Map edgesOfVertex()

in hugegraph-hubble/hubble-be/src/main/java/org/apache/hugegraph/service/query/GremlinQueryService.java [428:480]
47 lines of code
10 McCabe index (conditional complexity)

    private Map<String, Edge> edgesOfVertex(TypedResult result,
                                            Map<Object, Vertex> vertices,
                                            HugeClient client) {
        final HugeConfig config = this.config;
        int batchSize = config.get(HubbleOptions.GREMLIN_BATCH_QUERY_IDS);
        int edgeLimit = config.get(HubbleOptions.GREMLIN_EDGES_TOTAL_LIMIT);
        int degreeLimit = config.get(HubbleOptions.GREMLIN_VERTEX_DEGREE_LIMIT);

        Set<Object> vertexIds = vertices.keySet();
        Map<String, Edge> edges = new HashMap<>(vertexIds.size());
        Iterables.partition(vertexIds, batchSize).forEach(batch -> {
            List<String> escapedIds = batch.stream()
                                           .map(GremlinUtil::escapeId)
                                           .collect(Collectors.toList());
            String ids = StringUtils.join(escapedIds, ",");
            // Any better way to find two vertices has linked?
            String gremlin;
            if (result.getType().isPath()) {
                // If result type is path, the vertices count not too much in theory
                gremlin = String.format("g.V(%s).bothE().local(limit(%s)).dedup()",
                                        ids, degreeLimit);
            } else {
                gremlin = String.format("g.V(%s).bothE().dedup().limit(%s)",
                                        ids, edgeLimit);
            }
            ResultSet resultSet = client.gremlin().gremlin(gremlin).execute();
            // The edges count for per vertex
            Map<Object, Integer> degrees = new HashMap<>(resultSet.size());
            for (Iterator<Result> iter = resultSet.iterator(); iter.hasNext();) {
                Edge edge = iter.next().getEdge();
                Object source = edge.sourceId();
                Object target = edge.targetId();
                // only add the interconnected edges of the found vertices
                if (!vertexIds.contains(source) || !vertexIds.contains(target)) {
                    continue;
                }
                edges.put(edge.id(), edge);
                if (edges.size() >= edgeLimit) {
                    break;
                }

                int deg = degrees.compute(source, (k, v) -> v == null ? 1 : v + 1);
                if (deg >= degreeLimit) {
                    break;
                }
                deg = degrees.compute(target, (k, v) -> v == null ? 1 : v + 1);
                if (deg >= degreeLimit) {
                    break;
                }
            }
        });
        return edges;
    }