数据结构

基础信息

用户邮箱：

用户昵称：
手机号：
公司名称：
公司邮箱:

修改密码

申请证书

当前未申请证书.

申请证书

Certificate	Issued at	Valid until	Serial No.	File

Serial No.	Valid until	File

Not having one? Apply now! >>>

ProductName	CreateTime	ID	Price	File

ProductName	CreateTime	ID	Price	File

No Invoice

本节介绍驱动提供的核心数据结构。

Node

Node包含以下字段：

字段	类型	描述
`uuid`	string	点`_uuid`
`id`	string	点`_id`
`schema`	string	点所属的Schema名称
`values`	[key: string]: any	点属性键值对

如果一个查询返回点，使用asNodes()将它们转换成一个Node对象列表。

const requestConfig: RequestConfig = { graph: "g1" };
const response = await driver.gql("MATCH (n:User) RETURN n LIMIT 2", requestConfig);
const nodes = response.alias("n").asNodes();
for (const node of nodes) {
  console.log(node)
}

Node {
  uuid: '6557243256474697731',
  id: 'U4',
  schema: 'User',
  values: { name: 'mochaeach' }
}
Node {
  uuid: '7926337543195328514',
  id: 'U2',
  schema: 'User',
  values: { name: 'Brainy' }
}

Edge

Edge包含以下字段：

字段	类型	描述
`uuid`	string	边`_uuid`
`fromUuid`	string	边起点的`_uuid`
`toUuid`	string	边终点的`_uuid`
`from`	string	边起点的`_id`
`to`	string	边终点的`_id`
`schema`	string	边所属的Schema名称
`values`	[key: string]: any	边属性键值对

如果一个查询返回边，使用asEdges()将它们转换成一个Edge对象列表。

const requestConfig: RequestConfig = { graph: "g1" };
const response = await driver.gql("MATCH ()-[e]->() RETURN e LIMIT 2", requestConfig);
const edges = response.alias("e").asEdges();
for (const edge of edges) {
  console.log(edge)
}

Edge {
  uuid: '2',
  fromUuid: '6557243256474697731',
  toUuid: '7926337543195328514',
  from: 'U4',
  to: 'U2',
  schema: 'Follows',
  values: { createdOn: '2024-02-10' }
}
Edge {
  uuid: '3',
  fromUuid: '7926337543195328514',
  toUuid: '17870285520429383683',
  from: 'U2',
  to: 'U3',
  schema: 'Follows',
  values: { createdOn: '2024-02-01' }
}

Path

Path包含以下字段：

字段	类型	描述
`nodeUuids`	string[]	路径中点的`_uuid`列表
`edgeUuids`	string[]	路径中边的`_uuid`列表
`nodes`	Map<string, `Node`>	路径中点的映射，其中键是点的`_uuid`，值是相应的点
`edges`	Map<string, `Edge`>	路径中边的映射，其中键是边的`_uuid`，值是相应的边

Path支持的方法：

方法	参数	返回值	描述
`length()`	/	number	返回路径中的边数量

如果查询返回路径，可以先使用asGraph()将结果转换为一个Graph对象，通过Graph对象可获取返回的路径：

const requestConfig: RequestConfig = { graph: "g1" };
const response = await driver.gql("MATCH p = ()-[]-() RETURN p LIMIT 2", requestConfig);
const graph = response.alias("p").asGraph();
const paths = graph.getPaths();
for (const path of paths) {
  console.log("Node _uuids:", path.nodeUuids, "Length:", path.length())
};

Node _uuids: [ '6557243256474697731', '7926337543195328514' ] Length: 1
Node _uuids: [ '7926337543195328514', '17870285520429383683' ] Length: 1

Graph

Graph包含以下字段：

字段	类型	描述
`paths`	`Path`[]	返回的路径列表
`nodes`	Map<string, `Node`>	图中所有不重复点的映射，其中键是点的`_uuid`，值是相应的点
`edges`	Map<string, `Edge`>	图中所有不重复边的映射，其中键是边的`_uuid`，值是相应的边

Graph支持的方法：

方法	参数	返回值	描述
`getPaths()`	/	`Path`[]	返回组成图的`Path`对象列表
`addNode()`	`node: Node`	void	向`nodes`中新增一个点
`addEdge()`	`edge: Edge`	void	向`edges`中新增一条边

如果一个查询返回路径，使用asGraph()将它们转换成一个Graph对象。

const requestConfig: RequestConfig = { graph: "g1" };
const response = await driver.gql("MATCH p = ()-[]->() RETURN p LIMIT 2", requestConfig);
const graph = response.alias("p").asGraph();
console.log("Unique nodes:", graph.nodes)
console.log("Unique edges:", graph.edges)
console.log("All paths:", graph.paths)

Unique nodes: Map(3) {
  '6557243256474697731' => Node {
    uuid: '6557243256474697731',
    id: 'U4',
    schema: 'User',
    values: { name: 'mochaeach' }
  },
  '7926337543195328514' => Node {
    uuid: '7926337543195328514',
    id: 'U2',
    schema: 'User',
    values: { name: 'Brainy' }
  },
  '17870285520429383683' => Node {
    uuid: '17870285520429383683',
    id: 'U3',
    schema: 'User',
    values: { name: 'purplechalk' }
  }
}
Unique edges: Map(2) {
  '2' => Edge {
    uuid: '2',
    fromUuid: '6557243256474697731',
    toUuid: '7926337543195328514',
    from: 'U4',
    to: 'U2',
    schema: 'Follows',
    values: { createdOn: '2024-02-10' }
  },
  '3' => Edge {
    uuid: '3',
    fromUuid: '7926337543195328514',
    toUuid: '17870285520429383683',
    from: 'U2',
    to: 'U3',
    schema: 'Follows',
    values: { createdOn: '2024-02-01' }
  }
}
All paths: [
  Path {
    nodeUuids: [ '6557243256474697731', '7926337543195328514' ],
    edgeUuids: [ '2' ],
    nodes: Map(2) {
      '6557243256474697731' => [Node],
      '7926337543195328514' => [Node]
    },
    edges: Map(1) { '2' => [Edge] }
  },
  Path {
    nodeUuids: [ '7926337543195328514', '17870285520429383683' ],
    edgeUuids: [ '3' ],
    nodes: Map(2) {
      '7926337543195328514' => [Node],
      '17870285520429383683' => [Node]
    },
    edges: Map(1) { '3' => [Edge] }
  }
]

GraphSet

GraphSet包含以下字段：

字段	类型	描述
`id`	string	图ID
`name`	string	图名称
`totalNodes`	string	图中点的总数
`totalEdges`	string	图中边的总数
`shards`	string[]	用来存储图的Shard服务器的ID列表
`partitionBy`	string	用于图分片的哈希函数，包括`Crc32`（默认）、`Crc64WE`、`Crc64XZ`和`CityHash64`
`status`	string	图状态，包括`NORMAL`、`LOADING_SNAPSHOT`、`CREATING`、`DROPPING`和`SCALING`
`description`	string	图描述
`slotNum`	number	图分片使用的槽数量

如果一个查询获取数据库中的图（图集），使用asGraphSets()将它们转换成一个GraphSet对象列表。

const response = await driver.gql("SHOW GRAPH");
const graphsets = response.get(0).asGraphSets();
for (const graphset of graphsets) {
  console.log(graphset.name)
}

showGraph()方法也可以获取数据库中的图（图集），它直接返回一个GraphSet对象列表。

const graphs = await driver.showGraph();
graphs.forEach((graph) => console.log(graph.name));

g1
miniCircle
amz

Schema

Schema包含以下字段：

字段	类型	描述
`name`	string	Schema名称
`dbType`	`DBType`	Schema类型，包括`DBNODE`和`DBEDGE`
`properties`	`Property`[]	与Schema关联的属性列表
`description`	string	Schema描述
`total`	string	属于该Schema的点或边总数
`id`	string	Schema ID
`stats`	`SchemaStat`[]	一个`SchemaStat`对象列表，每个`SchemaStat`对象包含字段`schema`（Schema名称）、`dbType`（Schema类型）、`fromSchema`（起点Schema）、`toSchema`（终点Schema）以及`count`（点或边的数量）

如果一个查询获取图中定义的点、边Schema，使用asSchemas()将它们转换成一个Schema对象列表。

const requestConfig: RequestConfig = { graph: "miniCircle" };
const response = await driver.gql("SHOW NODE SCHEMA", requestConfig);
const schemas = response.get(0).asSchemas();
for (const schema of schemas) {
  console.log(schema.name)
}

showSchema()、showNodeSchema()和showEdgeSchema()方法也可以获取图中定义的点、边Schema，它们直接返回一个Schema对象列表。

const requestConfig: RequestConfig = { graph: "miniCircle" };
const schemas = await driver.showSchema(requestConfig);
schemas.forEach((schema: any) => {
  console.log(schema.name);
});

default
account
celebrity
country
movie

Property

Property包含以下字段：

字段	类型	描述
`name`	string	属性名
`type`	`UltipaPropertyType`	属性值类型，包括`INT32`、`UINT32`、`INT64`、`UINT64`、`FLOAT`、`DOUBLE`、`DECIMAL`、`STRING`、`TEXT`、`LOCAL_DATETIME`、`ZONED_DATETIME`、`DATE`、`LOCAL_TIME`、`ZONED_TIME`、`DATETIME`、`TIMESTAMP`、`YEAR_TO_MONTH`、`DAY_TO_SECOND`、`BLOB`、`BOOL`、`POINT`、`LIST`、`SET`、`MAP`、`UUID`、`ID`、`FROM`、`FROM_UUID`、`TO`、`TO_UUID`、`IGNORE`和`UNSET`
`subType`	`UltipaPropertyType`[]	如果`type`为`LIST`或`SET`，设定其元素类型；列表内只能包括一个`UltipaPropertyType`
`schema`	string	属性关联的Schema名称
`description`	string	属性描述
`lte`	boolean	属性是否加载到引擎（LTE）
`read`	boolean	属性是否可读
`write`	boolean	属性是否可写
`encrypt`	string	属性加密方法，包括`AES128`、`AES256`、`RSA`和`ECC`
`decimalExtra`	`DecimalExtra`	`DECIMAL`类型的精度（1到65）和标度（0到30）

如果一个查询获取图中定义的点、边属性，使用asProperties()将它们转换成一个Property对象列表。

const requestConfig: RequestConfig = { graph: "miniCircle" };
const response = await driver.gql("SHOW NODE account PROPERTY", requestConfig);
const properties = response.get(0).asProperties();
for (const property of properties) {
  console.log(property.name)
}

showProperty()、showNodeProperty()和showEdgeProperty()方法也可以获取图中定义的点、边属性，它们直接返回一个Property对象列表。

const requestConfig: RequestConfig = { graph: "miniCircle" };
const properties = await driver.showProperty(DBType.DBNODE, "account", requestConfig);
properties.nodeProperties.forEach((property) => {
  console.log(property.name)
});

_id
gender
year
industry
name

Attr

Attr包含以下字段：

字段	类型	描述
`name`	string	返回的别名
`values`	object[]	返回值
`propertyType`	`UltipaPropertyType`	返回的属性类型
`resultType`	`ResultType`	返回结果的类型，包括`RESULT_TYPE_UNSET`、`RESULT_TYPE_PATH`、`RESULT_TYPE_NODE`、`RESULT_TYPE_EDGE`、`RESULT_TYPE_ATTR`和`RESULT_TYPE_TABLE`

如果一个查询返回属性、表达式或计算结果等值，使用asAttr()将它们转换成一个Attr对象。

const requestConfig: RequestConfig = { graph: "g1" };
const response = await driver.gql("MATCH (n:User) LIMIT 2 RETURN n.name", requestConfig);
const attr = response.alias("n.name").asAttr();
console.log(attr)

Attr {
  propertyType: 7,
  resultType: 4,
  values: [ 'mochaeach', 'Brainy' ],
  name: 'n.name'
}

Table

Table包含以下字段：

字段	类型	描述
`name`	string	表名称
`headers`	`Header`[]	表头
`rows`	any[][]	表中的行

Table支持的方法：

方法	参数	返回值	描述
`toKV()`	/	any[]	将表中的所有行转换成键值对对象组成的数组

如果一个查询使用table()函数返回行和列，使用asTable()将它们转换成一个Table对象。

const requestConfig: RequestConfig = { graph: "g1" };
const response = await driver.gql("MATCH (n:User) LIMIT 2 RETURN table(n._id, n.name) AS result", requestConfig);
const table = response.alias("result").asTable();
console.log(table)

Table {
  name: 'result',
  headers: [
    Header { propertyName: 'n._id', propertyType: 7 },
    Header { propertyName: 'n.name', propertyType: 7 }
  ],
  rows: [ [ 'U4', 'mochaeach' ], [ 'U2', 'Brainy' ] ]
}

HDCGraph

HDCGraph包含以下字段：

字段	类型	描述
`name`	string	HDC图名称
`graphName`	string	HDC图的源图名称
`status`	string	HDC图状态
`stats`	string	HDC图的统计信息
`isDefault`	string	是否为源图的默认HDC图
`hdcServerName`	string	托管HDC图的HDC服务器名称
`hdcServerStatus`	string	托管HDC图的HDC服务器状态
`config`	string	HDC图的配置

如果一个查询获取一个图的HDC图，使用asHDCGraphs()将它们转换成一个HDCGraph对象列表。

const response = await driver.gql("SHOW HDC GRAPH ON 'hdc-server-1'");
const hdcGraphs = response.get(0).asHDCGraphs();
for (const hdcGraph of hdcGraphs) {
  console.log(hdcGraph.name)
}

showHDCGraph()方法也可以获取一个图的HDC图，它直接返回一个HDCGraph对象列表。

const requestConfig: RequestConfig = { graph: "g1" };
const hdcGraphs = await driver.showHDCGraph(requestConfig);
for (const hdcGraph of hdcGraphs) {
  console.log(hdcGraph.name);
}

g1_hdc_full
g1_hdc_nodes

Algo

Algo包含以下字段：

字段	类型	描述
`name`	string	算法名称
`type`	string	算法类型
`version`	string	算法版本
`params`	`AlgoParam`[]	算法参数，每个`AlgoParam`有字段`name`和`desc`
`writeSupportType`	string	算法支持的回写类型
`canRollback`	string	算法版本是否可回退
`configContext`	string	算法配置文件内容

如果一个查询获取数据库中安装的算法，使用asAlgos()将它们转换成一个Algo对象列表。

const response = await driver.gql("SHOW HDC ALGO ON 'hdc-server-1'");
const algos = response.get(0).asAlgos();
for (const algo of algos) {
  if (algo.type === "algo") {
    console.log(algo.name)
  }
}

showHDCAlgo()方法也可以获取数据库中安装的算法，它直接返回一个Algo对象列表。

const algos = await driver.showHDCAlgo("hdc-server-1");
for (const algo of algos) {
  if (algo.type == "algo") {
    console.log(algo.name);
  }
}

bipartite
fastRP

Projection

Projection包含以下字段：

字段	类型	描述
`name`	string	映射名称
`graphName`	string	映射的源图名称
`status`	string	映射状态
`stats`	string	映射的统计信息
`config`	string	映射的配置

如果一个查询获取一个图的映射，使用asProjections()将它们转换成一个Projection对象列表。

const requestConfig: RequestConfig = { graph: "g1" };
const response = await driver.gql("SHOW PROJECTION", requestConfig);
const projections = response.get(0).asProjections();
for (const projection of projections) {
  console.log(projection.name)
}

distG1
distG1_nodes

Index

Index包含以下字段：

字段	类型	描述
`id`	string	索引ID
`name`	string	索引名称
`properties`	string	索引关联的属性
`schema`	string	索引关联的Schema
`status`	string	索引状态
`size`	string	索引大小（单位：字节）
`dbType`	`DBType`	索引类型，包括`DBNODE`和`DBEDGE`

如果一个查询获取图中点、边的索引，使用asIndexes()将它们转换成一个Index对象列表。

const requestConfig: RequestConfig = { graph: "g1" };
const response = await driver.gql("SHOW NODE INDEX", requestConfig);
const indexes = response.get(0).asIndexes();
for (const index of indexes) {
  console.log(index)
}

showIndex()、showNodeIndex()和showEdgeIndex()方法也可以获取图中点、边的索引，它直接返回一个Index对象列表。

const requestConfig: RequestConfig = { graph: "g1" };
const indexList = await driver.showIndex(requestConfig);
for (const index of indexList) {
  console.log(index);
}

Index {
  id: '1',
  name: 'User_name',
  properties: 'name(1024)',
  schema: 'User',
  status: 'DONE',
  size: undefined,
  dbType: 0
}

Privilege

Privilege包含以下字段：

字段	类型	描述
`name`	string	权限名称
`level`	`PrivilegeLevel`	权限级别，包括`GraphLevel`和`SystemLevel`

如果一个查询获取嬴图中定义的权限，使用asPrivileges()将它们转换成一个Privilege对象列表。

const response = await driver.uql("show().privilege()");
const privileges = response.get(0).asPrivileges();

const graphPriviledgeNames = privileges
  .filter((p) => p.level === PrivilegeLevel.GraphLevel)
  .map((p) => p.name)
  .join(", ");
console.log("Graph privileges:" + graphPriviledgeNames);

const systemPriviledgeNames = privileges
  .filter((p) => p.level === PrivilegeLevel.SystemLevel)
  .map((p) => p.name)
  .join(", ");
console.log("System privileges:" + systemPriviledgeNames);

showPrivilege()方法也可以获取嬴图中定义的权限，它直接返回一个Privilege对象列表。

const privileges = await driver.showPrivilege();

const graphPriviledgeNames = privileges
  .filter((p) => p.level === PrivilegeLevel.GraphLevel)
  .map((p) => p.name)
  .join(", ");
console.log("Graph privileges:" + graphPriviledgeNames);

const systemPriviledgeNames = privileges
  .filter((p) => p.level === PrivilegeLevel.SystemLevel)
  .map((p) => p.name)
  .join(", ");
console.log("System privileges:" + systemPriviledgeNames);

Graph privileges: READ, INSERT, UPSERT, UPDATE, DELETE, CREATE_SCHEMA, DROP_SCHEMA, ALTER_SCHEMA, SHOW_SCHEMA, RELOAD_SCHEMA, CREATE_PROPERTY, DROP_PROPERTY, ALTER_PROPERTY, SHOW_PROPERTY, CREATE_FULLTEXT, DROP_FULLTEXT, SHOW_FULLTEXT, CREATE_INDEX, DROP_INDEX, SHOW_INDEX, LTE, UFE, CLEAR_JOB, STOP_JOB, SHOW_JOB, ALGO, CREATE_PROJECT, SHOW_PROJECT, DROP_PROJECT, CREATE_HDC_GRAPH, SHOW_HDC_GRAPH, DROP_HDC_GRAPH, COMPACT_HDC_GRAPH, SHOW_VECTOR_INDEX, CREATE_VECTOR_INDEX, DROP_VECTOR_INDEX, SHOW_CONSTRAINT, CREATE_CONSTRAINT, DROP_CONSTRAINT
System privileges: TRUNCATE, COMPACT, CREATE_GRAPH, SHOW_GRAPH, DROP_GRAPH, ALTER_GRAPH, TOP, KILL, STAT, SHOW_POLICY, CREATE_POLICY, DROP_POLICY, ALTER_POLICY, SHOW_USER, CREATE_USER, DROP_USER, ALTER_USER, SHOW_PRIVILEGE, SHOW_META, SHOW_SHARD, ADD_SHARD, DELETE_SHARD, REPLACE_SHARD, SHOW_HDC_SERVER, ADD_HDC_SERVER, DELETE_HDC_SERVER, LICENSE_UPDATE, LICENSE_DUMP, GRANT, REVOKE, SHOW_BACKUP, CREATE_BACKUP, SHOW_VECTOR_SERVER, ADD_VECTOR_SERVER, DELETE_VECTOR_SERVER

Policy

Policy包含以下字段：

字段	类型	描述
`name`	string	策略名称
`systemPrivileges`	string[]	策略中包含的系统权限
`graphPrivileges`	Map<string, string[]>	策略中包含的图集权限；在映射中，键是图集名称，值是相应的图集权限
`propertyPrivileges`	`PropertyPrivilege`	策略中包含的属性权限；`PropertyPrivilege`有`node`和`edge`两个字段，都是`PropertyPrivilegeElement`对象
`policies`	string[]	策略中包含的其他策略

PropertyPrivilegeElement包含以下字段：

字段	类型	描述
`read`	string[][]	一个由数组组成的数组；每个内部数组包含三个字符串，分别表示图、Schema和属性
`write`	string[][]	一个由数组组成的数组；每个内部数组包含三个字符串，分别表示图、Schema和属性
`deny`	string[][]	一个由数组组成的数组；每个内部数组包含三个字符串，分别表示图、Schema和属性

如果一个查询获取数据库中定义的策略（角色），使用asPolicies()将它们转换成一个Policy对象列表。

const response = await driver.gql("SHOW ROLE");
const policies = response.get(0).asPolicies();
for (const policy of policies) {
  console.log(policy.name)
}

showPolicy()方法也可以获取数据库中定义的策略（角色），它直接返回一个Policy对象列表。

const policies = await driver.showPolicy();
for (const policy of policies) {
  console.log(policy.name);
}

manager
Tester
operator
superADM

User

User包含以下字段：

字段	类型	描述
`username`	string	用户名
`password`	string	密码
`createdTime`	`Date`	用户创建时间
`systemPrivileges`	string[]	授予用户的系统权限
`graphPrivileges`	Map<string, string[]>	授予用户的图集权限；在映射中，键是图集名称，值是相应的图集权限
`propertyPrivileges`	`PropertyPrivilege`	授予用户的属性权限；`PropertyPrivilege`有`node`和`edge`两个字段，都是`PropertyPrivilegeElement`对象
`policies`	string[]	授予用户的策略

PropertyPrivilegeElement包含以下字段：

字段	类型	描述
`read`	string[][]	一个由数组组成的数组；每个内部数组包含三个字符串，分别表示图、Schema和属性
`write`	string[][]	一个由数组组成的数组；每个内部数组包含三个字符串，分别表示图、Schema和属性
`deny`	string[][]	一个由数组组成的数组；每个内部数组包含三个字符串，分别表示图、Schema和属性

如果一个查询获取数据库用户，使用asUsers()将它们转换成一个User对象列表。

const response = await driver.gql("SHOW USER");
const users = response.get(0).asUsers();
for (const user of users) {
  console.log(user.username)
}

showUser()方法也可以获取数据库用户，它直接返回一个User对象列表。

const users = await driver.showUser();
for (const user of users) {
  console.log(user.username);
}

user01
root
johndoe

Process

Process包含以下字段：

字段	类型	描述
`processId`	string	进程ID
`processQuery`	string	进程执行的语句
`status`	string	进程状态
`duration`	string	任务的运行时长（单位：秒）

如果一个查询获取数据库中的进程，使用asProcesses()将它们转换成一个Process对象列表。

const response = await driver.gql("TOP");
const processes = response.get(0).asProcesses();
for (const process of processes) {
  console.log(process)
}

top()方法也可以获取数据库中的进程，它直接返回一个Process对象列表。

const processes = await driver.top();
for (const process of processes){
  console.log(process);
}

Process {
  processId: '1060719',
  processQuery: 'MATCH p = ()-{1,7}() RETURN p',
  duration: '1',
  status: 'RUNNING'
}

Job

Job包含以下字段：

字段	类型	描述
`id`	string	作业ID
`graphName`	string	作业执行所在的图名称
`query`	string	作业执行的语句
`type`	string	作业类型
`errNsg`	string	作业错误信息
`result`	Map<any, any>	作业结果
`startTime`	string	作业开始时间
`endTime`	string	作业结束时间
`status`	string	作业状态
`progress`	string	作业的进度更新，例如提示回写操作已开始

如果一个查询获取一个图的作业，使用asJobs()将它们转换成一个Job对象列表。

const requestConfig: RequestConfig = { graph: "g1" };
const response = await driver.gql("SHOW JOB", requestConfig);
const jobs = response.get(0).asJobs();
for (const job of jobs) {
  console.log(job)
}

showJob()方法也可以获取一个图的作业，它直接返回一个Job对象列表。

const requestConfig: RequestConfig = { graph: "g1" };
const jobs = await driver.showJob(undefined, requestConfig);
for (const job of jobs) {
  console.log(job);
}

Job {
  id: '5',
  graphName: 'g1',
  query: 'CREATE INDEX User_name ON NODE User (name)',
  type: 'CREATE_INDEX',
  errMsg: '',
  result: null,
  startTime: '2025-09-23 17:43:54',
  endTime: '2025-09-23 17:43:55',
  status: 'FINISHED',
  progress: ''
}
Job {
  id: '5_1',
  graphName: 'g1',
  query: '',
  type: 'CREATE_INDEX',
  errMsg: '',
  result: null,
  startTime: '2025-09-23 17:43:55',
  endTime: '2025-09-23 17:43:55',
  status: 'FINISHED',
  progress: ''
}
Job {
  id: '5_2',
  graphName: 'g1',
  query: '',
  type: 'CREATE_INDEX',
  errMsg: '',
  result: null,
  startTime: '2025-09-23 17:43:55',
  endTime: '2025-09-23 17:43:55',
  status: 'FINISHED',
  progress: ''
}
Job {
  id: '5_3',
  graphName: 'g1',
  query: '',
  type: 'CREATE_INDEX',
  errMsg: '',
  result: null,
  startTime: '2025-09-23 17:43:55',
  endTime: '2025-09-23 17:43:55',
  status: 'FINISHED',
  progress: ''
}
Job {
  id: '1',
  graphName: 'g1',
  query: 'CREATE HDC GRAPH g1_hdc_full ON "hdc-server-1" OPTIONS {\n' +
    '  nodes: {"*": ["*"]},\n' +
    '  edges: {"*": ["*"]},\n' +
    '  direction: "undirected",\n' +
    '  load_id: true,\n' +
    '  update: "static"\n' +
    '}',
  type: 'CREATE_HDC_GRAPH',
  errMsg: '',
  result: Map(4) {
    'edge_count' => 4,
    'edge_schema' => { Follows: [Object], default: [Object] },
    'node_count' => 5,
    'node_schema' => { User: [Object], default: [Object] }
  },
  startTime: '2025-09-23 17:29:05',
  endTime: '2025-09-23 17:29:07',
  status: 'FINISHED',
  progress: ''
}
Job {
  id: '1_1',
  graphName: 'g1',
  query: '',
  type: 'CREATE_HDC_GRAPH',
  errMsg: '',
  result: null,
  startTime: '2025-09-23 17:29:05',
  endTime: '2025-09-23 17:29:07',
  status: 'FINISHED',
  progress: ''
}