Méthodes de Mapping

La méthode get() ou alias() de la classe Response retourne un DataItem, qui intègre le résultat de la requête. Vous devez utiliser la méthode as<Type>() de DataItem pour convertir le résultat au type de conducteur approprié.

let requestConfig = <RequestType.RequestConfig>{
  useMaster: true,
  graphSetName: "miniCircle",
};

let resp = await conn.uql(
  "find().nodes() as n return n{*} limit 5",
  requestConfig
);

console.log(resp.data?.get(0).asNodes());

Le résultat n provenant de la base de données contient cinq nodes, chacun du type NODE. La méthode asNodes() les convertit en une liste d'objets Node.

Méthodes de mapping de type disponibles sur DataItem:

Types de Conducteurs

Les objets de tous les types de conducteurs supportent les méthodes getter pour récupérer la valeur d'un champ et les méthodes setter pour définir la valeur d'un champ, même si elles ne sont pas explicitement répertoriées ci-dessous.

Node

Un objet Node a les champs suivants :

Méthodes sur un objet Node :

let resp = await conn.uql(
  "find().nodes() as n return n{*} limit 5",
  requestConfig
);
let nodeList = resp.data?.alias("n").asNodes();

console.log("ID of the 1st node:", nodeList[0].getID());
console.log("Name of the 1st node:", nodeList[0].get("name"));

ID of the 1st node: ULTIPA8000000000000001
Name of the 1st node: Titanic

Edge

Un objet Edge a les champs suivants :

Méthodes sur un objet Edge :

let resp = await conn.uql(
  "find().edges() as e return e{*} limit 5",
  requestConfig
);
let edgeList = resp.data?.alias("e").asEdges();

console.log("Values of the 1st edge", edgeList[0].getValues());

Values of the 1st edge {
  datetime: '2019-01-06 02:57:57',
  timestamp: 1546714677,
  targetPost: '703'
}

Path

Un objet Path a les champs suivants :

let resp = await conn.uql(
  "n().e()[:2].n() as paths return paths{*} limit 5",
  requestConfig
);
let pathList = resp.data?.alias("paths").asPaths();

console.log("Length of the 1st path:", pathList[0].length);
console.log("Edge list of the 1st path:", pathList[0].getEdges());
console.log(
  "Information of the 2nd node in the 1st path:",
  pathList[0].getNodes()[1]
);

Length of the 1st path: 2
Edge list of the 1st path: [
  Edge {
    from: 'ULTIPA800000000000001B',
    to: 'ULTIPA8000000000000001',
    uuid: '7',
    from_uuid: '27',
    to_uuid: '1',
    schema: 'follow',
    values: {}
  },
  Edge {
    from: 'ULTIPA8000000000000021',
    to: 'ULTIPA800000000000001B',
    uuid: '99',
    from_uuid: '33',
    to_uuid: '27',
    schema: 'follow',
    values: {}
  }
]
Information of the 2nd node in the 1st path: Node {
  id: 'ULTIPA800000000000001B',
  uuid: '27',
  schema: 'account',
  values: {
    year: 1988,
    industry: 'Transportation',
    double: '3.72'
  }
}

Graph

Un objet Graph a les champs suivants :

let resp = await conn.uql(
  "n(as n1).re(as e).n(as n2).limit(3) with toGraph(collect(n1), collect(n2), collect(e)) as graph return graph",
  requestConfig
);
let graphList = resp.data?.alias("graph").asGraph();

let nodeList = graphList.getNodes();
let edgeList = graphList.getEdges();
console.log(
  "Node IDs:",
  nodeList.map((node) => node.getID())
);
console.log(
  "Edge UUIDs:",
  edgeList.map((edge) => edge.getUUID())
);

Node IDs: [
  'ULTIPA8000000000000017',
  'ULTIPA8000000000000001',
  'ULTIPA800000000000001B',
  'ULTIPA8000000000000061'
]
Edge UUIDs: [ '43', '1576', '29' ]

GraphSet

Un objet GraphSet a les champs suivants :

let resp = await conn.uql("show().graph()");
let graphList = resp.data?.alias("_graph").asGraphInfos();

let unmountedGraph = graphList.filter((item) => item.status == "UNMOUNTED");
console.log(unmountedGraph.map((item) => item.name));

[ 'DFS_EG', 'cyber', 'cyber2' ]

Schema

Un objet Schema a les champs suivants :

let resp = await conn.uql("show().node_schema()", requestConfig);
let schemaList = resp.data?.alias("_nodeSchema").asSchemas();

for (let schema of schemaList) {
  console.log(schema.name, "has", schema.totalNodes, "nodes");
}

default has 0 nodes
account has 111 nodes
movie has 92 nodes
country has 23 nodes
celebrity has 78 nodes

Property

Un objet Property a les champs suivants :

let resp = await conn.uql("show().node_property(@user)", requestConfig);
let propertyList = resp.data?.alias("_nodeProperty").asProperties();

for (let property of propertyList) {
  if (property.lte == "true")
    console.log("LTE-ed property name:", property.name);
}

LTE-ed property name: location

Algo

Un objet Algo a les champs suivants :

let resp = await conn.uql("show().algo()");
let algoList = resp.data?.alias("_algoList").asAlgos();
console.log("Algo name:", algoList[0].param.name);
console.log("Algo version:", algoList[0].param.version);
console.log("Description:", algoList[0].param.description);

Algo name: lpa
Algo version: 1.0.10
Description: label propagation algorithm

Exta

Une exta est un algorithme personnalisé développé par les utilisateurs.

Un objet Exta a les champs suivants :

let resp = await conn.uql("show().exta()");
let extaList = resp.data?.alias("_extaList").asExtas();
console.log("Exta name:", extaList[0].name);

Exta name: page_rank 1

Index

Un objet Index a les champs suivants :

let resp = await conn.uql("show().index()");
let indexList = resp.data?.alias("_nodeIndex");
console.log(indexList.data);

Table {
  name: '_nodeIndex',
  alias: '_nodeIndex',
  headers: [ 'name', 'properties', 'schema', 'status', 'size' ],
  rows: []
}

let resp = await conn.uql("show().fulltext()");
let indexList = resp.data?.alias("_nodeFulltext");
console.log(indexList.data);

Table {
  name: '_nodeFulltext',
  alias: '_nodeFulltext',
  headers: [ 'name', 'properties', 'schema', 'status' ],
  rows: []
}

Privilege

Un objet Privilege a les champs suivants :

let resp = await conn.uql("show().privilege()");
let privilegeList = resp.data?.alias("_privilege").asTable();

console.log("System privileges:", privilegeList.rows[0][1]);

[TRUNCATE, COMPACT, CREATE_GRAPH, SHOW_GRAPH, DROP_GRAPH, ALTER_GRAPH, MOUNT_GRAPH, UNMOUNT_GRAPH, TOP, KILL, STAT, SHOW_POLICY, CREATE_POLICY, DROP_POLICY, ALTER_POLICY, SHOW_USER, CREATE_USER, DROP_USER, ALTER_USER, GRANT, REVOKE, SHOW_PRIVILEGE]

Policy

Un objet Policy a les champs suivants :

let resp = await conn.uql("show().policy()");
let policyList = resp.data?.alias("_policy");
console.log(policyList.data.rows[4]);

[
  'policy',
  '{"amz":["SHOW_ALGO","CREATE_PROPERTY","CLEAR_TASK","RESUME_TASK","CREATE_BACKUP","SHOW_PROPERTY","SHOW_FULLTEXT","SHOW_INDEX"]}',
  '["GRANT","DROP_GRAPH","CREATE_USER","COMPACT","UNMOUNT_GRAPH","STAT","DROP_POLICY"]',
  '{"node":{"read":[],"write":[],"deny":[]},"edge":{"read":[],"write":[],"deny":[]}}',
  '["subpolicy"]'
]

User

Un objet User a les champs suivants :

let resp = await conn.uql("show().user('Tester')");
let userList = resp.data.alias("_user").asTable();

console.log(userList.headers[0], ":", userList.rows[0][0]);
console.log(userList.headers[1], ":", userList.rows[0][1]);
console.log(userList.headers[2], ":", userList.rows[0][2]);
console.log(userList.headers[3], ":", userList.rows[0][3]);
console.log(userList.headers[4], ":", userList.rows[0][4]);

username : Tester
create : 1721974206
graphPrivileges : {"Ad_Click":["FIND_EDGE","FIND_NODE"],"DFS_EG":["UPDATE","INSERT"]}
systemPrivileges : ["MOUNT_GRAPH"]
propertyPrivileges : {"node":{"read":[],"write":[["miniCircle","account","name"]],"deny":[]},"edge":{"read":[],"write":[],"deny":[]} 

Stats

Un objet Stats a les champs suivants :

let resp = await conn.stats();
console.log("CPU usage:", resp.data.cpuUsage, "%");
console.log("Memory usage:", resp.data.memUsage);

CPU usage: 15.209929 %
Memory usage: 10418.183594

Process

Un objet Process a les champs suivants :

let requestConfig = <RequestType.RequestConfig>{
  useMaster: true,
  graphSetName: "amz",
};

let resp = await conn.uql("top()", requestConfig);
let processList = resp.data?.alias("_top");
console.log(processList.data.rows[0][0]);

a_1_3259_2

Task

Un objet Task a les champs suivants :

let requestConfig = <RequestType.RequestConfig>{
  useMaster: true,
  graphSetName: "miniCircle",
};

let resp = await conn.uql("show().task()", requestConfig);
let taskList = resp.data.alias("_task").asTasks();
console.log("Algo name:", taskList[0].task_info["algo_name"]);
console.log("Algo parameters:", taskList[0].param);
console.log("Result:", taskList[0].result);

Algo name: louvain
Algo parameters: { phase1_loop_num: '20', min_modularity_increase: '0.001' }
Result: {
  community_count: '11',
  modularity: '0.532784',
  result_files: 'communityID'
}

Table

Un objet Table a les champs suivants :

Méthodes sur un objet Table :

let resp = await conn.uql(
  "find().nodes() as n return table(n._id, n._uuid) as myTable limit 5",
  requestConfig
);
let tableInfo = resp.data.alias("myTable").asTable();
console.log("2nd row in table:", tableInfo.toKV()[1]);

2nd row in table: { 'n._id': 'ULTIPA8000000000000002', 'n._uuid': '2' }

Attr

Un objet Attr a les champs suivants :

let resp = await conn.uql(
  "find().nodes({@account}) as n return n.year limit 5",
  requestConfig
);
let myAttr = resp.data.alias("n.year").asAttrs();
console.log(myAttr.values);

[ 1978, 1989, 1982, 2007, 1973 ]