16.8 Creating Subgraphs
You can create subgraphs based on a graph that has been loaded into memory. You can use filter expressions or create bipartite subgraphs based on a vertex (node) collection that specifies the left set of the bipartite graph.
Note:
Starting from Graph Server and Client Release 22.3, creating subgraphs using filter expressions is deprecated. It is recommended that you load a subgraph from PGQL property graphs. See Loading a Subgraph from a PGQL Property Graph for more information.For information about reading a graph into memory, see Reading Graphs from Oracle Database into the Graph Server (PGX) for the various methods to load a graph into the graph server (PGX).
- About Filter Expressions
- Using a Simple Filter to Create a Subgraph
- Using a Complex Filter to Create a Subgraph
- Using a Vertex Set to Create a Bipartite Subgraph
Parent topic: Developing Applications with Graph Analytics
16.8.1 About Filter Expressions
Filter expressions are expressions that are evaluated for each vertex or edge. The expression can define predicates that a vertex or an edge must fulfil in order to be contained in the result, in this case a subgraph.
Consider an example graph that consists of four vertices (nodes) and four edges. For an edge to match the filter expression src.prop == 10
, the source vertex prop
property must equal 10. Two edges match that filter expression, as shown in the following figure.
The following figure shows the graph that results when the filter is applied.
Figure 16-6 Graph Created by the Simple Filter

Description of "Figure 16-6 Graph Created by the Simple Filter"
The vertex filter src.prop == 10
filters out the edges associated with
vertex 333 and the vertex itself.
Parent topic: Creating Subgraphs
16.8.2 Using a Simple Filter to Create a Subgraph
The following examples create the subgraph described in About Filter Expressions.
var subgraph = graph.filter(new VertexFilter("vertex.prop == 10"))
import oracle.pgx.api.*;
import oracle.pgx.api.filter.*;
PgxGraph graph = session.readGraphWithProperties(...);
PgxGraph subgraph = graph.filter(new VertexFilter("vertex.prop == 10"));
Parent topic: Creating Subgraphs
16.8.3 Using a Complex Filter to Create a Subgraph
This example uses a slightly more complex filter. It uses the outDegree
function, which calculates the number of outgoing edges for an identifier (source src
or destination dst
). The following filter expression matches all edges with a cost
property value greater than 50 and a destination vertex (node) with an outDegree
greater than 1.
dst.outDegree() > 1 && edge.cost > 50
One edge in the sample graph matches this filter expression, as shown in the following figure.
Figure 16-7 Edges Matching the outDegree Filter

Description of "Figure 16-7 Edges Matching the outDegree Filter"
The following figure shows the graph that results when the filter is applied. The filter excludes the edges associated with the vertices 99 and 1908, and so excludes those vertices also.
Figure 16-8 Graph Created by the outDegree Filter

Description of "Figure 16-8 Graph Created by the outDegree Filter"
Parent topic: Creating Subgraphs
16.8.4 Using a Vertex Set to Create a Bipartite Subgraph
You can create a bipartite subgraph by specifying a set of vertices (nodes), which are used as the left side. A bipartite subgraph has edges only between the left set of vertices and the right set of vertices. There are no edges within those sets, such as between two nodes on the left side. In the graph server (PGX), vertices that are isolated because all incoming and outgoing edges were deleted are not part of the bipartite subgraph.
The following figure shows a bipartite subgraph. No properties are shown.
The following examples create a bipartite subgraph from a simple graph consisting of
four vertices and four edges. The vertex ID values for the four vertices are
99
, 128
, 1908
and 333
respectively. See Figure 16-5 in About Filter Expressions for more information on the vertex and edge property values including the edge
direction between the vertices.
You must first create a vertex collection and fill it
with the vertices for the left side. In the example
shown, vertices with vertex ID values
333
and 99
are
added to the left side of the vertex collection.
Using the Shell to Create a Bipartite Subgraph
opg4j> s = graph.createVertexSet() ==> ... opg4j> s.addAll([graph.getVertex(333), graph.getVertex(99)]) ==> ... opg4j> s.size() ==> 2 opg4j> bGraph = graph.bipartiteSubGraphFromLeftSet(s) ==> PGX Bipartite Graph named sample-sub-graph-4
Using Java to Create a Bipartite Subgraph
import oracle.pgx.api.*; VertexSet<Integer> s = graph.createVertexSet(); s.addAll(graph.getVertex(333), graph.getVertex(99)); BipartiteGraph bGraph = graph.bipartiteSubGraphFromLeftSet(s);
When you create a subgraph, the graph server (PGX) automatically creates a Boolean vertex (node) property that indicates whether the vertex is on the left side. You can specify a unique name for the property.
The resulting bipartite subgraph looks like this:
Vertex with ID 1908
is excluded from the bipartite subgraph. The
only edge that connected that vertex extended from
128
to 1908
. The
edge was removed, because it violated the
bipartite properties of the subgraph. Vertex
1908
had no other edges, and so
was removed as well. Moreover, the edge from the
vertex with the ID 128
to the
vertex with ID 99
is not present
in the bipartite subgraph, because edges are only
allowed to go from left to right (and not from
right to left).
Parent topic: Creating Subgraphs