public Builder(String gremlin, GremlinManager executor) {
    this.request = new GremlinRequest(gremlin);
    this.manager = executor;
}
 

public static GremlinManager gremlin() {
    Assert.assertNotNull("Not opened client", client);
    return client.gremlin();
}
 

public GremlinManager gremlin() {
    return this.client.gremlin();
}
 

private QueryResult executeQuery(Card card, HugeClient client) {
    long startTime = System.currentTimeMillis();

    GremlinManager gremlinManager = client.gremlin();

    int limit = conf.getLimitData();
    // To know whether has more record,
    // so add "limit(limit+1)" after code.
    String limitCode = gremlinOptimizer.limitOptimize(card.getCode(),
                                                      limit + 1);
    LOG.info(limitCode);

    // Execute gremlin by HugeClient.
    ResultSet resultSet = gremlinManager.gremlin(limitCode).execute();

    QueryResult queryResult = new QueryResult();
    /*
     * Gremlin result will be stored in two places, the original
     * data is saved as a List<Object>, another is translated
     * into a graph or a table object if possible.
     */
    queryResult.setData(resultSet.data());

    List<Vertex> vertices = new ArrayList<>();
    List<Edge> edges = new ArrayList<>();
    Map<String, Object> styles = new HashMap<>();
    List<com.baidu.hugegraph.structure.graph.Path> paths = new ArrayList<>();
    if (!resultSet.iterator().hasNext()) {
        queryResult.setType(EMPTY);
    }

    queryResult.setType(getResultType(resultSet, limit));
    int count = 0;

    for (Iterator<Result> results = resultSet.iterator();
         results.hasNext();) {

        /*
         * The result might be null, and the object must be got via
         * Result.getObject method.
         */
        Result or = results.next();
        if (or == null) {
            continue;
        }
        Object object = or.getObject();
        if (object instanceof Vertex) {
            vertices.add((Vertex) object);
        } else if (object instanceof Edge) {
            edges.add((Edge) object);
        } else if (object instanceof
                   com.baidu.hugegraph.structure.graph.Path) {
            // Convert Object to Path
            paths.add((com.baidu.hugegraph.structure.graph.Path) object);
        }
        if (++count >= limit) {
            break;
        }
    }

    /*
     * When the results contains not only vertices\edges\paths,
     * how to deal with that?
     */
    switch (queryResult.getType()) {
        case PATH:
            // Extract vertices from paths ;
            vertices = getVertexFromPath(client, paths);
            edges = getEdgeFromVertex(client, vertices);
            styles = getGraphStyles(client);
            break;
        case VERTEX:
            // Extract edges from vertex ;
            edges = getEdgeFromVertex(client, vertices);
            styles = getGraphStyles(client);
            break;
        case EDGE:
            // Extract vertices from edges ;
            vertices = getVertexFromEdge(client, edges);
            styles = getGraphStyles(client);
            break;
        default:
            break;
    }

    queryResult.setGraphVertices(vertices);
    queryResult.setGraphEdges(edges);
    queryResult.setStyles(styles);
    queryResult.setShowNum(count);
    String message = "";
    if (count < resultSet.size()) {
        message = String.format("Partial %s records are shown!", count);
    }
    queryResult.setMessage(message);

    long endTime = System.currentTimeMillis();
    long duration = endTime - startTime;
    queryResult.setDuration(duration);

    return queryResult;
}