PgxGraph (Oracle Big Data Spatial and Graph In-memory Analyst Java API Reference v2.2.0 (E62127

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

All Implemented Interfaces:

java.lang.AutoCloseable, java.lang.Cloneable

Direct Known Subclasses:

BipartiteGraph
```
public class PgxGraph
extends PgxManagedObject
implements java.lang.Cloneable
```
A PGX Graph

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`PgxGraph.Degree` The degree.
`static class`	`PgxGraph.Mode` The mutation mode.
`static class`	`PgxGraph.MultiEdges` The multi-edges behavior.
`static class`	`PgxGraph.SelfEdges` The self-edges behavior.
`static class`	`PgxGraph.SortOrder` The direction.
`static class`	`PgxGraph.TrivialVertices` The trivial vertices behavior.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`BipartiteGraph`	`bipartiteSubGraphFromInDegree()` Blocking version of `bipartiteSubGraphFromInDegreeAsync()`.
`BipartiteGraph`	`bipartiteSubGraphFromInDegree(java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, java.lang.String newGraphName)` Blocking version of `bipartiteSubGraphFromInDegreeAsync(Collection, Collection, String)`.
`BipartiteGraph`	`bipartiteSubGraphFromInDegree(java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, java.lang.String newGraphName, java.lang.String isLeftPropName, boolean inPlace)` Blocking version of `bipartiteSubGraphFromInDegreeAsync(Collection, Collection, String, String, boolean)`.
`BipartiteGraph`	`bipartiteSubGraphFromInDegree(java.lang.String newGraphName)` Blocking version of `bipartiteSubGraphFromInDegreeAsync(String)`.
`PgxFuture<BipartiteGraph>`	`bipartiteSubGraphFromInDegreeAsync()` Create a bipartite version of this graph with all vertices of in-degree = 0 being the left set.
`PgxFuture<BipartiteGraph>`	`bipartiteSubGraphFromInDegreeAsync(java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, java.lang.String newGraphName)` Create a bipartite version of this graph with all vertices of in-degree = 0 being the left set.
`PgxFuture<BipartiteGraph>`	`bipartiteSubGraphFromInDegreeAsync(java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, java.lang.String newGraphName, java.lang.String isLeftPropName, boolean inPlace)` Create a bipartite version of this graph with all vertices of in-degree = 0 being the left set.
`PgxFuture<BipartiteGraph>`	`bipartiteSubGraphFromInDegreeAsync(java.lang.String newGraphName)` Create a bipartite version of this graph with all vertices of in-degree = 0 being the left set.
`BipartiteGraph`	`bipartiteSubGraphFromLeftSet(java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, VertexSet<?> vertexSet, java.lang.String newGraphName)` Blocking version of `bipartiteSubGraphFromLeftSetAsync(Collection, Collection, VertexSet, String)`.
`BipartiteGraph`	`bipartiteSubGraphFromLeftSet(java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, VertexSet<?> vertexSet, java.lang.String newGraphName, java.lang.String isLeftPropName)` Blocking version of `bipartiteSubGraphFromLeftSetAsync(Collection, Collection, VertexSet, String, String)`.
`BipartiteGraph`	`bipartiteSubGraphFromLeftSet(VertexSet<?> vertexSet)` Blocking version of `bipartiteSubGraphFromLeftSetAsync(VertexSet)`.
`BipartiteGraph`	`bipartiteSubGraphFromLeftSet(VertexSet<?> vertexSet, java.lang.String newGraphName)` Blocking version of `bipartiteSubGraphFromLeftSetAsync(VertexSet, String)`.
`PgxFuture<BipartiteGraph>`	`bipartiteSubGraphFromLeftSetAsync(java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, VertexSet<?> vertexSet, java.lang.String newGraphName)` Create a bipartite version of this graph with the given vertex set being the left set.
`PgxFuture<BipartiteGraph>`	`bipartiteSubGraphFromLeftSetAsync(java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, VertexSet<?> vertexSet, java.lang.String newGraphName, java.lang.String isLeftPropName)` Create a bipartite version of this graph with the given vertex set being the left set.
`PgxFuture<BipartiteGraph>`	`bipartiteSubGraphFromLeftSetAsync(VertexSet<?> vertexSet)` Create a bipartite version of this graph with the given vertex set being the left set.
`PgxFuture<BipartiteGraph>`	`bipartiteSubGraphFromLeftSetAsync(VertexSet<?> vertexSet, java.lang.String newGraphName)` Create a bipartite version of this graph with the given vertex set being the left set.
`PgxGraph`	`clone()` Blocking version of `cloneAsync()`.
`PgxGraph`	`clone(java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, java.lang.String newGraphName)` Blocking version of `cloneAsync()`.
`PgxGraph`	`clone(java.lang.String newGraphName)` Blocking version of `cloneAsync(String)`.
`PgxFuture<PgxGraph>`	`cloneAsync()` Convenience method of `cloneAsync(String)` Passing String(name) as `null`
`PgxFuture<PgxGraph>`	`cloneAsync(java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, java.lang.String newGraphName)` Creates a copy of this graph.
`PgxFuture<PgxGraph>`	`cloneAsync(java.lang.String newGraphName)` Convenience method of `cloneAsync(Collection, Collection, String)` Passing Collection(vertexProperties) as `VertexProperty.ALL` Collection(edgeProperties) as `EdgeProperty.ALL`
`<E> EdgeProperty<PgxVect<E>>`	`combineEdgePropertiesIntoVectorProperty(java.util.List<EdgeProperty<E>> edgePropertyList)` Blocking version of `combineEdgePropertiesIntoVectorPropertyAsync(List)` Calls `combineEdgePropertiesIntoVectorPropertyAsync(List)` and waits for the returned `PgxFuture` to complete.
`<E> EdgeProperty<PgxVect<E>>`	`combineEdgePropertiesIntoVectorProperty(java.util.List<EdgeProperty<E>> edgePropertyList, java.lang.String name)` Blocking version of `combineEdgePropertiesIntoVectorPropertyAsync(List, String)` Calls `combineEdgePropertiesIntoVectorPropertyAsync(List, String)` and waits for the returned `PgxFuture` to complete.
`<E> PgxFuture<EdgeProperty<PgxVect<E>>>`	`combineEdgePropertiesIntoVectorPropertyAsync(java.util.List<EdgeProperty<E>> edgePropertyList)` Takes a list of scalar edge properties of same type and creates a new edge vector property by combining them.
`<E> PgxFuture<EdgeProperty<PgxVect<E>>>`	`combineEdgePropertiesIntoVectorPropertyAsync(java.util.List<EdgeProperty<E>> edgePropertyList, java.lang.String name)` Takes a list of scalar edge properties of same type and creates a new edge vector property by combining them.
`<ID,V> VertexProperty<ID,PgxVect<V>>`	`combineVertexPropertiesIntoVectorProperty(java.util.List<VertexProperty<ID,V>> vertexPropertyList)` Blocking version of `combineVertexPropertiesIntoVectorPropertyAsync(List)` Calls `combineVertexPropertiesIntoVectorPropertyAsync(List)` and waits for the returned `PgxFuture` to complete.
`<ID,V> VertexProperty<ID,PgxVect<V>>`	`combineVertexPropertiesIntoVectorProperty(java.util.List<VertexProperty<ID,V>> vertexPropertyList, java.lang.String name)` Blocking version of `combineVertexPropertiesIntoVectorPropertyAsync(List, String)` Calls `combineVertexPropertiesIntoVectorPropertyAsync(List, String)` and waits for the returned `PgxFuture` to complete.
`<ID,V> PgxFuture<VertexProperty<ID,PgxVect<V>>>`	`combineVertexPropertiesIntoVectorPropertyAsync(java.util.List<VertexProperty<ID,V>> vertexPropertyList)` Takes a list of scalar vertex properties of same type and creates a new vertex vector property by combining them.
`<ID,V> PgxFuture<VertexProperty<ID,PgxVect<V>>>`	`combineVertexPropertiesIntoVectorPropertyAsync(java.util.List<VertexProperty<ID,V>> vertexPropertyList, java.lang.String name)` Takes a list of scalar vertex properties of same type and creates a new vertex vector property by combining them.
`<ID extends java.lang.Comparable<ID>> AllPaths<ID>`	`createAllPaths(PgxVertex<ID> src, EdgeProperty<java.lang.Double> cost, VertexProperty<ID,java.lang.Double> dist, VertexProperty<ID,PgxVertex<ID>> parent, VertexProperty<ID,PgxEdge> parentEdge)` Blocking version of `createAllPathsAsync(PgxVertex, EdgeProperty, VertexProperty, VertexProperty, VertexProperty)`.
`<ID> PgxFuture<AllPaths<ID>>`	`createAllPathsAsync(PgxVertex<ID> src, EdgeProperty<java.lang.Double> cost, VertexProperty<ID,java.lang.Double> dist, 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 java.lang.Comparable<ID>> GraphChangeSet<ID>`	`createChangeSet()` Creates a change set for updating the graph.
`<ID> Partition<ID>`	`createComponents(VertexProperty<ID,java.lang.Long> components, long numComponents)` Blocking version of `createComponentsAsync(VertexProperty, long)`.
`<ID> PgxFuture<Partition<ID>>`	`createComponentsAsync(VertexProperty<ID,java.lang.Long> components, long numComponents)` Creates a `Partition` object holding a collection of vertex sets, each representing a component.
`<V> EdgeProperty<V>`	`createEdgeProperty(PropertyType type)` Blocking version of `createEdgePropertyAsync(PropertyType)`.
`<V> EdgeProperty<V>`	`createEdgeProperty(PropertyType type, int dimension, java.lang.String name, boolean hardName)` Blocking version of `createEdgePropertyAsync(PropertyType, int, String, boolean)`.
`<V> EdgeProperty<V>`	`createEdgeProperty(PropertyType type, java.lang.String name)` Blocking version of `createEdgePropertyAsync(PropertyType, String)`.
`<V> PgxFuture<EdgeProperty<V>>`	`createEdgePropertyAsync(PropertyType type)` Creates a session-bound edge property
`<V> PgxFuture<EdgeProperty<V>>`	`createEdgePropertyAsync(PropertyType type, java.lang.String name)` Creates a session-bound edge property
`EdgeSequence`	`createEdgeSequence()` Blocking version of `createEdgeSequenceAsync()`.
`EdgeSequence`	`createEdgeSequence(java.lang.String name)` Blocking version of `createEdgeSequenceAsync(String)`.
`PgxFuture<EdgeSequence>`	`createEdgeSequenceAsync()` Creates a new edge sequence.
`PgxFuture<EdgeSequence>`	`createEdgeSequenceAsync(java.lang.String name)` Creates a new edge sequence.
`EdgeSet`	`createEdgeSet()` Blocking version of `createEdgeSetAsync()`.
`EdgeSet`	`createEdgeSet(java.lang.String name)` Blocking version of `createEdgeSetAsync(String)`.
`PgxFuture<EdgeSet>`	`createEdgeSetAsync()` Creates a new edge set.
`PgxFuture<EdgeSet>`	`createEdgeSetAsync(java.lang.String name)` Creates a new edge set.
`<V> EdgeProperty<PgxVect<V>>`	`createEdgeVectorProperty(PropertyType type, int dimension)` Blocking version of `createEdgeVectorPropertyAsync(PropertyType, int)`.
`<V> EdgeProperty<PgxVect<V>>`	`createEdgeVectorProperty(PropertyType type, int dimension, java.lang.String name)` Blocking version of `createEdgeVectorPropertyAsync(PropertyType, int, String)`.
`<V> PgxFuture<EdgeProperty<PgxVect<V>>>`	`createEdgeVectorPropertyAsync(PropertyType type, int dimension)` Creates a session-bound edge vector property
`<V> PgxFuture<EdgeProperty<PgxVect<V>>>`	`createEdgeVectorPropertyAsync(PropertyType type, int dimension, java.lang.String name)` Creates a session-bound edge vector property
`<K,V> PgxMap<K,V>`	`createMap(PropertyType keyType, PropertyType valType)` Blocking version of `createMapAsync(PropertyType, PropertyType)`.
`<K,V> PgxMap<K,V>`	`createMap(PropertyType keyType, PropertyType valType, java.lang.String mapName)` Blocking version of `createMapAsync(PropertyType, PropertyType, String)`.
`<K,V> PgxFuture<PgxMap<K,V>>`	`createMapAsync(PropertyType keyType, PropertyType valType)` Creates a session-bound map
`<K,V> PgxFuture<PgxMap<K,V>>`	`createMapAsync(PropertyType keyType, PropertyType valType, java.lang.String mapName)` Creates a session-bound map
`MergingStrategyBuilder`	`createMergingStrategyBuilder()` Creates a new `MergingStrategyBuilder` that can be used to build a new `MutationStrategy` to simplify this graph.
`<ID> PgxPath<ID>`	`createPath(PgxVertex<ID> src, PgxVertex<ID> dst, EdgeProperty<java.lang.Double> cost, VertexProperty<ID,PgxVertex<ID>> parent, VertexProperty<ID,PgxEdge> parentEdge)` Blocking version of `createPathAsync(PgxVertex, PgxVertex, EdgeProperty, VertexProperty, VertexProperty)`.
`<ID> PgxFuture<PgxPath<ID>>`	`createPathAsync(PgxVertex<ID> src, PgxVertex<ID> dst, EdgeProperty<java.lang.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).
`PickingStrategyBuilder`	`createPickingStrategyBuilder()` Creates a new `PickingStrategyBuilder` that can be used to build a new `PickingStrategy` to simplify this graph.
`<T> Scalar<T>`	`createScalar(PropertyType type)` Blocking version of `createScalarAsync(PropertyType)`.
`<T> Scalar<T>`	`createScalar(PropertyType type, java.lang.String newScalarName)` Blocking version of `createScalarAsync(PropertyType, String)`.
`<T> PgxFuture<Scalar<T>>`	`createScalarAsync(PropertyType type)` Creates a new Scalar.
`<T> PgxFuture<Scalar<T>>`	`createScalarAsync(PropertyType type, java.lang.String newScalarName)` Create a session-bound scalar.
`<T> Scalar<PgxVect<T>>`	`createVectorScalar(PropertyType type, int dimension)` Blocking version of `createVectorScalarAsync(PropertyType, int)`.
`<T> Scalar<PgxVect<T>>`	`createVectorScalar(PropertyType type, int dimension, java.lang.String newScalarName)` Blocking version of `createVectorScalarAsync(PropertyType, int, String)`.
`<T> PgxFuture<Scalar<PgxVect<T>>>`	`createVectorScalarAsync(PropertyType type, int dimension)` Create a session-bound vector scalar.
`<T> PgxFuture<Scalar<PgxVect<T>>>`	`createVectorScalarAsync(PropertyType type, int dimension, java.lang.String newScalarName)` Create a session-bound vector scalar.
`<ID,V> VertexProperty<ID,V>`	`createVertexProperty(PropertyType type)` Blocking version of `createVertexPropertyAsync(PropertyType)`.
`<ID,V> VertexProperty<ID,V>`	`createVertexProperty(PropertyType type, int dimension, java.lang.String name, boolean hardName)` Blocking version of `createVertexPropertyAsync(PropertyType, int, String, boolean)`.
`<ID,V> VertexProperty<ID,V>`	`createVertexProperty(PropertyType type, java.lang.String name)` Blocking version of `createVertexPropertyAsync(PropertyType, String)`.
`<ID,V> PgxFuture<VertexProperty<ID,V>>`	`createVertexPropertyAsync(PropertyType type)` Creates a session-bound vertex property
`<ID,V> PgxFuture<VertexProperty<ID,V>>`	`createVertexPropertyAsync(PropertyType type, java.lang.String name)` Creates a session-bound vertex property
`<E> VertexSequence<E>`	`createVertexSequence()` Blocking version of `createVertexSequenceAsync()`.
`<E> VertexSequence<E>`	`createVertexSequence(java.lang.String name)` Blocking version of `createVertexSequenceAsync(String)`.
`<E> PgxFuture<VertexSequence<E>>`	`createVertexSequenceAsync()` Creates a new vertex sequence.
`<E> PgxFuture<VertexSequence<E>>`	`createVertexSequenceAsync(java.lang.String name)` Creates a new vertex sequence.
`<E> VertexSet<E>`	`createVertexSet()` Blocking version of `createVertexSetAsync()`.
`<E> VertexSet<E>`	`createVertexSet(java.lang.String name)` Blocking version of `createVertexSetAsync(String)`.
`<E> PgxFuture<VertexSet<E>>`	`createVertexSetAsync()` Creates a new vertex set.
`<E> PgxFuture<VertexSet<E>>`	`createVertexSetAsync(java.lang.String name)` Creates a new vertex set.
`<ID,V> VertexProperty<ID,PgxVect<V>>`	`createVertexVectorProperty(PropertyType type, int dimension)` Blocking version of `createVertexVectorPropertyAsync(PropertyType, int)`.
`<ID,V> VertexProperty<ID,PgxVect<V>>`	`createVertexVectorProperty(PropertyType type, int dimension, java.lang.String name)` Blocking version of `createVertexVectorPropertyAsync(PropertyType, int, String)`.
`<ID,V> PgxFuture<VertexProperty<ID,PgxVect<V>>>`	`createVertexVectorPropertyAsync(PropertyType type, int dimension)` Creates a session-bound vertex vector property
`<ID,V> PgxFuture<VertexProperty<ID,PgxVect<V>>>`	`createVertexVectorPropertyAsync(PropertyType type, int dimension, java.lang.String name)` Creates a session-bound vertex vector property
`PgxGraph`	`filter(java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, GraphFilter graphFilter, java.lang.String newGraphName)` Blocking version of `filterAsync(Collection, Collection, GraphFilter, String)`.
`PgxGraph`	`filter(GraphFilter graphFilter)` Blocking version of `filterAsync(GraphFilter)`.
`PgxGraph`	`filter(GraphFilter graphFilter, java.lang.String newGraphName)` Blocking version of `filterAsync(GraphFilter, String)`.
`PgxFuture<PgxGraph>`	`filterAsync(java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, GraphFilter graphFilter, java.lang.String newGraphName)` Create a subgraph of this graph.
`PgxFuture<PgxGraph>`	`filterAsync(GraphFilter graphFilter)` Create a subgraph of this graph.
`PgxFuture<PgxGraph>`	`filterAsync(GraphFilter graphFilter, java.lang.String newGraphName)` Create a subgraph of this 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.
`java.lang.String`	`getDataSourceVersion()` Gets the format-specific version identifier provided by data-source (timestamp for files, snapshot ID for databases).
`PgxEdge`	`getEdge(long id)` Blocking version of `getEdgeAsync(long)` Calls `getEdgeAsync(long)` and waits for the returned `PgxFuture` to complete.
`PgxFuture<PgxEdge>`	`getEdgeAsync(long id)` Looks up a `PgxEdge` of this graph by ID.
`EdgeLabel`	`getEdgeLabel()` Blocking version of `getEdgeLabelAsync()`.
`PgxFuture<EdgeLabel>`	`getEdgeLabelAsync()` Get the edge labels belonging to this graph.
`java.util.Set<EdgeProperty<?>>`	`getEdgeProperties()` Blocking version of `getEdgePropertiesAsync()`.
`PgxFuture<java.util.Set<EdgeProperty<?>>>`	`getEdgePropertiesAsync()` Get the set of edge properties belonging to this graph.
`<V> EdgeProperty<V>`	`getEdgeProperty(java.lang.String name)` Blocking version of `getEdgePropertyAsync(String)`.
`<V> PgxFuture<EdgeProperty<V>>`	`getEdgePropertyAsync(java.lang.String name)` Gets an edge property of this graph
`EdgeSet`	`getEdges()` Blocking version of `getEdges()`.
`EdgeSet`	`getEdges(EdgeFilter filter)` Blocking version of `getEdges(EdgeFilter)`.
`PgxFuture<EdgeSet>`	`getEdgesAsync()` Creates a new edge set containing all edges.
`<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).
`java.lang.String`	`getName()` Gets the name.
`long`	`getNumEdges()` Gets the number of edges
`long`	`getNumVertices()` Gets the number of vertices
`ServerInstance`	`getPgxInstance()` Gets the server instance.
`PgxSession`	`getSession()` Gets the session.
`<ID> PgxVertex<ID>`	`getVertex(ID id)` Blocking version of `getVertexAsync(Object)`.
`<ID> PgxFuture<PgxVertex<ID>>`	`getVertexAsync(ID id)` Looks up a `PgxVertex` of this graph by ID.
`IdType`	`getVertexIdType()` Gets the vertex ID type of this graph.
`<ID> VertexLabels<ID>`	`getVertexLabels()` Blocking version of `getVertexLabelsAsync()`.
`<ID> PgxFuture<VertexLabels<ID>>`	`getVertexLabelsAsync()` Get the vertex labels belonging to this graph.
`java.util.Set<VertexProperty<?,?>>`	`getVertexProperties()` Blocking version of `getVertexPropertiesAsync()`.
`PgxFuture<java.util.Set<VertexProperty<?,?>>>`	`getVertexPropertiesAsync()` Get the set of vertex properties belonging to this graph.
`<ID,V> VertexProperty<ID,V>`	`getVertexProperty(java.lang.String name)` Blocking version of `getVertexPropertyAsync(String)`.
`<ID,V> PgxFuture<VertexProperty<ID,V>>`	`getVertexPropertyAsync(java.lang.String name)` Gets a vertex property of this graph
`<E> VertexSet<E>`	`getVertices()` Blocking version of `getVerticesAsync()`.
`<E> VertexSet<E>`	`getVertices(VertexFilter filter)` Blocking version of `getVerticesAsync(VertexFilter)`.
`<E> VertexSet<E>`	`getVertices(VertexFilter filter, java.lang.String name)` Blocking version of `getVerticesAsync(VertexFilter,String)`.
`<E> PgxFuture<VertexSet<E>>`	`getVerticesAsync()` Creates a new vertex set containing all vertices.
`<E> PgxFuture<VertexSet<E>>`	`getVerticesAsync(VertexFilter filter)` Creates a new vertex set containing vertices according to the given filter expression.
`<E> PgxFuture<VertexSet<E>>`	`getVerticesAsync(VertexFilter filter, java.lang.String name)` Creates a new vertex set containing vertices according to the given filter expression.
`boolean`	`hasEdge(long id)` Blocking version of `hasEdgeAsync(long)` Calls `hasEdgeAsync(long)` and waits for the returned `PgxFuture` to complete.
`PgxFuture<java.lang.Boolean>`	`hasEdgeAsync(long id)` Looks up whether the graph has an Edge with the given ID
`<ID> boolean`	`hasVertex(ID id)` Blocking version of `hasVertexAsync(Object)`.
`<ID> PgxFuture<java.lang.Boolean>`	`hasVertexAsync(ID id)` Looks up whether the graph has a Vertex with the given ID
`java.lang.Boolean`	`isBipartiteGraph(VertexProperty<?,java.lang.Boolean> isLeft)` Blocking version of `isBipartiteGraphAsync(VertexProperty)`.
`<ID> PgxFuture<java.lang.Boolean>`	`isBipartiteGraphAsync(VertexProperty<ID,java.lang.Boolean> isLeft)` Checks whether a given graph is a bipartite graph.
`boolean`	`isDirected()`
`boolean`	`isFresh()` Blocking version of `isFreshAsync()`.
`PgxFuture<java.lang.Boolean>`	`isFreshAsync()` Check whether an in-memory representation of a graph is fresh.
`boolean`	`isTransient()` Gets the transient flag of this graph.
`<ID> PgxVertex<ID>`	`pickRandomVertex()` Blocking version of `pickRandomVertexAsync()`.
`<ID> PgxFuture<PgxVertex<ID>>`	`pickRandomVertexAsync()` Picks a random vertex in the graph.
`PgqlResultSet`	`queryPgql(java.lang.String pgqlString)` Blocking version of `queryPgql(String)`.
`PgqlResultSet`	`queryPgql(java.lang.String pgqlString, PatternMatchingSemantic patternMatchingSemantic)` Blocking version of `queryPgql(String, PatternMatchingSemantic)`.
`PgxFuture<PgqlResultSet>`	`queryPgqlAsync(java.lang.String pgqlString)` Submits a pattern matching query.
`PgxFuture<PgqlResultSet>`	`queryPgqlAsync(java.lang.String pgqlString, PatternMatchingSemantic patternMatchingSemantic)` Submits a pattern matching query.
`PgxGraph`	`simplify()` Blocking version of `simplifyAsync()`.
`PgxGraph`	`simplify(java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, PgxGraph.MultiEdges multiEdges, PgxGraph.SelfEdges selfEdges, PgxGraph.TrivialVertices trivialVertices, PgxGraph.Mode mode, java.lang.String newGraphName)` Blocking version of `simplifyAsync(Collection, Collection, MultiEdges, SelfEdges, TrivialVertices, Mode, String)`.
`PgxGraph`	`simplify(oracle.pgx.common.mutations.MutationStrategy mutationStrategy)`
`PgxGraph`	`simplify(PgxGraph.MultiEdges multiEdges, PgxGraph.SelfEdges selfEdges, PgxGraph.TrivialVertices trivialVertices, PgxGraph.Mode mode, java.lang.String newGraphName)` Blocking version of `simplifyAsync(MultiEdges, SelfEdges, TrivialVertices, Mode, String)`.
`PgxGraph`	`simplify(java.lang.String newGraphName)` Blocking version of `simplifyAsync(String)`.
`PgxFuture<PgxGraph>`	`simplifyAsync()` Convenience method around `simplifyAsync(String)` passing null as graphName
`PgxFuture<PgxGraph>`	`simplifyAsync(java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, PgxGraph.MultiEdges multiEdges, PgxGraph.SelfEdges selfEdges, PgxGraph.TrivialVertices trivialVertices, PgxGraph.Mode mode, java.lang.String newGraphName)` Create a simplified version of a graph.
`PgxFuture<PgxGraph>`	`simplifyAsync(oracle.pgx.common.mutations.MutationStrategy mutationStrategy)`
`PgxFuture<PgxGraph>`	`simplifyAsync(PgxGraph.MultiEdges multiEdges, PgxGraph.SelfEdges selfEdges, PgxGraph.TrivialVertices trivialVertices, PgxGraph.Mode mode, java.lang.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.
`PgxFuture<PgxGraph>`	`simplifyAsync(java.lang.String newGraphName)` Convenience method for `simplifyAsync(MultiEdges, SelfEdges, TrivialVertices, Mode, String)` Passing StrategyType as `StrategyType.REMOVE_MULTI_EDGES` SelfEdges as `SelfEdges.REMOVE_SELF_EDGES` Trivial Vertices as `TrivialVertices.REMOVE_TRIVIAL_VERTICES` Mode as `Mode.CREATE_COPY` Create a simplified version of a graph.
`PgxGraph`	`sortByDegree()` Blocking version of `sortByDegreeAsync()`.
`PgxGraph`	`sortByDegree(java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, PgxGraph.SortOrder sortOrder, PgxGraph.Degree degree, PgxGraph.Mode mode, java.lang.String newGraphName)` Blocking version of `sortByDegreeAsync(Collection, Collection, SortOrder, Degree, Mode, String)`.
`PgxGraph`	`sortByDegree(PgxGraph.SortOrder sortOrder, PgxGraph.Degree degree, PgxGraph.Mode mode, java.lang.String newGraphName)` Blocking version of `sortByDegreeAsync(SortOrder, Degree, Mode, String)`.
`PgxGraph`	`sortByDegree(java.lang.String newGraphName)` Blocking version of `sortByDegreeAsync(String)`.
`PgxFuture<PgxGraph>`	`sortByDegreeAsync()` Create a sorted version of a graph and all its properties.
`PgxFuture<PgxGraph>`	`sortByDegreeAsync(java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, PgxGraph.SortOrder sortOrder, PgxGraph.Degree degree, PgxGraph.Mode mode, java.lang.String newGraphName)` Create a sorted version of a graph and all its properties.
`PgxFuture<PgxGraph>`	`sortByDegreeAsync(PgxGraph.SortOrder sortOrder, PgxGraph.Degree degree, PgxGraph.Mode mode, java.lang.String newGraphName)` Create a sorted version of a graph and all its properties.
`PgxFuture<PgxGraph>`	`sortByDegreeAsync(java.lang.String newGraphName)` Create a sorted version of a graph and all its properties.
`PgxGraph`	`sparsify(java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, double e, java.lang.String newGraphName)` Blocking version of `sparsifyAsync(Collection, Collection, double, String)`.
`PgxGraph`	`sparsify(double e)` Blocking version of `sparsifyAsync(double)`.
`PgxGraph`	`sparsify(double e, java.lang.String newGraphName)` Blocking version of `sparsifyAsync(double, String)`.
`PgxFuture<PgxGraph>`	`sparsifyAsync(java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, double e, java.lang.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, java.lang.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, java.lang.String targetPath)` Blocking version of `storeAsync(Format, String)`.
`FileGraphConfig`	`store(Format targetFormat, java.lang.String targetPath, boolean overwrite)` Blocking version of `storeAsync(Format, String, boolean)`.
`FileGraphConfig`	`store(Format targetFormat, java.lang.String targetPath, java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, boolean overwrite)` Blocking version of `storeAsync(Format, String, Collection, Collection, boolean)`.
`GraphConfig`	`store(GraphConfig targetConfig, boolean overwrite)` Blocking version of `storeAsync(GraphConfig, boolean)`.
`PgxFuture<FileGraphConfig>`	`storeAsync(Format targetFormat, java.lang.String targetPath)` Stores this graph in a given file format on a file system.
`PgxFuture<FileGraphConfig>`	`storeAsync(Format targetFormat, java.lang.String targetPath, boolean overwrite)` Stores this graph in a given file format on a file system.
`PgxFuture<FileGraphConfig>`	`storeAsync(Format targetFormat, java.lang.String targetPath, java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, boolean overwrite)` Stores this graph in a given file format on a file system.
`PgxFuture<GraphConfig>`	`storeAsync(GraphConfig targetConfig, boolean overwrite)` Stores this graph in a file or database.
`java.lang.String`	`toString()`
`PgxGraph`	`transpose()` Blocking version of `transposeAsync()`
`PgxGraph`	`transpose(java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, java.util.Map<java.lang.String,java.lang.String> edgeLabelMapping, PgxGraph.Mode mode, java.lang.String newGraphName)` Blocking version of `transposeAsync(Collection, Collection, Map, Mode, String)`
`PgxGraph`	`transpose(PgxGraph.Mode mode)` Blocking version of `transposeAsync(Mode)`
`PgxGraph`	`transpose(PgxGraph.Mode mode, java.lang.String newGraphName)` Blocking version of `transposeAsync(Mode, String)`
`PgxGraph`	`transpose(java.lang.String newGraphName)` Blocking version of `transposeAsync(String)`
`PgxFuture<PgxGraph>`	`transposeAsync()` Convenience method around `transposeAsync(String)` passing null as graphName
`PgxFuture<PgxGraph>`	`transposeAsync(java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, java.util.Map<java.lang.String,java.lang.String> edgeLabelMapping, PgxGraph.Mode mode, java.lang.String newGraphName)` Creates a transpose of this graph.
`PgxFuture<PgxGraph>`	`transposeAsync(PgxGraph.Mode mode)` Convenience method around `transposeAsync(Mode, String)` passing null as graphName
`PgxFuture<PgxGraph>`	`transposeAsync(PgxGraph.Mode mode, java.lang.String newGraphName)` Convenience method around `transposeAsync(Collection, Collection, Map, Mode, String)` Passing Collection(vertexProps) as `VertexProperty.ALL` Collection(edgeProps) as `EdgeProperty.ALL`*
`PgxFuture<PgxGraph>`	`transposeAsync(java.lang.String newGraphName)` Convenience method around `transposeAsync(Mode, String)` Passing Mode as `Mode.CREATE_COPY`
`PgxGraph`	`undirect()` Blocking version of `undirectAsync()`.
`PgxGraph`	`undirect(java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, PgxGraph.MultiEdges multiEdges, PgxGraph.SelfEdges selfEdges, PgxGraph.TrivialVertices trivialVertices, PgxGraph.Mode mode, java.lang.String newGraphName)` Blocking version of `undirectAsync(Collection, Collection, MultiEdges, SelfEdges, Mode, String)`.
`PgxGraph`	`undirect(oracle.pgx.common.mutations.MutationStrategy mutationStrategy)` Blocking version of `undirectAsync(MutationStrategy)`
`PgxGraph`	`undirect(PgxGraph.MultiEdges multiEdges, PgxGraph.SelfEdges selfEdges, PgxGraph.Mode mode, java.lang.String newGraphName)` Blocking version of `undirectAsync(MultiEdges, SelfEdges, Mode, String)`.
`PgxGraph`	`undirect(java.lang.String newGraphName)` Blocking version of `undirectAsync(String)`.
`PgxFuture<PgxGraph>`	`undirectAsync()` Convenience method around `undirectAsync(String)` passing null as graphName
`PgxFuture<PgxGraph>`	`undirectAsync(java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, PgxGraph.MultiEdges multiEdges, PgxGraph.SelfEdges selfEdges, PgxGraph.Mode mode, java.lang.String newGraphName)` Convenience method to create for `undirectAsync(MutationStrategy)`.
`PgxFuture<PgxGraph>`	`undirectAsync(oracle.pgx.common.mutations.MutationStrategy mutationStrategy)` Create an undirected version of a graph.
`PgxFuture<PgxGraph>`	`undirectAsync(PgxGraph.MultiEdges multiEdges, PgxGraph.SelfEdges selfEdges, PgxGraph.Mode mode, java.lang.String newGraphName)` Convenience method for `undirectAsync(Collection, Collection, MultiEdges, SelfEdges, Mode, String)` Passing Collection(vertexProps) as `VertexProperty.ALL` and Collection(edgeProps) as `EdgeProperty.ALL`
`PgxFuture<PgxGraph>`	`undirectAsync(java.lang.String newGraphName)` Convenience method around `undirectAsync(MultiEdges, SelfEdges, Mode, String)` Passing StrategyType as `StrategyType.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
  - bipartiteSubGraphFromInDegree
```
public BipartiteGraph bipartiteSubGraphFromInDegree()
                                             throws java.util.concurrent.ExecutionException,
                                                    java.lang.InterruptedException
```
    Blocking version of bipartiteSubGraphFromInDegreeAsync(). Calls bipartiteSubGraphFromInDegreeAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - bipartiteSubGraphFromInDegree
```
public BipartiteGraph bipartiteSubGraphFromInDegree(java.util.Collection<VertexProperty<?,?>> vertexProps,
                                                    java.util.Collection<EdgeProperty<?>> edgeProps,
                                                    java.lang.String newGraphName)
                                             throws java.util.concurrent.ExecutionException,
                                                    java.lang.InterruptedException
```
    Blocking version of bipartiteSubGraphFromInDegreeAsync(Collection, Collection, String). Calls bipartiteSubGraphFromInDegreeAsync(Collection, Collection, String) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - bipartiteSubGraphFromInDegree
```
public BipartiteGraph bipartiteSubGraphFromInDegree(java.util.Collection<VertexProperty<?,?>> vertexProps,
                                                    java.util.Collection<EdgeProperty<?>> edgeProps,
                                                    java.lang.String newGraphName,
                                                    java.lang.String isLeftPropName,
                                                    boolean inPlace)
                                             throws java.util.concurrent.ExecutionException,
                                                    java.lang.InterruptedException
```
    Blocking version of bipartiteSubGraphFromInDegreeAsync(Collection, Collection, String, String, boolean). Calls bipartiteSubGraphFromInDegreeAsync(Collection, Collection, String, String, boolean) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - bipartiteSubGraphFromInDegree
```
public BipartiteGraph bipartiteSubGraphFromInDegree(java.lang.String newGraphName)
                                             throws java.util.concurrent.ExecutionException,
                                                    java.lang.InterruptedException
```
    Blocking version of bipartiteSubGraphFromInDegreeAsync(String). Calls bipartiteSubGraphFromInDegreeAsync(String) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - bipartiteSubGraphFromInDegreeAsync
```
public PgxFuture<BipartiteGraph> bipartiteSubGraphFromInDegreeAsync()
```
    Create a bipartite version of this graph with all vertices of in-degree = 0 being the left set.
    
    Returns:
    
    resulting graph
  - bipartiteSubGraphFromInDegreeAsync
```
public PgxFuture<BipartiteGraph> bipartiteSubGraphFromInDegreeAsync(java.util.Collection<VertexProperty<?,?>> vertexProps,
                                                                    java.util.Collection<EdgeProperty<?>> edgeProps,
                                                                    java.lang.String newGraphName)
```
    Create a bipartite version of this graph with all vertices of in-degree = 0 being the left set.
    
    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
  - bipartiteSubGraphFromInDegreeAsync
```
public PgxFuture<BipartiteGraph> bipartiteSubGraphFromInDegreeAsync(java.util.Collection<VertexProperty<?,?>> vertexProps,
                                                                    java.util.Collection<EdgeProperty<?>> edgeProps,
                                                                    java.lang.String newGraphName,
                                                                    java.lang.String isLeftPropName,
                                                                    boolean inPlace)
```
    Create a bipartite version of this graph with all vertices of in-degree = 0 being the left set.
    
    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.
    
    isLeftPropName - name of the boolean isLeft vertex property of the new graph. f null, a name will be generated.
    
    inPlace - whether to create a new copy (false) or overwrite this graph (true)
    
    Returns:
    
    resulting graph
  - bipartiteSubGraphFromInDegreeAsync
```
public PgxFuture<BipartiteGraph> bipartiteSubGraphFromInDegreeAsync(java.lang.String newGraphName)
```
    Create a bipartite version of this graph with all vertices of in-degree = 0 being the left set.
    
    Parameters:
    
    newGraphName - name of the new graph. If null, a name will be generated.
    
    Returns:
    
    resulting graph
  - bipartiteSubGraphFromLeftSet
```
public BipartiteGraph bipartiteSubGraphFromLeftSet(java.util.Collection<VertexProperty<?,?>> vertexProps,
                                                   java.util.Collection<EdgeProperty<?>> edgeProps,
                                                   VertexSet<?> vertexSet,
                                                   java.lang.String newGraphName)
                                            throws java.util.concurrent.ExecutionException,
                                                   java.lang.InterruptedException
```
    Blocking version of bipartiteSubGraphFromLeftSetAsync(Collection, Collection, VertexSet, String). Calls bipartiteSubGraphFromLeftSetAsync(Collection, Collection, VertexSet, String) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - bipartiteSubGraphFromLeftSet
```
public BipartiteGraph bipartiteSubGraphFromLeftSet(java.util.Collection<VertexProperty<?,?>> vertexProps,
                                                   java.util.Collection<EdgeProperty<?>> edgeProps,
                                                   VertexSet<?> vertexSet,
                                                   java.lang.String newGraphName,
                                                   java.lang.String isLeftPropName)
                                            throws java.util.concurrent.ExecutionException,
                                                   java.lang.InterruptedException
```
    Blocking version of bipartiteSubGraphFromLeftSetAsync(Collection, Collection, VertexSet, String, String). Calls bipartiteSubGraphFromLeftSetAsync(Collection, Collection, VertexSet, String, String) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - bipartiteSubGraphFromLeftSet
```
public BipartiteGraph bipartiteSubGraphFromLeftSet(VertexSet<?> vertexSet)
                                            throws java.util.concurrent.ExecutionException,
                                                   java.lang.InterruptedException
```
    Blocking version of bipartiteSubGraphFromLeftSetAsync(VertexSet). Calls bipartiteSubGraphFromLeftSetAsync(VertexSet) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - bipartiteSubGraphFromLeftSet
```
public BipartiteGraph bipartiteSubGraphFromLeftSet(VertexSet<?> vertexSet,
                                                   java.lang.String newGraphName)
                                            throws java.util.concurrent.ExecutionException,
                                                   java.lang.InterruptedException
```
    Blocking version of bipartiteSubGraphFromLeftSetAsync(VertexSet, String). Calls bipartiteSubGraphFromLeftSetAsync(VertexSet, String) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - bipartiteSubGraphFromLeftSetAsync
```
public PgxFuture<BipartiteGraph> bipartiteSubGraphFromLeftSetAsync(java.util.Collection<VertexProperty<?,?>> vertexProps,
                                                                   java.util.Collection<EdgeProperty<?>> edgeProps,
                                                                   VertexSet<?> vertexSet,
                                                                   java.lang.String newGraphName)
```
    Create a bipartite version of this graph with the given vertex set being the left set.
    
    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.
    
    Returns:
    
    resulting graph
  - bipartiteSubGraphFromLeftSetAsync
```
public PgxFuture<BipartiteGraph> bipartiteSubGraphFromLeftSetAsync(java.util.Collection<VertexProperty<?,?>> vertexProps,
                                                                   java.util.Collection<EdgeProperty<?>> edgeProps,
                                                                   VertexSet<?> vertexSet,
                                                                   java.lang.String newGraphName,
                                                                   java.lang.String isLeftPropName)
```
    Create a bipartite version of this graph with the given vertex set being the left set.
    
    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 - name of the boolean isLeft vertex property of the new graph. f null, a name will be generated.
    
    Returns:
    
    resulting graph
  - bipartiteSubGraphFromLeftSetAsync
```
public PgxFuture<BipartiteGraph> bipartiteSubGraphFromLeftSetAsync(VertexSet<?> vertexSet)
```
    Create a bipartite version of this graph with the given vertex set being the left set.
    Convenience method around bipartiteSubGraphFromLeftSetAsync(Collection, Collection, VertexSet, String, String) passing vertexProps as VertexProperty.ALLnewGraphName, edgeProps as EdgeProperty.ALL and isLeftPropName as null
    
    Parameters:
    
    vertexSet - vertex set representing the left side
    
    Returns:
    
    resulting graph
  - bipartiteSubGraphFromLeftSetAsync
```
public PgxFuture<BipartiteGraph> bipartiteSubGraphFromLeftSetAsync(VertexSet<?> vertexSet,
                                                                   java.lang.String newGraphName)
```
    Create a bipartite version of this graph with the given vertex set being the left set.
    Convenience method around bipartiteSubGraphFromLeftSetAsync(Collection, Collection, VertexSet, String, String) passing newGraphName and isLeftPropName as null
    
    Parameters:
    
    vertexSet - vertex set representing the left side
    
    newGraphName - name of the new graph
    
    Returns:
    
    resulting graph
  - clone
```
public PgxGraph clone()
```
    Blocking version of cloneAsync(). Calls cloneAsync() and waits for the returned PgxFuture to complete.
    
    Overrides:
    
    clone in class java.lang.Object
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - clone
```
public PgxGraph clone(java.util.Collection<VertexProperty<?,?>> vertexProps,
                      java.util.Collection<EdgeProperty<?>> edgeProps,
                      java.lang.String newGraphName)
               throws java.util.concurrent.ExecutionException,
                      java.lang.InterruptedException
```
    Blocking version of cloneAsync(). Calls cloneAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - clone
```
public PgxGraph clone(java.lang.String newGraphName)
               throws java.util.concurrent.ExecutionException,
                      java.lang.InterruptedException
```
    Blocking version of cloneAsync(String). Calls cloneAsync(String) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.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
    Returns:
    
    resulting graph
  - cloneAsync
```
public PgxFuture<PgxGraph> cloneAsync(java.util.Collection<VertexProperty<?,?>> vertexProps,
                                      java.util.Collection<EdgeProperty<?>> edgeProps,
                                      java.lang.String newGraphName)
```
    Creates a copy of this 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(java.lang.String newGraphName)
```
    Convenience method of cloneAsync(Collection, Collection, String)
    Passing
    - Collection(vertexProperties) as VertexProperty.ALL
    - Collection(edgeProperties) as EdgeProperty.ALL
    Parameters:
    
    newGraphName - name of the new graph. If null, a name will be generated.
    
    Returns:
    
    resulting graph
  - combineEdgePropertiesIntoVectorProperty
```
public <E> EdgeProperty<PgxVect<E>> combineEdgePropertiesIntoVectorProperty(java.util.List<EdgeProperty<E>> edgePropertyList)
                                                                     throws java.util.concurrent.ExecutionException,
                                                                            java.lang.InterruptedException
```
    Blocking version of combineEdgePropertiesIntoVectorPropertyAsync(List) Calls combineEdgePropertiesIntoVectorPropertyAsync(List) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - combineEdgePropertiesIntoVectorProperty
```
public <E> EdgeProperty<PgxVect<E>> combineEdgePropertiesIntoVectorProperty(java.util.List<EdgeProperty<E>> edgePropertyList,
                                                                            java.lang.String name)
                                                                     throws java.util.concurrent.ExecutionException,
                                                                            java.lang.InterruptedException
```
    Blocking version of combineEdgePropertiesIntoVectorPropertyAsync(List, String) Calls combineEdgePropertiesIntoVectorPropertyAsync(List, String) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - combineEdgePropertiesIntoVectorPropertyAsync
```
public <E> PgxFuture<EdgeProperty<PgxVect<E>>> combineEdgePropertiesIntoVectorPropertyAsync(java.util.List<EdgeProperty<E>> edgePropertyList)
```
    Takes a list of scalar edge properties of same type and creates a new edge vector property by combining them. The dimension of the vector property will be equals to the number of properties.
    
    Type Parameters:
    
    E - edge property type
    
    Parameters:
    
    edgePropertyList - list of scalar edge properties
    
    Returns:
    
    a future holding a vertex vector or an exceptionally completed future if the list the list of given properties are not all the same type. Property will be created with default name just like createEdgeProperty(PropertyType)
  - combineEdgePropertiesIntoVectorPropertyAsync
```
public <E> PgxFuture<EdgeProperty<PgxVect<E>>> combineEdgePropertiesIntoVectorPropertyAsync(java.util.List<EdgeProperty<E>> edgePropertyList,
                                                                                            java.lang.String name)
```
    Takes a list of scalar edge properties of same type and creates a new edge vector property by combining them. The dimension of the vector property will be equals to the number of properties.
    
    Type Parameters:
    
    E - edge property type
    
    Parameters:
    
    edgePropertyList - list of scalar edge properties
    
    name - name for the vector property. If not null, vector property will be named <name>. If that results in a name conflict, the returned future will complete exceptionally.
    
    Returns:
    
    a future holding a vertex vector or an exceptionally completed future if the list the list of given properties are not all the same type. Property will be created with default name just like createEdgeProperty(PropertyType)
  - combineVertexPropertiesIntoVectorProperty
```
public <ID,V> VertexProperty<ID,PgxVect<V>> combineVertexPropertiesIntoVectorProperty(java.util.List<VertexProperty<ID,V>> vertexPropertyList)
                                                                               throws java.util.concurrent.ExecutionException,
                                                                                      java.lang.InterruptedException
```
    Blocking version of combineVertexPropertiesIntoVectorPropertyAsync(List) Calls combineVertexPropertiesIntoVectorPropertyAsync(List) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - combineVertexPropertiesIntoVectorProperty
```
public <ID,V> VertexProperty<ID,PgxVect<V>> combineVertexPropertiesIntoVectorProperty(java.util.List<VertexProperty<ID,V>> vertexPropertyList,
                                                                                      java.lang.String name)
                                                                               throws java.util.concurrent.ExecutionException,
                                                                                      java.lang.InterruptedException
```
    Blocking version of combineVertexPropertiesIntoVectorPropertyAsync(List, String) Calls combineVertexPropertiesIntoVectorPropertyAsync(List, String) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - combineVertexPropertiesIntoVectorPropertyAsync
```
public <ID,V> PgxFuture<VertexProperty<ID,PgxVect<V>>> combineVertexPropertiesIntoVectorPropertyAsync(java.util.List<VertexProperty<ID,V>> vertexPropertyList)
```
    Takes a list of scalar vertex properties of same type and creates a new vertex vector property by combining them. The dimension of the vector property will be equals to the number of properties.
    
    Type Parameters:
    
    ID - property type
    
    V - vector property type
    
    Parameters:
    
    vertexPropertyList - list of scalar vertex properties
    
    Returns:
    
    a future holding a vertex vector or an exceptionally completed future if the list the list of given properties are not all the same type. Property will be created with default name just like createVertexProperty(PropertyType)
  - combineVertexPropertiesIntoVectorPropertyAsync
```
public <ID,V> PgxFuture<VertexProperty<ID,PgxVect<V>>> combineVertexPropertiesIntoVectorPropertyAsync(java.util.List<VertexProperty<ID,V>> vertexPropertyList,
                                                                                                      java.lang.String name)
```
    Takes a list of scalar vertex properties of same type and creates a new vertex vector property by combining them. The dimension of the vector property will be equals to the number of properties.
    
    Type Parameters:
    
    ID - property type
    
    V - vector property type
    
    Parameters:
    
    vertexPropertyList - list of scalar vertex properties
    
    name - name for the vector property. If not null, vector property will be named <name>. If that results in a name conflict, the returned future will complete exceptionally.
    
    Returns:
    
    a future holding a vertex vector or an exceptionally completed future if the list the list of given properties are not all the same type. Property will be created with default name just like createVertexProperty(PropertyType)
  - createAllPaths
```
public <ID extends java.lang.Comparable<ID>> AllPaths<ID> createAllPaths(PgxVertex<ID> src,
                                                                         EdgeProperty<java.lang.Double> cost,
                                                                         VertexProperty<ID,java.lang.Double> dist,
                                                                         VertexProperty<ID,PgxVertex<ID>> parent,
                                                                         VertexProperty<ID,PgxEdge> parentEdge)
                                                                  throws java.util.concurrent.ExecutionException,
                                                                         java.lang.InterruptedException
```
    Blocking version of createAllPathsAsync(PgxVertex, EdgeProperty, VertexProperty, VertexProperty, VertexProperty). Calls createAllPathsAsync(PgxVertex, EdgeProperty, VertexProperty, VertexProperty, VertexProperty) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createAllPathsAsync
```
public <ID> PgxFuture<AllPaths<ID>> createAllPathsAsync(PgxVertex<ID> src,
                                                        EdgeProperty<java.lang.Double> cost,
                                                        VertexProperty<ID,java.lang.Double> dist,
                                                        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.
  - createChangeSet
```
public <ID extends java.lang.Comparable<ID>> GraphChangeSet<ID> createChangeSet()
```
    Creates a change set for updating the graph.
    Note: This is currently not supported for undirected graphs.
    
    Returns:
    
    an empty change set
  - createComponents
```
public <ID> Partition<ID> createComponents(VertexProperty<ID,java.lang.Long> components,
                                           long numComponents)
                                    throws java.util.concurrent.ExecutionException,
                                           java.lang.InterruptedException
```
    Blocking version of createComponentsAsync(VertexProperty, long). Calls createComponentsAsync(VertexProperty, long) and waits for returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createComponentsAsync
```
public <ID> PgxFuture<Partition<ID>> createComponentsAsync(VertexProperty<ID,java.lang.Long> components,
                                                           long 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
```
public <V> EdgeProperty<V> createEdgeProperty(PropertyType type)
                                       throws java.util.concurrent.ExecutionException,
                                              java.lang.InterruptedException
```
    Blocking version of createEdgePropertyAsync(PropertyType). Calls createEdgePropertyAsync(PropertyType) and waits for returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createEdgeProperty
```
public <V> EdgeProperty<V> createEdgeProperty(PropertyType type,
                                              int dimension,
                                              java.lang.String name,
                                              boolean hardName)
                                       throws java.util.concurrent.ExecutionException,
                                              java.lang.InterruptedException
```
    Blocking version of createEdgePropertyAsync(PropertyType, int, String, boolean). Calls createEdgePropertyAsync(PropertyType, int, String, boolean) and waits for returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createEdgeProperty
```
public <V> EdgeProperty<V> createEdgeProperty(PropertyType type,
                                              java.lang.String name)
                                       throws java.util.concurrent.ExecutionException,
                                              java.lang.InterruptedException
```
    Blocking version of createEdgePropertyAsync(PropertyType, String). Calls createEdgePropertyAsync(PropertyType, String) and waits for returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createEdgePropertyAsync
```
public <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> PgxFuture<EdgeProperty<V>> createEdgePropertyAsync(PropertyType type,
                                                              java.lang.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
```
public EdgeSequence createEdgeSequence()
                                throws java.util.concurrent.ExecutionException,
                                       java.lang.InterruptedException
```
    Blocking version of createEdgeSequenceAsync(). Calls createEdgeSequenceAsync() and waits for returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createEdgeSequence
```
public EdgeSequence createEdgeSequence(java.lang.String name)
                                throws java.util.concurrent.ExecutionException,
                                       java.lang.InterruptedException
```
    Blocking version of createEdgeSequenceAsync(String). Calls createEdgeSequenceAsync(String) and waits for returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.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(java.lang.String name)
```
    Creates a new edge sequence.
    
    Parameters:
    
    name - name of the edge sequence to be created
    
    Returns:
    
    the newly created edge sequence
  - createEdgeSet
```
public EdgeSet createEdgeSet()
                      throws java.util.concurrent.ExecutionException,
                             java.lang.InterruptedException
```
    Blocking version of createEdgeSetAsync(). Calls createEdgeSetAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createEdgeSet
```
public EdgeSet createEdgeSet(java.lang.String name)
                      throws java.util.concurrent.ExecutionException,
                             java.lang.InterruptedException
```
    Blocking version of createEdgeSetAsync(String). Calls createEdgeSetAsync(String) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.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 edge set
  - createEdgeSetAsync
```
public PgxFuture<EdgeSet> createEdgeSetAsync(java.lang.String name)
```
    Creates a new edge set.
    
    Parameters:
    
    name - name of the edge set to be created
    
    Returns:
    
    the newly created edge set
  - createEdgeVectorProperty
```
public <V> EdgeProperty<PgxVect<V>> createEdgeVectorProperty(PropertyType type,
                                                             int dimension)
                                                      throws java.util.concurrent.ExecutionException,
                                                             java.lang.InterruptedException
```
    Blocking version of createEdgeVectorPropertyAsync(PropertyType, int). Calls createEdgeVectorPropertyAsync(PropertyType, int) and waits for returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createEdgeVectorProperty
```
public <V> EdgeProperty<PgxVect<V>> createEdgeVectorProperty(PropertyType type,
                                                             int dimension,
                                                             java.lang.String name)
                                                      throws java.util.concurrent.ExecutionException,
                                                             java.lang.InterruptedException
```
    Blocking version of createEdgeVectorPropertyAsync(PropertyType, int, String). Calls createEdgeVectorPropertyAsync(PropertyType, int, String) and waits for returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createEdgeVectorPropertyAsync
```
public <V> PgxFuture<EdgeProperty<PgxVect<V>>> createEdgeVectorPropertyAsync(PropertyType type,
                                                                             int dimension)
```
    Creates a session-bound edge vector property
    
    Parameters:
    
    type - type of vector property to create
    
    dimension - of vector property to be created
    
    Returns:
    
    newly created vector property
  - createEdgeVectorPropertyAsync
```
public <V> PgxFuture<EdgeProperty<PgxVect<V>>> createEdgeVectorPropertyAsync(PropertyType type,
                                                                             int dimension,
                                                                             java.lang.String name)
```
    Creates a session-bound edge vector property
    
    Parameters:
    
    type - type of vector property to create
    
    dimension - of vector property to be created
    
    name - of vector property to be created
    
    Returns:
    
    newly created vector property
  - createMap
```
public <K,V> PgxMap<K,V> createMap(PropertyType keyType,
                                   PropertyType valType)
                            throws java.util.concurrent.ExecutionException,
                                   java.lang.InterruptedException
```
    Blocking version of createMapAsync(PropertyType, PropertyType). Calls createMapAsync(PropertyType, PropertyType) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createMap
```
public <K,V> PgxMap<K,V> createMap(PropertyType keyType,
                                   PropertyType valType,
                                   java.lang.String mapName)
                            throws java.util.concurrent.ExecutionException,
                                   java.lang.InterruptedException
```
    Blocking version of createMapAsync(PropertyType, PropertyType, String). Calls createMapAsync(PropertyType, PropertyType, String) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createMapAsync
```
public <K,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,V> PgxFuture<PgxMap<K,V>> createMapAsync(PropertyType keyType,
                                                   PropertyType valType,
                                                   java.lang.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
    
    mapName - how the map should be named
    
    Returns:
    
    newly created map
  - createMergingStrategyBuilder
```
public MergingStrategyBuilder createMergingStrategyBuilder()
                                                    throws java.util.concurrent.ExecutionException,
                                                           java.lang.InterruptedException
```
    Creates a new MergingStrategyBuilder that can be used to build a new MutationStrategy to simplify this graph.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createPath
```
public <ID> PgxPath<ID> createPath(PgxVertex<ID> src,
                                   PgxVertex<ID> dst,
                                   EdgeProperty<java.lang.Double> cost,
                                   VertexProperty<ID,PgxVertex<ID>> parent,
                                   VertexProperty<ID,PgxEdge> parentEdge)
                            throws java.util.concurrent.ExecutionException,
                                   java.lang.InterruptedException
```
    Blocking version of createPathAsync(PgxVertex, PgxVertex, EdgeProperty, VertexProperty, VertexProperty). Calls createPathAsync(PgxVertex, PgxVertex, EdgeProperty, VertexProperty, VertexProperty) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createPathAsync
```
public <ID> PgxFuture<PgxPath<ID>> createPathAsync(PgxVertex<ID> src,
                                                   PgxVertex<ID> dst,
                                                   EdgeProperty<java.lang.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.
  - createPickingStrategyBuilder
```
public PickingStrategyBuilder createPickingStrategyBuilder()
                                                    throws java.util.concurrent.ExecutionException,
                                                           java.lang.InterruptedException
```
    Creates a new PickingStrategyBuilder that can be used to build a new PickingStrategy to simplify this graph.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createScalar
```
public <T> Scalar<T> createScalar(PropertyType type)
                           throws java.util.concurrent.ExecutionException,
                                  java.lang.InterruptedException
```
    Blocking version of createScalarAsync(PropertyType). Calls createScalarAsync(PropertyType) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createScalar
```
public <T> Scalar<T> createScalar(PropertyType type,
                                  java.lang.String newScalarName)
                           throws java.util.concurrent.ExecutionException,
                                  java.lang.InterruptedException
```
    Blocking version of createScalarAsync(PropertyType, String). Calls createScalarAsync(PropertyType, String) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.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,
                                                  java.lang.String newScalarName)
```
    Create a session-bound scalar.
    
    Parameters:
    
    type - the type of scalar
    
    newScalarName - name of the scalar to be created
    
    Returns:
    
    the newly created scalar
  - createVectorScalar
```
public <T> Scalar<PgxVect<T>> createVectorScalar(PropertyType type,
                                                 int dimension)
                                          throws java.util.concurrent.ExecutionException,
                                                 java.lang.InterruptedException
```
    Blocking version of createVectorScalarAsync(PropertyType, int). Calls createVectorScalarAsync(PropertyType, int) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createVectorScalar
```
public <T> Scalar<PgxVect<T>> createVectorScalar(PropertyType type,
                                                 int dimension,
                                                 java.lang.String newScalarName)
                                          throws java.util.concurrent.ExecutionException,
                                                 java.lang.InterruptedException
```
    Blocking version of createVectorScalarAsync(PropertyType, int, String). Calls createVectorScalarAsync(PropertyType, int, String) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createVectorScalarAsync
```
public <T> PgxFuture<Scalar<PgxVect<T>>> createVectorScalarAsync(PropertyType type,
                                                                 int dimension)
```
    Create a session-bound vector scalar.
    
    Parameters:
    
    type - the type of vector scalar
    
    dimension - of vector scalar to be created
    
    Returns:
    
    the newly created vector scalar
  - createVectorScalarAsync
```
public <T> PgxFuture<Scalar<PgxVect<T>>> createVectorScalarAsync(PropertyType type,
                                                                 int dimension,
                                                                 java.lang.String newScalarName)
```
    Create a session-bound vector scalar.
    
    Parameters:
    
    type - the type of vector scalar
    
    dimension - of vector scalar to be created
    
    newScalarName - name of the vector scalar to be created
    
    Returns:
    
    the newly created vector scalar
  - createVertexProperty
```
public <ID,V> VertexProperty<ID,V> createVertexProperty(PropertyType type)
                                                 throws java.util.concurrent.ExecutionException,
                                                        java.lang.InterruptedException
```
    Blocking version of createVertexPropertyAsync(PropertyType). Calls createVertexPropertyAsync(PropertyType) and waits for returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createVertexProperty
```
public <ID,V> VertexProperty<ID,V> createVertexProperty(PropertyType type,
                                                        int dimension,
                                                        java.lang.String name,
                                                        boolean hardName)
                                                 throws java.util.concurrent.ExecutionException,
                                                        java.lang.InterruptedException
```
    Blocking version of createVertexPropertyAsync(PropertyType, int, String, boolean). Calls createVertexPropertyAsync(PropertyType, int, String, boolean) and waits for returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createVertexProperty
```
public <ID,V> VertexProperty<ID,V> createVertexProperty(PropertyType type,
                                                        java.lang.String name)
                                                 throws java.util.concurrent.ExecutionException,
                                                        java.lang.InterruptedException
```
    Blocking version of createVertexPropertyAsync(PropertyType, String). Calls createVertexPropertyAsync(PropertyType, String) and waits for returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createVertexPropertyAsync
```
public <ID,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,V> PgxFuture<VertexProperty<ID,V>> createVertexPropertyAsync(PropertyType type,
                                                                        java.lang.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
```
public <E> VertexSequence<E> createVertexSequence()
                                           throws java.util.concurrent.ExecutionException,
                                                  java.lang.InterruptedException
```
    Blocking version of createVertexSequenceAsync(). Calls createVertexSequenceAsync() and waits for returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createVertexSequence
```
public <E> VertexSequence<E> createVertexSequence(java.lang.String name)
                                           throws java.util.concurrent.ExecutionException,
                                                  java.lang.InterruptedException
```
    Blocking version of createVertexSequenceAsync(String). Calls createVertexSequenceAsync(String) and waits for returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createVertexSequenceAsync
```
public <E> PgxFuture<VertexSequence<E>> createVertexSequenceAsync()
```
    Creates a new vertex sequence.
    
    Returns:
    
    newly created VertexSequence
  - createVertexSequenceAsync
```
public <E> PgxFuture<VertexSequence<E>> createVertexSequenceAsync(java.lang.String name)
```
    Creates a new vertex sequence.
    
    Parameters:
    
    name - the name of the collection to be created
    
    Returns:
    
    newly created VertexSequence
  - createVertexSet
```
public <E> VertexSet<E> createVertexSet()
                                 throws java.util.concurrent.ExecutionException,
                                        java.lang.InterruptedException
```
    Blocking version of createVertexSetAsync(). Calls createVertexSetAsync() and waits for returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createVertexSet
```
public <E> VertexSet<E> createVertexSet(java.lang.String name)
                                 throws java.util.concurrent.ExecutionException,
                                        java.lang.InterruptedException
```
    Blocking version of createVertexSetAsync(String). Calls createVertexSetAsync(String) and waits for returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createVertexSetAsync
```
public <E> PgxFuture<VertexSet<E>> createVertexSetAsync()
```
    Creates a new vertex set.
    
    Returns:
    
    the newly created vertex set
  - createVertexSetAsync
```
public <E> PgxFuture<VertexSet<E>> createVertexSetAsync(java.lang.String name)
```
    Creates a new vertex set.
    
    Parameters:
    
    name - name of the vertex set to be created
    
    Returns:
    
    the newly created vertex set
  - createVertexVectorProperty
```
public <ID,V> VertexProperty<ID,PgxVect<V>> createVertexVectorProperty(PropertyType type,
                                                                       int dimension)
                                                                throws java.util.concurrent.ExecutionException,
                                                                       java.lang.InterruptedException
```
    Blocking version of createVertexVectorPropertyAsync(PropertyType, int). Calls createVertexVectorPropertyAsync(PropertyType, int) and waits for returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createVertexVectorProperty
```
public <ID,V> VertexProperty<ID,PgxVect<V>> createVertexVectorProperty(PropertyType type,
                                                                       int dimension,
                                                                       java.lang.String name)
                                                                throws java.util.concurrent.ExecutionException,
                                                                       java.lang.InterruptedException
```
    Blocking version of createVertexVectorPropertyAsync(PropertyType, int, String). Calls createVertexVectorPropertyAsync(PropertyType, int, String) and waits for returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - createVertexVectorPropertyAsync
```
public <ID,V> PgxFuture<VertexProperty<ID,PgxVect<V>>> createVertexVectorPropertyAsync(PropertyType type,
                                                                                       int dimension)
```
    Creates a session-bound vertex vector property
    
    Parameters:
    
    type - type of the vector property to create
    
    dimension - of vector property to be created
    
    Returns:
    
    newly created vector property
  - createVertexVectorPropertyAsync
```
public <ID,V> PgxFuture<VertexProperty<ID,PgxVect<V>>> createVertexVectorPropertyAsync(PropertyType type,
                                                                                       int dimension,
                                                                                       java.lang.String name)
```
    Creates a session-bound vertex vector property
    
    Parameters:
    
    type - type of vector property to create
    
    dimension - of vector property to be created
    
    name - of vector property to be created
    
    Returns:
    
    newly created vector property
  - filter
```
public PgxGraph filter(java.util.Collection<VertexProperty<?,?>> vertexProps,
                       java.util.Collection<EdgeProperty<?>> edgeProps,
                       GraphFilter graphFilter,
                       java.lang.String newGraphName)
                throws java.util.concurrent.ExecutionException,
                       java.lang.InterruptedException
```
    Blocking version of filterAsync(Collection, Collection, GraphFilter, String). Calls filterAsync(Collection, Collection, GraphFilter, String) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - filter
```
public PgxGraph filter(GraphFilter graphFilter)
                throws java.util.concurrent.ExecutionException,
                       java.lang.InterruptedException
```
    Blocking version of filterAsync(GraphFilter). Calls filterAsync(GraphFilter) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - filter
```
public PgxGraph filter(GraphFilter graphFilter,
                       java.lang.String newGraphName)
                throws java.util.concurrent.ExecutionException,
                       java.lang.InterruptedException
```
    Blocking version of filterAsync(GraphFilter, String). Calls filterAsync(GraphFilter, String) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - filterAsync
```
public PgxFuture<PgxGraph> filterAsync(java.util.Collection<VertexProperty<?,?>> vertexProps,
                                       java.util.Collection<EdgeProperty<?>> edgeProps,
                                       GraphFilter graphFilter,
                                       java.lang.String newGraphName)
```
    Create a subgraph of this 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 this 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,
                                       java.lang.String newGraphName)
```
    Create a subgraph of this 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 java.lang.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)
                throws java.util.concurrent.ExecutionException,
                       java.lang.InterruptedException
```
    Blocking version of getEdgeAsync(long) Calls getEdgeAsync(long) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - getEdgeAsync
```
public PgxFuture<PgxEdge> getEdgeAsync(long id)
```
    Looks up a PgxEdge of this graph by ID.
    
    Parameters:
    
    id - the ID of the edge
    
    Returns:
    
    the PgxEdge object
  - getEdgeLabel
```
public EdgeLabel getEdgeLabel()
                       throws java.util.concurrent.ExecutionException,
                              java.lang.InterruptedException
```
    Blocking version of getEdgeLabelAsync(). Calls getEdgeLabelAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - getEdgeLabelAsync
```
public PgxFuture<EdgeLabel> getEdgeLabelAsync()
```
    Get the edge labels belonging to this graph.
    
    Returns:
    
    the edge labels, encoded as an EdgeProperty.
  - getEdgeProperties
```
public java.util.Set<EdgeProperty<?>> getEdgeProperties()
                                                 throws java.util.concurrent.ExecutionException,
                                                        java.lang.InterruptedException
```
    Blocking version of getEdgePropertiesAsync(). Calls getEdgePropertiesAsync() and waits for returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - getEdgePropertiesAsync
```
public PgxFuture<java.util.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
```
public <V> EdgeProperty<V> getEdgeProperty(java.lang.String name)
                                    throws java.util.concurrent.ExecutionException,
                                           java.lang.InterruptedException
```
    Blocking version of getEdgePropertyAsync(String). Calls getEdgePropertyAsync(String) and waits for returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - getEdgePropertyAsync
```
public <V> PgxFuture<EdgeProperty<V>> getEdgePropertyAsync(java.lang.String name)
```
    Gets 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:
    
    java.lang.NullPointerException - if the passed name is null
  - getEdges
```
public EdgeSet getEdges()
                 throws java.lang.InterruptedException,
                        java.util.concurrent.ExecutionException
```
    Blocking version of getEdges(). Calls getEdges() and waits for returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - getEdges
```
public EdgeSet getEdges(EdgeFilter filter)
                 throws java.lang.InterruptedException,
                        java.util.concurrent.ExecutionException
```
    Blocking version of getEdges(EdgeFilter). Calls getEdges(EdgeFilter) and waits for returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - getEdgesAsync
```
public PgxFuture<EdgeSet> getEdgesAsync()
```
    Creates a new edge set containing all edges.
    
    Returns:
    
    newly created edges set
  - getEdgesAsync
```
public <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 number of estimated mega-bytes.
  - getName
```
public java.lang.String getName()
```
    Gets the name.
    
    Specified by:
    
    getName in class PgxManagedObject
    
    Returns:
    
    the name of this 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()
```
    Gets the server instance.
    
    Returns:
    
    the instance this graph belongs to.
  - getSession
```
public PgxSession getSession()
```
    Gets the session.
    
    Returns:
    
    the session this graph belongs to.
  - getVertex
```
public <ID> PgxVertex<ID> getVertex(ID id)
                             throws java.util.concurrent.ExecutionException,
                                    java.lang.InterruptedException
```
    Blocking version of getVertexAsync(Object). Calls getVertexAsync(Object) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - getVertexAsync
```
public <ID> PgxFuture<PgxVertex<ID>> getVertexAsync(ID id)
```
    Looks up a PgxVertex of this graph by ID.
    
    Parameters:
    
    id - the ID of the vertex
    
    Returns:
    
    the PgxVertex object
  - getVertexIdType
```
public IdType getVertexIdType()
```
    Gets the vertex ID type of this graph.
    
    Returns:
    
    the vertex ID type.
  - getVertexLabels
```
public <ID> VertexLabels<ID> getVertexLabels()
                                      throws java.util.concurrent.ExecutionException,
                                             java.lang.InterruptedException
```
    Blocking version of getVertexLabelsAsync(). Calls getVertexLabelsAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - getVertexLabelsAsync
```
public <ID> PgxFuture<VertexLabels<ID>> getVertexLabelsAsync()
```
    Get the vertex labels belonging to this graph.
    
    Returns:
    
    the vertex labels, encoded as a VertexProperty.
  - getVertexProperties
```
public java.util.Set<VertexProperty<?,?>> getVertexProperties()
                                                       throws java.util.concurrent.ExecutionException,
                                                              java.lang.InterruptedException
```
    Blocking version of getVertexPropertiesAsync(). Calls getVertexPropertiesAsync() and waits for returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - getVertexPropertiesAsync
```
public PgxFuture<java.util.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
```
public <ID,V> VertexProperty<ID,V> getVertexProperty(java.lang.String name)
                                              throws java.util.concurrent.ExecutionException,
                                                     java.lang.InterruptedException
```
    Blocking version of getVertexPropertyAsync(String). Calls getVertexPropertyAsync(String) and waits for returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - getVertexPropertyAsync
```
public <ID,V> PgxFuture<VertexProperty<ID,V>> getVertexPropertyAsync(java.lang.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:
    
    java.lang.NullPointerException - if the passed name is null
  - getVertices
```
public <E> VertexSet<E> getVertices()
                             throws java.lang.InterruptedException,
                                    java.util.concurrent.ExecutionException
```
    Blocking version of getVerticesAsync(). Calls getVerticesAsync() and waits for returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - getVertices
```
public <E> VertexSet<E> getVertices(VertexFilter filter)
                             throws java.lang.InterruptedException,
                                    java.util.concurrent.ExecutionException
```
    Blocking version of getVerticesAsync(VertexFilter). Calls getVerticesAsync(VertexFilter) and waits for returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - getVertices
```
public <E> VertexSet<E> getVertices(VertexFilter filter,
                                    java.lang.String name)
                             throws java.lang.InterruptedException,
                                    java.util.concurrent.ExecutionException
```
    Blocking version of getVerticesAsync(VertexFilter,String). Calls getVerticesAsync(VertexFilter,String) and waits for returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - getVerticesAsync
```
public <E> PgxFuture<VertexSet<E>> getVerticesAsync()
```
    Creates a new vertex set containing all vertices.
    
    Returns:
    
    newly created vertex set
  - getVerticesAsync
```
public <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
  - getVerticesAsync
```
public <E> PgxFuture<VertexSet<E>> getVerticesAsync(VertexFilter filter,
                                                    java.lang.String name)
```
    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
    
    name - the name of the collection to be created. If NULL, a name will be generated.
    
    Returns:
    
    newly created vertex set
  - hasEdge
```
public boolean hasEdge(long id)
                throws java.util.concurrent.ExecutionException,
                       java.lang.InterruptedException
```
    Blocking version of hasEdgeAsync(long) Calls hasEdgeAsync(long) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - hasEdgeAsync
```
public PgxFuture<java.lang.Boolean> hasEdgeAsync(long id)
```
    Looks up whether the graph has an Edge with the given ID
    
    Parameters:
    
    id - the ID of the edge
    
    Returns:
    
    true if the graph has an Edge with the given ID
  - hasVertex
```
public <ID> boolean hasVertex(ID id)
                       throws java.util.concurrent.ExecutionException,
                              java.lang.InterruptedException
```
    Blocking version of hasVertexAsync(Object). Calls hasVertexAsync(Object) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - hasVertexAsync
```
public <ID> PgxFuture<java.lang.Boolean> hasVertexAsync(ID id)
```
    Looks up whether the graph has a Vertex with the given ID
    
    Parameters:
    
    id - the ID of the vertex
    
    Returns:
    
    true if the graph has a Vertex with the given ID
  - isBipartiteGraph
```
public java.lang.Boolean isBipartiteGraph(VertexProperty<?,java.lang.Boolean> isLeft)
                                   throws java.util.concurrent.ExecutionException,
                                          java.lang.InterruptedException
```
    Blocking version of isBipartiteGraphAsync(VertexProperty). Calls isBipartiteGraphAsync(VertexProperty) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - isBipartiteGraphAsync
```
public <ID> PgxFuture<java.lang.Boolean> isBipartiteGraphAsync(VertexProperty<ID,java.lang.Boolean> isLeft)
```
    Checks whether a given graph is a bipartite graph. A graph is considered a bipartite graph if all nodes can be divided in a 'left' and a 'right' side where edges only go from nodes on the 'left' side to nodes on the 'right' side.
    
    Parameters:
    
    isLeft - boolean vertex property that - if the method returns true - will contain for each node whether it is on the 'left' side of the bipartite graph. If the method returns false, the content is undefined.
    
    Returns:
    
    true if the graph is a bipartite graph, false otherwise
  - isDirected
```
public boolean isDirected()
```
  - isFresh
```
public boolean isFresh()
                throws java.util.concurrent.ExecutionException,
                       java.lang.InterruptedException
```
    Blocking version of isFreshAsync(). Calls isFreshAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - isFreshAsync
```
public PgxFuture<java.lang.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()
```
    Gets the transient flag of this graph.
    
    Returns:
    
    true if this graph is transient (session-bound, private), false otherwise.
  - pickRandomVertex
```
public <ID> PgxVertex<ID> pickRandomVertex()
                                    throws java.util.concurrent.ExecutionException,
                                           java.lang.InterruptedException
```
    Blocking version of pickRandomVertexAsync(). Calls pickRandomVertexAsync() and waits for returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - pickRandomVertexAsync
```
public <ID> PgxFuture<PgxVertex<ID>> pickRandomVertexAsync()
```
    Picks a random vertex in the graph.
    
    Returns:
    
    a random vertex.
  - queryPgql
```
public PgqlResultSet queryPgql(java.lang.String pgqlString)
                        throws java.util.concurrent.ExecutionException,
                               java.lang.InterruptedException
```
    Blocking version of queryPgql(String). Calls queryPgql(String) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - queryPgql
```
public PgqlResultSet queryPgql(java.lang.String pgqlString,
                               PatternMatchingSemantic patternMatchingSemantic)
                        throws java.util.concurrent.ExecutionException,
                               java.lang.InterruptedException
```
    Blocking version of queryPgql(String, PatternMatchingSemantic). Calls queryPgqlAsync(String, PatternMatchingSemantic) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - queryPgqlAsync
```
public PgxFuture<PgqlResultSet> queryPgqlAsync(java.lang.String pgqlString)
```
    Submits a pattern matching query.
    
    Parameters:
    
    pgqlString - query string in PGQL
    
    Returns:
    
    the query result set
  - queryPgqlAsync
```
public PgxFuture<PgqlResultSet> queryPgqlAsync(java.lang.String pgqlString,
                                               PatternMatchingSemantic patternMatchingSemantic)
```
    Submits a pattern matching query.
    
    Parameters:
    
    pgqlString - query string in PGQL
    
    patternMatchingSemantic - pattern matching semantic; either graph isomorphism (PatternMatchingSemantic.ISOMORPHISM) or graph homomorphism (PatternMatchingSemantic.HOMOMORPHISM)
    
    Returns:
    
    the query result set.
  - simplify
```
public PgxGraph simplify()
                  throws java.util.concurrent.ExecutionException,
                         java.lang.InterruptedException
```
    Blocking version of simplifyAsync(). Calls simplifyAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - simplify
```
public PgxGraph simplify(java.util.Collection<VertexProperty<?,?>> vertexProps,
                         java.util.Collection<EdgeProperty<?>> edgeProps,
                         PgxGraph.MultiEdges multiEdges,
                         PgxGraph.SelfEdges selfEdges,
                         PgxGraph.TrivialVertices trivialVertices,
                         PgxGraph.Mode mode,
                         java.lang.String newGraphName)
                  throws java.util.concurrent.ExecutionException,
                         java.lang.InterruptedException
```
    Blocking version of simplifyAsync(Collection, Collection, MultiEdges, SelfEdges, TrivialVertices, Mode, String). Calls simplifyAsync(Collection, Collection, MultiEdges, SelfEdges, TrivialVertices, Mode, String) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - simplify
```
public PgxGraph simplify(oracle.pgx.common.mutations.MutationStrategy mutationStrategy)
                  throws java.util.concurrent.ExecutionException,
                         java.lang.InterruptedException
```
    Throws:
    
    java.util.concurrent.ExecutionException
    
    java.lang.InterruptedException
  - simplify
```
public PgxGraph simplify(PgxGraph.MultiEdges multiEdges,
                         PgxGraph.SelfEdges selfEdges,
                         PgxGraph.TrivialVertices trivialVertices,
                         PgxGraph.Mode mode,
                         java.lang.String newGraphName)
                  throws java.util.concurrent.ExecutionException,
                         java.lang.InterruptedException
```
    Blocking version of simplifyAsync(MultiEdges, SelfEdges, TrivialVertices, Mode, String). Calls simplifyAsync(MultiEdges, SelfEdges, TrivialVertices, Mode, String) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - simplify
```
public PgxGraph simplify(java.lang.String newGraphName)
                  throws java.util.concurrent.ExecutionException,
                         java.lang.InterruptedException
```
    Blocking version of simplifyAsync(String). Calls simplifyAsync(String) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - simplifyAsync
```
public PgxFuture<PgxGraph> simplifyAsync()
```
    Convenience method around simplifyAsync(String) passing null as graphName
    
    Returns:
    
    the resulting graph
  - simplifyAsync
```
public PgxFuture<PgxGraph> simplifyAsync(java.util.Collection<VertexProperty<?,?>> vertexProps,
                                         java.util.Collection<EdgeProperty<?>> edgeProps,
                                         PgxGraph.MultiEdges multiEdges,
                                         PgxGraph.SelfEdges selfEdges,
                                         PgxGraph.TrivialVertices trivialVertices,
                                         PgxGraph.Mode mode,
                                         java.lang.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 can 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(oracle.pgx.common.mutations.MutationStrategy mutationStrategy)
```
  - simplifyAsync
```
public PgxFuture<PgxGraph> simplifyAsync(PgxGraph.MultiEdges multiEdges,
                                         PgxGraph.SelfEdges selfEdges,
                                         PgxGraph.TrivialVertices trivialVertices,
                                         PgxGraph.Mode mode,
                                         java.lang.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 can 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(java.lang.String newGraphName)
```
    Convenience method for simplifyAsync(MultiEdges, SelfEdges, TrivialVertices, Mode, String)
    Passing
    - StrategyType as StrategyType.REMOVE_MULTI_EDGES
    - SelfEdges as SelfEdges.REMOVE_SELF_EDGES
    - Trivial Vertices as TrivialVertices.REMOVE_TRIVIAL_VERTICES
    - Mode as Mode.CREATE_COPY
    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:
    
    newGraphName - name of the new graph, if empty string, a name will be generated.
    
    Returns:
    
    resulting graph
  - sortByDegree
```
public PgxGraph sortByDegree()
                      throws java.util.concurrent.ExecutionException,
                             java.lang.InterruptedException
```
    Blocking version of sortByDegreeAsync(). Calls sortByDegreeAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - sortByDegree
```
public PgxGraph sortByDegree(java.util.Collection<VertexProperty<?,?>> vertexProps,
                             java.util.Collection<EdgeProperty<?>> edgeProps,
                             PgxGraph.SortOrder sortOrder,
                             PgxGraph.Degree degree,
                             PgxGraph.Mode mode,
                             java.lang.String newGraphName)
                      throws java.util.concurrent.ExecutionException,
                             java.lang.InterruptedException
```
    Blocking version of sortByDegreeAsync(Collection, Collection, SortOrder, Degree, Mode, String). Calls sortByDegreeAsync(Collection, Collection, SortOrder, Degree, Mode, String) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - sortByDegree
```
public PgxGraph sortByDegree(PgxGraph.SortOrder sortOrder,
                             PgxGraph.Degree degree,
                             PgxGraph.Mode mode,
                             java.lang.String newGraphName)
                      throws java.util.concurrent.ExecutionException,
                             java.lang.InterruptedException
```
    Blocking version of sortByDegreeAsync(SortOrder, Degree, Mode, String). Calls sortByDegreeAsync(SortOrder, Degree, Mode, String) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - sortByDegree
```
public PgxGraph sortByDegree(java.lang.String newGraphName)
                      throws java.util.concurrent.ExecutionException,
                             java.lang.InterruptedException
```
    Blocking version of sortByDegreeAsync(String). Calls sortByDegreeAsync(String) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.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(java.util.Collection<VertexProperty<?,?>> vertexProps,
                                             java.util.Collection<EdgeProperty<?>> edgeProps,
                                             PgxGraph.SortOrder sortOrder,
                                             PgxGraph.Degree degree,
                                             PgxGraph.Mode mode,
                                             java.lang.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.
    
    sortOrder - sort order. Constants PgxGraph.SortOrder.ASCENDING or PgxGraph.SortOrder.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.SortOrder sortOrder,
                                             PgxGraph.Degree degree,
                                             PgxGraph.Mode mode,
                                             java.lang.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, SortOrder, Degree, Mode, String)
    
    Passing
    - Collection(vertexProps) as VertexProperty.ALL
    - Collection(edgeProps) as EdgeProperty.ALL
    Parameters:
    
    sortOrder - sort order. Constants PgxGraph.SortOrder.ASCENDING or PgxGraph.SortOrder.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(java.lang.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(SortOrder, Degree, Mode, String)
    
    Passing
    - SortOrder as SortOrder.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
```
public PgxGraph sparsify(java.util.Collection<VertexProperty<?,?>> vertexProps,
                         java.util.Collection<EdgeProperty<?>> edgeProps,
                         double e,
                         java.lang.String newGraphName)
                  throws java.util.concurrent.ExecutionException,
                         java.lang.InterruptedException
```
    Blocking version of sparsifyAsync(Collection, Collection, double, String). Calls sparsifyAsync(Collection, Collection, double, String) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - sparsify
```
public PgxGraph sparsify(double e)
                  throws java.util.concurrent.ExecutionException,
                         java.lang.InterruptedException
```
    Blocking version of sparsifyAsync(double). Calls sparsifyAsync(double) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - sparsify
```
public PgxGraph sparsify(double e,
                         java.lang.String newGraphName)
                  throws java.util.concurrent.ExecutionException,
                         java.lang.InterruptedException
```
    Blocking version of sparsifyAsync(double, String). Calls sparsifyAsync(double, String) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - sparsifyAsync
```
public PgxFuture<PgxGraph> sparsifyAsync(java.util.Collection<VertexProperty<?,?>> vertexProps,
                                         java.util.Collection<EdgeProperty<?>> edgeProps,
                                         double e,
                                         java.lang.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
    
    Returns:
    
    resulting graph
  - sparsifyAsync
```
public PgxFuture<PgxGraph> sparsifyAsync(double e,
                                         java.lang.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.0.
    
    newGraphName - name of the new graph. If null, a name will be generated.
    
    Returns:
    
    resulting graph
  - store
```
public FileGraphConfig store(Format targetFormat,
                             java.lang.String targetPath)
                      throws java.util.concurrent.ExecutionException,
                             java.lang.InterruptedException
```
    Blocking version of storeAsync(Format, String). Calls storeAsync(Format, String) and waits for returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - store
```
public FileGraphConfig store(Format targetFormat,
                             java.lang.String targetPath,
                             boolean overwrite)
                      throws java.util.concurrent.ExecutionException,
                             java.lang.InterruptedException
```
    Blocking version of storeAsync(Format, String, boolean). Calls storeAsync(Format, String, boolean) and waits for returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - store
```
public FileGraphConfig store(Format targetFormat,
                             java.lang.String targetPath,
                             java.util.Collection<VertexProperty<?,?>> vertexProps,
                             java.util.Collection<EdgeProperty<?>> edgeProps,
                             boolean overwrite)
                      throws java.util.concurrent.ExecutionException,
                             java.lang.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:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - store
```
public GraphConfig store(GraphConfig targetConfig,
                         boolean overwrite)
                  throws java.util.concurrent.ExecutionException,
                         java.lang.InterruptedException
```
    Blocking version of storeAsync(GraphConfig, boolean). Calls storeAsync(GraphConfig, boolean) and waits for returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - storeAsync
```
public PgxFuture<FileGraphConfig> storeAsync(Format targetFormat,
                                             java.lang.String targetPath)
```
    Stores this graph in a given file format on a file system. This is a convenience method around store(Format, String, boolean), setting the overwrite flag to false.
    
    Parameters:
    
    targetFormat - the format in which to store this graph. Note that only single file formats are supported.
    
    targetPath - the path the graph should be written to. Use schemes to write to a specific file system.
    
    Returns:
    
    A graph config object which can be used to load the stored graph back into memory.
  - storeAsync
```
public PgxFuture<FileGraphConfig> storeAsync(Format targetFormat,
                                             java.lang.String targetPath,
                                             boolean overwrite)
```
    Stores this graph in a given file format on a file system. This is a convenience method around storeAsync(Format, String, Collection, Collection, boolean), storing all vertex and edge properties and no file system attributes.
    
    Parameters:
    
    targetFormat - the format in which to store this graph. Note that only single file formats are supported.
    
    targetPath - the path the graph should be written to. Use schemes to write to a specific file system.
    
    overwrite - Set this flag to true if you want to overwrite any existing file rather than getting an exception if the target path already exists.
    
    Returns:
    
    A graph config object which can be used to load the stored graph back into memory.
  - storeAsync
```
public PgxFuture<FileGraphConfig> storeAsync(Format targetFormat,
                                             java.lang.String targetPath,
                                             java.util.Collection<VertexProperty<?,?>> vertexProps,
                                             java.util.Collection<EdgeProperty<?>> edgeProps,
                                             boolean overwrite)
```
    Stores this graph in a given file format on a file system.
    
    Parameters:
    
    targetFormat - the format in which to store this graph. Note that only file formats with vertices and edge combined in same file are supported.
    
    targetPath - the path the graph should be written to. Use schemes to write to a specific file system.
    
    vertexProps - the collection of vertex properties to store together with the graph data. You can use VertexProperty.NONE or VertexProperty.ALL to indicate all or no properties.
    
    edgeProps - the collection of edge properties to store together with the graph data. You can use EdgeProperty.NONE or EdgeProperty.ALL to indicate all or no properties.
    
    overwrite - Set this flag to true if you want to overwrite any existing file rather than getting an exception if the target path already exists.
    
    Returns:
    
    A graph config object which can be used to load the stored graph back into memory.
  - storeAsync
```
public PgxFuture<GraphConfig> storeAsync(GraphConfig targetConfig,
                                         boolean overwrite)
```
    Stores this graph in a file or database.
    
    Parameters:
    
    targetConfig - the graph configuration describing the stored graph.
    
    overwrite - Set this flag to true if you want to overwrite any existing file rather than getting an exception if the target path already exists.
    
    Returns:
    
    the given graph config. Can be used to load the stored graph back into memory.
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - transpose
```
public PgxGraph transpose()
                   throws java.util.concurrent.ExecutionException,
                          java.lang.InterruptedException
```
    Blocking version of transposeAsync()
    
    Returns:
    
    resulting graph
    
    Throws:
    
    java.util.concurrent.ExecutionException
    
    java.lang.InterruptedException
  - transpose
```
public PgxGraph transpose(java.util.Collection<VertexProperty<?,?>> vertexProps,
                          java.util.Collection<EdgeProperty<?>> edgeProps,
                          java.util.Map<java.lang.String,java.lang.String> edgeLabelMapping,
                          PgxGraph.Mode mode,
                          java.lang.String newGraphName)
                   throws java.util.concurrent.ExecutionException,
                          java.lang.InterruptedException
```
    Blocking version of transposeAsync(Collection, Collection, Map, Mode, String)
    
    Returns:
    
    resulting graph
    
    Throws:
    
    java.util.concurrent.ExecutionException
    
    java.lang.InterruptedException
  - transpose
```
public PgxGraph transpose(PgxGraph.Mode mode)
                   throws java.util.concurrent.ExecutionException,
                          java.lang.InterruptedException
```
    Blocking version of transposeAsync(Mode)
    
    Returns:
    
    resulting graph
    
    Throws:
    
    java.util.concurrent.ExecutionException
    
    java.lang.InterruptedException
  - transpose
```
public PgxGraph transpose(PgxGraph.Mode mode,
                          java.lang.String newGraphName)
                   throws java.util.concurrent.ExecutionException,
                          java.lang.InterruptedException
```
    Blocking version of transposeAsync(Mode, String)
    
    Returns:
    
    resulting graph
    
    Throws:
    
    java.util.concurrent.ExecutionException
    
    java.lang.InterruptedException
  - transpose
```
public PgxGraph transpose(java.lang.String newGraphName)
                   throws java.util.concurrent.ExecutionException,
                          java.lang.InterruptedException
```
    Blocking version of transposeAsync(String)
    
    Returns:
    
    resulting graph
    
    Throws:
    
    java.util.concurrent.ExecutionException
    
    java.lang.InterruptedException
  - transposeAsync
```
public PgxFuture<PgxGraph> transposeAsync()
```
    Convenience method around transposeAsync(String) passing null as graphName
    
    Returns:
    
    the resulting graph
  - transposeAsync
```
public PgxFuture<PgxGraph> transposeAsync(java.util.Collection<VertexProperty<?,?>> vertexProps,
                                          java.util.Collection<EdgeProperty<?>> edgeProps,
                                          java.util.Map<java.lang.String,java.lang.String> edgeLabelMapping,
                                          PgxGraph.Mode mode,
                                          java.lang.String newGraphName)
```
    Creates a transpose of this graph. A transpose of a directed graph is another directed graph on the same set of vertices with all of the edges reversed. If this graph contains an edge (u,v) then the return graph will contain an edge (v,u) and vice versa. If this graph is undirected (isDirected() returns false), this operation has no effect and will either return a copy or act as identity function depending on the mode parameter.
    
    Parameters:
    
    vertexProps - vertex properties to be transformed as well. Constants VertexProperty.ALL or VertexProperty.NONE can be used.
    
    edgeProps - edge properties to be transformed as well. Constants EdgeProperty.ALL or EdgeProperty.NONE can be used.
    
    edgeLabelMapping - can be used to rename edge labels. For example, an edge (John,Mary) labeled "fatherOf" can be transformed to be labeled "hasFather" on the transpose graph's edge (Mary,John) by passing in a map like Collections.singletonMap("fatherOf", "hasFather"). If the given map is an empty map, the transpose graph will have the same edge labels as this graph. If the given map is NULL, the transpose graph won't contain any edge labels (all labels will be removed). If any key in the given map does not exist as an edge label, it will be ignored.
    
    mode - 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:
    
    a future holding the transpose of this graph upon successful completion.
  - transposeAsync
```
public PgxFuture<PgxGraph> transposeAsync(PgxGraph.Mode mode)
```
    Convenience method around transposeAsync(Mode, String) passing null as graphName
    
    Returns:
    
    the resulting graph
  - transposeAsync
```
public PgxFuture<PgxGraph> transposeAsync(PgxGraph.Mode mode,
                                          java.lang.String newGraphName)
```
    Convenience method around transposeAsync(Collection, Collection, Map, Mode, String)
    
    Passing
    - Collection(vertexProps) as VertexProperty.ALL
    - Collection(edgeProps) as EdgeProperty.ALL
    - *
    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
  - transposeAsync
```
public PgxFuture<PgxGraph> transposeAsync(java.lang.String newGraphName)
```
    Convenience method around transposeAsync(Mode, String)
    
    Passing
    - 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
  - undirect
```
public PgxGraph undirect()
                  throws java.util.concurrent.ExecutionException,
                         java.lang.InterruptedException
```
    Blocking version of undirectAsync(). Calls undirectAsync() and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - undirect
```
public PgxGraph undirect(java.util.Collection<VertexProperty<?,?>> vertexProps,
                         java.util.Collection<EdgeProperty<?>> edgeProps,
                         PgxGraph.MultiEdges multiEdges,
                         PgxGraph.SelfEdges selfEdges,
                         PgxGraph.TrivialVertices trivialVertices,
                         PgxGraph.Mode mode,
                         java.lang.String newGraphName)
                  throws java.util.concurrent.ExecutionException,
                         java.lang.InterruptedException
```
    Blocking version of undirectAsync(Collection, Collection, MultiEdges, SelfEdges, Mode, String). Calls undirectAsync(Collection, Collection, MultiEdges, SelfEdges, Mode, String) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - undirect
```
public PgxGraph undirect(oracle.pgx.common.mutations.MutationStrategy mutationStrategy)
                  throws java.util.concurrent.ExecutionException,
                         java.lang.InterruptedException
```
    Blocking version of undirectAsync(MutationStrategy)
    
    Parameters:
    
    mutationStrategy -
    
    Returns:
    
    Throws:
    
    java.util.concurrent.ExecutionException
    
    java.lang.InterruptedException
  - undirect
```
public PgxGraph undirect(PgxGraph.MultiEdges multiEdges,
                         PgxGraph.SelfEdges selfEdges,
                         PgxGraph.Mode mode,
                         java.lang.String newGraphName)
                  throws java.util.concurrent.ExecutionException,
                         java.lang.InterruptedException
```
    Blocking version of undirectAsync(MultiEdges, SelfEdges, Mode, String). Calls undirectAsync(MultiEdges, SelfEdges, Mode, String) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.
  - undirect
```
public PgxGraph undirect(java.lang.String newGraphName)
                  throws java.util.concurrent.ExecutionException,
                         java.lang.InterruptedException
```
    Blocking version of undirectAsync(String). Calls undirectAsync(String) and waits for the returned PgxFuture to complete.
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread gets interrupted while waiting for completion.
    
    java.util.concurrent.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 null as graphName
    
    Returns:
    
    the resulting graph
  - undirectAsync
```
public PgxFuture<PgxGraph> undirectAsync(java.util.Collection<VertexProperty<?,?>> vertexProps,
                                         java.util.Collection<EdgeProperty<?>> edgeProps,
                                         PgxGraph.MultiEdges multiEdges,
                                         PgxGraph.SelfEdges selfEdges,
                                         PgxGraph.Mode mode,
                                         java.lang.String newGraphName)
```
    Convenience method to create for undirectAsync(MutationStrategy).
    
    Parameters:
    
    vertexProps - vertex properties belonging to graph. Constants VertexProperty.ALL or VertexProperty.NONE can be used.
    
    edgeProps -
    
    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 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(oracle.pgx.common.mutations.MutationStrategy mutationStrategy)
```
    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.
    EdgeProperties are handled according to the provided MutationStrategy.
    
    Parameters:
    
    mutationStrategy -
    
    Returns:
    
    resulting graph
  - undirectAsync
```
public PgxFuture<PgxGraph> undirectAsync(PgxGraph.MultiEdges multiEdges,
                                         PgxGraph.SelfEdges selfEdges,
                                         PgxGraph.Mode mode,
                                         java.lang.String newGraphName)
```
    Convenience method for undirectAsync(Collection, Collection, MultiEdges, SelfEdges, Mode, String)
    
    Passing Collection(vertexProps) as VertexProperty.ALL and Collection(edgeProps) as EdgeProperty.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 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(java.lang.String newGraphName)
```
    Convenience method around undirectAsync(MultiEdges, SelfEdges, Mode, String)
    
    Passing
    - StrategyType as StrategyType.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

bipartiteSubGraphFromInDegree

bipartiteSubGraphFromInDegree

bipartiteSubGraphFromInDegree

bipartiteSubGraphFromInDegree

bipartiteSubGraphFromInDegreeAsync

bipartiteSubGraphFromInDegreeAsync

bipartiteSubGraphFromInDegreeAsync

bipartiteSubGraphFromInDegreeAsync

bipartiteSubGraphFromLeftSet

bipartiteSubGraphFromLeftSet

bipartiteSubGraphFromLeftSet

bipartiteSubGraphFromLeftSet

bipartiteSubGraphFromLeftSetAsync

bipartiteSubGraphFromLeftSetAsync

bipartiteSubGraphFromLeftSetAsync

bipartiteSubGraphFromLeftSetAsync

clone

clone

clone

cloneAsync

cloneAsync

cloneAsync

combineEdgePropertiesIntoVectorProperty

combineEdgePropertiesIntoVectorProperty

combineEdgePropertiesIntoVectorPropertyAsync

combineEdgePropertiesIntoVectorPropertyAsync

combineVertexPropertiesIntoVectorProperty

combineVertexPropertiesIntoVectorProperty

combineVertexPropertiesIntoVectorPropertyAsync

combineVertexPropertiesIntoVectorPropertyAsync

createAllPaths

createAllPathsAsync

createChangeSet

createComponents

createComponentsAsync

createEdgeProperty

createEdgeProperty

createEdgeProperty

createEdgePropertyAsync

createEdgePropertyAsync

createEdgeSequence

createEdgeSequence

createEdgeSequenceAsync

createEdgeSequenceAsync

createEdgeSet

createEdgeSet

createEdgeSetAsync

createEdgeSetAsync

createEdgeVectorProperty

createEdgeVectorProperty

createEdgeVectorPropertyAsync

createEdgeVectorPropertyAsync

createMap

createMap

createMapAsync

createMapAsync

createMergingStrategyBuilder

createPath

createPathAsync

createPickingStrategyBuilder

createScalar

createScalar

createScalarAsync

createScalarAsync

createVectorScalar

createVectorScalar

createVectorScalarAsync

createVectorScalarAsync

createVertexProperty

createVertexProperty

createVertexProperty

createVertexPropertyAsync

createVertexPropertyAsync