@ultipa-graph/ultipa-driver 5.0.0-s5.0

package/dist/types/types.js

@@ -0,0 +1,706 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ULTIPA = void 0;
+const utils_1 = require("../utils");
+const ULTIPA_RPC = __importStar(require("../proto/ultipa_pb"));
+let { PropertyType: RRC_PropertyType, ErrorCode, DBType: RPC_DBType, 
+// TASK_STATUS, 
+JOB_STATUS: RPC_JOB_STATUS, FollowerRole: RCP_FollowerRole, ResultType: RPC_ResultType, InsertType: RPC_InsertType, PlanNode: RPC_PlanNode, QueryType: RPC_QueryType } = ULTIPA_RPC;
+const _1 = require(".");
+var ULTIPA;
+(function (ULTIPA) {
+    /**
+     * Raft集群的类型
+     */
+    let ClientType;
+    (function (ClientType) {
+        ClientType[ClientType["Default"] = 0] = "Default";
+        ClientType[ClientType["Algo"] = 1] = "Algo";
+        ClientType[ClientType["Update"] = 2] = "Update";
+        ClientType[ClientType["Leader"] = 3] = "Leader";
+    })(ClientType = ULTIPA.ClientType || (ULTIPA.ClientType = {}));
+    /**
+     * 连接的配置
+     */
+    class UltipaConfig {
+    }
+    ULTIPA.UltipaConfig = UltipaConfig;
+    /**
+     * 属性类型
+     */
+    let PropertyType;
+    (function (PropertyType) {
+        PropertyType[PropertyType["PROPERTY_UNSET"] = RRC_PropertyType.UNSET] = "PROPERTY_UNSET";
+        PropertyType[PropertyType["PROPERTY_INT32"] = RRC_PropertyType.INT32] = "PROPERTY_INT32";
+        PropertyType[PropertyType["PROPERTY_STRING"] = RRC_PropertyType.STRING] = "PROPERTY_STRING";
+        PropertyType[PropertyType["PROPERTY_FLOAT"] = RRC_PropertyType.FLOAT] = "PROPERTY_FLOAT";
+        PropertyType[PropertyType["PROPERTY_DOUBLE"] = RRC_PropertyType.DOUBLE] = "PROPERTY_DOUBLE";
+        PropertyType[PropertyType["PROPERTY_UINT32"] = RRC_PropertyType.UINT32] = "PROPERTY_UINT32";
+        PropertyType[PropertyType["PROPERTY_INT64"] = RRC_PropertyType.INT64] = "PROPERTY_INT64";
+        PropertyType[PropertyType["PROPERTY_UINT64"] = RRC_PropertyType.UINT64] = "PROPERTY_UINT64";
+        PropertyType[PropertyType["PROPERTY_DATETIME"] = RRC_PropertyType.DATETIME] = "PROPERTY_DATETIME";
+        PropertyType[PropertyType["PROPERTY_TIMESTAMP"] = RRC_PropertyType.TIMESTAMP] = "PROPERTY_TIMESTAMP";
+        PropertyType[PropertyType["PROPERTY_TEXT"] = RRC_PropertyType.TEXT] = "PROPERTY_TEXT";
+        PropertyType[PropertyType["PROPERTY_BLOB"] = RRC_PropertyType.BLOB] = "PROPERTY_BLOB";
+        PropertyType[PropertyType["PROPERTY_POINT"] = RRC_PropertyType.POINT] = "PROPERTY_POINT";
+        PropertyType[PropertyType["PROPERTY_DECIMAL"] = RRC_PropertyType.DECIMAL] = "PROPERTY_DECIMAL";
+        PropertyType[PropertyType["PROPERTY_LIST"] = RRC_PropertyType.LIST] = "PROPERTY_LIST";
+        PropertyType[PropertyType["PROPERTY_SET"] = RRC_PropertyType.SET] = "PROPERTY_SET";
+        PropertyType[PropertyType["PROPERTY_MAP"] = RRC_PropertyType.MAP] = "PROPERTY_MAP";
+        PropertyType[PropertyType["PROPERTY_NULL"] = RRC_PropertyType.NULL_] = "PROPERTY_NULL";
+        PropertyType[PropertyType["PROPERTY_BOOL"] = RRC_PropertyType.BOOL] = "PROPERTY_BOOL";
+        PropertyType[PropertyType["unset"] = RRC_PropertyType.UNSET] = "unset";
+        PropertyType[PropertyType["int32"] = RRC_PropertyType.INT32] = "int32";
+        PropertyType[PropertyType["string"] = RRC_PropertyType.STRING] = "string";
+        PropertyType[PropertyType["float"] = RRC_PropertyType.FLOAT] = "float";
+        PropertyType[PropertyType["double"] = RRC_PropertyType.DOUBLE] = "double";
+        PropertyType[PropertyType["uint32"] = RRC_PropertyType.UINT32] = "uint32";
+        PropertyType[PropertyType["int64"] = RRC_PropertyType.INT64] = "int64";
+        PropertyType[PropertyType["uint64"] = RRC_PropertyType.UINT64] = "uint64";
+        PropertyType[PropertyType["datetime"] = RRC_PropertyType.DATETIME] = "datetime";
+        PropertyType[PropertyType["timestamp"] = RRC_PropertyType.TIMESTAMP] = "timestamp";
+        PropertyType[PropertyType["text"] = RRC_PropertyType.TEXT] = "text";
+        PropertyType[PropertyType["blob"] = RRC_PropertyType.BLOB] = "blob";
+        PropertyType[PropertyType["point"] = RRC_PropertyType.POINT] = "point";
+        PropertyType[PropertyType["decimal"] = RRC_PropertyType.DECIMAL] = "decimal";
+        PropertyType[PropertyType["list"] = RRC_PropertyType.LIST] = "list";
+        PropertyType[PropertyType["set"] = RRC_PropertyType.SET] = "set";
+        PropertyType[PropertyType["map"] = RRC_PropertyType.MAP] = "map";
+        PropertyType[PropertyType["null"] = RRC_PropertyType.NULL_] = "null";
+        PropertyType[PropertyType["bool"] = RRC_PropertyType.BOOL] = "bool";
+    })(PropertyType = ULTIPA.PropertyType || (ULTIPA.PropertyType = {}));
+    /**
+     * 返回状态码
+     */
+    let Code;
+    (function (Code) {
+        Code[Code["SUCCESS"] = ErrorCode.SUCCESS] = "SUCCESS";
+        Code[Code["FAILED"] = ErrorCode.FAILED] = "FAILED";
+        Code[Code["PARAM_ERROR"] = ErrorCode.PARAM_ERROR] = "PARAM_ERROR";
+        Code[Code["BASE_DB_ERROR"] = ErrorCode.BASE_DB_ERROR] = "BASE_DB_ERROR";
+        Code[Code["ENGINE_ERROR"] = ErrorCode.ENGINE_ERROR] = "ENGINE_ERROR";
+        Code[Code["SYSTEM_ERROR"] = ErrorCode.SYSTEM_ERROR] = "SYSTEM_ERROR";
+        Code[Code["SYNTAX_ERROR"] = ErrorCode.SYNTAX_ERROR] = "SYNTAX_ERROR";
+        Code[Code["PERMISSION_DENIED"] = ErrorCode.PERMISSION_DENIED] = "PERMISSION_DENIED";
+        Code[Code["DUPLICATE_ID"] = ErrorCode.DUPLICATE_ID] = "DUPLICATE_ID";
+        Code[Code["RAFT_REDIRECT"] = ErrorCode.RAFT_REDIRECT] = "RAFT_REDIRECT";
+        Code[Code["RAFT_LEADER_NOT_YET_ELECTED"] = ErrorCode.RAFT_LEADER_NOT_YET_ELECTED] = "RAFT_LEADER_NOT_YET_ELECTED";
+        Code[Code["RAFT_LOG_ERROR"] = ErrorCode.RAFT_LOG_ERROR] = "RAFT_LOG_ERROR";
+        // UQL_ERROR =                      ErrorCode.UQL_ERROR,
+        Code[Code["NOT_RAFT_MODE"] = ErrorCode.NOT_RAFT_MODE] = "NOT_RAFT_MODE";
+        Code[Code["RAFT_NO_AVAILABLE_FOLLOWERS"] = ErrorCode.RAFT_NO_AVAILABLE_FOLLOWERS] = "RAFT_NO_AVAILABLE_FOLLOWERS";
+        Code[Code["RAFT_NO_AVAILABLE_ALGO_SERVERS"] = ErrorCode.RAFT_NO_AVAILABLE_ALGO_SERVERS] = "RAFT_NO_AVAILABLE_ALGO_SERVERS";
+        Code[Code["UNKNOWN_ERROR"] = 1000] = "UNKNOWN_ERROR";
+    })(Code = ULTIPA.Code || (ULTIPA.Code = {}));
+    let ResultType;
+    (function (ResultType) {
+        ResultType[ResultType["RESULT_TYPE_UNSET"] = RPC_ResultType.RESULT_TYPE_UNSET] = "RESULT_TYPE_UNSET";
+        ResultType[ResultType["RESULT_TYPE_PATH"] = RPC_ResultType.RESULT_TYPE_PATH] = "RESULT_TYPE_PATH";
+        ResultType[ResultType["RESULT_TYPE_NODE"] = RPC_ResultType.RESULT_TYPE_NODE] = "RESULT_TYPE_NODE";
+        ResultType[ResultType["RESULT_TYPE_EDGE"] = RPC_ResultType.RESULT_TYPE_EDGE] = "RESULT_TYPE_EDGE";
+        ResultType[ResultType["RESULT_TYPE_ATTR"] = RPC_ResultType.RESULT_TYPE_ATTR] = "RESULT_TYPE_ATTR";
+        ResultType[ResultType["RESULT_TYPE_TABLE"] = RPC_ResultType.RESULT_TYPE_TABLE] = "RESULT_TYPE_TABLE";
+    })(ResultType = ULTIPA.ResultType || (ULTIPA.ResultType = {}));
+    let AuthenticateType;
+    (function (AuthenticateType) {
+        AuthenticateType[AuthenticateType["PERMISSION_TYPE_UNSET"] = ULTIPA_RPC.AuthenticateType.PERMISSION_TYPE_UNSET] = "PERMISSION_TYPE_UNSET";
+        AuthenticateType[AuthenticateType["PERMISSION_TYPE_UQL"] = ULTIPA_RPC.AuthenticateType.PERMISSION_TYPE_UQL] = "PERMISSION_TYPE_UQL";
+        AuthenticateType[AuthenticateType["PERMISSION_TYPE_GQL"] = ULTIPA_RPC.AuthenticateType.PERMISSION_TYPE_GQL] = "PERMISSION_TYPE_GQL";
+        AuthenticateType[AuthenticateType["PERMISSION_TYPE_INSERTNODES"] = ULTIPA_RPC.AuthenticateType.PERMISSION_TYPE_INSERTNODES] = "PERMISSION_TYPE_INSERTNODES";
+        AuthenticateType[AuthenticateType["PERMISSION_TYPE_INSERTEDGES"] = ULTIPA_RPC.AuthenticateType.PERMISSION_TYPE_INSERTEDGES] = "PERMISSION_TYPE_INSERTEDGES";
+        AuthenticateType[AuthenticateType["PERMISSION_TYPE_EXPORT"] = ULTIPA_RPC.AuthenticateType.PERMISSION_TYPE_EXPORT] = "PERMISSION_TYPE_EXPORT";
+        AuthenticateType[AuthenticateType["PERMISSION_TYPE_DOWNLOADFILE"] = ULTIPA_RPC.AuthenticateType.PERMISSION_TYPE_DOWNLOADFILE] = "PERMISSION_TYPE_DOWNLOADFILE";
+        AuthenticateType[AuthenticateType["PERMISSION_TYPE_INSTALLALGO"] = ULTIPA_RPC.AuthenticateType.PERMISSION_TYPE_INSTALLALGO] = "PERMISSION_TYPE_INSTALLALGO";
+        AuthenticateType[AuthenticateType["PERMISSION_TYPE_UNINSTALLALGO"] = ULTIPA_RPC.AuthenticateType.PERMISSION_TYPE_UNINSTALLALGO] = "PERMISSION_TYPE_UNINSTALLALGO";
+        AuthenticateType[AuthenticateType["PERMISSION_TYPE_ROLLBACKALGO"] = ULTIPA_RPC.AuthenticateType.PERMISSION_TYPE_ROLLBACKALGO] = "PERMISSION_TYPE_ROLLBACKALGO";
+        // PERMISSION_TYPE_UPLOADER = ULTIPA_RPC.AuthenticateType.PERMISSION_TYPE_UPLOADER,
+        // PERMISSION_TYPE_CREATEGRAPHBYUPLOADER = ULTIPA_RPC.AuthenticateType.PERMISSION_TYPE_CREATEGRAPHBYUPLOADER,
+        // PERMISSION_TYPE_INSTALLEXTA = ULTIPA_RPC.AuthenticateType.PERMISSION_TYPE_INSTALLEXTA,
+        // PERMISSION_TYPE_UNINSTALLEXTA = ULTIPA_RPC.AuthenticateType.PERMISSION_TYPE_UNINSTALLEXTA,
+    })(AuthenticateType = ULTIPA.AuthenticateType || (ULTIPA.AuthenticateType = {}));
+    let InsertType;
+    (function (InsertType) {
+        InsertType[InsertType["INSERT_TYPE_NORMAL"] = RPC_InsertType.NORMAL] = "INSERT_TYPE_NORMAL";
+        InsertType[InsertType["INSERT_TYPE_OVERWRITE"] = RPC_InsertType.OVERWRITE] = "INSERT_TYPE_OVERWRITE";
+        InsertType[InsertType["INSERT_TYPE_UPSERT"] = RPC_InsertType.UPSERT] = "INSERT_TYPE_UPSERT";
+    })(InsertType = ULTIPA.InsertType || (ULTIPA.InsertType = {}));
+    /** 语言类型 */
+    let QueryType;
+    (function (QueryType) {
+        QueryType[QueryType["QL_UNSET"] = 0] = "QL_UNSET";
+        QueryType[QueryType["UQL"] = 1] = "UQL";
+        QueryType[QueryType["GQL"] = 2] = "GQL";
+    })(QueryType = ULTIPA.QueryType || (ULTIPA.QueryType = {}));
+    /**
+     * 数据库类型
+     */
+    let DBType;
+    (function (DBType) {
+        /**
+         * 点
+         */
+        DBType[DBType["DBNODE"] = RPC_DBType.DBNODE] = "DBNODE";
+        /**
+         * 边
+         */
+        DBType[DBType["DBEDGE"] = RPC_DBType.DBEDGE] = "DBEDGE";
+    })(DBType = ULTIPA.DBType || (ULTIPA.DBType = {}));
+    /**
+     * 算法任务的状态
+     */
+    let JOB_STATUS;
+    (function (JOB_STATUS) {
+        JOB_STATUS[JOB_STATUS["JOB_PENDING"] = RPC_JOB_STATUS.JOB_PENDING] = "JOB_PENDING";
+        JOB_STATUS[JOB_STATUS["JOB_COMPUTING"] = RPC_JOB_STATUS.JOB_COMPUTING] = "JOB_COMPUTING";
+        JOB_STATUS[JOB_STATUS["JOB_WRITING"] = RPC_JOB_STATUS.JOB_WRITING] = "JOB_WRITING";
+        JOB_STATUS[JOB_STATUS["JOB_DONE"] = RPC_JOB_STATUS.JOB_DONE] = "JOB_DONE";
+        JOB_STATUS[JOB_STATUS["JOB_FAILED"] = RPC_JOB_STATUS.JOB_FAILED] = "JOB_FAILED";
+        JOB_STATUS[JOB_STATUS["JOB_STOPPED"] = RPC_JOB_STATUS.JOB_STOPPED] = "JOB_STOPPED";
+    })(JOB_STATUS = ULTIPA.JOB_STATUS || (ULTIPA.JOB_STATUS = {}));
+    /**
+     * 点的结构
+     */
+    class Node {
+        getID() {
+            return this._id;
+        }
+        getUUID() {
+            return this._uuid;
+        }
+        getSchema() {
+            return this.schema;
+        }
+        getValues() {
+            return this.values;
+        }
+        get(prop_name) {
+            var _a;
+            return (_a = this.values) === null || _a === void 0 ? void 0 : _a.get(prop_name);
+        }
+        set(prop_name, value) {
+            if (!this.values) {
+                this.values = new Map();
+            }
+            if (this.values) {
+                this.values.set(prop_name, value);
+            }
+        }
+    }
+    ULTIPA.Node = Node;
+    function NewNodeRow(jsonObj) {
+        let v = new Node();
+        Object.assign(v, jsonObj);
+        return v;
+    }
+    function NewNodeTable(jsonArray) {
+        let v = [];
+        jsonArray === null || jsonArray === void 0 ? void 0 : jsonArray.forEach(o => {
+            v.push(NewNodeRow(o));
+        });
+        return v;
+    }
+    function NewNodeAlias(jsonObj) {
+        let v = {};
+        Object.assign(v, jsonObj);
+        v.nodes = NewNodeTable(v.nodes);
+        return v;
+    }
+    /**
+     * 边的结构
+     */
+    class Edge {
+        getUUID() {
+            return this._uuid;
+        }
+        getSchema() {
+            return this.schema;
+        }
+        getFrom() {
+            return this._from;
+        }
+        getTo() {
+            return this._to;
+        }
+        getValues() {
+            return this.values;
+        }
+        get(prop_name) {
+            return this.values.get(prop_name);
+        }
+        set(prop_name, value) {
+            if (!this.values) {
+                this.values = new Map();
+            }
+            if (this.values) {
+                this.values.set(prop_name, value);
+            }
+        }
+    }
+    ULTIPA.Edge = Edge;
+    function NewEdgeRow(jsonObj) {
+        let v = new Edge();
+        Object.assign(v, jsonObj);
+        return v;
+    }
+    function NewEdgeTable(jsonArray) {
+        let v = [];
+        jsonArray === null || jsonArray === void 0 ? void 0 : jsonArray.forEach(o => {
+            v.push(NewEdgeRow(o));
+        });
+        return v;
+    }
+    function NewEdgeAlias(jsonObj) {
+        let v = {};
+        Object.assign(v, jsonObj);
+        v.edges = NewEdgeTable(v.edges);
+        return v;
+    }
+    /**
+     * 路径的结构
+     */
+    class Path {
+        getNodes() {
+            return this.nodeUUIDs;
+        }
+        getEdges() {
+            return this.edgeUUIDs;
+        }
+    }
+    ULTIPA.Path = Path;
+    function NewPath(jsonObj) {
+        let v = new Path();
+        Object.assign(v, jsonObj);
+        if (v.nodeUUIDs) {
+            v.nodeUUIDs = NewNodeTable(jsonObj).map(j => j._uuid);
+        }
+        if (v.edgeUUIDs) {
+            v.edgeUUIDs = NewEdgeTable(jsonObj).map(j => j._uuid);
+        }
+        return v;
+    }
+    function NewPaths(jsonArray) {
+        let v = [];
+        jsonArray === null || jsonArray === void 0 ? void 0 : jsonArray.forEach(obj => {
+            v.push(NewPath(obj));
+        });
+        return v;
+    }
+    class Graph {
+        getPaths() {
+            return this.paths;
+        }
+        getNodes() {
+            return this.nodes;
+        }
+        getEdges() {
+            return this.edges;
+        }
+    }
+    ULTIPA.Graph = Graph;
+    function NewGraph(jsonArray) {
+        let v = new Graph();
+        Object.assign(v, jsonArray);
+        if (v.paths) {
+            v.paths = NewPaths(jsonArray.paths);
+        }
+        if (v.edges) {
+            v.edges = new Map();
+            NewEdgeTable(jsonArray.edges).forEach(e => {
+                v.edges.set(e._uuid, e);
+            });
+        }
+        if (v.nodes) {
+            v.nodes = new Map();
+            NewNodeTable(jsonArray.nodes).forEach(n => {
+                v.nodes.set(n._uuid, n);
+            });
+        }
+        return v;
+    }
+    function NewPathAlias(jsonObj) {
+        let v = {};
+        Object.assign(v, jsonObj);
+        if (v.paths) {
+            v.paths = NewPaths(v.paths);
+        }
+        return v;
+    }
+    function NewGraphAlias(jsonObj) {
+        let v = {};
+        Object.assign(v, jsonObj);
+        if (v.graph) {
+            v.graph = NewGraph(v.graph);
+        }
+        return v;
+    }
+    class License {
+    }
+    ULTIPA.License = License;
+    /**
+     * 表格的结构
+     */
+    class Table {
+        toKV() {
+            return utils_1.FormatResponse.tableToArray(this);
+        }
+        getHeaders() {
+            return this.headers;
+        }
+        getRows() {
+            return this.rows;
+        }
+    }
+    ULTIPA.Table = Table;
+    ;
+    function NewTable(jsonObj) {
+        let v = new Table();
+        Object.assign(v, jsonObj);
+        return v;
+    }
+    function NewQueryReplyBase(jsonObj) {
+        let v = {};
+        Object.assign(v, jsonObj);
+        if (v.paths) {
+            v.paths = v.paths.map(obj => {
+                return NewPathAlias(obj);
+            });
+        }
+        if (v.nodes) {
+            v.nodes = v.nodes.map(obj => {
+                return NewNodeAlias(obj);
+            });
+        }
+        if (v.edges) {
+            v.edges = v.edges.map(obj => {
+                return NewEdgeAlias(obj);
+            });
+        }
+        if (v.tables) {
+            v.tables = v.tables.map(obj => {
+                return NewTable(obj);
+            });
+        }
+        if (v.graph) {
+            v.graph = v.graph.map(obj => {
+                return NewGraphAlias(obj);
+            });
+        }
+        return v;
+    }
+    function getExplainPlansTreeTopNode(plans) {
+        let top = null;
+        let nodes = [];
+        plans === null || plans === void 0 ? void 0 : plans.plan_nodes.forEach((node, i) => {
+            node = Object.assign({}, node);
+            if (i == 0) {
+                top = node;
+            }
+            let lastNode = nodes[nodes.length - 1];
+            if (node.children_num > 0) {
+                node.children = [];
+                nodes.push(node);
+            }
+            if (lastNode) {
+                lastNode.children.push(node);
+                if (lastNode.children.length == lastNode.children_num) {
+                    nodes = nodes.filter(n => n != lastNode);
+                }
+            }
+        });
+        return top;
+    }
+    ULTIPA.getExplainPlansTreeTopNode = getExplainPlansTreeTopNode;
+    class QueryReply {
+        constructor(queryReplyBase) {
+            this.datas = [];
+            this.aliasMap = {};
+            if (queryReplyBase) {
+                queryReplyBase.paths.forEach(o => {
+                    this.aliasMap[o.alias] = new DataItem(o.alias, o.paths, ResultType.RESULT_TYPE_PATH);
+                });
+                queryReplyBase.graph.forEach(o => {
+                    this.aliasMap[o.alias] = new DataItem(o.alias, o.graph, ResultType.RESULT_TYPE_PATH);
+                });
+                queryReplyBase.nodes.forEach(o => {
+                    this.aliasMap[o.alias] = new DataItem(o.alias, o.nodes, ResultType.RESULT_TYPE_NODE);
+                });
+                queryReplyBase.edges.forEach(o => {
+                    this.aliasMap[o.alias] = new DataItem(o.alias, o.edges, ResultType.RESULT_TYPE_EDGE);
+                });
+                queryReplyBase.attrs.forEach(o => {
+                    this.aliasMap[o.alias] = new DataItem(o.alias, o, ResultType.RESULT_TYPE_ATTR);
+                });
+                queryReplyBase.tables.forEach(o => {
+                    this.aliasMap[o.alias] = new DataItem(o.alias, o, ResultType.RESULT_TYPE_TABLE);
+                });
+                queryReplyBase.results.forEach(o => {
+                    if (!this.aliasMap[o.alias]) {
+                        this.aliasMap[o.alias] = new DataItem(o.alias, this.defaultValueFromType(o.result_type, o.alias), o.result_type);
+                    }
+                    this.datas.push(this.aliasMap[o.alias]);
+                });
+                this.statistics = queryReplyBase.statistics;
+                this.explainPlansTreeTopNode = getExplainPlansTreeTopNode(queryReplyBase.explainPlans);
+            }
+        }
+        defaultValueFromType(type, alias) {
+            switch (type) {
+                case ResultType.RESULT_TYPE_NODE:
+                case ResultType.RESULT_TYPE_EDGE:
+                case ResultType.RESULT_TYPE_PATH:
+                    return [];
+                case ResultType.RESULT_TYPE_ATTR:
+                    let r = {
+                        alias: alias,
+                        attr: null,
+                    };
+                    return r;
+                case ResultType.RESULT_TYPE_TABLE:
+                    let t = new ULTIPA.Table();
+                    t.alias = alias;
+                    t.headers = [];
+                    t.rows = [];
+                    return t;
+                default:
+                    break;
+            }
+        }
+        ___aliasMapFromDatas() {
+            this.aliasMap = {};
+            this.datas.forEach(o => {
+                this.aliasMap[o.alias] = o;
+            });
+        }
+        isEmpty() {
+            return this.datas.length == 0;
+        }
+        singleDataNodes() {
+            var _a;
+            return ((_a = this.datas[0]) === null || _a === void 0 ? void 0 : _a.asNodes()) || this.defaultValueFromType(ResultType.RESULT_TYPE_NODE, "unknown");
+        }
+        singleDataEdges() {
+            var _a;
+            return ((_a = this.datas[0]) === null || _a === void 0 ? void 0 : _a.asEdges()) || this.defaultValueFromType(ResultType.RESULT_TYPE_EDGE, "unknown");
+        }
+        singleDataPaths() {
+            var _a;
+            return ((_a = this.datas[0]) === null || _a === void 0 ? void 0 : _a.asPaths()) || this.defaultValueFromType(ResultType.RESULT_TYPE_PATH, "unknown");
+        }
+        getTables() {
+            let tables = this.datas.filter(o => {
+                return o.type == ResultType.RESULT_TYPE_TABLE;
+            }).map(o => o.data);
+            return tables;
+        }
+        singleDataTables() {
+            var _a;
+            return ((_a = this.datas[0]) === null || _a === void 0 ? void 0 : _a.asTable()) || this.defaultValueFromType(ResultType.RESULT_TYPE_TABLE, "unknown");
+        }
+        singleDataAttrs() {
+            var _a;
+            return ((_a = this.datas[0]) === null || _a === void 0 ? void 0 : _a.asAttrs()) || this.defaultValueFromType(ResultType.RESULT_TYPE_ATTR, "unknown");
+        }
+        ;
+        get(index) {
+            return this.datas[index];
+        }
+        alias(alias) {
+            let rs = this.aliasMap[alias];
+            if (!rs) {
+                throw new Error(`Not Found Alias [${alias}]`);
+            }
+            return rs;
+        }
+        toJSON() {
+            return {
+                statistics: this.statistics,
+                explainPlansTreeTopNode: this.explainPlansTreeTopNode,
+                datas: this.datas,
+            };
+        }
+    }
+    ULTIPA.QueryReply = QueryReply;
+    function NewQueryReply(jsonObj) {
+        let v = new QueryReply(null);
+        Object.assign(v, jsonObj);
+        if (v.datas) {
+            v.datas = v.datas.map(obj => NewDataItem(obj));
+        }
+        v.___aliasMapFromDatas();
+        return v;
+    }
+    class DataItem {
+        constructor(alias, data, type) {
+            this.data = data;
+            this.alias = alias;
+            this.type = type;
+            this.type_desc = ResultType[type];
+        }
+        _asTypeError(t) {
+            if (this.type != t) {
+                throw new Error(`DataItem ${this.alias} is not type ${ResultType[t]}, but ${this.type_desc}`);
+            }
+        }
+        asEdges() {
+            this._asTypeError(ResultType.RESULT_TYPE_EDGE);
+            return this.data;
+        }
+        asPaths() {
+            this._asTypeError(ResultType.RESULT_TYPE_PATH);
+            return this.data.paths;
+        }
+        asGraph() {
+            this._asTypeError(ResultType.RESULT_TYPE_PATH);
+            return this.data;
+        }
+        asNodes() {
+            this._asTypeError(ResultType.RESULT_TYPE_NODE);
+            return this.data;
+        }
+        asTable() {
+            this._asTypeError(ResultType.RESULT_TYPE_TABLE);
+            return this.data;
+        }
+        asAttrs() {
+            this._asTypeError(ResultType.RESULT_TYPE_ATTR);
+            return this.data;
+        }
+        asNodeList() {
+            return this.asAttrs();
+        }
+        asEdgeList() {
+            return this.asAttrs();
+        }
+        asPathList() {
+            return this.asAttrs();
+        }
+        asGraphs() {
+            return this.asTableWithT();
+        }
+        asProperties() {
+            return this.asTableWithT();
+        }
+        asSchemas() {
+            return this.asTableWithT();
+        }
+        asAlgos() {
+            var _a;
+            let algos = [];
+            (_a = this.asTableWithT()) === null || _a === void 0 ? void 0 : _a.forEach(data => {
+                algos.push(_1.type_util.algoFormat(data));
+            });
+            return algos;
+        }
+        asExtas() {
+            return this.asTableWithT();
+        }
+        asTasks() {
+            var _a;
+            let tasks = [];
+            (_a = this.asTableWithT()) === null || _a === void 0 ? void 0 : _a.forEach(data => {
+                tasks.push(_1.type_util.taskFormat(data));
+            });
+            return tasks;
+        }
+        asAny() {
+            return this.data;
+        }
+        asTableWithT() {
+            var _a;
+            return (_a = this.asTable()) === null || _a === void 0 ? void 0 : _a.toKV();
+        }
+        toJSONString() {
+            return JSON.stringify(this);
+        }
+    }
+    ULTIPA.DataItem = DataItem;
+    function NewDataItem(jsonObj) {
+        let v = new DataItem(jsonObj.alias, jsonObj.data, jsonObj.type);
+        switch (v.type) {
+            case ResultType.RESULT_TYPE_EDGE:
+                v.data = NewEdgeTable(v.data);
+                break;
+            case ResultType.RESULT_TYPE_NODE:
+                v.data = NewNodeTable(v.data);
+                break;
+            case ResultType.RESULT_TYPE_PATH:
+                v.data = NewGraph(v.data);
+                break;
+            case ResultType.RESULT_TYPE_TABLE:
+                v.data = NewTable(v.data);
+                break;
+            default:
+                break;
+        }
+        return v;
+    }
+    /**
+     * 所有请求的统一返回结构体
+     */
+    class Response {
+    }
+    ULTIPA.Response = Response;
+    /**
+     * uql请求的返回结构体
+     */
+    class QueryResponse extends Response {
+    }
+    ULTIPA.QueryResponse = QueryResponse;
+    function NewQueryResponse(jsonObj) {
+        let v = new QueryResponse();
+        Object.assign(v, jsonObj);
+        if (v.data) {
+            v.data = NewQueryReply(v.data);
+        }
+        return v;
+    }
+    ULTIPA.NewQueryResponse = NewQueryResponse;
+    class QueryBaseResponse extends Response {
+    }
+    ULTIPA.QueryBaseResponse = QueryBaseResponse;
+    function NewUQLBaseResponse(jsonObj) {
+        let v = new QueryBaseResponse();
+        Object.assign(v, jsonObj);
+        if (v.data) {
+            v.data = NewQueryReplyBase(v.data);
+        }
+        return v;
+    }
+    ULTIPA.NewUQLBaseResponse = NewUQLBaseResponse;
+    function formatBaseResponse(base) {
+        let res = Object.assign({}, base);
+        res.data = new QueryReply(res.data);
+        return res;
+    }
+    ULTIPA.formatBaseResponse = formatBaseResponse;
+    class UQLSingleResponse {
+    }
+    ULTIPA.UQLSingleResponse = UQLSingleResponse;
+    class TruncateType {
+    }
+    ULTIPA.TruncateType = TruncateType;
+})(ULTIPA = exports.ULTIPA || (exports.ULTIPA = {}));
+//# sourceMappingURL=types.js.map