PgxGraph (Oracle Big Data Spatial and Graph Property Graph)

java.lang.Object
- oracle.pgx.api.Destroyable
- - oracle.pgx.api.PgxManagedObject
  - - oracle.pgx.api.PgxGraph

All Implemented Interfaces:

AutoCloseable

Direct Known Subclasses:

BipartiteGraph
```
public class PgxGraph
extends PgxManagedObject
```
A PGX Graph

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`PgxGraph.Degree`
`static class`	`PgxGraph.Direction`
`static class`	`PgxGraph.Mode`
`static class`	`PgxGraph.MultiEdges`
`static class`	`PgxGraph.SelfEdges`
`static class`	`PgxGraph.TrivialVertices`

Method Summary

Methods
Modifier and Type	Method and Description
`BipartiteGraph`	`bipartiteSubGraphFromLeftSet(Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, VertexSet<?> vertexSet, String newGraphName)` Blocking version of `#bipartiteSubGraphFromLeftSetAsync()`.
`BipartiteGraph`	`bipartiteSubGraphFromLeftSet(Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, VertexSet<?> vertexSet, String newGraphName, String isLeftPropName)` Blocking version of `#bipartiteSubGraphFromLeftSetAsync()`.
`BipartiteGraph`	`bipartiteSubGraphFromLeftSet(VertexSet<?> vertexSet)` Blocking version of `#bipartiteSubGraphFromLeftSetAsync()`.
`BipartiteGraph`	`bipartiteSubGraphFromLeftSet(VertexSet<?> vertexSet, String newGraphName)` Blocking version of `#bipartiteSubGraphFromLeftSetAsync()`.
`PgxFuture<BipartiteGraph>`	`bipartiteSubGraphFromLeftSetAsync(Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, VertexSet<?> vertexSet, String newGraphName)` Create a bipartite version of a graph.
`PgxFuture<BipartiteGraph>`	`bipartiteSubGraphFromLeftSetAsync(Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, VertexSet<?> vertexSet, String newGraphName, String isLeftPropName)`
`PgxFuture<BipartiteGraph>`	`bipartiteSubGraphFromLeftSetAsync(VertexSet<?> vertexSet)` Create a bipartite version of a graph. `#bipartiteSubGraphFromLeftSet(Collection, Collection, VertexSet)` Passing vertexProps as `VertexProperty.ALL` edgeProps as `EdgeProperty.ALL`
`PgxFuture<BipartiteGraph>`	`bipartiteSubGraphFromLeftSetAsync(VertexSet<?> vertexSet, String newGraphName)` Create a bipartite version of a graph.
`PgxGraph`	`clone()` Blocking version of `cloneAsync()`.
`PgxGraph`	`clone(Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, String newGraphName)` Blocking version of `cloneAsync()`.
`PgxGraph`	`clone(String newGraphName)` Blocking version of `cloneAsync()`.
`PgxFuture<PgxGraph>`	`cloneAsync()` Convenience method of `cloneAsync(String)` Passing String(name) as `null` Create a copy of a graph.
`PgxFuture<PgxGraph>`	`cloneAsync(Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, String newGraphName)` Create a copy of a graph.
`PgxFuture<PgxGraph>`	`cloneAsync(String newGraphName)` Convenience method of `cloneAsync(Collection, Collection, String)` Passing Collection(vertexProperties) as `VertexProperty.ALL` Collection(edgeProperties) as `EdgeProperty.ALL` Create a copy of a graph.
`<ID extends Comparable<ID>> AllPaths<ID>`	`createAllPaths(PgxVertex<ID> src, EdgeProperty<Double> cost, VertexProperty<ID,PgxVertex<ID>> parent, VertexProperty<ID,PgxEdge> parentEdge)` Blocking version of `#createAllPathsAsync()`.
`<ID extends Comparable<ID>> PgxFuture<AllPaths<ID>>`	`createAllPathsAsync(PgxVertex<ID> src, EdgeProperty<Double> cost, VertexProperty<ID,PgxVertex<ID>> parent, VertexProperty<ID,PgxEdge> parentEdge)` Creates a `AllPaths` object representing all the shortest paths from a single source to all the possible destinations (shortest regarding the given edge costs).
`<ID extends Comparable<ID>> Partition<ID>`	`createComponents(VertexProperty<ID,Integer> components, int numComponents)` Blocking version of `#createComponentsAsync()`.
`<ID extends Comparable<ID>> PgxFuture<Partition<ID>>`	`createComponentsAsync(VertexProperty<ID,Integer> components, int numComponents)` Creates a `Partition` object holding a collection of vertex sets, each representing a component.
`<V extends Comparable<V>> EdgeProperty<V>`	`createEdgeProperty(PropertyType type)` Blocking version of `#createEdgePropertyAsync()`.
`<V extends Comparable<V>> EdgeProperty<V>`	`createEdgeProperty(PropertyType type, String name)` Blocking version of `#createEdgePropertyAsync()`.
`<V extends Comparable<V>> PgxFuture<EdgeProperty<V>>`	`createEdgePropertyAsync(PropertyType type)` Creates a session-bound edge property
`<V extends Comparable<V>> PgxFuture<EdgeProperty<V>>`	`createEdgePropertyAsync(PropertyType type, String name)` Creates a session-bound edge property
`EdgeSequence`	`createEdgeSequence()` Blocking version of `createEdgeSequenceAsync()`.
`EdgeSequence`	`createEdgeSequence(String name)` Blocking version of `createEdgeSequenceAsync()`.
`PgxFuture<EdgeSequence>`	`createEdgeSequenceAsync()` Creates a new Edge Sequence.
`PgxFuture<EdgeSequence>`	`createEdgeSequenceAsync(String name)` Creates a new Edge Sequence.
`EdgeSet`	`createEdgeSet()` Blocking version of `createEdgeSetAsync()`.
`EdgeSet`	`createEdgeSet(String name)` Blocking version of `createEdgeSetAsync()`.
`PgxFuture<EdgeSet>`	`createEdgeSetAsync()` Creates a new Edge Set.
`PgxFuture<EdgeSet>`	`createEdgeSetAsync(String name)` Creates a new Edge Set.
`<K extends Comparable<K>,V extends Comparable<V>> PgxMap<K,V>`	`createMap(PropertyType keyType, PropertyType valType)` Blocking version of `#createMapAsync()`.
`<K extends Comparable<K>,V extends Comparable<V>> PgxMap<K,V>`	`createMap(PropertyType keyType, PropertyType valType, MapType mapType)` Blocking version of `#createMapAsync()`.
`<K extends Comparable<K>,V extends Comparable<V>> PgxMap<K,V>`	`createMap(PropertyType keyType, PropertyType valType, MapType mapType, String mapName)` Blocking version of `#createMapAsync()`.
`<K extends Comparable<K>,V extends Comparable<V>> PgxFuture<PgxMap<K,V>>`	`createMapAsync(PropertyType keyType, PropertyType valType)` Creates a session-bound map
`<K extends Comparable<K>,V extends Comparable<V>> PgxFuture<PgxMap<K,V>>`	`createMapAsync(PropertyType keyType, PropertyType valType, MapType mapType)` Creates a session-bound map
`<K extends Comparable<K>,V extends Comparable<V>> PgxFuture<PgxMap<K,V>>`	`createMapAsync(PropertyType keyType, PropertyType valType, MapType mapType, String mapName)` Creates a session-bound map
`<ID extends Comparable<ID>> PgxPath<ID>`	`createPath(PgxVertex<ID> src, PgxVertex<ID> dst, EdgeProperty<Double> cost, VertexProperty<ID,PgxVertex<ID>> parent, VertexProperty<ID,PgxEdge> parentEdge)` Blocking version of `#createPathAsync()`.
`<ID extends Comparable<ID>> PgxFuture<PgxPath<ID>>`	`createPathAsync(PgxVertex<ID> src, PgxVertex<ID> dst, EdgeProperty<Double> cost, VertexProperty<ID,PgxVertex<ID>> parent, VertexProperty<ID,PgxEdge> parentEdge)` Creates a `PgxPath` object representing the shortest path from one source to one destination (shortest regarding the given edge costs).
`<T> Scalar<T>`	`createScalar(PropertyType type)` Blocking version of `#createScalarAsync()`.
`<T> Scalar<T>`	`createScalar(PropertyType type, String newScalarName)` Blocking version of `#createScalarAsync()`.
`<T> PgxFuture<Scalar<T>>`	`createScalarAsync(PropertyType type)` Creates a new Scalar.
`<T> PgxFuture<Scalar<T>>`	`createScalarAsync(PropertyType type, String newScalarName)` Create a session-bound scalar.
`<ID extends Comparable<ID>,V extends Comparable<V>> VertexProperty<ID,V>`	`createVertexProperty(PropertyType type)` Blocking version of `#createVertexPropertyAsync()`.
`<ID extends Comparable<ID>,V extends Comparable<V>> VertexProperty<ID,V>`	`createVertexProperty(PropertyType type, String name)` Blocking version of `#createVertexPropertyAsync()`.
`<ID extends Comparable<ID>,V extends Comparable<V>> PgxFuture<VertexProperty<ID,V>>`	`createVertexPropertyAsync(PropertyType type)` Creates a session-bound vertex property
`<ID extends Comparable<ID>,V extends Comparable<V>> PgxFuture<VertexProperty<ID,V>>`	`createVertexPropertyAsync(PropertyType type, String name)` Creates a session-bound vertex property
`<E extends Comparable<E>> VertexSequence<E>`	`createVertexSequence()` Blocking version of `createVertexSequenceAsync()`.
`<E extends Comparable<E>> VertexSequence<E>`	`createVertexSequence(String name)` Blocking version of `createVertexSequenceAsync()`.
`<E extends Comparable<E>> PgxFuture<VertexSequence<E>>`	`createVertexSequenceAsync()` Creates a new Vertex Sequence.
`<E extends Comparable<E>> PgxFuture<VertexSequence<E>>`	`createVertexSequenceAsync(String name)` Creates a new Vertex Sequence.
`<E extends Comparable<E>> VertexSet<E>`	`createVertexSet()` Blocking version of `createVertexSetAsync()`.
`<E extends Comparable<E>> VertexSet<E>`	`createVertexSet(String name)` Blocking version of `createVertexSetAsync()`.
`<E extends Comparable<E>> PgxFuture<VertexSet<E>>`	`createVertexSetAsync()` Creates a new Vertex Set.
`<E extends Comparable<E>> PgxFuture<VertexSet<E>>`	`createVertexSetAsync(String name)` Creates a new Vertex Set.
`PgxGraph`	`filter(Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, GraphFilter graphFilter, String newGraphName)` Blocking version of `#filterAsync()`.
`PgxGraph`	`filter(GraphFilter graphFilter)` Blocking version of `#filterAsync()`.
`PgxGraph`	`filter(GraphFilter graphFilter, String newGraphName)` Blocking version of `#filterAsync()`.
`PgxFuture<PgxGraph>`	`filterAsync(Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, GraphFilter graphFilter, String newGraphName)` Create a subgraph of a graph.
`PgxFuture<PgxGraph>`	`filterAsync(GraphFilter graphFilter)` Create a subgraph of a graph.
`PgxFuture<PgxGraph>`	`filterAsync(GraphFilter graphFilter, String newGraphName)` Create a subgraph of a graph.
`GraphConfig`	`getConfig()` Gets the graph configuration object used to specify the data source of this graph.
`long`	`getCreationRequestTimestamp()` Gets the timestamp when this graph was requested to be created.
`long`	`getCreationTimestamp()` Gets the timestamp when this graph finished creation.
`String`	`getDataSourceVersion()` Gets the format-specific version identifier provided by data-source (timestamp for files, snapshot ID for databases).
`PgxEdge`	`getEdge(long id)` Gets a `PgxEdge` of this graph by ID.
`Set<EdgeProperty<?>>`	`getEdgeProperties()` Blocking version of `getEdgePropertiesAsync()`.
`PgxFuture<Set<EdgeProperty<?>>>`	`getEdgePropertiesAsync()` Get the set of edge properties belonging to this graph.
`<V extends Comparable<V>> EdgeProperty<V>`	`getEdgeProperty(String name)` Blocking version of `#getEdgePropertyAsync()`.
`<V extends Comparable<V>> PgxFuture<EdgeProperty<V>>`	`getEdgePropertyAsync(String name)` get an edge property of this graph
`EdgeSet`	`getEdges(EdgeFilter filter)` Blocking version of `#getEdges()`.
`<E extends Comparable<E>> PgxFuture<EdgeSet>`	`getEdgesAsync(EdgeFilter filter)` Creates a new Edge Set containing edges according to the given filter expression.
`long`	`getMemoryMb()` Gets the estimated number of memory this graph (including its properties) consumes in memory (in megabytes).
`String`	`getName()`
`long`	`getNumEdges()` Gets the number of edges
`long`	`getNumVertices()` Gets the number of vertices
`ServerInstance`	`getPgxInstance()`
`PgxSession`	`getSession()`
`<ID extends Comparable<ID>> PgxVertex<ID>`	`getVertex(ID id)` Gets a `PgxVertex` of this graph by ID.
`IdType`	`getVertexIdType()` Gets the vertex ID type of this graph.
`Set<VertexProperty<?,?>>`	`getVertexProperties()` Blocking version of `getVertexPropertiesAsync()`.
`PgxFuture<Set<VertexProperty<?,?>>>`	`getVertexPropertiesAsync()` Get the set of vertex properties belonging to this graph.
`<ID extends Comparable<ID>,V extends Comparable<V>> VertexProperty<ID,V>`	`getVertexProperty(String name)` Blocking version of `#getVertexPropertyAsync()`.
`<ID extends Comparable<ID>,V extends Comparable<V>> PgxFuture<VertexProperty<ID,V>>`	`getVertexPropertyAsync(String name)` Gets a vertex property of this graph
`<E extends Comparable<E>> VertexSet<E>`	`getVertices(VertexFilter filter)` Blocking version of `#getVerticesAsync()`.
`<E extends Comparable<E>> PgxFuture<VertexSet<E>>`	`getVerticesAsync(VertexFilter filter)` Creates a new Vertex Set containing vertices according to the given filter expression.
`boolean`	`isFresh()` Blocking version of `isFreshAsync()`.
`PgxFuture<Boolean>`	`isFreshAsync()` Check whether an in-memory representation of a graph is fresh.
`boolean`	`isTransient()`
`<ID extends Comparable<ID>> PgxVertex<ID>`	`pickRandomVertex()` Blocking version of `pickRandomVertexAsync()`.
`<ID extends Comparable<ID>> PgxFuture<PgxVertex<ID>>`	`pickRandomVertexAsync()` Picks a random vertex in the graph.
`PgxGraph`	`simplify(Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, PgxGraph.MultiEdges multiEdges, PgxGraph.SelfEdges selfEdges, PgxGraph.TrivialVertices trivialVertices, PgxGraph.Mode mode, String newGraphName)` Blocking version of `#simplifyAsync()`.
`PgxGraph`	`simplify(PgxGraph.MultiEdges multiEdges, PgxGraph.SelfEdges selfEdges, PgxGraph.TrivialVertices trivialVertices, PgxGraph.Mode mode, String newGraphName)` Blocking version of `#simplifyAsync()`.
`PgxFuture<PgxGraph>`	`simplifyAsync(Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, PgxGraph.MultiEdges multiEdges, PgxGraph.SelfEdges selfEdges, PgxGraph.TrivialVertices trivialVertices, PgxGraph.Mode mode, String newGraphName)` Create a simplified version of a graph.
`PgxFuture<PgxGraph>`	`simplifyAsync(PgxGraph.MultiEdges multiEdges, PgxGraph.SelfEdges selfEdges, PgxGraph.TrivialVertices trivialVertices, PgxGraph.Mode mode, String newGraphName)` Convenience method for `simplifyAsync(Collection, Collection, MultiEdges, SelfEdges, TrivialVertices, Mode, String)` Passing Collection(vertexProperties) as `VertexProperty.ALL` Collection(edgeProperties) as `EdgeProperty.ALL` Create a simplified version of a graph.
`PgxGraph`	`sortByDegree()` Blocking version of `sortByDegreeAsync()`.
`PgxGraph`	`sortByDegree(Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, PgxGraph.Direction direction, PgxGraph.Degree degree, PgxGraph.Mode mode, String newGraphName)` Blocking version of `sortByDegreeAsync()`.
`PgxGraph`	`sortByDegree(PgxGraph.Direction direction, PgxGraph.Degree degree, PgxGraph.Mode mode, String newGraphName)` Blocking version of `sortByDegreeAsync()`.
`PgxGraph`	`sortByDegree(String newGraphName)` Blocking version of `sortByDegreeAsync()`.
`PgxFuture<PgxGraph>`	`sortByDegreeAsync()` Create a sorted version of a graph and all its properties.
`PgxFuture<PgxGraph>`	`sortByDegreeAsync(Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, PgxGraph.Direction direction, PgxGraph.Degree degree, PgxGraph.Mode mode, String newGraphName)` Create a sorted version of a graph and all its properties.
`PgxFuture<PgxGraph>`	`sortByDegreeAsync(PgxGraph.Direction direction, PgxGraph.Degree degree, PgxGraph.Mode mode, String newGraphName)` Create a sorted version of a graph and all its properties.
`PgxFuture<PgxGraph>`	`sortByDegreeAsync(String newGraphName)` Create a sorted version of a graph and all its properties.
`PgxGraph`	`sparsify(Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, double e, String newGraphName)` Blocking version of `#sparsifyAsync()`.
`PgxGraph`	`sparsify(double e)` Blocking version of `#sparsifyAsync()`.
`PgxGraph`	`sparsify(double e, String newGraphName)` Blocking version of `#sparsifyAsync()`.
`PgxFuture<PgxGraph>`	`sparsifyAsync(Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, double e, String newGraphName)` Sparsifies the given graph and returns a new graph with less edges.
`PgxFuture<PgxGraph>`	`sparsifyAsync(double e)` Sparsifies the given graph and returns a new graph with less edges. Convenience method around `sparsify(double, String)` Passing newGraphName as `null`
`PgxFuture<PgxGraph>`	`sparsifyAsync(double e, String newGraphName)` Sparsifies the given graph and returns a new graph with less edges. Convenience method around `sparsify(Collection, Collection, double, String)` Passing vertexProps as `VertexProperty.ALL` edgeProps as `EdgeProperty.ALL`
`FileGraphConfig`	`store(Format targetFormat, String targetPath)` Blocking version of `storeAsync(Format, String)`.
`FileGraphConfig`	`store(Format targetFormat, String targetPath, boolean overwrite)` Blocking version of `storeAsync(Format, String, boolean)`.
`FileGraphConfig`	`store(Format targetFormat, String targetPath, Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, boolean overwrite)` Blocking version of `storeAsync(Format, String, Collection, Collection, boolean)`.
`PgxFuture<FileGraphConfig>`	`storeAsync(Format targetFormat, String targetPath)`
`PgxFuture<FileGraphConfig>`	`storeAsync(Format targetFormat, String targetPath, boolean overwrite)`
`PgxFuture<FileGraphConfig>`	`storeAsync(Format targetFormat, String targetPath, Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, boolean overwrite)`
`String`	`toString()`
`PgxGraph`	`undirect()` Blocking version of `undirectAsync()`.
`PgxGraph`	`undirect(Collection<VertexProperty<?,?>> vertexProps, PgxGraph.MultiEdges multiEdges, PgxGraph.SelfEdges selfEdges, PgxGraph.TrivialVertices trivialVertices, PgxGraph.Mode mode, String newGraphName)` Blocking version of `undirectAsync()`.
`PgxGraph`	`undirect(PgxGraph.MultiEdges multiEdges, PgxGraph.SelfEdges selfEdges, PgxGraph.TrivialVertices trivialVertices, PgxGraph.Mode mode, String newGraphName)` Blocking version of `undirectAsync()`.
`PgxGraph`	`undirect(String newGraphName)` Blocking version of `undirectAsync()`.
`PgxFuture<PgxGraph>`	`undirectAsync()` Convenience method around `undirectAsync(String)` Passing String(newGraphName) as null
`PgxFuture<PgxGraph>`	`undirectAsync(Collection<VertexProperty<?,?>> vertexProps, PgxGraph.MultiEdges multiEdges, PgxGraph.SelfEdges selfEdges, PgxGraph.TrivialVertices trivialVertices, PgxGraph.Mode mode, String newGraphName)` Create an undirected version of a graph.
`PgxFuture<PgxGraph>`	`undirectAsync(PgxGraph.MultiEdges multiEdges, PgxGraph.SelfEdges selfEdges, PgxGraph.TrivialVertices trivialVertices, PgxGraph.Mode mode, String newGraphName)` Convenience method for `undirectAsync(Collection, MultiEdges, SelfEdges, TrivialVertices, Mode, String)` Passing Collection(vertexProps) as `VertexProperty.ALL`
`PgxFuture<PgxGraph>`	`undirectAsync(String newGraphName)` Convenience method around `undirectAsync(MultiEdges, SelfEdges, TrivialVertices, Mode, String)` Passing MultiEdges as `MultiEdges.KEEP_MULTI_EDGES` SelfEdges as `SelfEdges.KEEP_SELF_EDGES` Trivial Vertices as `TrivialVertices.KEEP_TRIVIALVERTICES` Mode as `Mode.CREATE_COPY`

Methods inherited from class oracle.pgx.api.PgxManagedObject
equals, hashCode

Methods inherited from class oracle.pgx.api.Destroyable
close, destroy, destroyAsync

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

- Method Detail
  - bipartiteSubGraphFromLeftSet
```
@Generated(value="src/python/synchronize.py")
public BipartiteGraph bipartiteSubGraphFromLeftSet(Collection<VertexProperty<?,?>> vertexProps,
                                                         Collection<EdgeProperty<?>> edgeProps,
                                                         VertexSet<?> vertexSet,
                                                         String newGraphName)
                                            throws ExecutionException,
                                                   InterruptedException
```
    Blocking version of #bipartiteSubGraphFromLeftSetAsync(). Calls #bipartiteSubGraphFromLeftSetAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - bipartiteSubGraphFromLeftSet
```
@Generated(value="src/python/synchronize.py")
public BipartiteGraph bipartiteSubGraphFromLeftSet(Collection<VertexProperty<?,?>> vertexProps,
                                                         Collection<EdgeProperty<?>> edgeProps,
                                                         VertexSet<?> vertexSet,
                                                         String newGraphName,
                                                         String isLeftPropName)
                                            throws ExecutionException,
                                                   InterruptedException
```
    Blocking version of #bipartiteSubGraphFromLeftSetAsync(). Calls #bipartiteSubGraphFromLeftSetAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - bipartiteSubGraphFromLeftSet
```
@Generated(value="src/python/synchronize.py")
public BipartiteGraph bipartiteSubGraphFromLeftSet(VertexSet<?> vertexSet)
                                            throws ExecutionException,
                                                   InterruptedException
```
    Blocking version of #bipartiteSubGraphFromLeftSetAsync(). Calls #bipartiteSubGraphFromLeftSetAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - bipartiteSubGraphFromLeftSet
```
@Generated(value="src/python/synchronize.py")
public BipartiteGraph bipartiteSubGraphFromLeftSet(VertexSet<?> vertexSet,
                                                         String newGraphName)
                                            throws ExecutionException,
                                                   InterruptedException
```
    Blocking version of #bipartiteSubGraphFromLeftSetAsync(). Calls #bipartiteSubGraphFromLeftSetAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - bipartiteSubGraphFromLeftSetAsync
```
public PgxFuture<BipartiteGraph> bipartiteSubGraphFromLeftSetAsync(Collection<VertexProperty<?,?>> vertexProps,
                                                          Collection<EdgeProperty<?>> edgeProps,
                                                          VertexSet<?> vertexSet,
                                                          String newGraphName)
```
    Create a bipartite version of a graph.
    
    Parameters:
    
    vertexProps - vertex properties belonging to graph specified by graph to be transformed as well. Constants VertexProperty.ALL or VertexProperty.NONE can be used.
    
    edgeProps - edge properties belonging to graph specified by graph to be transformed as well. Constants EdgeProperty.ALL or EdgeProperty.NONE can be used.
    
    vertexSet - vertex set representing the left side
    
    newGraphName - name of the new graph. If null, a name will be generated.
    
    isLeftPropName - after the method finishes, the name that will be associated with a boolean property that will contain the information whether a node is on the left side of the bipartite subgraph. The name must not be a name of an existing node property for this graph. If the argument is null, a new unique name will be created.
    
    Returns:
    
    resulting graph
  - bipartiteSubGraphFromLeftSetAsync
```
public PgxFuture<BipartiteGraph> bipartiteSubGraphFromLeftSetAsync(Collection<VertexProperty<?,?>> vertexProps,
                                                          Collection<EdgeProperty<?>> edgeProps,
                                                          VertexSet<?> vertexSet,
                                                          String newGraphName,
                                                          String isLeftPropName)
```
  - bipartiteSubGraphFromLeftSetAsync
```
public PgxFuture<BipartiteGraph> bipartiteSubGraphFromLeftSetAsync(VertexSet<?> vertexSet)
```
    Create a bipartite version of a graph.
    #bipartiteSubGraphFromLeftSet(Collection, Collection, VertexSet)
    Passing
    - vertexProps as VertexProperty.ALL
    - edgeProps as EdgeProperty.ALL
    Parameters:
    
    vertexSet - vertex set representing the left side
    
    Returns:
    
    resulting graph
  - bipartiteSubGraphFromLeftSetAsync
```
public PgxFuture<BipartiteGraph> bipartiteSubGraphFromLeftSetAsync(VertexSet<?> vertexSet,
                                                          String newGraphName)
```
    Create a bipartite version of a graph.
    Convenience method around bipartiteSubGraphFromLeftSetAsync(Collection, Collection, VertexSet, String, String) passing newGraphName and isLeftPropName as null
    
    Parameters:
    
    vertexProps - vertex properties belonging to graph specified by graph to be transformed as well. Constants VertexProperty.ALL or VertexProperty.NONE can be used.
    
    edgeProps - edge properties belonging to graph specified by graph to be transformed as well. Constants EdgeProperty.ALL or EdgeProperty.NONE can be used.
    
    vertexSet - vertex set representing the left side
    
    Returns:
    
    resulting graph
  - clone
```
@Generated(value="src/python/synchronize.py")
public PgxGraph clone()
```
    Blocking version of cloneAsync(). Calls cloneAsync() and waits for the returned PgxFuture to complete.
    
    Overrides:
    
    clone in class Object
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - clone
```
@Generated(value="src/python/synchronize.py")
public PgxGraph clone(Collection<VertexProperty<?,?>> vertexProps,
                            Collection<EdgeProperty<?>> edgeProps,
                            String newGraphName)
               throws ExecutionException,
                      InterruptedException
```
    Blocking version of cloneAsync(). Calls cloneAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - clone
```
@Generated(value="src/python/synchronize.py")
public PgxGraph clone(String newGraphName)
               throws ExecutionException,
                      InterruptedException
```
    Blocking version of cloneAsync(). Calls cloneAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - cloneAsync
```
public PgxFuture<PgxGraph> cloneAsync()
```
    Convenience method of cloneAsync(String)
    Passing
    - String(name) as null
    Create a copy of a graph.
    Returns:
    
    resulting graph
  - cloneAsync
```
public PgxFuture<PgxGraph> cloneAsync(Collection<VertexProperty<?,?>> vertexProps,
                             Collection<EdgeProperty<?>> edgeProps,
                             String newGraphName)
```
    Create a copy of a graph.
    
    Parameters:
    
    vertexProps - vertex properties belonging to graph specified by graph to be transformed as well. Constants VertexProperty.ALL or VertexProperty.NONE can be used.
    
    edgeProps - edge properties belonging to graph specified by graph to be transformed as well. Constants EdgeProperty.ALL or EdgeProperty.NONE can be used.
    
    newGraphName - name of the new graph. If null, a name will be generated.
    
    Returns:
    
    resulting graph
  - cloneAsync
```
public PgxFuture<PgxGraph> cloneAsync(String newGraphName)
```
    Convenience method of cloneAsync(Collection, Collection, String)
    Passing
    - Collection(vertexProperties) as VertexProperty.ALL
    - Collection(edgeProperties) as EdgeProperty.ALL
    Create a copy of a graph.
    Parameters:
    
    newGraphName - name of the new graph. If null, a name will be generated.
    
    Returns:
    
    resulting graph
  - createAllPaths
```
@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> AllPaths<ID> createAllPaths(PgxVertex<ID> src,
                                                                     EdgeProperty<Double> cost,
                                                                     VertexProperty<ID,PgxVertex<ID>> parent,
                                                                     VertexProperty<ID,PgxEdge> parentEdge)
                                                   throws ExecutionException,
                                                          InterruptedException
```
    Blocking version of #createAllPathsAsync(). Calls #createAllPathsAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createAllPathsAsync
```
public <ID extends Comparable<ID>> PgxFuture<AllPaths<ID>> createAllPathsAsync(PgxVertex<ID> src,
                                                                      EdgeProperty<Double> cost,
                                                                      VertexProperty<ID,PgxVertex<ID>> parent,
                                                                      VertexProperty<ID,PgxEdge> parentEdge)
```
    Creates a AllPaths object representing all the shortest paths from a single source to all the possible destinations (shortest regarding the given edge costs).
    
    Parameters:
    
    src - source vertex
    
    cost - property holding the edge costs. If null, the resulting cost will equal the hop distance.
    
    parent - property holding the parent vertices of all the shortest paths. For example, if the source vertex is A and the shortest path to C is A -> B -> C, then then parent[C] -> B and parent[B] -> A.
    
    parentEdge - property holding the parent edges for each vertex shortest path
    
    Returns:
    
    the AllPaths object.
  - createComponents
```
@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> Partition<ID> createComponents(VertexProperty<ID,Integer> components,
                                                                        int numComponents)
                                                      throws ExecutionException,
                                                             InterruptedException
```
    Blocking version of #createComponentsAsync(). Calls #createComponentsAsync() and waits for returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createComponentsAsync
```
public <ID extends Comparable<ID>> PgxFuture<Partition<ID>> createComponentsAsync(VertexProperty<ID,Integer> components,
                                                                         int numComponents)
```
    Creates a Partition object holding a collection of vertex sets, each representing a component.
    
    Parameters:
    
    components - property mapping each vertex to its component ID. Note that only component IDs in the range of [0..numComponents-1] are allowed. The returned future will complete exceptionally with an IllegalArgumentException if an invalid component ID is encountered. Gaps are supported: certain IDs not being associated with any vertices will yield to empty components.
    
    numComponents - how many different components the components property contains
    
    Returns:
    
    the Partition object.
  - createEdgeProperty
```
@Generated(value="src/python/synchronize.py")
public <V extends Comparable<V>> EdgeProperty<V> createEdgeProperty(PropertyType type)
                                                         throws ExecutionException,
                                                                InterruptedException
```
    Blocking version of #createEdgePropertyAsync(). Calls #createEdgePropertyAsync() and waits for returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createEdgeProperty
```
@Generated(value="src/python/synchronize.py")
public <V extends Comparable<V>> EdgeProperty<V> createEdgeProperty(PropertyType type,
                                                                          String name)
                                                         throws ExecutionException,
                                                                InterruptedException
```
    Blocking version of #createEdgePropertyAsync(). Calls #createEdgePropertyAsync() and waits for returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createEdgePropertyAsync
```
public <V extends Comparable<V>> PgxFuture<EdgeProperty<V>> createEdgePropertyAsync(PropertyType type)
```
    Creates a session-bound edge property
    
    Parameters:
    
    type - type of property to create
    
    Returns:
    
    newly created property
  - createEdgePropertyAsync
```
public <V extends Comparable<V>> PgxFuture<EdgeProperty<V>> createEdgePropertyAsync(PropertyType type,
                                                                           String name)
```
    Creates a session-bound edge property
    
    Parameters:
    
    type - type of property to create
    
    name - of property to be created
    
    Returns:
    
    newly created property
  - createEdgeSequence
```
@Generated(value="src/python/synchronize.py")
public EdgeSequence createEdgeSequence()
                                throws ExecutionException,
                                       InterruptedException
```
    Blocking version of createEdgeSequenceAsync(). Calls createEdgeSequenceAsync() and waits for returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createEdgeSequence
```
@Generated(value="src/python/synchronize.py")
public EdgeSequence createEdgeSequence(String name)
                                throws ExecutionException,
                                       InterruptedException
```
    Blocking version of createEdgeSequenceAsync(). Calls createEdgeSequenceAsync() and waits for returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createEdgeSequenceAsync
```
public PgxFuture<EdgeSequence> createEdgeSequenceAsync()
```
    Creates a new Edge Sequence.
    
    Returns:
    
    the newly created Edge Sequence
  - createEdgeSequenceAsync
```
public PgxFuture<EdgeSequence> createEdgeSequenceAsync(String name)
```
    Creates a new Edge Sequence.
    
    Parameters:
    
    name - name of the Edge Sequence to be created
    
    Returns:
    
    the newly created Edge Sequence
  - createEdgeSet
```
@Generated(value="src/python/synchronize.py")
public EdgeSet createEdgeSet()
                      throws ExecutionException,
                             InterruptedException
```
    Blocking version of createEdgeSetAsync(). Calls createEdgeSetAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createEdgeSet
```
@Generated(value="src/python/synchronize.py")
public EdgeSet createEdgeSet(String name)
                      throws ExecutionException,
                             InterruptedException
```
    Blocking version of createEdgeSetAsync(). Calls createEdgeSetAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createEdgeSetAsync
```
public PgxFuture<EdgeSet> createEdgeSetAsync()
```
    Creates a new Edge Set.
    
    Returns:
    
    the newly created EdgeSet
  - createEdgeSetAsync
```
public PgxFuture<EdgeSet> createEdgeSetAsync(String name)
```
    Creates a new Edge Set.
    
    Parameters:
    
    name - name of the Edge Set to be created
    
    Returns:
    
    the newly created EdgeSet
  - createMap
```
@Generated(value="src/python/synchronize.py")
public <K extends Comparable<K>,V extends Comparable<V>> PgxMap<K,V> createMap(PropertyType keyType,
                                                                                     PropertyType valType)
                                                                  throws ExecutionException,
                                                                         InterruptedException
```
    Blocking version of #createMapAsync(). Calls #createMapAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createMap
```
@Generated(value="src/python/synchronize.py")
public <K extends Comparable<K>,V extends Comparable<V>> PgxMap<K,V> createMap(PropertyType keyType,
                                                                                     PropertyType valType,
                                                                                     MapType mapType)
                                                                  throws ExecutionException,
                                                                         InterruptedException
```
    Blocking version of #createMapAsync(). Calls #createMapAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createMap
```
@Generated(value="src/python/synchronize.py")
public <K extends Comparable<K>,V extends Comparable<V>> PgxMap<K,V> createMap(PropertyType keyType,
                                                                                     PropertyType valType,
                                                                                     MapType mapType,
                                                                                     String mapName)
                                                                  throws ExecutionException,
                                                                         InterruptedException
```
    Blocking version of #createMapAsync(). Calls #createMapAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createMapAsync
```
public <K extends Comparable<K>,V extends Comparable<V>> PgxFuture<PgxMap<K,V>> createMapAsync(PropertyType keyType,
                                                                                      PropertyType valType)
```
    Creates a session-bound map
    
    Parameters:
    
    keyType - Property type of the keys that are going to be stored inside the map
    
    valType - Property type of the values that are going to be stored inside the map
    
    Returns:
    
    newly created map
  - createMapAsync
```
public <K extends Comparable<K>,V extends Comparable<V>> PgxFuture<PgxMap<K,V>> createMapAsync(PropertyType keyType,
                                                                                      PropertyType valType,
                                                                                      MapType mapType)
```
    Creates a session-bound map
    
    Parameters:
    
    keyType - Property type of the keys that are going to be stored inside the map
    
    valType - Property type of the values that are going to be stored inside the map
    
    mapType - Type of the map that is going to be created
    
    Returns:
    
    newly created map
  - createMapAsync
```
public <K extends Comparable<K>,V extends Comparable<V>> PgxFuture<PgxMap<K,V>> createMapAsync(PropertyType keyType,
                                                                                      PropertyType valType,
                                                                                      MapType mapType,
                                                                                      String mapName)
```
    Creates a session-bound map
    
    Parameters:
    
    keyType - Property type of the keys that are going to be stored inside the map
    
    valType - Property type of the values that are going to be stored inside the map
    
    mapType - Type of the map that is going to be created
    
    mapName - how the map should be named
    
    Returns:
    
    newly created map
  - createPath
```
@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> PgxPath<ID> createPath(PgxVertex<ID> src,
                                                                PgxVertex<ID> dst,
                                                                EdgeProperty<Double> cost,
                                                                VertexProperty<ID,PgxVertex<ID>> parent,
                                                                VertexProperty<ID,PgxEdge> parentEdge)
                                              throws ExecutionException,
                                                     InterruptedException
```
    Blocking version of #createPathAsync(). Calls #createPathAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createPathAsync
```
public <ID extends Comparable<ID>> PgxFuture<PgxPath<ID>> createPathAsync(PgxVertex<ID> src,
                                                                 PgxVertex<ID> dst,
                                                                 EdgeProperty<Double> cost,
                                                                 VertexProperty<ID,PgxVertex<ID>> parent,
                                                                 VertexProperty<ID,PgxEdge> parentEdge)
```
    Creates a PgxPath object representing the shortest path from one source to one destination (shortest regarding the given edge costs). If there are multiple shortest paths, an arbitrary one will be returned.
    
    Parameters:
    
    src - source vertex of the path
    
    dst - destination vertex of the path
    
    cost - property holding the edge costs. If null, the resulting cost will equal the hop distance.
    
    parent - property holding the parent vertices for each vertex of the shortest path. For example, if the shortest path is A -> B -> C, then parent[C] -> B and parent[B] -> A.
    
    parentEdge - property holding the parent edges for each vertex of the shortest path
    
    Returns:
    
    the PgxPath object.
  - createScalar
```
@Generated(value="src/python/synchronize.py")
public <T> Scalar<T> createScalar(PropertyType type)
                       throws ExecutionException,
                              InterruptedException
```
    Blocking version of #createScalarAsync(). Calls #createScalarAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createScalar
```
@Generated(value="src/python/synchronize.py")
public <T> Scalar<T> createScalar(PropertyType type,
                                        String newScalarName)
                       throws ExecutionException,
                              InterruptedException
```
    Blocking version of #createScalarAsync(). Calls #createScalarAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createScalarAsync
```
public <T> PgxFuture<Scalar<T>> createScalarAsync(PropertyType type)
```
    Creates a new Scalar.
    
    Parameters:
    
    type - the Property Type
    
    Returns:
    
    newly created Scalar.
  - createScalarAsync
```
public <T> PgxFuture<Scalar<T>> createScalarAsync(PropertyType type,
                                         String newScalarName)
```
    Create a session-bound scalar.
    
    Parameters:
    
    newScalarName - name of the scalar to be created
    
    type - the type of scalar
    
    Returns:
    
    the newly created scalar
  - createVertexProperty
```
@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>,V extends Comparable<V>> VertexProperty<ID,V> createVertexProperty(PropertyType type)
                                                                                       throws ExecutionException,
                                                                                              InterruptedException
```
    Blocking version of #createVertexPropertyAsync(). Calls #createVertexPropertyAsync() and waits for returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createVertexProperty
```
@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>,V extends Comparable<V>> VertexProperty<ID,V> createVertexProperty(PropertyType type,
                                                                                                           String name)
                                                                                       throws ExecutionException,
                                                                                              InterruptedException
```
    Blocking version of #createVertexPropertyAsync(). Calls #createVertexPropertyAsync() and waits for returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createVertexPropertyAsync
```
public <ID extends Comparable<ID>,V extends Comparable<V>> PgxFuture<VertexProperty<ID,V>> createVertexPropertyAsync(PropertyType type)
```
    Creates a session-bound vertex property
    
    Parameters:
    
    type - type of the property to create
    
    Returns:
    
    newly created property
  - createVertexPropertyAsync
```
public <ID extends Comparable<ID>,V extends Comparable<V>> PgxFuture<VertexProperty<ID,V>> createVertexPropertyAsync(PropertyType type,
                                                                                                            String name)
```
    Creates a session-bound vertex property
    
    Parameters:
    
    type - type of property to create
    
    name - of property to be created
    
    Returns:
    
    newly created property
  - createVertexSequence
```
@Generated(value="src/python/synchronize.py")
public <E extends Comparable<E>> VertexSequence<E> createVertexSequence()
                                                             throws ExecutionException,
                                                                    InterruptedException
```
    Blocking version of createVertexSequenceAsync(). Calls createVertexSequenceAsync() and waits for returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createVertexSequence
```
@Generated(value="src/python/synchronize.py")
public <E extends Comparable<E>> VertexSequence<E> createVertexSequence(String name)
                                                             throws ExecutionException,
                                                                    InterruptedException
```
    Blocking version of createVertexSequenceAsync(). Calls createVertexSequenceAsync() and waits for returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createVertexSequenceAsync
```
public <E extends Comparable<E>> PgxFuture<VertexSequence<E>> createVertexSequenceAsync()
```
    Creates a new Vertex Sequence.
    
    Returns:
    
    newly created VertexSequence
  - createVertexSequenceAsync
```
public <E extends Comparable<E>> PgxFuture<VertexSequence<E>> createVertexSequenceAsync(String name)
```
    Creates a new Vertex Sequence.
    
    Parameters:
    
    name - the name of the collection to be created
    
    Returns:
    
    newly created VertexSequence
  - createVertexSet
```
@Generated(value="src/python/synchronize.py")
public <E extends Comparable<E>> VertexSet<E> createVertexSet()
                                                   throws ExecutionException,
                                                          InterruptedException
```
    Blocking version of createVertexSetAsync(). Calls createVertexSetAsync() and waits for returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createVertexSet
```
@Generated(value="src/python/synchronize.py")
public <E extends Comparable<E>> VertexSet<E> createVertexSet(String name)
                                                   throws ExecutionException,
                                                          InterruptedException
```
    Blocking version of createVertexSetAsync(). Calls createVertexSetAsync() and waits for returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createVertexSetAsync
```
public <E extends Comparable<E>> PgxFuture<VertexSet<E>> createVertexSetAsync()
```
    Creates a new Vertex Set.
    
    Returns:
    
    the newly created Vertex Set
  - createVertexSetAsync
```
public <E extends Comparable<E>> PgxFuture<VertexSet<E>> createVertexSetAsync(String name)
```
    Creates a new Vertex Set.
    
    Parameters:
    
    name - name of the vertex set to be created
    
    Returns:
    
    the newly created Vertex Set
  - filter
```
@Generated(value="src/python/synchronize.py")
public PgxGraph filter(Collection<VertexProperty<?,?>> vertexProps,
                             Collection<EdgeProperty<?>> edgeProps,
                             GraphFilter graphFilter,
                             String newGraphName)
                throws ExecutionException,
                       InterruptedException
```
    Blocking version of #filterAsync(). Calls #filterAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - filter
```
@Generated(value="src/python/synchronize.py")
public PgxGraph filter(GraphFilter graphFilter)
                throws ExecutionException,
                       InterruptedException
```
    Blocking version of #filterAsync(). Calls #filterAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - filter
```
@Generated(value="src/python/synchronize.py")
public PgxGraph filter(GraphFilter graphFilter,
                             String newGraphName)
                throws ExecutionException,
                       InterruptedException
```
    Blocking version of #filterAsync(). Calls #filterAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - filterAsync
```
public PgxFuture<PgxGraph> filterAsync(Collection<VertexProperty<?,?>> vertexProps,
                              Collection<EdgeProperty<?>> edgeProps,
                              GraphFilter graphFilter,
                              String newGraphName)
```
    Create a subgraph of a graph. To create the subgraph, a given filter expression is used to determine which parts of the graph will be part of the subgraph.
    
    Parameters:
    
    vertexProps - vertex properties belonging to graph specified by graph to be transformed as well. Constants VertexProperty.ALL or VertexProperty.NONE can be used.
    
    edgeProps - edge properties belonging to graph specified by graph to be transformed as well. Constants EdgeProperty.ALL or EdgeProperty.NONE can be used.
    
    graphFilter - GraphFilter object representing a filter expression that is applied to create the subgraph
    
    newGraphName - name of the new graph. If null, a name will be generated.
    
    Returns:
    
    resulting graph
  - filterAsync
```
public PgxFuture<PgxGraph> filterAsync(GraphFilter graphFilter)
```
    Create a subgraph of a graph. To create the subgraph, a given filter expression is used to determine which parts of the graph will be part of the subgraph.
    Convenience method around filterAsync(GraphFilter, String)
    Passing
    - newGraphName as null
    Parameters:
    
    graphFilter - GraphFilter object representing a filter expression that is applied to create the subgraph
    
    Returns:
    
    resulting graph
  - filterAsync
```
public PgxFuture<PgxGraph> filterAsync(GraphFilter graphFilter,
                              String newGraphName)
```
    Create a subgraph of a graph. To create the subgraph, a given filter expression is used to determine which parts of the graph will be part of the subgraph.
    Convenience method around filterAsync(Collection, Collection, GraphFilter, String)
    Passing
    - vertexProps as VertexProperty.ALL
    - edgeProps as EdgeProperty.ALL
    Parameters:
    
    graphFilter - GraphFilter object representing a filter expression that is applied to create the subgraph
    
    newGraphName - name of the new graph. If null, a name will be generated.
    
    Returns:
    
    resulting graph
  - getConfig
```
public GraphConfig getConfig()
```
    Gets the graph configuration object used to specify the data source of this graph.
    
    Returns:
    
    the config. Can be null if graph was not created from a datasource (isTransient() is true).
  - getCreationRequestTimestamp
```
public long getCreationRequestTimestamp()
```
    Gets the timestamp when this graph was requested to be created.
    
    Returns:
    
    the timestamp when this graph was requested to be created in milliseconds since Jan 1st, 1970 (UTC).
  - getCreationTimestamp
```
public long getCreationTimestamp()
```
    Gets the timestamp when this graph finished creation.
    
    Returns:
    
    the timestamp when this graph finished creation in milliseconds since Jan 1st, 1970 (UTC).
  - getDataSourceVersion
```
public String getDataSourceVersion()
```
    Gets the format-specific version identifier provided by data-source (timestamp for files, snapshot ID for databases).
    
    Returns:
    
    the dataSourceVersion. Can be null if graph was not created from a datasource ( isTransient() is true).
  - getEdge
```
public PgxEdge getEdge(long id)
```
    Gets a PgxEdge of this graph by ID. Note that this method does *not* check whether the given ID exists.
    
    Parameters:
    
    id - the ID of the vertex
    
    Returns:
    
    the PgxEdge object
  - getEdgeProperties
```
@Generated(value="src/python/synchronize.py")
public Set<EdgeProperty<?>> getEdgeProperties()
                                       throws ExecutionException,
                                              InterruptedException
```
    Blocking version of getEdgePropertiesAsync(). Calls getEdgePropertiesAsync() and waits for returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - getEdgePropertiesAsync
```
public PgxFuture<Set<EdgeProperty<?>>> getEdgePropertiesAsync()
```
    Get the set of edge properties belonging to this graph. This list might contain transient properties.
    
    Returns:
    
    all edge properties of this graph
  - getEdgeProperty
```
@Generated(value="src/python/synchronize.py")
public <V extends Comparable<V>> EdgeProperty<V> getEdgeProperty(String name)
                                                      throws ExecutionException,
                                                             InterruptedException
```
    Blocking version of #getEdgePropertyAsync(). Calls #getEdgePropertyAsync() and waits for returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - getEdgePropertyAsync
```
public <V extends Comparable<V>> PgxFuture<EdgeProperty<V>> getEdgePropertyAsync(String name)
```
    get an edge property of this graph
    
    Parameters:
    
    name - the name of the edge property
    
    Returns:
    
    the edge property object or null if no such property exists
    
    Throws:
    
    NullPointerException - if the passed name is null
  - getEdges
```
@Generated(value="src/python/synchronize.py")
public EdgeSet getEdges(EdgeFilter filter)
                 throws InterruptedException,
                        ExecutionException
```
    Blocking version of #getEdges(). Calls #getEdges() and waits for returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - getEdgesAsync
```
public <E extends Comparable<E>> PgxFuture<EdgeSet> getEdgesAsync(EdgeFilter filter)
```
    Creates a new Edge Set containing edges according to the given filter expression.
    
    Parameters:
    
    filter - the edge filter expression used to create the Edge Set
    
    Returns:
    
    newly created Edge Set
  - getMemoryMb
```
public long getMemoryMb()
```
    Gets the estimated number of memory this graph (including its properties) consumes in memory (in megabytes).
    
    Returns:
    
    the memoryMb
  - getName
```
public String getName()
```
    Specified by:
    
    getName in class PgxManagedObject
    
    Returns:
    
    the name of the graph
  - getNumEdges
```
public long getNumEdges()
```
    Gets the number of edges
    
    Returns:
    
    the numEdges
  - getNumVertices
```
public long getNumVertices()
```
    Gets the number of vertices
    
    Returns:
    
    the numVertices
  - getPgxInstance
```
public ServerInstance getPgxInstance()
```
    Returns:
    
    returns the current instance of PGX
  - getSession
```
public PgxSession getSession()
```
    Returns:
    
    returns the current session of PGX
  - getVertex
```
public <ID extends Comparable<ID>> PgxVertex<ID> getVertex(ID id)
```
    Gets a PgxVertex of this graph by ID. Note that this method does *not* check whether the given ID exists.
    
    Parameters:
    
    id - the ID of the vertex
    
    Returns:
    
    the PgxVertex object
    
    Throws:
    
    IllegalArgumentException - if given ID is null or not of type IdType
  - getVertexIdType
```
public IdType getVertexIdType()
```
    Gets the vertex ID type of this graph.
    
    Returns:
    
    the vertexIdType
  - getVertexProperties
```
@Generated(value="src/python/synchronize.py")
public Set<VertexProperty<?,?>> getVertexProperties()
                                             throws ExecutionException,
                                                    InterruptedException
```
    Blocking version of getVertexPropertiesAsync(). Calls getVertexPropertiesAsync() and waits for returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - getVertexPropertiesAsync
```
public PgxFuture<Set<VertexProperty<?,?>>> getVertexPropertiesAsync()
```
    Get the set of vertex properties belonging to this graph. This list might contain transient properties.
    
    Returns:
    
    all vertex properties of this graph
  - getVertexProperty
```
@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>,V extends Comparable<V>> VertexProperty<ID,V> getVertexProperty(String name)
                                                                                    throws ExecutionException,
                                                                                           InterruptedException
```
    Blocking version of #getVertexPropertyAsync(). Calls #getVertexPropertyAsync() and waits for returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - getVertexPropertyAsync
```
public <ID extends Comparable<ID>,V extends Comparable<V>> PgxFuture<VertexProperty<ID,V>> getVertexPropertyAsync(String name)
```
    Gets a vertex property of this graph
    
    Parameters:
    
    name - the name of the vertex property
    
    Returns:
    
    the vertex property object or null if no such property exists
    
    Throws:
    
    NullPointerException - if the passed name is null
  - getVertices
```
@Generated(value="src/python/synchronize.py")
public <E extends Comparable<E>> VertexSet<E> getVertices(VertexFilter filter)
                                               throws InterruptedException,
                                                      ExecutionException
```
    Blocking version of #getVerticesAsync(). Calls #getVerticesAsync() and waits for returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - getVerticesAsync
```
public <E extends Comparable<E>> PgxFuture<VertexSet<E>> getVerticesAsync(VertexFilter filter)
```
    Creates a new Vertex Set containing vertices according to the given filter expression.
    
    Parameters:
    
    filter - the vertex filter expression used to create the Vertex Set
    
    Returns:
    
    newly created Vertex Set
  - isFresh
```
@Generated(value="src/python/synchronize.py")
public boolean isFresh()
                throws ExecutionException,
                       InterruptedException
```
    Blocking version of isFreshAsync(). Calls isFreshAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - isFreshAsync
```
public PgxFuture<Boolean> isFreshAsync()
```
    Check whether an in-memory representation of a graph is fresh. If the given graph is not the latest snapshot in memory the method will return false. If the given graph is the latest snapshot in memory, its snapshot version gets compared to the latest version reported by datasource (SCN for databases, last-modified timestamp for files). If the given graph is transient (private, session-bound), it is always considered fresh.
    
    Returns:
    
    true if given graph is fresh, false otherwise
  - isTransient
```
public boolean isTransient()
```
    Returns:
    
    true if this graph is transient (session-bound, private), false otherwise.
  - pickRandomVertex
```
@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> PgxVertex<ID> pickRandomVertex()
                                                      throws ExecutionException,
                                                             InterruptedException
```
    Blocking version of pickRandomVertexAsync(). Calls pickRandomVertexAsync() and waits for returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - pickRandomVertexAsync
```
public <ID extends Comparable<ID>> PgxFuture<PgxVertex<ID>> pickRandomVertexAsync()
```
    Picks a random vertex in the graph.
    
    Returns:
    
    a random vertex.
  - simplify
```
@Generated(value="src/python/synchronize.py")
public PgxGraph simplify(Collection<VertexProperty<?,?>> vertexProps,
                               Collection<EdgeProperty<?>> edgeProps,
                               PgxGraph.MultiEdges multiEdges,
                               PgxGraph.SelfEdges selfEdges,
                               PgxGraph.TrivialVertices trivialVertices,
                               PgxGraph.Mode mode,
                               String newGraphName)
                  throws ExecutionException,
                         InterruptedException
```
    Blocking version of #simplifyAsync(). Calls #simplifyAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - simplify
```
@Generated(value="src/python/synchronize.py")
public PgxGraph simplify(PgxGraph.MultiEdges multiEdges,
                               PgxGraph.SelfEdges selfEdges,
                               PgxGraph.TrivialVertices trivialVertices,
                               PgxGraph.Mode mode,
                               String newGraphName)
                  throws ExecutionException,
                         InterruptedException
```
    Blocking version of #simplifyAsync(). Calls #simplifyAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - simplifyAsync
```
public PgxFuture<PgxGraph> simplifyAsync(Collection<VertexProperty<?,?>> vertexProps,
                                Collection<EdgeProperty<?>> edgeProps,
                                PgxGraph.MultiEdges multiEdges,
                                PgxGraph.SelfEdges selfEdges,
                                PgxGraph.TrivialVertices trivialVertices,
                                PgxGraph.Mode mode,
                                String newGraphName)
```
    Create a simplified version of a graph. Note that the returned graph and properties are transient and therefore session bound. They can be explicitly destroyed and get automatically freed once the session dies.
    
    Parameters:
    
    vertexProps - vertex properties belonging to graph specified by graph to be transformed as well. Constants VertexProperty.ALL or VertexProperty.NONE can be used.
    
    edgeProps - edge properties belonging to graph specified by graph to be transformed as well. Constants EdgeProperty.ALL or EdgeProperty.NONE can be used.
    
    multiEdges - defines if multi-edges should be kept in the result. Constants PgxGraph.MultiEdges.KEEP_MULTI_EDGES or PgxGraph.MultiEdges.REMOVE_MULTI_EDGES can be used
    
    selfEdges - defines if self-edges should be kept in the result. Constants PgxGraph.SelfEdges.KEEP_SELF_EDGES or PgxGraph.SelfEdges.REMOVE_SELF_EDGES cane be used.
    
    trivialVertices - defines if isolated nodes should be kept in the result. Constants PgxGraph.TrivialVertices.KEEP_TRIVIAL_VERTICES or PgxGraph.TrivialVertices.REMOVE_TRIVIAL_VERTICES can be used
    
    mode - defines if a copy of the graph should be created, otherwise graph is mutated in place. Constants PgxGraph.Mode.MUTATE_IN_PLACE or PgxGraph.Mode.CREATE_COPY can be used
    
    newGraphName - name of the new graph (only relevant if mode == PgxGraph.Mode.CREATE_COPY ). If null, a name will be generated.
    
    Returns:
    
    resulting graph
  - simplifyAsync
```
public PgxFuture<PgxGraph> simplifyAsync(PgxGraph.MultiEdges multiEdges,
                                PgxGraph.SelfEdges selfEdges,
                                PgxGraph.TrivialVertices trivialVertices,
                                PgxGraph.Mode mode,
                                String newGraphName)
```
    Convenience method for simplifyAsync(Collection, Collection, MultiEdges, SelfEdges, TrivialVertices, Mode, String)
    Passing
    - Collection(vertexProperties) as VertexProperty.ALL
    - Collection(edgeProperties) as EdgeProperty.ALL
    Create a simplified version of a graph. Note that the returned graph and properties are transient and therefore session bound. They can be explicitly destroyed and get automatically freed once the session dies.
    Parameters:
    
    multiEdges - defines if multi-edges should be kept in the result. Constants PgxGraph.MultiEdges.KEEP_MULTI_EDGES or PgxGraph.MultiEdges.REMOVE_MULTI_EDGES can be used
    
    selfEdges - defines if self-edges should be kept in the result. Constants PgxGraph.SelfEdges.KEEP_SELF_EDGES or PgxGraph.SelfEdges.REMOVE_SELF_EDGES cane be used.
    
    trivialVertices - defines if isolated nodes should be kept in the result. Constants PgxGraph.TrivialVertices.KEEP_TRIVIAL_VERTICES or PgxGraph.TrivialVertices.REMOVE_TRIVIAL_VERTICES can be used
    
    mode - defines if a copy of the graph should be created, otherwise graph is mutated in place. Constants PgxGraph.Mode.MUTATE_IN_PLACE or PgxGraph.Mode.CREATE_COPY can be used
    
    newGraphName - name of the new graph (only relevant if mode == PgxGraph.Mode.CREATE_COPY ). If null, a name will be generated.
    
    Returns:
    
    resulting graph
  - sortByDegree
```
@Generated(value="src/python/synchronize.py")
public PgxGraph sortByDegree()
                      throws ExecutionException,
                             InterruptedException
```
    Blocking version of sortByDegreeAsync(). Calls sortByDegreeAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - sortByDegree
```
@Generated(value="src/python/synchronize.py")
public PgxGraph sortByDegree(Collection<VertexProperty<?,?>> vertexProps,
                                   Collection<EdgeProperty<?>> edgeProps,
                                   PgxGraph.Direction direction,
                                   PgxGraph.Degree degree,
                                   PgxGraph.Mode mode,
                                   String newGraphName)
                      throws ExecutionException,
                             InterruptedException
```
    Blocking version of sortByDegreeAsync(). Calls sortByDegreeAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - sortByDegree
```
@Generated(value="src/python/synchronize.py")
public PgxGraph sortByDegree(PgxGraph.Direction direction,
                                   PgxGraph.Degree degree,
                                   PgxGraph.Mode mode,
                                   String newGraphName)
                      throws ExecutionException,
                             InterruptedException
```
    Blocking version of sortByDegreeAsync(). Calls sortByDegreeAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - sortByDegree
```
@Generated(value="src/python/synchronize.py")
public PgxGraph sortByDegree(String newGraphName)
                      throws ExecutionException,
                             InterruptedException
```
    Blocking version of sortByDegreeAsync(). Calls sortByDegreeAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - sortByDegreeAsync
```
public PgxFuture<PgxGraph> sortByDegreeAsync()
```
    Create a sorted version of a graph and all its properties. The returned graph is sorted such that the node numbering is ordered by the degree of the nodes. Note that the returned graph and properties are transient.
    
    Convenience method around sortByDegree(String)
    Passing newGraphName as null
    
    Returns:
    
    newly created graph
  - sortByDegreeAsync
```
public PgxFuture<PgxGraph> sortByDegreeAsync(Collection<VertexProperty<?,?>> vertexProps,
                                    Collection<EdgeProperty<?>> edgeProps,
                                    PgxGraph.Direction direction,
                                    PgxGraph.Degree degree,
                                    PgxGraph.Mode mode,
                                    String newGraphName)
```
    Create a sorted version of a graph and all its properties. The returned graph is sorted such that the node numbering is ordered by the degree of the nodes. Note that the returned graph and properties are transient.
    
    Parameters:
    
    vertexProps - vertex properties belonging to graph specified by graph to be transformed as well. Constants VertexProperty.ALL or VertexProperty.NONE can be used.
    
    edgeProps - edge properties belonging to graph specified by graph to be transformed as well. Constants EdgeProperty.ALL or EdgeProperty.NONE can be used.
    
    direction - order direction. Constants PgxGraph.Direction.ASCENDING or PgxGraph.Direction.DESCENDING should be used
    
    degree - degree sorting mode. Constants PgxGraph.Degree.OUT or PgxGraph.Degree.IN should be used
    
    mode - it specifies if the graph should be mutated in place or a new one should be created. Constants PgxGraph.Mode.MUTATE_IN_PLACE or PgxGraph.Mode.CREATE_COPY should be used
    
    newGraphName - name of the new graph (only relevant if a new copy is being created). If null, a name will be generated.
    
    Returns:
    
    newly created graph
  - sortByDegreeAsync
```
public PgxFuture<PgxGraph> sortByDegreeAsync(PgxGraph.Direction direction,
                                    PgxGraph.Degree degree,
                                    PgxGraph.Mode mode,
                                    String newGraphName)
```
    Create a sorted version of a graph and all its properties. The returned graph is sorted such that the node numbering is ordered by the degree of the nodes. Note that the returned graph and properties are transient.
    
    Convenience method around sortByDegreeAsync(Collection, Collection, Direction, Degree, Mode, String)
    Passing
    - Collection(vertexProps) as VertexProperty.ALL
    - Collection(edgeProps) as EdgeProperty.ALL
    Parameters:
    
    direction - order direction. Constants PgxGraph.Direction.ASCENDING or PgxGraph.Direction.DESCENDING should be used
    
    degree - degree sorting mode. Constants PgxGraph.Degree.OUT or PgxGraph.Degree.IN should be used
    
    mode - it specifies if the graph should be mutated in place or a new one should be created. Constants PgxGraph.Mode.MUTATE_IN_PLACE or PgxGraph.Mode.CREATE_COPY should be used
    
    newGraphName - name of the new graph (only relevant if a new copy is being created). If null, a name will be generated.
    
    Returns:
    
    newly created graph
  - sortByDegreeAsync
```
public PgxFuture<PgxGraph> sortByDegreeAsync(String newGraphName)
```
    Create a sorted version of a graph and all its properties. The returned graph is sorted such that the node numbering is ordered by the degree of the nodes. Note that the returned graph and properties are transient.
    
    Convenience method around sortByDegree(Direction, Degree, Mode, String)
    
    Passing
    - Direction as Direction.DESCENDING
    - Degree as Degree.IN
    - Mode as Mode.CREATE_COPY
    Parameters:
    
    newGraphName - name of the new graph (only relevant if a new copy is being created). If null, a name will be generated.
    
    Returns:
    
    newly created graph
  - sparsify
```
@Generated(value="src/python/synchronize.py")
public PgxGraph sparsify(Collection<VertexProperty<?,?>> vertexProps,
                               Collection<EdgeProperty<?>> edgeProps,
                               double e,
                               String newGraphName)
                  throws ExecutionException,
                         InterruptedException
```
    Blocking version of #sparsifyAsync(). Calls #sparsifyAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - sparsify
```
@Generated(value="src/python/synchronize.py")
public PgxGraph sparsify(double e)
                  throws ExecutionException,
                         InterruptedException
```
    Blocking version of #sparsifyAsync(). Calls #sparsifyAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - sparsify
```
@Generated(value="src/python/synchronize.py")
public PgxGraph sparsify(double e,
                               String newGraphName)
                  throws ExecutionException,
                         InterruptedException
```
    Blocking version of #sparsifyAsync(). Calls #sparsifyAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - sparsifyAsync
```
public PgxFuture<PgxGraph> sparsifyAsync(Collection<VertexProperty<?,?>> vertexProps,
                                Collection<EdgeProperty<?>> edgeProps,
                                double e,
                                String newGraphName)
```
    Sparsifies the given graph and returns a new graph with less edges. The underlying algorithm is based on the paper by V. Satuluri, S. Parthasarathy, Y. Ruan: 'Local Graph Sparsification for Scalable Clustering'.
    
    Parameters:
    
    vertexProps - vertex properties belonging to graph specified by graph to be transformed as well. Constants VertexProperty.ALL or VertexProperty.NONE can be used.
    
    edgeProps - edge properties belonging to graph specified by graph to be transformed as well. Constants EdgeProperty.ALL or EdgeProperty.NONE can be used.
    
    e - the sparsification coefficient
    
    newGraphName - name of the new graph. If null, a name will be generated.
    
    Returns:
    
    resulting graph
  - sparsifyAsync
```
public PgxFuture<PgxGraph> sparsifyAsync(double e)
```
    Sparsifies the given graph and returns a new graph with less edges.
    Convenience method around sparsify(double, String)
    Passing
    - newGraphName as null
    Parameters:
    
    e - the sparsification coefficient
    
    newGraphName - name of the new graph. If null, a name will be generated.
    
    Returns:
    
    resulting graph
  - sparsifyAsync
```
public PgxFuture<PgxGraph> sparsifyAsync(double e,
                                String newGraphName)
```
    Sparsifies the given graph and returns a new graph with less edges.
    Convenience method around sparsify(Collection, Collection, double, String)
    Passing
    - vertexProps as VertexProperty.ALL
    - edgeProps as EdgeProperty.ALL
    Parameters:
    
    e - the sparsification coefficient. Must be between 0.0 and 1.1.
    
    newGraphName - name of the new graph. If null, a name will be generated.
    
    Returns:
    
    resulting graph
  - store
```
@Generated(value="src/python/synchronize.py")
public FileGraphConfig store(Format targetFormat,
                                   String targetPath)
                      throws ExecutionException,
                             InterruptedException
```
    Blocking version of storeAsync(Format, String). Calls storeAsync(Format, String) and waits for returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - store
```
@Generated(value="src/python/synchronize.py")
public FileGraphConfig store(Format targetFormat,
                                   String targetPath,
                                   boolean overwrite)
                      throws ExecutionException,
                             InterruptedException
```
    Blocking version of storeAsync(Format, String, boolean). Calls storeAsync(Format, String, boolean) and waits for returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - store
```
@Generated(value="src/python/synchronize.py")
public FileGraphConfig store(Format targetFormat,
                                   String targetPath,
                                   Collection<VertexProperty<?,?>> vertexProps,
                                   Collection<EdgeProperty<?>> edgeProps,
                                   boolean overwrite)
                      throws ExecutionException,
                             InterruptedException
```
    Blocking version of storeAsync(Format, String, Collection, Collection, boolean). Calls storeAsync(Format, String, Collection, Collection, boolean) and waits for returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - storeAsync
```
public PgxFuture<FileGraphConfig> storeAsync(Format targetFormat,
                                    String targetPath)
```
  - storeAsync
```
public PgxFuture<FileGraphConfig> storeAsync(Format targetFormat,
                                    String targetPath,
                                    boolean overwrite)
```
  - storeAsync
```
public PgxFuture<FileGraphConfig> storeAsync(Format targetFormat,
                                    String targetPath,
                                    Collection<VertexProperty<?,?>> vertexProps,
                                    Collection<EdgeProperty<?>> edgeProps,
                                    boolean overwrite)
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class PgxManagedObject
  - undirect
```
@Generated(value="src/python/synchronize.py")
public PgxGraph undirect()
                  throws ExecutionException,
                         InterruptedException
```
    Blocking version of undirectAsync(). Calls undirectAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - undirect
```
@Generated(value="src/python/synchronize.py")
public PgxGraph undirect(Collection<VertexProperty<?,?>> vertexProps,
                               PgxGraph.MultiEdges multiEdges,
                               PgxGraph.SelfEdges selfEdges,
                               PgxGraph.TrivialVertices trivialVertices,
                               PgxGraph.Mode mode,
                               String newGraphName)
                  throws ExecutionException,
                         InterruptedException
```
    Blocking version of undirectAsync(). Calls undirectAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - undirect
```
@Generated(value="src/python/synchronize.py")
public PgxGraph undirect(PgxGraph.MultiEdges multiEdges,
                               PgxGraph.SelfEdges selfEdges,
                               PgxGraph.TrivialVertices trivialVertices,
                               PgxGraph.Mode mode,
                               String newGraphName)
                  throws ExecutionException,
                         InterruptedException
```
    Blocking version of undirectAsync(). Calls undirectAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - undirect
```
@Generated(value="src/python/synchronize.py")
public PgxGraph undirect(String newGraphName)
                  throws ExecutionException,
                         InterruptedException
```
    Blocking version of undirectAsync(). Calls undirectAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - undirectAsync
```
public PgxFuture<PgxGraph> undirectAsync()
```
    Convenience method around undirectAsync(String) Passing String(newGraphName) as null
    
    Returns:
    
    the resulting graph
  - undirectAsync
```
public PgxFuture<PgxGraph> undirectAsync(Collection<VertexProperty<?,?>> vertexProps,
                                PgxGraph.MultiEdges multiEdges,
                                PgxGraph.SelfEdges selfEdges,
                                PgxGraph.TrivialVertices trivialVertices,
                                PgxGraph.Mode mode,
                                String newGraphName)
```
    Create an undirected version of a graph. Note that the returned graph and properties are transient and therefore session bound. They can be explicitly destroyed and get automatically freed once the session dies. Undirecting edge properties is currently not supported.
    
    Parameters:
    
    vertexProps - vertex properties belonging to graph. Constants VertexProperty.ALL or VertexProperty.NONE can be used.
    
    multiEdges - defines if multi-edges should be kept in the result. Constants PgxGraph.MultiEdges.KEEP_MULTI_EDGES or PgxGraph.MultiEdges.REMOVE_MULTI_EDGES can be used
    
    selfEdges - defines if self-edges should be kept in the result. Constants PgxGraph.SelfEdges.KEEP_SELF_EDGES or PgxGraph.SelfEdges.REMOVE_SELF_EDGES cane be used.
    
    trivialVertices - defines if isolated nodes should be kept in the result. Constants PgxGraph.TrivialVertices.KEEP_TRIVIAL_VERTICES or PgxGraph.TrivialVertices.REMOVE_TRIVIAL_VERTICES can be used
    
    mode - defines if a copy of the graph should be created, otherwise graph is mutated in place. Constants PgxGraph.Mode.MUTATE_IN_PLACE or PgxGraph.Mode.CREATE_COPY can be used
    
    newGraphName - name of the new graph (only relevant if mode == PgxGraph.Mode.CREATE_COPY ). If null, a name will be generated.
    
    Returns:
    
    resulting graph
  - undirectAsync
```
public PgxFuture<PgxGraph> undirectAsync(PgxGraph.MultiEdges multiEdges,
                                PgxGraph.SelfEdges selfEdges,
                                PgxGraph.TrivialVertices trivialVertices,
                                PgxGraph.Mode mode,
                                String newGraphName)
```
    Convenience method for undirectAsync(Collection, MultiEdges, SelfEdges, TrivialVertices, Mode, String)
    Passing Collection(vertexProps) as VertexProperty.ALL
    
    Parameters:
    
    multiEdges - defines if multi-edges should be kept in the result.
    
    selfEdges - defines if self-edges should be kept in the result. Constants PgxGraph.SelfEdges.KEEP_SELF_EDGES or PgxGraph.SelfEdges.REMOVE_SELF_EDGES cane be used.
    
    trivialVertices - defines if isolated nodes should be kept in the result. Constants PgxGraph.TrivialVertices.KEEP_TRIVIAL_VERTICES or PgxGraph.TrivialVertices.REMOVE_TRIVIAL_VERTICES can be used
    
    mode - defines if a copy of the graph should be created, otherwise graph is mutated in place. Constants PgxGraph.Mode.MUTATE_IN_PLACE or PgxGraph.Mode.CREATE_COPY can be used
    
    newGraphName - name of the new graph (only relevant if mode == PgxGraph.Mode.CREATE_COPY ). If null, a name will be generated.
    
    Returns:
    
    resulting graph
  - undirectAsync
```
public PgxFuture<PgxGraph> undirectAsync(String newGraphName)
```
    Convenience method around undirectAsync(MultiEdges, SelfEdges, TrivialVertices, Mode, String)
    Passing
    - MultiEdges as MultiEdges.KEEP_MULTI_EDGES
    - SelfEdges as SelfEdges.KEEP_SELF_EDGES
    - Trivial Vertices as TrivialVertices.KEEP_TRIVIALVERTICES
    - Mode as Mode.CREATE_COPY
    Parameters:
    
    newGraphName - name of the new graph (only relevant if mode == PgxGraph.Mode.CREATE_COPY ). If null, a name will be generated.
    
    Returns:
    
    resulting graph

Class PgxGraph

Nested Class Summary

Method Summary

Methods inherited from class oracle.pgx.api.PgxManagedObject

Methods inherited from class oracle.pgx.api.Destroyable

Methods inherited from class java.lang.Object

Method Detail

bipartiteSubGraphFromLeftSet

bipartiteSubGraphFromLeftSet

bipartiteSubGraphFromLeftSet

bipartiteSubGraphFromLeftSet

bipartiteSubGraphFromLeftSetAsync

bipartiteSubGraphFromLeftSetAsync

bipartiteSubGraphFromLeftSetAsync

bipartiteSubGraphFromLeftSetAsync

clone

clone

clone

cloneAsync

cloneAsync

cloneAsync

createAllPaths

createAllPathsAsync

createComponents

createComponentsAsync

createEdgeProperty

createEdgeProperty

createEdgePropertyAsync

createEdgePropertyAsync

createEdgeSequence

createEdgeSequence

createEdgeSequenceAsync

createEdgeSequenceAsync

createEdgeSet

createEdgeSet

createEdgeSetAsync

createEdgeSetAsync

createMap

createMap

createMap

createMapAsync

createMapAsync

createMapAsync

createPath

createPathAsync

createScalar

createScalar

createScalarAsync

createScalarAsync

createVertexProperty

createVertexProperty

createVertexPropertyAsync

createVertexPropertyAsync

createVertexSequence

createVertexSequence

createVertexSequenceAsync

createVertexSequenceAsync

createVertexSet

createVertexSet

createVertexSetAsync

createVertexSetAsync

filter

filter

filter

filterAsync

filterAsync

filterAsync

getConfig

getCreationRequestTimestamp

getCreationTimestamp

getDataSourceVersion

getEdge

getEdgeProperties

getEdgePropertiesAsync

getEdgeProperty

getEdgePropertyAsync

getEdges

getEdgesAsync

getMemoryMb

getName