Overview

An HDC projection resides in the memory of a HDC (High-Density Computing) server, containing either full or partial data from a graphset loaded from the physcial storage of shard servers.

HDC projections support all graph algorithms and data-retrieving graph queries.

Managing HDC Projections

Showing HDC Projections

Retrieves information about all HDC projections of the current graphset:

hdc.graph.show()

Or retrieves a specific projection, such as the one named hdcGraph_1:

hdc.graph.show("hdcGraph_1")

It returns a table _projectList with the following fields:

When retrieving a specific projection using hdc.graph.show("<projectName>"), two supplementary tables are returned:

• _graph_from_<hdcName>: Shows all HDC projections created on <hdcName>.
• _algoList_from_<hdcName>: Lists all algorithms installed on <hdcName>.

Here, <hdcName> is the name of the HDC server where the projection was created.

Creating an HDC Projection

The hdc.graph.create().to() clause creates an in-memory projection of the current graphset to an HDC server. The project creation is executed as a job, you may run show().job() afterward to verify the success of the creation.

hdc.graph.create("<projectName>", {
  nodes: {
    "<schema1?>": ["<property1?>", "<property2?>", ...],
    "<schema2?>": ["<property1?>", "<property2?>", ...],
    ...
  },
  edges: {
    "<schema1?>": ["<property1?>", "<property2?>", ...],
    "<schema2?>": ["<property1?>", "<property2?>", ...],
    ...
  },
  direction: "<edgeDirection?>",
  load_id: <boolean?>,
  update: "<dataSyncMode>",
  query: "query",
  default: <boolean?>
}).to("<hdcName>")

Examples

To project the entire current graphset to hdc-server-1 as hdcGraph:

hdc.graph.create("hdcGraph", {
  nodes: {"*": ["*"]},
  edges: {"*": ["*"]},
  direction: "undirected",
  load_id: true,
  update: "static",
  query: "query",
  default: true
}).to("hdc-server-1")

To project @account and @movie nodes with selected properties and incoming @rate edges in the current graphset to hdc-server-1 as hdcGraph_1, while omitting nodes' _id values:

hdc.graph.create("hdcGraph_1", {
  nodes: {
    "account": ["name", "gender"],
    "movie": ["name", "year"]
  },
  edges: {"rate": ["*"]},
  direction: "in",
  load_id: false,
  update: "static",
  query: "query",
  default: false
}).to("hdc-server-1")

Dropping an HDC Projection

You can drop any HDC projection of the current graphset from the HDC server using the hdc.graph.drop() clause.

The following example deletes the HDC projection named hdcGraph_1:

hdc.graph.drop("hdcGraph_1")

Example Graph and Projection

To create the graph, execute each of the following UQL queries sequentially in an empty graphset:

create().node_schema("entity").edge_schema("link")
create().edge_property(@link, "weight", float)
insert().into(@entity).nodes([{_id:"A"},{_id:"B"},{_id:"C"},{_id:"D"}])
insert().into(@link).edges([{_from:"A", _to:"B", weight:1},{_from:"A", _to:"C", weight:1.5},{_from:"A", _to:"D", weight:0.5},{_from:"B", _to:"C", weight:2},{_from:"C", _to:"D", weight:0.5}])

To create an HDC projection hdcGraph of the entire graph:

hdc.graph.create("hdcGraph", {
  nodes: {"*": ["*"]},
  edges: {"*": ["*"]},
  direction: "undirected",
  load_id: true,
  update: "static",
  query: "query",
  default: false
}).to("hdc-server-1")

Executing Queries

To execute a UQL query on an HDC projection, use the syntax exec{<query>} on <projectName>. Note that HDC projections only support queries that retrieve data from the database.

To run the ab() query on hdcGraph:

exec{
  ab().src({_id == "A"}).dest({_id == "C"}).depth(2) as p
  return p
} on hdcGraph

Result:

To run the khop() query on hdcGraph:

exec{
  khop().src({_id == "A"}).depth(1).direction(right) as n
  return count(n)
} on hdcGraph

Result:

Any query attempting to write data will fail in HDC projections. For instance, the following query results in an error indicating that node insertion is not supported.

exec{
  insert().into(@entity).nodes([{_id: "E"}])
} on hdcGraph

Executing Algorithms

HDC projections run HDC algorithms. HDC algorithms run using one of the six execution modes: File Writeback, DB Writeback, Stats Writeback, Full Return, Stream Return, and Stats Return.

Writeback Modes

To execute an algorithm on an HDC projection using a writeback mode (File, DB, Stats), use the syntax algo().params().write(). In the params() method, you must include the parameter project to specify the name of the projection.

File Writeback

Runs the Degree Centrality algorithm on hdcGraph to compute the out-degree of all nodes and write the results back to a file degree.txt:

algo(degree).params({
  project: "hdcGraph",
  return_id_uuid: "id",
  direction: "out"
}).write({
  file: {
    filename: "degree.txt"
  }
})

Result:

_id,degree_centrality
D,0
B,1
A,3
C,1

DB Writeback

Runs the Degree Centrality algorithm on hdcGraph to compute the degree of all nodes and write the results back to the node property degree:

algo(degree).params({
  project: "hdcGraph"
}).write({
  db: {
    property: "degree"
  }
})

Stats Writeback

Runs the Triangle Counting algorithm to count the number of triangles on the hdcGraph and write the statistical summaries to the job:

algo(triangle_counting).params({
  project: "hdcGraph",
  result_type: 1
}).write({
  stats: {}
})

Results:

Return Modes

To execute an algorithm on an HDC projection using a return mode (Full, Stream, Stats), use the syntax exec{<algo>} on <projectName>.

Full Return

Runs the Degree Centrality algorithm on hdcGraph to compute the out-degree of all nodes and return the results:

exec{
  algo(degree).params({
    return_id_uuid: "id",
    direction: "out"
  }) as r
  return r
} on hdcGraph

Results:

Stream Return

Runs the Degree Centrality algorithm on hdcGraph to compute the out-degree of all nodes and return the results:

exec{
  algo(degree).params({
    return_id_uuid: "id",
    direction: "out"
  }).stream() as r
  return r
} on hdcGraph

Results:

Stats Return

Runs the Triangle Counting algorithm to count the number of triangles on hdcGraph and return the statistical summaries:

exec{
  algo(triangle_counting).params({
    result_type: 1
  }).stats() as s
  return s
} on hdcGraph

Results:

Graph Traversal Direction

If an HDC projection is created with the direction option set to in or out, graph traversal is restricted to incoming or outgoing edges, respectively. Queries or algorithms attempting to traverse in the missing direction throws errors or yields empty results.

To create an HDC projection hdcGraph_in_edges of the graph with nodes and incoming edges:

hdc.graph.create("hdcGraph_in_edges", {
  nodes: {"*": ["*"]},
  edges: {"*": ["*"]},
  direction: "in",
  load_id: true,
  update: "static",
  query: "query",
  default: false
}).to("hdc-server-1")

This khop() query attempts to follow the outgoing (right) edges on hdcGraph_in_edges, no result will be returned.

exec{
  khop().src({_id == "A"}).depth(1).direction(right) as n
  return count(n)
} on hdcGraph_in_edges

Result:

This Degree Centrality algorithm computes the out-degree of all nodes on hdcGraph_in_edges, they are all 0.

exec{
  algo(degree).params({
    return_id_uuid: "id",
    direction: "out"
  }) as r
  return r
} on hdcGraph_in_edges

Results:

Exclusion of Node IDs

If an HDC projection is created with the load_id option set to false, it does not contain the _id values for nodes. Queries or algorithms referencing _id throws errors or yields empty results. In algorithm writeback files, _id values are replaced with _uuid values instead.

To create an HDC projection hdcGraph_no_id of the graph without nodes' _id values:

hdc.graph.create("hdcGraph_no_id", {
  nodes: {"*": ["*"]},
  edges: {"*": ["*"]},
  direction: "undirected",
  load_id: false,
  update: "static",
  query: "query",
  default: false
}).to("hdc-server-1")

The ab() query utilizes _id to filter nodes on hdcGraph_no_id, error occurs as the projection lacks nodes' _id:

exec{
  ab().src({_id == "A"}).dest({_id == "C"}).depth(2) as p
  return p{*}
} on hdcGraph_no_id

The Degree Centrality algorithm computes the degree of all nodes on hdcGraph_no_id, since the projection does not include node _id values, the results will appear empty for that column:

exec{
  algo(degree).params({
    return_id_uuid: "id"
  }) as r
  return r
} on hdcGraph_no_id

Results:

The Degree Centrality algorithm computes the degree of all nodes on hdcGraph_no_id and writes the results back to a file degree.txt, nodes' _id are replaced with _uuid:

algo(degree).params({
  project: "hdcGraph_no_id",
  return_id_uuid: "id"
}).write({
  file: {
    filename: "degree.txt"
  }
})

Results:

_uuid,degree_centrality
288232575174967298,2
3530824306881724417,2
10016007770295238657,3
12033620403357220866,3

Exclusion of Properties

If an HDC projection is created without certain properties, queries or algorithms referencing those properties throws errors or yields empty results.

To create an HDC projection hdcGraph_no_weight of the graph containing nodes and only system properties of @link edges:

hdc.graph.create("hdcGraph_no_weight", {
  nodes: {"*": ["*"]},
  edges: {"link": []},
  direction: "undirected",
  load_id: true,
  update: "static",
  query: "query",
  default: false
}).to("hdc-server-1")

The ab() query finds shortest path between two nodes on hdcGraph_no_weight, weighted by the edge property @link.weight, error occurs as the weight property is missing:

exec{
  ab().src({_id == "A"}).dest({_id == "C"}).depth(2).shortest(@link.weight) as p
  return p
} on hdcGraph_no_weight

The Degree Centrality algorithm computes the degree of all nodes weighted by the edge property @link.weight on hdcGraph_no_weight, error occurs as the weight property is missing:

exec{
  algo(degree).params({
    edge_schema_property: "@link.weight"
  }) as r
  return r
} on hdcGraph_no_weight