16.2.3 Publishing a Graph
You can publish a graph that is loaded into the graph server (PGX), so that it can be referenced by other sessions. Similarly, the snapshots of a graph can also be made available to other sessions.
Publishing a Graph with Snapshots
After loading a graph is loaded into the graph server, if you want to
make all snapshots of the graph visible to other sessions (under the same user),
then use the publishWithSnapshots()
method. When a graph is
published with snapshots, the GraphMetaData
information of each
snapshot is also made available to the other sessions, with the exception of the
graph configuration, which is null
.
When calling the publishWithSnapshots()
method, all the
persistent properties of all the snapshots are published and made visible to the
other sessions. Transient properties are session-private and therefore they must be
published explicitly. Once published, all properties become read-only. Hence,
transient properties are not published when calling
publishWithSnapshots()
without arguments.
Publishing a graph with publishWithSnapshots()
method,
will move the graph name from the session-private namespace to the public namespace.
If a graph with the same name has been already published, then the
publishWithSnapshots()
method will fail with an exception.
opg4j> graph.publishWithSnapshots()
graph.publishWithSnapshots();
>>> graph.publish_with_snapshots()
If you want to publish specific transient properties, then you can list
them within the publishWithSnapshots()
call, as shown in the
following example:
opg4j> var prop1 = graph.createVertexProperty(PropertyType.INTEGER, "prop1")
opg4j> prop1.fill(0)
opg4j> var cost = graph.createEdgeProperty(PropertyType.DOUBLE, "cost")
opg4j> cost.fill(0d)
opg4j> graph.publishWithSnapshots(List.of(prop1), List.of(cost))
VertexProperty<Integer, Integer> prop1 = graph.createVertexProperty(PropertyType.INTEGER, "prop1");
prop1.fill(0);
EdgeProperty<Double> cost = graph.createEdgeProperty(PropertyType.DOUBLE, "cost");
cost.fill(0d);
Collection<VertexProperty<?, ?>> vertexProps = Arrays.asList(prop1);
Collection<EdgeProperty<?>> edgeProps = Arrays.asList(cost);
graph.publishWithSnapshots(vertexProps,edgeProps);
Alternatively, all properties can be published at once by passing the built-in
VertexProperty.ALL
and EdgeProperty.ALL
to
publishWithSnapshots()
, as in the following example.
opg4j> var prop1 = graph.createVertexProperty(PropertyType.INTEGER, "prop1")
opg4j> prop1.fill(0)
opg4j> var cost = graph.createEdgeProperty(PropertyType.DOUBLE, "cost")
opg4j> cost.fill(0d)
opg4j> graph.publishWithSnapshots(VertexProperty.ALL, EdgeProperty.ALL)
VertexProperty<Integer, Integer> prop1 = graph.createVertexProperty(PropertyType.INTEGER, "prop1");
prop1.fill(0);
EdgeProperty<Double> cost = graph.createEdgeProperty(PropertyType.DOUBLE, "cost");
cost.fill(0d);
Collection<VertexProperty<?, ?>> vertexProps = Arrays.asList(prop);
Collection<EdgeProperty<?>> edgeProps = Arrays.asList(cost);
graph.publishWithSnapshots(VertexProperty.ALL, EdgeProperty.ALL);
After creating a snapshot, properties in the new snapshot will inherit
the publishing state of properties in the old snapshot. This implies that if a
property is published in the old snapshot, it will also be published in the new
snapshot. Otherwise it will remain session private in the new snapshot. This
behavior is configurable with
enable_snapshot_properties_publish_state_propagation flag
(see
Configuration Parameters for the Graph Server (PGX) Engine). By default, this flag is enabled. However, it can be disabled
by setting its value to false, in which case, the publishing state of the properties
will be ignored when creating new snapshots and the properties in new snapshots will
be session-private.
Note:
By default, callingpublishWithSnapshots()
is allowed only on the latest
snapshot. Calling publishWithSnapshots()
on an old snapshot will
result in an exception. To allow calling publishWithSnapshots()
on
any snapshot, set the
enable_snapshot_properties_publish_state_propagation
configuration field in the pgx.conf
file to
false
.
opg4j> var prop1 = graph.createVertexProperty(PropertyType.INTEGER, "prop1")
opg4j> prop1.fill(0)
opg4j> var prop2 = graph.createVertexProperty(PropertyType.INTEGER, "prop2")
opg4j> prop2.fill(0)
opg4j> var cost = graph.createEdgeProperty(PropertyType.DOUBLE, "cost")
opg4j> cost.fill(0d)
// the example intentionally avoids publishing prop2
opg4j> graph.publishWithSnapshots(List.of(prop1), List.of(cost))
opg4j> var snapshot = graph.createChangeSet().buildNewSnapshot()
opg4j> snapshot.getVertexProperty("prop1").isPublished()
=> true
opg4j> snapshot.getVertexProperty("prop2").isPublished()
=> false
opg4j> snapshot.getEdgeProperty("cost").isPublished()
=> true
// publish prop2 in snapshot, this will make it published in future snapshots too
// but not in the previous snapshots
opg4j> snapshot.getVertexProperty("prop2").publish()
opg4j> var snapshot2 = snapshot.createChangeSet().buildNewSnapshot();
opg4j> snapshot2.getVertexProperty("prop1").isPublished()
=> true
opg4j> snapshot2.getVertexProperty("prop2").isPublished()
=> true
opg4j> snapshot2.getEdgeProperty("cost").isPublished()
=> true
VertexProperty<Integer, Integer> prop1 = graph.createVertexProperty(PropertyType.INTEGER, "prop1");
prop1.fill(0);
VertexProperty<Integer, Integer> prop2 = graph.createVertexProperty(PropertyType.INTEGER, "prop2");
prop2.fill(0);
EdgeProperty<Double> cost = graph.createEdgeProperty(PropertyType.DOUBLE, "cost");
cost.fill(0d);
// the example intentionally avoids publishing prop2
graph.publishWithSnapshots(List.of(prop1), List.of(cost));
PgxGraph snapshot = graph.createChangeSet().buildNewSnapshot();
System.out.println(snapshot.getVertexProperty("prop1").isPublished()); // Returns true
System.out.println(snapshot.getVertexProperty("prop2").isPublished()); // Returns false
System.out.println(snapshot.getEdgeProperty("cost").isPublished()); // Returns true
// publish prop2 in snapshot, this will make it published in future snapshots too
// but not in the previous snapshots.
snapshot.getVertexProperty("prop2").publish();
PgxGraph snapshot2 = snapshot.createChangeSet().buildNewSnapshot();
System.out.println(snapshot2.getVertexProperty("prop1").isPublished()); // Returns true
System.out.println(snapshot2.getVertexProperty("prop2").isPublished()); // Returns true
System.out.println(snapshot2.getEdgeProperty("cost").isPublished()); // Returns true
Publishing a Single Graph Snapshot
The PgxGraph#publish()
method can be used to publish the
current selected snapshot of the graph. The publish operation will move the graph
name from the session-private namespace to the public namespace. If a graph with the
same name has been already published, then the publish()
method
will fail with an exception. Graphs published with snapshots and single published
snapshots share the same namespace.
Table 14-6 describes the grants required to publish a graph.
Note that calling the publish()
method without arguments
publishes the snapshot with its persistent properties only. However, if you want to
publish specific transient properties, then you must list them within the
publish()
call as shown:
opg4j> var prop1 = graph.createVertexProperty(PropertyType.INTEGER, "prop1")
opg4j> prop1.fill(0)
opg4j> var cost = graph.createEdgeProperty(PropertyType.DOUBLE, "cost")
opg4j> cost.fill(0d)
opg4j> graph.publish(List.of(prop1), List.of(cost))
VertexProperty<Integer, Integer> prop1 = graph.createVertexProperty(PropertyType.INTEGER, "prop1");
prop1.fill(0);
EdgeProperty<Double> cost = graph.createEdgeProperty(PropertyType.DOUBLE, "cost");
cost.fill(0d);
Collection<VertexProperty<?, ?>> vertexProps = Arrays.asList(prop);
Collection<EdgeProperty<?>> edgeProps = Arrays.asList(cost);
graph.publish(vertexProps, edgeProps);
prop = graph.create_vertex_property("integer", "prop1")
prop1.fill(0)
cost = graph.create_edge_property("double", "cost")
cost.fill(float(0))
vertex_props = [prop]
edge_props = [cost]
graph.publish(vertex_props, edge_props)
Referencing a Published Graph from Another Session
You can reference a published graph by its name in another session,
using the PgxSession#getGraph()
method.
The following example references a published graph
myGraph
in a new session (session2
):
opg4j> var session2 = instance.createSession("session2")
opg4j> var graph2 = session2.getGraph(Namespace.PUBLIC, "myGraph")
PgxSession session2 = instance.createSession("session2");
PgxGraph graph2 = session2.getGraph(Namespace.PUBLIC, "myGraph");
session2 = pypgx.get_session("session2");
PgxGraph graph2 = session2.get_graph("myGraph")
session2
can access only the published snapshot. If the graph has
been published without snapshots, calling the
getAvailableSnapshots()
method will return an empty queue.
In case if the graph snapshots have been published, then the call to
getGraph()
returns the most recent available snapshot.
session2
can see all the available snapshots through the
getAvailableSnapshots()
method. You can then set a specific
snapshot using the PgxSession#setSnapshot()
method.
Note:
If a referenced graph is not required anymore, then it is important that you release the graph. See Deleting a Graph for more information.Publishing a Property
After publishing (a single snapshot or all of them), you can still publish transient properties individually. By default, the publishing state of the transient properties are associated to the specific snapshot on which they are created and thus they are visible only on that snapshot.
opg4j> graph.getVertexProperty("prop1").publish()
opg4j> graph.getEdgeProperty("cost").publish()
graph.getVertexProperty("prop1").publish();
graph.getEdgeProperty("cost").publish();
graph.get_vertex_property("prop1").publish()
graph.get_edge_property("cost").publish()
Getting a Published Property in Another Session
Sessions referencing a published graph (with or without snapshots) can reference a published property through the
PgxGraph#getVertexProperty
and
PgxGraph#getEdgeProperty
.
opg4j> var session2 = instance.createSession("session2")
opg4j> var graph2 = session2.getGraph(Namespace.PUBLIC, "myGraph")
opg4j> var vertexProperty = graph2.getVertexProperty("prop1")
opg4j> var edgeProperty = graph2.getEdgeProperty("cost")
PgxSession session2 = instance.createSession("session2");
PgxGraph graph2 = session2.getGraph(Namespace.PUBLIC, "myGraph");
VertexProperty<Integer, Integer> vertexProperty = graph2.getVertexProperty("prop1");
EdgeProperty<Double> edgeProperty = graph2.getEdgeProperty("cost");
session2 = pypgx.get_session(session_name ="session2")
graph2 = session2.get_graph("myGraph")
vertex_property = graph2.get_vertex_property("prop1")
edge_property = graph2.get_edge_property("cost")
Pinning a Published Graph
You can pin a published graph so that it remains published even if no session uses it.
opg4j> graph.pin()
graph.pin();
>>> graph.pin()
Unpinning a Published Graph
You can unpin a published graph that was earlier pinned. By doing this, you can remove the graph and all its snapshots, if no other session is using a snapshot of the graph.
opg4j> var graph = session.getGraph("bank_graph_analytics")
graph ==> PgxGraph[name=bank_graph_analytics,N=999,E=4993,created=1660217577201]
opg4j> graph.unpin()
PgxGraph graph = session.getGraph("bank_graph_analytics");
graph.unpin();
>>> graph = session.get_graph("bank_graph_analytics")
>>> graph.unpin()
Related Topics
Parent topic: Graph Management in the Graph Server (PGX)