PgxGraph (Oracle Graph Java API Reference Release 20.3 (F15858-03))

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
```
This class is a reference to a graph on the server side: operations on objects of this class are executed on the server side onto the referenced graph. Note that a session can have multiple objects referencing the same graph: the result of any operation mutating the graph on any of those references will be visible on all of them.

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.Retention` The Retention 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
`void`	`addRedactionRule(PgxRedactionRuleConfig ruleConfig, AuthorizationType type, java.lang.String... names)` Blocking version of `addRedactionRule(PgxRedactionRuleConfig, AuthorizationType, String...)` Calls `addRedactionRuleAsync(PgxRedactionRuleConfig, AuthorizationType, String...)` )} and waits for the returned `PgxFuture` to complete.
`PgxFuture<java.lang.Void>`	`addRedactionRuleAsync(PgxRedactionRuleConfig ruleConfig, AuthorizationType type, java.lang.String... names)` Add a redaction rule configuration for an AuthorizationType names.
`GraphAlterationBuilder`	`alterGraph()` Create a graph alteration builder to define the graph schema alterations to perform on the graph
`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)`.
`PgxGraph`	`cloneAndExecutePgql(java.lang.String pgqlString)` (BETA) Blocking version of `cloneAndExecutePgqlAsync(String)`.
`PgxGraph`	`cloneAndExecutePgql(java.lang.String pgqlString, java.lang.String graphName)` (BETA) Blocking version of `cloneAndExecutePgqlAsync(String, String)`.
`PgxFuture<PgxGraph>`	`cloneAndExecutePgqlAsync(java.lang.String pgqlString)` (BETA) Convenience method of `cloneAndExecutePgqlAsync(String, String)` Passing String(name) as `null`
`PgxFuture<PgxGraph>`	`cloneAndExecutePgqlAsync(java.lang.String pgqlString, java.lang.String newGraphName)` (BETA) Convenience method for executing `cloneAsync(String)` on a graph and `executePgqlAsync(String)` on its result
`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 deep 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> 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 using `IdGenerationStrategy.AUTO_GENERATED` for edge ID generation strategy Note: This is currently not supported for undirected graphs.
`<ID extends java.lang.Comparable<ID>> GraphChangeSet<ID>`	`createChangeSet(IdGenerationStrategy vertexIdGenerationStrategy, IdGenerationStrategy edgeIdGenerationStrategy)` 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).
`<ID> PgxFuture<PgxPath<ID>>`	`createPathAsync(VertexSequence<ID> nodeSequence, EdgeSequence edgeSequence)` Creates a `PgxPath` object from a sequence of vertices and edges.
`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
`void`	`destroy(PgxGraph.Retention retention)` Blocking version of `destroyAsync(boolean ignoreNotFound, Retention retention)`.
`void`	`destroyEdgePropertyIfExists(java.lang.String name)` Blocking version of `destroyEdgePropertyIfExistsAsync(String)`.
`PgxFuture<java.lang.Void>`	`destroyEdgePropertyIfExistsAsync(java.lang.String name)` Destroys an edge property if it exists.
`void`	`destroyVertexPropertyIfExists(java.lang.String name)` Blocking version of `destroyVertexPropertyIfExistsAsync(String)`.
`PgxFuture<java.lang.Void>`	`destroyVertexPropertyIfExistsAsync(java.lang.String name)` Destroys a vertex property if it exists.
`boolean`	`equals(java.lang.Object obj)`
`PgqlResultSet`	`executePgql(java.lang.String pgqlString)` (BETA) Blocking version of `executePgqlAsync(String)`.
`PgxFuture<PgqlResultSet>`	`executePgqlAsync(java.lang.String pgqlString)` (BETA) Submits a PGQL (both select and modify) query.
`Operation`	`explainPgql(java.lang.String pgqlString)` Blocking version of `explainPgql(String)`.
`PgxFuture<Operation>`	`explainPgqlAsync(java.lang.String pgqlString)` Explain the execution plan of a pattern matching query.
`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.
`java.util.Map<java.lang.String,PgxCollection<? extends PgxEntity<?>,?>>`	`getCollections()` Blocking version of `getCollectionsAsync()`.
`PgxFuture<java.util.Map<java.lang.String,PgxCollection<? extends PgxEntity<?>,?>>>`	`getCollectionsAsync()` Retrieves all currently allocated collections associated with the 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.
`IdStrategy`	`getEdgeIdStrategy()` Gets the ID strategy used for the edges of this graph.
`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(Namespace namespace, java.lang.String name)` Blocking version of `getEdgePropertyAsync(Namespace, String)`.
`<V> EdgeProperty<V>`	`getEdgeProperty(java.lang.String name)` Blocking version of `getEdgePropertyAsync(String)`.
`<V> PgxFuture<EdgeProperty<V>>`	`getEdgePropertyAsync(Namespace namespace, java.lang.String name)` Gets an edge property of this graph in the given namespace.
`<V> PgxFuture<EdgeProperty<V>>`	`getEdgePropertyAsync(java.lang.String name)` Gets an edge property of this graph The property will be first looked up in the session private namespace, if it is not found there it will be looked up in the public namespace.
`EdgeSet`	`getEdges()` Blocking version of `getEdges()`.
`EdgeSet`	`getEdges(EdgeFilter filter)` Blocking version of `getEdges(EdgeFilter)`.
`EdgeSet`	`getEdges(EdgeFilter filter, java.lang.String name)` Blocking version of `getEdges(EdgeFilter, String)`.
`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.
`PgxFuture<EdgeSet>`	`getEdgesAsync(EdgeFilter filter, java.lang.String name)` Creates a new edge set containing edges according to the given filter expression.
`oracle.pgx.common.PgxId`	`getId()` Returns an internal identifier for this graph snapshot.
`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
`<V> EdgeProperty<V>`	`getOrCreateEdgeProperty(PropertyType type, java.lang.String name)` Blocking version of `getOrCreateEdgePropertyAsync(PropertyType, String)`.
`<V> PgxFuture<EdgeProperty<V>>`	`getOrCreateEdgePropertyAsync(PropertyType type, java.lang.String name)` Gets or creates an edge property
`<V> EdgeProperty<PgxVect<V>>`	`getOrCreateEdgeVectorProperty(PropertyType type, int dimension, java.lang.String name)` Blocking version of `getOrCreateEdgeVectorPropertyAsync(PropertyType, int, String)`.
`<V> PgxFuture<EdgeProperty<PgxVect<V>>>`	`getOrCreateEdgeVectorPropertyAsync(PropertyType type, int dimension, java.lang.String name)` Gets or creates an edge vector property
`<V> PgxFuture<EdgeProperty<PgxVect<V>>>`	`getOrCreateEdgeVertexPropertyAsync(PropertyType type, int dimension, java.lang.String name)` Gets or creates an edge vector property
`<ID,V> VertexProperty<ID,V>`	`getOrCreateVertexProperty(PropertyType type, java.lang.String name)` Blocking version of `getOrCreateVertexPropertyAsync(PropertyType, String)`.
`<ID,V> PgxFuture<VertexProperty<ID,V>>`	`getOrCreateVertexPropertyAsync(PropertyType type, java.lang.String name)` Gets or creates a vertex property
`<ID,V> VertexProperty<ID,PgxVect<V>>`	`getOrCreateVertexVectorProperty(PropertyType type, int dimension, java.lang.String name)` Blocking version of `getOrCreateVertexVectorPropertyAsync(PropertyType, int, String)`.
`<ID,V> PgxFuture<VertexProperty<ID,PgxVect<V>>>`	`getOrCreateVertexVectorPropertyAsync(PropertyType type, int dimension, java.lang.String name)` Gets or creates a vertex vector property
`ServerInstance`	`getPgxInstance()` Gets the server instance.
`PgxEdge`	`getRandomEdge()` Blocking version of `getRandomEdgeAsync()`.
`PgxFuture<PgxEdge>`	`getRandomEdgeAsync()` Picks a random edge in the graph.
`<ID> PgxVertex<ID>`	`getRandomVertex()` Blocking version of `getRandomVertexAsync()`.
`<ID> PgxFuture<PgxVertex<ID>>`	`getRandomVertexAsync()` Picks a random vertex in the graph.
`java.util.List<PgxRedactionRuleConfig>`	`getRedactionRules(AuthorizationType type, java.lang.String name)` Blocking version of `getRedactionRules(AuthorizationType, String)` Calls `getRedactionRulesAsync(AuthorizationType, String)` )} and waits for the returned `PgxFuture` to complete.
`PgxFuture<java.util.List<PgxRedactionRuleConfig>>`	`getRedactionRulesAsync(AuthorizationType type, java.lang.String name)` Gets redaction rules for an AuthorizationType name.
`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.
`IdStrategy`	`getVertexIdStrategy()` Gets the ID strategy used for the vertices of this graph.
`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(Namespace namespace, java.lang.String name)` Blocking version of `getVertexPropertyAsync(Namespace, String)`.
`<ID,V> VertexProperty<ID,V>`	`getVertexProperty(java.lang.String name)` Blocking version of `getVertexPropertyAsync(String)`.
`<ID,V> PgxFuture<VertexProperty<ID,V>>`	`getVertexPropertyAsync(Namespace namespace, java.lang.String name)` Gets a vertex property of this graph in the given namespace.
`<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.
`void`	`grantPermission(oracle.pgx.common.auth.PgxRole role, oracle.pgx.common.auth.PgxResourcePermission permission)` Blocking version of `grantPermissionAsync(PgxRole, PgxResourcePermission)`.
`void`	`grantPermission(oracle.pgx.common.auth.PgxUser user, oracle.pgx.common.auth.PgxResourcePermission permission)` Blocking version of `grantPermissionAsync(PgxUser, PgxResourcePermission)`.
`PgxFuture<java.lang.Void>`	`grantPermissionAsync(oracle.pgx.common.auth.PgxRole role, oracle.pgx.common.auth.PgxResourcePermission permission)` Grants a permission on this graph to the given role.
`PgxFuture<java.lang.Void>`	`grantPermissionAsync(oracle.pgx.common.auth.PgxUser user, oracle.pgx.common.auth.PgxResourcePermission permission)` Grants a permission on this graph to the given user.
`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
`boolean`	`hasEdgeLabel()` Blocking version of `hasEdgeLabelAsync()`.
`PgxFuture<java.lang.Boolean>`	`hasEdgeLabelAsync()`
`<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
`boolean`	`hasVertexLabels()` Blocking version of `hasVertexLabelsAsync()`.
`PgxFuture<java.lang.Boolean>`	`hasVertexLabelsAsync()`
`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`	`isPublished()` Blocking version of `isPublishedAsync()`.
`PgxFuture<java.lang.Boolean>`	`isPublishedAsync()` Checks if this graph is published.
`boolean`	`isPublishedWithSnapshots()` Blocking version of `isPublishedWithSnapshotsAsync()`.
`PgxFuture<java.lang.Boolean>`	`isPublishedWithSnapshotsAsync()` Checks if this graph is published with snapshots.
`boolean`	`isTransient()` Gets the transient flag of this graph.
`PgxPreparedStatement`	`preparePgql(java.lang.String pgqlString)` Blocking version of `preparePgql(String)`.
`PgxFuture<PgxPreparedStatement>`	`preparePgqlAsync(java.lang.String pgqlString)` Prepares a pattern matching select only query.
`void`	`publish()` Blocking version of `publishAsync()`.
`void`	`publish(java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps)`
`PgxFuture<java.lang.Void>`	`publishAsync()` Publishes the graph so it can be shared between sessions.
`PgxFuture<java.lang.Void>`	`publishAsync(java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps)` Publishes the graph so It can be shared between sessions.
`void`	`publishWithSnapshots()` Blocking version of `publishWithSnapshotsAsync()` .
`void`	`publishWithSnapshots(java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps)` Blocking version of `publishWithSnapshotsAsync(Collection, Collection)`.
`PgxFuture<java.lang.Void>`	`publishWithSnapshotsAsync()` Publishes the graph and all its snapshots so they can be shared between sessions.
`PgxFuture<java.lang.Void>`	`publishWithSnapshotsAsync(java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps)` Publishes the graph and all its snapshots so they can be shared between sessions.
`PgqlResultSet`	`queryPgql(java.lang.String pgqlString)` Blocking version of `queryPgql(String)`.
`PgxFuture<PgqlResultSet>`	`queryPgqlAsync(java.lang.String pgqlString)` Submits a pattern matching select only query.
`void`	`removeRedactionRule(PgxRedactionRuleConfig ruleConfig, AuthorizationType type, java.lang.String... names)` Blocking version of `removeRedactionRule(PgxRedactionRuleConfig, AuthorizationType, String...)` Calls `removeRedactionRuleAsync(PgxRedactionRuleConfig, AuthorizationType, String...)` )} and waits for the returned `PgxFuture` to complete.
`PgxFuture<java.lang.Void>`	`removeRedactionRuleAsync(PgxRedactionRuleConfig ruleConfig, AuthorizationType type, java.lang.String... names)` Removes a redaction rule for AuthorizationType names.
`void`	`rename(java.lang.String newGraphName)` Blocking version of `renameAsync(String)`.
`PgxFuture<java.lang.Void>`	`renameAsync(java.lang.String newGraphName)` Renames this graph.
`void`	`revokePermission(oracle.pgx.common.auth.PgxRole role)` Blocking version of `revokePermissionAsync(PgxRole)`.
`void`	`revokePermission(oracle.pgx.common.auth.PgxUser user)` Blocking version of `revokePermissionAsync(PgxUser)`.
`PgxFuture<java.lang.Void>`	`revokePermissionAsync(oracle.pgx.common.auth.PgxRole role)` Revokes all permissions on this graph from the given role.
`PgxFuture<java.lang.Void>`	`revokePermissionAsync(oracle.pgx.common.auth.PgxUser user)` Revokes all permissions on this graph from the given user.
`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 getId()
`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, FileGraphStoringConfig storingConfig)` Blocking version of `storeAsync(Format, FileGraphStoringConfig)`.
`FileGraphConfig`	`store(Format targetFormat, FileGraphStoringConfig storingConfig, boolean overwrite)` Blocking version of `storeAsync(Format, FileGraphStoringConfig, boolean)`.
`FileGraphConfig`	`store(Format targetFormat, FileGraphStoringConfig storingConfig, java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, boolean overwrite)` Blocking version of `storeAsync(Format, FileGraphStoringConfig, Collection, Collection, boolean)`.
`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)`.
`FileGraphConfig`	`store(Format targetFormat, java.lang.String targetBasePath, int numPartitions)` Blocking version of `storeAsync(Format, String, int)`.
`FileGraphConfig`	`store(Format targetFormat, java.lang.String targetBasePath, int numPartitions, boolean overwrite)` Blocking version of `storeAsync(Format, String, int, boolean)`.
`FileGraphConfig`	`store(Format targetFormat, java.lang.String targetBasePath, int numPartitions, java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, boolean overwrite)` Blocking version of `storeAsync(Format, String, int, Collection, Collection, boolean)`.
`GraphConfig`	`store(GraphConfig targetConfig, boolean overwrite)` Blocking version of `storeAsync(GraphConfig, boolean)`.
`GraphConfig`	`store(GraphConfig targetConfig, java.util.Set<java.lang.String> vertexProvidersToStore, java.util.Set<java.lang.String> edgeProvidersToStore, boolean overwrite)` Blocking version of `storeAsync(GraphConfig, Set, Set, boolean)`.
`PartitionedGraphConfig`	`store(ProviderFormat targetFormat, java.util.Map<java.lang.String,FileGraphStoringConfig> vertexStoringConfigs, java.util.Map<java.lang.String,FileGraphStoringConfig> edgeStoringConfigs)` Blocking version of `storeAsync(ProviderFormat, Map, Map)`.
`PartitionedGraphConfig`	`store(ProviderFormat targetFormat, java.util.Map<java.lang.String,FileGraphStoringConfig> vertexStoringConfigs, java.util.Map<java.lang.String,FileGraphStoringConfig> edgeStoringConfigs, boolean overwrite)` Blocking version of `storeAsync(ProviderFormat, Map, Map, boolean)`.
`PartitionedGraphConfig`	`store(ProviderFormat targetFormat, java.util.Map<java.lang.String,FileGraphStoringConfig> vertexStoringConfigs, java.util.Map<java.lang.String,FileGraphStoringConfig> edgeStoringConfigs, java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, boolean overwrite)` Blocking version of `storeAsync(ProviderFormat, Map, Map, Collection, Collection, boolean)`.
`PartitionedGraphConfig`	`store(ProviderFormat targetFormat, java.util.Set<java.lang.String> vertexProvidersToStore, java.util.Set<java.lang.String> edgeProvidersToStore, java.util.Map<java.lang.String,FileGraphStoringConfig> vertexStoringConfigs, java.util.Map<java.lang.String,FileGraphStoringConfig> edgeStoringConfigs, boolean overwrite)` Blocking version of `storeAsync(ProviderFormat, Set, Set, Map, Map, boolean)`.
`PartitionedGraphConfig`	`store(ProviderFormat targetFormat, java.util.Set<java.lang.String> vertexProvidersToStore, java.util.Set<java.lang.String> edgeProvidersToStore, java.util.Map<java.lang.String,FileGraphStoringConfig> vertexStoringConfigs, java.util.Map<java.lang.String,FileGraphStoringConfig> edgeStoringConfigs, java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, boolean overwrite)` Blocking version of `storeAsync(ProviderFormat, Set, Set, Map, Map, Collection, Collection, boolean)`.
`PartitionedGraphConfig`	`store(ProviderFormat targetFormat, java.lang.String targetBasePath)` Blocking version of `storeAsync(ProviderFormat, String)`.
`PartitionedGraphConfig`	`store(ProviderFormat targetFormat, java.lang.String targetBasePath, boolean overwrite)` Blocking version of `storeAsync(ProviderFormat, String, boolean)`.
`PartitionedGraphConfig`	`store(ProviderFormat targetFormat, java.lang.String targetBasePath, java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, boolean overwrite)` Blocking version of `storeAsync(ProviderFormat, String, Collection, Collection, boolean)`.
`PartitionedGraphConfig`	`store(ProviderFormat targetFormat, java.lang.String targetBasePath, int numPartitions)` Blocking version of `storeAsync(ProviderFormat, String, int)`.
`PartitionedGraphConfig`	`store(ProviderFormat targetFormat, java.lang.String targetBasePath, int numPartitions, boolean overwrite)` Blocking version of `storeAsync(ProviderFormat, String, int, boolean)`.
`PartitionedGraphConfig`	`store(ProviderFormat targetFormat, java.lang.String targetBasePath, int numPartitions, java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, boolean overwrite)` Blocking version of `storeAsync(ProviderFormat, String, int, Collection, Collection, boolean)`.
`PartitionedGraphConfig`	`store(ProviderFormat targetFormat, java.lang.String targetBasePath, int numPartitions, java.util.Set<java.lang.String> vertexProvidersToStore, java.util.Set<java.lang.String> edgeProvidersToStore)` Blocking version of `storeAsync(ProviderFormat, String, int, Set, Set)`.
`PartitionedGraphConfig`	`store(ProviderFormat targetFormat, java.lang.String targetBasePath, int numPartitions, java.util.Set<java.lang.String> vertexProvidersToStore, java.util.Set<java.lang.String> edgeProvidersToStore, boolean overwrite)` Blocking version of `storeAsync(ProviderFormat, String, int, Set, Set, , boolean)`.
`PartitionedGraphConfig`	`store(ProviderFormat targetFormat, java.lang.String targetBasePath, int numPartitions, java.util.Set<java.lang.String> vertexProvidersToStore, java.util.Set<java.lang.String> edgeProvidersToStore, java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, boolean overwrite)` Blocking version of `storeAsync(ProviderFormat, String, int, Set, Set, Collection, Collection, boolean)`.
`PartitionedGraphConfig`	`store(ProviderFormat targetFormat, java.lang.String targetBasePath, java.util.Set<java.lang.String> vertexProvidersToStore, java.util.Set<java.lang.String> edgeProvidersToStore)` Blocking version of `storeAsync(ProviderFormat, String, Set ,Set)`.
`PartitionedGraphConfig`	`store(ProviderFormat targetFormat, java.lang.String targetBasePath, java.util.Set<java.lang.String> vertexProvidersToStore, java.util.Set<java.lang.String> edgeProvidersToStore, boolean overwrite)` Blocking version of `storeAsync(ProviderFormat, String, boolean)`.
`PartitionedGraphConfig`	`store(ProviderFormat targetFormat, java.lang.String targetBasePath, java.util.Set<java.lang.String> vertexProvidersToStore, java.util.Set<java.lang.String> edgeProvidersToStore, java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, boolean overwrite)` Blocking version of `storeAsync(ProviderFormat, String, Set, Set, Collection, Collection, boolean)`.
`PgxFuture<FileGraphConfig>`	`storeAsync(Format targetFormat, FileGraphStoringConfig storingConfig)` Stores this graph in a given file format in multiple partitions on a file system.
`PgxFuture<FileGraphConfig>`	`storeAsync(Format targetFormat, FileGraphStoringConfig storingConfig, boolean overwrite)` Stores this graph in a given file format in multiple partitions on a file system.
`PgxFuture<FileGraphConfig>`	`storeAsync(Format targetFormat, FileGraphStoringConfig storingConfig, java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, boolean overwrite)` Stores this graph in a given file format in multiple partitions on a file system.
`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<FileGraphConfig>`	`storeAsync(Format targetFormat, java.lang.String targetBasePath, int numPartitions)` Stores this graph in a given file format in multiple partitions on a file system.
`PgxFuture<FileGraphConfig>`	`storeAsync(Format targetFormat, java.lang.String targetBasePath, int numPartitions, boolean overwrite)` Stores this graph in a given file format in multiple partitions on a file system.
`PgxFuture<FileGraphConfig>`	`storeAsync(Format targetFormat, java.lang.String targetBasePath, int numPartitions, java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, boolean overwrite)` Stores this graph in a given file format in multiple partitions on a file system.
`PgxFuture<GraphConfig>`	`storeAsync(GraphConfig targetConfig, boolean overwrite)` Stores this graph in a file or database.
`PgxFuture<GraphConfig>`	`storeAsync(GraphConfig targetConfig, java.util.Set<java.lang.String> vertexProvidersToStore, java.util.Set<java.lang.String> edgeProvidersToStore, boolean overwrite)` Stores this graph in a file or database.
`PgxFuture<PartitionedGraphConfig>`	`storeAsync(ProviderFormat targetFormat, java.util.Map<java.lang.String,FileGraphStoringConfig> vertexStoringConfigs, java.util.Map<java.lang.String,FileGraphStoringConfig> edgeStoringConfigs)` Stores this graph in a given file format in multiple partitions on a file system.
`PgxFuture<PartitionedGraphConfig>`	`storeAsync(ProviderFormat targetFormat, java.util.Map<java.lang.String,FileGraphStoringConfig> vertexStoringConfigs, java.util.Map<java.lang.String,FileGraphStoringConfig> edgeStoringConfigs, boolean overwrite)` Stores this graph in a given file format in multiple partitions on a file system.
`PgxFuture<PartitionedGraphConfig>`	`storeAsync(ProviderFormat targetFormat, java.util.Map<java.lang.String,FileGraphStoringConfig> vertexStoringConfigs, java.util.Map<java.lang.String,FileGraphStoringConfig> edgeStoringConfigs, java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, boolean overwrite)` Stores this graph in a given file format in multiple partitions on a file system.
`PgxFuture<PartitionedGraphConfig>`	`storeAsync(ProviderFormat targetFormat, java.util.Set<java.lang.String> vertexProvidersToStore, java.util.Set<java.lang.String> edgeProvidersToStore, java.util.Map<java.lang.String,FileGraphStoringConfig> vertexStoringConfigs, java.util.Map<java.lang.String,FileGraphStoringConfig> edgeStoringConfigs, boolean overwrite)` Stores this graph in a given file format in multiple partitions on a file system.
`PgxFuture<PartitionedGraphConfig>`	`storeAsync(ProviderFormat targetFormat, java.util.Set<java.lang.String> vertexProvidersToStore, java.util.Set<java.lang.String> edgeProvidersToStore, java.util.Map<java.lang.String,FileGraphStoringConfig> vertexStoringConfigs, java.util.Map<java.lang.String,FileGraphStoringConfig> edgeStoringConfigs, java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, boolean overwrite)` Stores this graph in a given file format in multiple partitions on a file system.
`PgxFuture<PartitionedGraphConfig>`	`storeAsync(ProviderFormat targetFormat, java.lang.String targetBasePath)` Stores this graph in a given file format on a file system.
`PgxFuture<PartitionedGraphConfig>`	`storeAsync(ProviderFormat targetFormat, java.lang.String targetBasePath, boolean overwrite)` Stores this graph in a given file format on a file system.
`PgxFuture<PartitionedGraphConfig>`	`storeAsync(ProviderFormat targetFormat, java.lang.String targetBasePath, 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<PartitionedGraphConfig>`	`storeAsync(ProviderFormat targetFormat, java.lang.String targetBasePath, int numPartitions)` Stores this graph in a given file format in multiple partitions on a file system.
`PgxFuture<PartitionedGraphConfig>`	`storeAsync(ProviderFormat targetFormat, java.lang.String targetBasePath, int numPartitions, boolean overwrite)` Stores this graph in a given file format in multiple partitions on a file system.
`PgxFuture<PartitionedGraphConfig>`	`storeAsync(ProviderFormat targetFormat, java.lang.String targetBasePath, int numPartitions, java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, boolean overwrite)` Stores this graph in a given file format in multiple partitions on a file system.
`PgxFuture<PartitionedGraphConfig>`	`storeAsync(ProviderFormat targetFormat, java.lang.String targetBasePath, int numPartitions, java.util.Set<java.lang.String> vertexProvidersToStore, java.util.Set<java.lang.String> edgeProvidersToStore)` Stores this graph in a given file format in multiple partitions on a file system.
`PgxFuture<PartitionedGraphConfig>`	`storeAsync(ProviderFormat targetFormat, java.lang.String targetBasePath, int numPartitions, java.util.Set<java.lang.String> vertexProvidersToStore, java.util.Set<java.lang.String> edgeProvidersToStore, boolean overwrite)` Stores this graph in a given file format in multiple partitions on a file system.
`PgxFuture<PartitionedGraphConfig>`	`storeAsync(ProviderFormat targetFormat, java.lang.String targetBasePath, int numPartitions, java.util.Set<java.lang.String> vertexProvidersToStore, java.util.Set<java.lang.String> edgeProvidersToStore, java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, boolean overwrite)` Stores this graph in a given file format in multiple partitions on a file system.
`PgxFuture<PartitionedGraphConfig>`	`storeAsync(ProviderFormat targetFormat, java.lang.String targetBasePath, java.util.Set<java.lang.String> vertexProvidersToStore, java.util.Set<java.lang.String> edgeProvidersToStore)` Stores this graph in a given file format on a file system.
`PgxFuture<PartitionedGraphConfig>`	`storeAsync(ProviderFormat targetFormat, java.lang.String targetBasePath, java.util.Set<java.lang.String> vertexProvidersToStore, java.util.Set<java.lang.String> edgeProvidersToStore, boolean overwrite)` Stores this graph in a given file format on a file system.
`PgxFuture<PartitionedGraphConfig>`	`storeAsync(ProviderFormat targetFormat, java.lang.String targetBasePath, java.util.Set<java.lang.String> vertexProvidersToStore, java.util.Set<java.lang.String> edgeProvidersToStore, java.util.Collection<VertexProperty<?,?>> vertexProps, java.util.Collection<EdgeProperty<?>> edgeProps, boolean overwrite)` Stores this graph in a given file format on a file system.
`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 getId()
`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 getId()
`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 getId()
`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
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
  - addRedactionRule
```
public void addRedactionRule(PgxRedactionRuleConfig ruleConfig,
                             AuthorizationType type,
                             java.lang.String... names)
```
    Blocking version of addRedactionRule(PgxRedactionRuleConfig, AuthorizationType, String...) Calls addRedactionRuleAsync(PgxRedactionRuleConfig, AuthorizationType, String...) )} and waits for the returned PgxFuture to complete.
  - addRedactionRuleAsync
```
public PgxFuture<java.lang.Void> addRedactionRuleAsync(PgxRedactionRuleConfig ruleConfig,
                                                       AuthorizationType type,
                                                       java.lang.String... names)
```
    Add a redaction rule configuration for an AuthorizationType names.
    
    Parameters:
    
    ruleConfig - the rule configuration to add for given names
    
    type - the type of the @link #AuthorizationType
    
    names - the AuthorizationType users to whom the rule configuration will be added
  - alterGraph
```
public GraphAlterationBuilder alterGraph()
```
    Create a graph alteration builder to define the graph schema alterations to perform on the graph
    
    Returns:
    
    an empty graph alteration builder
    
    Since:
    
    20.1
  - 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 that should be kept in the mutated graph. Constants VertexProperty.ALL or VertexProperty.NONE can be used.
    
    edgeProps - edge properties that should be kept in the mutated graph. 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
  - clone
```
public PgxGraph clone(java.util.Collection<VertexProperty<?,?>> vertexProps,
                      java.util.Collection<EdgeProperty<?>> edgeProps,
                      java.lang.String newGraphName)
```
    Blocking version of cloneAsync(). Calls cloneAsync() and waits for the returned PgxFuture to complete.
  - clone
```
public PgxGraph clone(java.lang.String newGraphName)
```
    Blocking version of cloneAsync(String). Calls cloneAsync(String) and waits for the returned PgxFuture to complete.
  - cloneAndExecutePgql
```
public PgxGraph cloneAndExecutePgql(java.lang.String pgqlString)
                             throws java.util.concurrent.ExecutionException,
                                    java.lang.InterruptedException
```
    (BETA) Blocking version of cloneAndExecutePgqlAsync(String). Calls cloneAndExecutePgqlAsync(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.
    
    Since:
    
    19.1
  - cloneAndExecutePgql
```
public PgxGraph cloneAndExecutePgql(java.lang.String pgqlString,
                                    java.lang.String graphName)
                             throws java.util.concurrent.ExecutionException,
                                    java.lang.InterruptedException
```
    (BETA) Blocking version of cloneAndExecutePgqlAsync(String, String). Calls cloneAndExecutePgqlAsync(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.
    
    Since:
    
    19.1
  - cloneAndExecutePgqlAsync
```
public PgxFuture<PgxGraph> cloneAndExecutePgqlAsync(java.lang.String pgqlString)
```
    (BETA) Convenience method of cloneAndExecutePgqlAsync(String, String)
    Passing
    - String(name) as null
    Parameters:
    
    pgqlString - query string in PGQL
    
    Returns:
    
    resulting graph
    
    Since:
    
    19.1
  - cloneAndExecutePgqlAsync
```
public PgxFuture<PgxGraph> cloneAndExecutePgqlAsync(java.lang.String pgqlString,
                                                    java.lang.String newGraphName)
```
    (BETA) Convenience method for executing cloneAsync(String) on a graph and executePgqlAsync(String) on its result
    
    Parameters:
    
    pgqlString - query string in PGQL
    
    newGraphName - name of the new graph. If null, a name will be generated.
    
    Returns:
    
    resulting graph
    
    Since:
    
    19.1
  - 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 deep copy of this graph. The resulting graph will be a session-private, full 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 . 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 . 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> 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). Calls createAllPathsAsync(PgxVertex, EdgeProperty, VertexProperty, VertexProperty, VertexProperty) and waits for the returned PgxFuture to complete.
  - 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 using IdGenerationStrategy.AUTO_GENERATED for edge ID generation strategy Note: This is currently not supported for undirected graphs.
    
    Returns:
    
    an empty change set
  - createChangeSet
```
public <ID extends java.lang.Comparable<ID>> GraphChangeSet<ID> createChangeSet(IdGenerationStrategy vertexIdGenerationStrategy,
                                                                                IdGenerationStrategy edgeIdGenerationStrategy)
```
    Creates a change set for updating the graph. Note: This is currently not supported for undirected graphs.
    
    Parameters:
    
    vertexIdGenerationStrategy - the vertices Id generation strategy to be used
    
    edgeIdGenerationStrategy - the edges Id generation strategy to be used
    
    Returns:
    
    an empty change set
    
    Since:
    
    3.1.0
  - createComponents
```
public <ID> Partition<ID> createComponents(VertexProperty<ID,java.lang.Long> components,
                                           long numComponents)
```
    Blocking version of createComponentsAsync(VertexProperty, long). Calls createComponentsAsync(VertexProperty, long) and waits for returned PgxFuture to complete.
  - 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)
```
    Blocking version of createEdgePropertyAsync(PropertyType). Calls createEdgePropertyAsync(PropertyType) and waits for returned PgxFuture to complete.
  - createEdgeProperty
```
public <V> EdgeProperty<V> createEdgeProperty(PropertyType type,
                                              int dimension,
                                              java.lang.String name,
                                              boolean hardName)
```
    Blocking version of createEdgePropertyAsync(PropertyType, int, String, boolean). Calls createEdgePropertyAsync(PropertyType, int, String, boolean) and waits for returned PgxFuture to complete.
  - createEdgeProperty
```
public <V> EdgeProperty<V> createEdgeProperty(PropertyType type,
                                              java.lang.String name)
```
    Blocking version of createEdgePropertyAsync(PropertyType, String). Calls createEdgePropertyAsync(PropertyType, String) and waits for returned PgxFuture to complete.
  - 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()
```
    Blocking version of createEdgeSequenceAsync(). Calls createEdgeSequenceAsync() and waits for returned PgxFuture to complete.
  - createEdgeSequence
```
public EdgeSequence createEdgeSequence(java.lang.String name)
```
    Blocking version of createEdgeSequenceAsync(String). Calls createEdgeSequenceAsync(String) and waits for returned PgxFuture to complete.
  - 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()
```
    Blocking version of createEdgeSetAsync(). Calls createEdgeSetAsync() and waits for the returned PgxFuture to complete.
  - createEdgeSet
```
public EdgeSet createEdgeSet(java.lang.String name)
```
    Blocking version of createEdgeSetAsync(String). Calls createEdgeSetAsync(String) and waits for the returned PgxFuture to complete.
  - 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)
```
    Blocking version of createEdgeVectorPropertyAsync(PropertyType, int). Calls createEdgeVectorPropertyAsync(PropertyType, int) and waits for returned PgxFuture to complete.
  - createEdgeVectorProperty
```
public <V> EdgeProperty<PgxVect<V>> createEdgeVectorProperty(PropertyType type,
                                                             int dimension,
                                                             java.lang.String name)
```
    Blocking version of createEdgeVectorPropertyAsync(PropertyType, int, String). Calls createEdgeVectorPropertyAsync(PropertyType, int, String) and waits for returned PgxFuture to complete.
  - 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)
```
    Blocking version of createMapAsync(PropertyType, PropertyType). Calls createMapAsync(PropertyType, PropertyType) and waits for the returned PgxFuture to complete.
  - createMap
```
public <K,V> PgxMap<K,V> createMap(PropertyType keyType,
                                   PropertyType valType,
                                   java.lang.String mapName)
```
    Blocking version of createMapAsync(PropertyType, PropertyType, String). Calls createMapAsync(PropertyType, PropertyType, String) and waits for the returned PgxFuture to complete.
  - 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)
```
    Blocking version of createPathAsync(PgxVertex, PgxVertex, EdgeProperty, VertexProperty, VertexProperty). Calls createPathAsync(PgxVertex, PgxVertex, EdgeProperty, VertexProperty, VertexProperty) and waits for the returned PgxFuture to complete.
  - 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.
  - createPathAsync
```
public <ID> PgxFuture<PgxPath<ID>> createPathAsync(VertexSequence<ID> nodeSequence,
                                                   EdgeSequence edgeSequence)
```
    Creates a PgxPath object from a sequence of vertices and edges.
    
    Parameters:
    
    nodeSequence - the vertices to be used for the path creation
    
    edgeSequence - the edges to be used for the path creation
    
    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)
```
    Blocking version of createScalarAsync(PropertyType). Calls createScalarAsync(PropertyType) and waits for the returned PgxFuture to complete.
  - createScalar
```
public <T> Scalar<T> createScalar(PropertyType type,
                                  java.lang.String newScalarName)
```
    Blocking version of createScalarAsync(PropertyType, String). Calls createScalarAsync(PropertyType, String) and waits for the returned PgxFuture to complete.
  - 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)
```
    Blocking version of createVectorScalarAsync(PropertyType, int). Calls createVectorScalarAsync(PropertyType, int) and waits for the returned PgxFuture to complete.
  - createVectorScalar
```
public <T> Scalar<PgxVect<T>> createVectorScalar(PropertyType type,
                                                 int dimension,
                                                 java.lang.String newScalarName)
```
    Blocking version of createVectorScalarAsync(PropertyType, int, String). Calls createVectorScalarAsync(PropertyType, int, String) and waits for the returned PgxFuture to complete.
  - 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)
```
    Blocking version of createVertexPropertyAsync(PropertyType). Calls createVertexPropertyAsync(PropertyType) and waits for returned PgxFuture to complete.
  - createVertexProperty
```
public <ID,V> VertexProperty<ID,V> createVertexProperty(PropertyType type,
                                                        int dimension,
                                                        java.lang.String name,
                                                        boolean hardName)
```
    Blocking version of createVertexPropertyAsync(PropertyType, int, String, boolean). Calls createVertexPropertyAsync(PropertyType, int, String, boolean) and waits for returned PgxFuture to complete.
  - createVertexProperty
```
public <ID,V> VertexProperty<ID,V> createVertexProperty(PropertyType type,
                                                        java.lang.String name)
```
    Blocking version of createVertexPropertyAsync(PropertyType, String). Calls createVertexPropertyAsync(PropertyType, String) and waits for returned PgxFuture to complete.
  - 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()
```
    Blocking version of createVertexSequenceAsync(). Calls createVertexSequenceAsync() and waits for returned PgxFuture to complete.
  - createVertexSequence
```
public <E> VertexSequence<E> createVertexSequence(java.lang.String name)
```
    Blocking version of createVertexSequenceAsync(String). Calls createVertexSequenceAsync(String) and waits for returned PgxFuture to complete.
  - 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()
```
    Blocking version of createVertexSetAsync(). Calls createVertexSetAsync() and waits for returned PgxFuture to complete.
  - createVertexSet
```
public <E> VertexSet<E> createVertexSet(java.lang.String name)
```
    Blocking version of createVertexSetAsync(String). Calls createVertexSetAsync(String) and waits for returned PgxFuture to complete.
  - 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)
```
    Blocking version of createVertexVectorPropertyAsync(PropertyType, int). Calls createVertexVectorPropertyAsync(PropertyType, int) and waits for returned PgxFuture to complete.
  - createVertexVectorProperty
```
public <ID,V> VertexProperty<ID,PgxVect<V>> createVertexVectorProperty(PropertyType type,
                                                                       int dimension,
                                                                       java.lang.String name)
```
    Blocking version of createVertexVectorPropertyAsync(PropertyType, int, String). Calls createVertexVectorPropertyAsync(PropertyType, int, String) and waits for returned PgxFuture to complete.
  - 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
  - destroy
```
public void destroy(PgxGraph.Retention retention)
```
    Blocking version of destroyAsync(boolean ignoreNotFound, Retention retention). Calls destroyAsync(boolean ignoreNotFound, Retention retention) and waits for the returned PgxFuture to complete.
  - destroyEdgePropertyIfExists
```
public void destroyEdgePropertyIfExists(java.lang.String name)
```
    Blocking version of destroyEdgePropertyIfExistsAsync(String). Calls destroyEdgePropertyIfExistsAsync(String) and waits for the returned PgxFuture to complete.
    
    Since:
    
    3.1.0
  - destroyEdgePropertyIfExistsAsync
```
public PgxFuture<java.lang.Void> destroyEdgePropertyIfExistsAsync(java.lang.String name)
```
    Destroys an edge property if it exists. Does nothing otherwise.
    
    Parameters:
    
    name - the name of the edge property to destroy
    
    Since:
    
    3.1.0
  - destroyVertexPropertyIfExists
```
public void destroyVertexPropertyIfExists(java.lang.String name)
```
    Blocking version of destroyVertexPropertyIfExistsAsync(String). Calls destroyVertexPropertyIfExistsAsync(String) and waits for the returned PgxFuture to complete.
    
    Since:
    
    3.1.0
  - destroyVertexPropertyIfExistsAsync
```
public PgxFuture<java.lang.Void> destroyVertexPropertyIfExistsAsync(java.lang.String name)
```
    Destroys a vertex property if it exists. Does nothing otherwise.
    
    Parameters:
    
    name - the name of the vertex property to destroy
    
    Since:
    
    3.1.0
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Overrides:
    
    equals in class PgxManagedObject
  - executePgql
```
public PgqlResultSet executePgql(java.lang.String pgqlString)
                          throws java.util.concurrent.ExecutionException,
                                 java.lang.InterruptedException
```
    (BETA) Blocking version of executePgqlAsync(String). Calls executePgqlAsync(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.
    
    Since:
    
    19.1
  - executePgqlAsync
```
public PgxFuture<PgqlResultSet> executePgqlAsync(java.lang.String pgqlString)
```
    (BETA) Submits a PGQL (both select and modify) query.
    
    Parameters:
    
    pgqlString - query string in PGQL
    
    Returns:
    
    the query result set
    
    Since:
    
    19.1
  - explainPgql
```
public Operation explainPgql(java.lang.String pgqlString)
                      throws java.util.concurrent.ExecutionException,
                             java.lang.InterruptedException
```
    Blocking version of explainPgql(String). Calls explainPgqlAsync(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.
  - explainPgqlAsync
```
public PgxFuture<Operation> explainPgqlAsync(java.lang.String pgqlString)
```
    Explain the execution plan of a pattern matching query. Note: Different PGX versions may return different execution plans.
    
    Parameters:
    
    pgqlString - query string in PGQL
    
    Returns:
    
    the query plan
  - 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 that should be kept in the mutated graph. Constants VertexProperty.ALL or VertexProperty.NONE can be used.
    
    edgeProps - edge properties that should be kept in the mutated graph. 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
  - getCollections
```
public java.util.Map<java.lang.String,PgxCollection<? extends PgxEntity<?>,?>> getCollections()
```
    Blocking version of getCollectionsAsync(). Calls getCollectionsAsync() and waits for returned PgxFuture to complete.
  - getCollectionsAsync
```
public PgxFuture<java.util.Map<java.lang.String,PgxCollection<? extends PgxEntity<?>,?>>> getCollectionsAsync()
```
    Retrieves all currently allocated collections associated with the graph.
    
    Returns:
    
    a map that contains all collections of this graph as values and their names as keys
  - 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)
```
    Blocking version of getEdgeAsync(long) Calls getEdgeAsync(long) and waits for the returned PgxFuture to complete.
  - 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
  - getEdgeIdStrategy
```
public IdStrategy getEdgeIdStrategy()
```
    Gets the ID strategy used for the edges of this graph.
    
    Returns:
    
    the edge ID strategy.
  - getEdgeLabel
```
public EdgeLabel getEdgeLabel()
```
    Blocking version of getEdgeLabelAsync(). Calls getEdgeLabelAsync() and waits for the returned PgxFuture to complete.
  - 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()
```
    Blocking version of getEdgePropertiesAsync(). Calls getEdgePropertiesAsync() and waits for returned PgxFuture to complete.
  - getEdgePropertiesAsync
```
public PgxFuture<java.util.Set<EdgeProperty<?>>> getEdgePropertiesAsync()
```
    Get the set of edge properties belonging to this graph. This list might contain transient, private and published properties.
    
    Returns:
    
    all edge properties of this graph
  - getEdgeProperty
```
public <V> EdgeProperty<V> getEdgeProperty(Namespace namespace,
                                           java.lang.String name)
```
    Blocking version of getEdgePropertyAsync(Namespace, String). Calls getEdgePropertyAsync(Namespace, String) and waits for returned PgxFuture to complete.
  - getEdgeProperty
```
public <V> EdgeProperty<V> getEdgeProperty(java.lang.String name)
```
    Blocking version of getEdgePropertyAsync(String). Calls getEdgePropertyAsync(String) and waits for returned PgxFuture to complete.
  - getEdgePropertyAsync
```
public <V> PgxFuture<EdgeProperty<V>> getEdgePropertyAsync(Namespace namespace,
                                                           java.lang.String name)
```
    Gets an edge property of this graph in the given namespace. If the namespace is null, use same semantics as getEdgePropertyAsync(String)
    
    Parameters:
    
    namespace - the namespace in which to look up the property. Can be null, which implies same behavior as getEdgePropertyAsync(String)
    
    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
  - getEdgePropertyAsync
```
public <V> PgxFuture<EdgeProperty<V>> getEdgePropertyAsync(java.lang.String name)
```
    Gets an edge property of this graph The property will be first looked up in the session private namespace, if it is not found there it will be looked up in the public namespace. If a property with the given name is not found in either the private or public namespace, null is returned.
    
    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()
```
    Blocking version of getEdges(). Calls getEdgesAsync() and waits for returned PgxFuture to complete.
  - getEdges
```
public EdgeSet getEdges(EdgeFilter filter)
                 throws java.lang.InterruptedException,
                        java.util.concurrent.ExecutionException
```
    Blocking version of getEdges(EdgeFilter). Calls getEdgesAsync(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.
  - getEdges
```
public EdgeSet getEdges(EdgeFilter filter,
                        java.lang.String name)
                 throws java.lang.InterruptedException,
                        java.util.concurrent.ExecutionException
```
    Blocking version of getEdges(EdgeFilter, String). Calls getEdgesAsync(EdgeFilter, 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.
  - 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
  - getEdgesAsync
```
public PgxFuture<EdgeSet> getEdgesAsync(EdgeFilter filter,
                                        java.lang.String name)
```
    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
    
    name - the name of the collection to be created. If NULL, a name will be generated.
    
    Returns:
    
    newly created edge set
  - getId
```
public final oracle.pgx.common.PgxId getId()
```
    Returns an internal identifier for this graph snapshot. Only meant for internal usage.
    
    Returns:
    
    the internal identifier of this graph snapshot
    
    Since:
    
    19.4
  - 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
  - getOrCreateEdgeProperty
```
public <V> EdgeProperty<V> getOrCreateEdgeProperty(PropertyType type,
                                                   java.lang.String name)
```
    Blocking version of getOrCreateEdgePropertyAsync(PropertyType, String). Calls getOrCreateEdgePropertyAsync(PropertyType, String) and waits for returned PgxFuture to complete.
    
    Since:
    
    3.1.0
  - getOrCreateEdgePropertyAsync
```
public <V> PgxFuture<EdgeProperty<V>> getOrCreateEdgePropertyAsync(PropertyType type,
                                                                   java.lang.String name)
```
    Gets or creates an edge property
    
    Parameters:
    
    type - type of property to create
    
    name - of property to be created
    
    Returns:
    
    newly created property if edge property with given name does not exist, the already existent edge property otherwise
    
    Since:
    
    3.1.0
  - getOrCreateEdgeVectorProperty
```
public <V> EdgeProperty<PgxVect<V>> getOrCreateEdgeVectorProperty(PropertyType type,
                                                                  int dimension,
                                                                  java.lang.String name)
```
    Blocking version of getOrCreateEdgeVectorPropertyAsync(PropertyType, int, String). Calls getOrCreateEdgeVectorPropertyAsync(PropertyType, int, String) and waits for returned PgxFuture to complete.
    
    Since:
    
    3.1.0
  - getOrCreateEdgeVectorPropertyAsync
```
public <V> PgxFuture<EdgeProperty<PgxVect<V>>> getOrCreateEdgeVectorPropertyAsync(PropertyType type,
                                                                                  int dimension,
                                                                                  java.lang.String name)
```
    Gets or creates an edge vector property
    
    Parameters:
    
    type - type of property to create
    
    name - of property to be created
    
    Returns:
    
    newly created property if vector edge property with given name does not exist, the already existent edge vector property otherwise
    
    Since:
    
    3.1.0
  - getOrCreateEdgeVertexPropertyAsync
```
public <V> PgxFuture<EdgeProperty<PgxVect<V>>> getOrCreateEdgeVertexPropertyAsync(PropertyType type,
                                                                                  int dimension,
                                                                                  java.lang.String name)
```
    Gets or creates an edge vector property
    
    Parameters:
    
    type - type of property to create
    
    name - of property to be created
    
    Returns:
    
    newly created property if edge vector property with given name does not exist, the already existent edge vector property otherwise
    
    Since:
    
    3.1.0
  - getOrCreateVertexProperty
```
public <ID,V> VertexProperty<ID,V> getOrCreateVertexProperty(PropertyType type,
                                                             java.lang.String name)
```
    Blocking version of getOrCreateVertexPropertyAsync(PropertyType, String). Calls getOrCreateVertexPropertyAsync(PropertyType, String) and waits for returned PgxFuture to complete.
    
    Since:
    
    3.1.0
  - getOrCreateVertexPropertyAsync
```
public <ID,V> PgxFuture<VertexProperty<ID,V>> getOrCreateVertexPropertyAsync(PropertyType type,
                                                                             java.lang.String name)
```
    Gets or creates a vertex property
    
    Parameters:
    
    type - type of property to create
    
    name - of property to be created
    
    Returns:
    
    newly created property if vertex property with given name does not exist, the already existent vertex property otherwise
    
    Since:
    
    3.1.0
  - getOrCreateVertexVectorProperty
```
public <ID,V> VertexProperty<ID,PgxVect<V>> getOrCreateVertexVectorProperty(PropertyType type,
                                                                            int dimension,
                                                                            java.lang.String name)
```
    Blocking version of getOrCreateVertexVectorPropertyAsync(PropertyType, int, String). Calls getOrCreateVertexVectorPropertyAsync(PropertyType, int, String) and waits for returned PgxFuture to complete.
    
    Since:
    
    3.1.0
  - getOrCreateVertexVectorPropertyAsync
```
public <ID,V> PgxFuture<VertexProperty<ID,PgxVect<V>>> getOrCreateVertexVectorPropertyAsync(PropertyType type,
                                                                                            int dimension,
                                                                                            java.lang.String name)
```
    Gets or creates a vertex vector property
    
    Parameters:
    
    type - type of property to create
    
    name - of property to be created
    
    Returns:
    
    newly created property if vector vertex property with given name does not exist, the already existent vertex vector property otherwise
    
    Since:
    
    3.1.0
  - getPgxInstance
```
public ServerInstance getPgxInstance()
```
    Gets the server instance.
    
    Returns:
    
    the instance this graph belongs to.
  - getRandomEdge
```
public PgxEdge getRandomEdge()
```
    Blocking version of getRandomEdgeAsync(). Calls getRandomEdgeAsync() and waits for returned PgxFuture to complete.
  - getRandomEdgeAsync
```
public PgxFuture<PgxEdge> getRandomEdgeAsync()
```
    Picks a random edge in the graph.
    
    Returns:
    
    a random edge.
    
    Since:
    
    2.5.0
  - getRandomVertex
```
public <ID> PgxVertex<ID> getRandomVertex()
```
    Blocking version of getRandomVertexAsync(). Calls getRandomVertexAsync() and waits for returned PgxFuture to complete.
    
    Since:
    
    2.5.0
  - getRandomVertexAsync
```
public <ID> PgxFuture<PgxVertex<ID>> getRandomVertexAsync()
```
    Picks a random vertex in the graph.
    
    Returns:
    
    a random vertex.
    
    Since:
    
    2.5.0
  - getRedactionRules
```
public java.util.List<PgxRedactionRuleConfig> getRedactionRules(AuthorizationType type,
                                                                java.lang.String name)
```
    Blocking version of getRedactionRules(AuthorizationType, String) Calls getRedactionRulesAsync(AuthorizationType, String) )} and waits for the returned PgxFuture to complete.
  - getRedactionRulesAsync
```
public PgxFuture<java.util.List<PgxRedactionRuleConfig>> getRedactionRulesAsync(AuthorizationType type,
                                                                                java.lang.String name)
```
    Gets redaction rules for an AuthorizationType name.
    
    Parameters:
    
    type - the type of the @link #AuthorizationType
    
    name - the AuthorizationType user from whom rules will be returned
  - getSession
```
public PgxSession getSession()
```
    Gets the session.
    
    Returns:
    
    the session this graph belongs to.
  - getVertex
```
public <ID> PgxVertex<ID> getVertex(ID id)
```
    Blocking version of getVertexAsync(Object). Calls getVertexAsync(Object) and waits for the returned PgxFuture to complete.
  - 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
  - getVertexIdStrategy
```
public IdStrategy getVertexIdStrategy()
```
    Gets the ID strategy used for the vertices of this graph.
    
    Returns:
    
    the vertex ID strategy.
  - getVertexIdType
```
public IdType getVertexIdType()
```
    Gets the vertex ID type of this graph.
    
    Returns:
    
    the vertex ID type.
  - getVertexLabels
```
public <ID> VertexLabels<ID> getVertexLabels()
```
    Blocking version of getVertexLabelsAsync(). Calls getVertexLabelsAsync() and waits for the returned PgxFuture to complete.
  - 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()
```
    Blocking version of getVertexPropertiesAsync(). Calls getVertexPropertiesAsync() and waits for returned PgxFuture to complete.
  - getVertexPropertiesAsync
```
public PgxFuture<java.util.Set<VertexProperty<?,?>>> getVertexPropertiesAsync()
```
    Get the set of vertex properties belonging to this graph. This list might contain transient, private and published properties.
    
    Returns:
    
    all vertex properties of this graph
  - getVertexProperty
```
public <ID,V> VertexProperty<ID,V> getVertexProperty(Namespace namespace,
                                                     java.lang.String name)
```
    Blocking version of getVertexPropertyAsync(Namespace, String). Calls getVertexPropertyAsync(Namespace, String) and waits for returned PgxFuture to complete.
  - getVertexProperty
```
public <ID,V> VertexProperty<ID,V> getVertexProperty(java.lang.String name)
```
    Blocking version of getVertexPropertyAsync(String). Calls getVertexPropertyAsync(String) and waits for returned PgxFuture to complete.
  - getVertexPropertyAsync
```
public <ID,V> PgxFuture<VertexProperty<ID,V>> getVertexPropertyAsync(Namespace namespace,
                                                                     java.lang.String name)
```
    Gets a vertex property of this graph in the given namespace. If the namespace is null, use same semantics as getVertexPropertyAsync(String)
    
    Parameters:
    
    namespace - the namespace in which to look up the property. Can be null, which implies same behavior as getVertexPropertyAsync(String)
    
    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
  - getVertexPropertyAsync
```
public <ID,V> PgxFuture<VertexProperty<ID,V>> getVertexPropertyAsync(java.lang.String name)
```
    Gets a vertex property of this graph. The property will be first looked up in the session private namespace, if it is not found there it will be looked up in the public namespace. If a property with the given name is not found in either the private or public namespace, null is returned.
    
    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()
```
    Blocking version of getVerticesAsync(). Calls getVerticesAsync() and waits for returned PgxFuture to complete.
  - 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
  - grantPermission
```
public void grantPermission(oracle.pgx.common.auth.PgxRole role,
                            oracle.pgx.common.auth.PgxResourcePermission permission)
```
    Blocking version of grantPermissionAsync(PgxRole, PgxResourcePermission). Calls grantPermissionAsync(PgxRole, PgxResourcePermission) and waits for the returned PgxFuture to complete.
    
    Since:
    
    20.1.0
  - grantPermission
```
public void grantPermission(oracle.pgx.common.auth.PgxUser user,
                            oracle.pgx.common.auth.PgxResourcePermission permission)
```
    Blocking version of grantPermissionAsync(PgxUser, PgxResourcePermission). Calls grantPermissionAsync(PgxUser, PgxResourcePermission) and waits for the returned PgxFuture to complete.
    
    Since:
    
    20.1.0
  - grantPermissionAsync
```
public PgxFuture<java.lang.Void> grantPermissionAsync(oracle.pgx.common.auth.PgxRole role,
                                                      oracle.pgx.common.auth.PgxResourcePermission permission)
```
    Grants a permission on this graph to the given role. Cannot grant PgxResourcePermission.MANAGE.
    
    Parameters:
    
    role - the role the permission is granted to
    
    permission - the permission
    
    Since:
    
    20.1.0
  - grantPermissionAsync
```
public PgxFuture<java.lang.Void> grantPermissionAsync(oracle.pgx.common.auth.PgxUser user,
                                                      oracle.pgx.common.auth.PgxResourcePermission permission)
```
    Grants a permission on this graph to the given user. Cannot grant PgxResourcePermission.MANAGE.
    
    Parameters:
    
    user - the user the permission is granted to
    
    permission - the permission
    
    Since:
    
    20.1.0
  - hasEdge
```
public boolean hasEdge(long id)
```
    Blocking version of hasEdgeAsync(long) Calls hasEdgeAsync(long) and waits for the returned PgxFuture to complete.
  - 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
  - hasEdgeLabel
```
public boolean hasEdgeLabel()
```
    Blocking version of hasEdgeLabelAsync(). Calls hasEdgeLabelAsync() and waits for returned PgxFuture to complete.
  - hasEdgeLabelAsync
```
public PgxFuture<java.lang.Boolean> hasEdgeLabelAsync()
```
    Returns:
    
    true if the graph has edge labels, false if not
  - hasVertex
```
public <ID> boolean hasVertex(ID id)
```
    Blocking version of hasVertexAsync(Object). Calls hasVertexAsync(Object) and waits for the returned PgxFuture to complete.
  - 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
  - hasVertexLabels
```
public boolean hasVertexLabels()
```
    Blocking version of hasVertexLabelsAsync(). Calls hasVertexLabelsAsync() and waits for returned PgxFuture to complete.
  - hasVertexLabelsAsync
```
public PgxFuture<java.lang.Boolean> hasVertexLabelsAsync()
```
    Returns:
    
    true if the graph has vertex labels, false if not
  - 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
  - isPublished
```
public boolean isPublished()
```
    Blocking version of isPublishedAsync(). Calls isPublishedAsync() and waits for returned PgxFuture to complete.
  - isPublishedAsync
```
public PgxFuture<java.lang.Boolean> isPublishedAsync()
```
    Checks if this graph is published.
    
    Returns:
    
    true if this graph is published, false otherwise.
  - isPublishedWithSnapshots
```
public boolean isPublishedWithSnapshots()
```
    Blocking version of isPublishedWithSnapshotsAsync(). Calls isPublishedWithSnapshotsAsync() and waits for returned PgxFuture to complete.
  - isPublishedWithSnapshotsAsync
```
public PgxFuture<java.lang.Boolean> isPublishedWithSnapshotsAsync()
```
    Checks if this graph is published with snapshots.
    
    Returns:
    
    true if this graph is published, 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.
  - preparePgql
```
public PgxPreparedStatement preparePgql(java.lang.String pgqlString)
```
    Blocking version of preparePgql(String). Calls preparePgqlAsync(String) and waits for the returned PgxFuture to complete.
  - preparePgqlAsync
```
public PgxFuture<PgxPreparedStatement> preparePgqlAsync(java.lang.String pgqlString)
```
    Prepares a pattern matching select only query.
    
    Parameters:
    
    pgqlString - query string in PGQL
    
    Returns:
    
    a prepared statement object
  - publish
```
public void publish()
```
    Blocking version of publishAsync(). Calls publishAsync() and waits for returned PgxFuture to complete.
  - publish
```
public void publish(java.util.Collection<VertexProperty<?,?>> vertexProps,
                    java.util.Collection<EdgeProperty<?>> edgeProps)
```
  - publishAsync
```
public PgxFuture<java.lang.Void> publishAsync()
```
    Publishes the graph so it can be shared between sessions. This moves the graph name from the private into the public namespace.
  - publishAsync
```
public PgxFuture<java.lang.Void> publishAsync(java.util.Collection<VertexProperty<?,?>> vertexProps,
                                              java.util.Collection<EdgeProperty<?>> edgeProps)
```
    Publishes the graph so It can be shared between sessions. This moves the graph name from the private into the public namespace.
    
    Parameters:
    
    vertexProps - list of vertex properties belonging to graph specified by graph to be published as well. Constants Properties.ALL or Properties.NONE can be used.
    
    edgeProps - list of edge properties belonging to graph specified by graph to be published as well. Constants Properties.ALL or Properties.NONE can be used.
  - publishWithSnapshots
```
public void publishWithSnapshots()
```
    Blocking version of publishWithSnapshotsAsync() . Calls publishWithSnapshotsAsync() and waits for returned PgxFuture to complete.
  - publishWithSnapshots
```
public void publishWithSnapshots(java.util.Collection<VertexProperty<?,?>> vertexProps,
                                 java.util.Collection<EdgeProperty<?>> edgeProps)
```
    Blocking version of publishWithSnapshotsAsync(Collection, Collection). Calls publishWithSnapshotsAsync(Collection, Collection) and waits for returned PgxFuture to complete.
  - publishWithSnapshotsAsync
```
public PgxFuture<java.lang.Void> publishWithSnapshotsAsync()
```
    Publishes the graph and all its snapshots so they can be shared between sessions.
  - publishWithSnapshotsAsync
```
public PgxFuture<java.lang.Void> publishWithSnapshotsAsync(java.util.Collection<VertexProperty<?,?>> vertexProps,
                                                           java.util.Collection<EdgeProperty<?>> edgeProps)
```
    Publishes the graph and all its snapshots so they can be shared between sessions. This moves the graph name from the private into the public namespace.
    
    Parameters:
    
    vertexProps - list of vertex properties belonging to graph specified by graph to be published as well. Constants Properties.ALL or Properties.NONE can be used.
    
    edgeProps - list of edge properties belonging to graph specified by graph to be published as well. Constants Properties.ALL or Properties.NONE can be used.
  - queryPgql
```
public PgqlResultSet queryPgql(java.lang.String pgqlString)
                        throws java.util.concurrent.ExecutionException,
                               java.lang.InterruptedException
```
    Blocking version of queryPgql(String). Calls queryPgqlAsync(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.
  - queryPgqlAsync
```
public PgxFuture<PgqlResultSet> queryPgqlAsync(java.lang.String pgqlString)
```
    Submits a pattern matching select only query.
    
    Parameters:
    
    pgqlString - query string in PGQL
    
    Returns:
    
    the query result set
  - removeRedactionRule
```
public void removeRedactionRule(PgxRedactionRuleConfig ruleConfig,
                                AuthorizationType type,
                                java.lang.String... names)
```
    Blocking version of removeRedactionRule(PgxRedactionRuleConfig, AuthorizationType, String...) Calls removeRedactionRuleAsync(PgxRedactionRuleConfig, AuthorizationType, String...) )} and waits for the returned PgxFuture to complete.
  - removeRedactionRuleAsync
```
public PgxFuture<java.lang.Void> removeRedactionRuleAsync(PgxRedactionRuleConfig ruleConfig,
                                                          AuthorizationType type,
                                                          java.lang.String... names)
```
    Removes a redaction rule for AuthorizationType names.
    
    Parameters:
    
    ruleConfig - the rule configuration to remove for given names
    
    type - the type of the @link #AuthorizationType
    
    names - the AuthorizationType users to whom the rule configuration will be removed
  - rename
```
public void rename(java.lang.String newGraphName)
```
    Blocking version of renameAsync(String). Calls renameAsync(String) and waits for the returned PgxFuture to complete.
  - renameAsync
```
public PgxFuture<java.lang.Void> renameAsync(java.lang.String newGraphName)
```
    Renames this graph.
    
    Parameters:
    
    newGraphName - the new name.
  - revokePermission
```
public void revokePermission(oracle.pgx.common.auth.PgxRole role)
```
    Blocking version of revokePermissionAsync(PgxRole). Calls revokePermissionAsync(PgxRole) and waits for the returned PgxFuture to complete.
    
    Since:
    
    20.1.0
  - revokePermission
```
public void revokePermission(oracle.pgx.common.auth.PgxUser user)
```
    Blocking version of revokePermissionAsync(PgxUser). Calls revokePermissionAsync(PgxUser) and waits for the returned PgxFuture to complete.
    
    Since:
    
    20.1.0
  - revokePermissionAsync
```
public PgxFuture<java.lang.Void> revokePermissionAsync(oracle.pgx.common.auth.PgxRole role)
```
    Revokes all permissions on this graph from the given role.
    
    Parameters:
    
    role - the role for which all permissions will be revoked from
    
    Since:
    
    20.1.0
  - revokePermissionAsync
```
public PgxFuture<java.lang.Void> revokePermissionAsync(oracle.pgx.common.auth.PgxUser user)
```
    Revokes all permissions on this graph from the given user.
    
    Parameters:
    
    user - the user for which all permissions will be revoked from
    
    Since:
    
    20.1.0
  - 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 getId()
    
    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 that should be kept in the mutated graph. Constants VertexProperty.ALL or VertexProperty.NONE can be used.
    
    edgeProps - edge properties that should be kept in the mutated graph. 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 that should be kept in the mutated graph. Constants VertexProperty.ALL or VertexProperty.NONE can be used.
    
    edgeProps - edge properties that should be kept in the mutated graph. 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,
                             FileGraphStoringConfig storingConfig)
                      throws java.util.concurrent.ExecutionException,
                             java.lang.InterruptedException
```
    Blocking version of storeAsync(Format, FileGraphStoringConfig). Calls storeAsync(Format, FileGraphStoringConfig) 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,
                             FileGraphStoringConfig storingConfig,
                             boolean overwrite)
                      throws java.util.concurrent.ExecutionException,
                             java.lang.InterruptedException
```
    Blocking version of storeAsync(Format, FileGraphStoringConfig, boolean). Calls storeAsync(Format, FileGraphStoringConfig, 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,
                             FileGraphStoringConfig storingConfig,
                             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, FileGraphStoringConfig, Collection, Collection, boolean). Calls storeAsync(Format, FileGraphStoringConfig, 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 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 FileGraphConfig store(Format targetFormat,
                             java.lang.String targetBasePath,
                             int numPartitions)
                      throws java.util.concurrent.ExecutionException,
                             java.lang.InterruptedException
```
    Blocking version of storeAsync(Format, String, int). Calls storeAsync(Format, String, 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.
  - store
```
public FileGraphConfig store(Format targetFormat,
                             java.lang.String targetBasePath,
                             int numPartitions,
                             boolean overwrite)
                      throws java.util.concurrent.ExecutionException,
                             java.lang.InterruptedException
```
    Blocking version of storeAsync(Format, String, int, boolean). Calls storeAsync(Format, String, int, 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 targetBasePath,
                             int numPartitions,
                             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, int, Collection, Collection, boolean). Calls storeAsync(Format, String, int, 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.
  - store
```
public GraphConfig store(GraphConfig targetConfig,
                         java.util.Set<java.lang.String> vertexProvidersToStore,
                         java.util.Set<java.lang.String> edgeProvidersToStore,
                         boolean overwrite)
                  throws java.util.concurrent.ExecutionException,
                         java.lang.InterruptedException
```
    Blocking version of storeAsync(GraphConfig, Set, Set, 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.
  - store
```
public PartitionedGraphConfig store(ProviderFormat targetFormat,
                                    java.util.Map<java.lang.String,FileGraphStoringConfig> vertexStoringConfigs,
                                    java.util.Map<java.lang.String,FileGraphStoringConfig> edgeStoringConfigs)
                             throws java.util.concurrent.ExecutionException,
                                    java.lang.InterruptedException
```
    Blocking version of storeAsync(ProviderFormat, Map, Map). Calls storeAsync(ProviderFormat, Map, Map) 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.
    
    Since:
    
    19.4.0
  - store
```
public PartitionedGraphConfig store(ProviderFormat targetFormat,
                                    java.util.Map<java.lang.String,FileGraphStoringConfig> vertexStoringConfigs,
                                    java.util.Map<java.lang.String,FileGraphStoringConfig> edgeStoringConfigs,
                                    boolean overwrite)
                             throws java.util.concurrent.ExecutionException,
                                    java.lang.InterruptedException
```
    Blocking version of storeAsync(ProviderFormat, Map, Map, boolean). Calls storeAsync(ProviderFormat, Map, Map, 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.
    
    Since:
    
    19.4.0
  - store
```
public PartitionedGraphConfig store(ProviderFormat targetFormat,
                                    java.util.Map<java.lang.String,FileGraphStoringConfig> vertexStoringConfigs,
                                    java.util.Map<java.lang.String,FileGraphStoringConfig> edgeStoringConfigs,
                                    java.util.Collection<VertexProperty<?,?>> vertexProps,
                                    java.util.Collection<EdgeProperty<?>> edgeProps,
                                    boolean overwrite)
                             throws java.util.concurrent.ExecutionException,
                                    java.lang.InterruptedException
```
    Blocking version of storeAsync(ProviderFormat, Map, Map, Collection, Collection, boolean). Calls storeAsync(ProviderFormat, Map, Map, 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.
    
    Since:
    
    19.4.0
  - store
```
public PartitionedGraphConfig store(ProviderFormat targetFormat,
                                    java.util.Set<java.lang.String> vertexProvidersToStore,
                                    java.util.Set<java.lang.String> edgeProvidersToStore,
                                    java.util.Map<java.lang.String,FileGraphStoringConfig> vertexStoringConfigs,
                                    java.util.Map<java.lang.String,FileGraphStoringConfig> edgeStoringConfigs,
                                    boolean overwrite)
                             throws java.util.concurrent.ExecutionException,
                                    java.lang.InterruptedException
```
    Blocking version of storeAsync(ProviderFormat, Set, Set, Map, Map, boolean). Calls storeAsync(ProviderFormat, Map, Map, 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.
    
    Since:
    
    20.1
  - store
```
public PartitionedGraphConfig store(ProviderFormat targetFormat,
                                    java.util.Set<java.lang.String> vertexProvidersToStore,
                                    java.util.Set<java.lang.String> edgeProvidersToStore,
                                    java.util.Map<java.lang.String,FileGraphStoringConfig> vertexStoringConfigs,
                                    java.util.Map<java.lang.String,FileGraphStoringConfig> edgeStoringConfigs,
                                    java.util.Collection<VertexProperty<?,?>> vertexProps,
                                    java.util.Collection<EdgeProperty<?>> edgeProps,
                                    boolean overwrite)
                             throws java.util.concurrent.ExecutionException,
                                    java.lang.InterruptedException
```
    Blocking version of storeAsync(ProviderFormat, Set, Set, Map, Map, Collection, Collection, boolean). Calls storeAsync(ProviderFormat, Map, Map, 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.
    
    Since:
    
    20.1
  - store
```
public PartitionedGraphConfig store(ProviderFormat targetFormat,
                                    java.lang.String targetBasePath)
                             throws java.util.concurrent.ExecutionException,
                                    java.lang.InterruptedException
```
    Blocking version of storeAsync(ProviderFormat, String). Calls storeAsync(ProviderFormat, 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.
    
    Since:
    
    19.4.0
  - store
```
public PartitionedGraphConfig store(ProviderFormat targetFormat,
                                    java.lang.String targetBasePath,
                                    boolean overwrite)
                             throws java.util.concurrent.ExecutionException,
                                    java.lang.InterruptedException
```
    Blocking version of storeAsync(ProviderFormat, 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.
    
    Since:
    
    19.4.0
  - store
```
public PartitionedGraphConfig store(ProviderFormat targetFormat,
                                    java.lang.String targetBasePath,
                                    java.util.Collection<VertexProperty<?,?>> vertexProps,
                                    java.util.Collection<EdgeProperty<?>> edgeProps,
                                    boolean overwrite)
                             throws java.util.concurrent.ExecutionException,
                                    java.lang.InterruptedException
```
    Blocking version of storeAsync(ProviderFormat, 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.
    
    Since:
    
    19.4.0
  - store
```
public PartitionedGraphConfig store(ProviderFormat targetFormat,
                                    java.lang.String targetBasePath,
                                    int numPartitions)
                             throws java.util.concurrent.ExecutionException,
                                    java.lang.InterruptedException
```
    Blocking version of storeAsync(ProviderFormat, String, int). Calls storeAsync(ProviderFormat, String, 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.
    
    Since:
    
    19.4.0
  - store
```
public PartitionedGraphConfig store(ProviderFormat targetFormat,
                                    java.lang.String targetBasePath,
                                    int numPartitions,
                                    boolean overwrite)
                             throws java.util.concurrent.ExecutionException,
                                    java.lang.InterruptedException
```
    Blocking version of storeAsync(ProviderFormat, String, int, boolean). Calls storeAsync(ProviderFormat, String, int, 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.
    
    Since:
    
    19.4.0
  - store
```
public PartitionedGraphConfig store(ProviderFormat targetFormat,
                                    java.lang.String targetBasePath,
                                    int numPartitions,
                                    java.util.Collection<VertexProperty<?,?>> vertexProps,
                                    java.util.Collection<EdgeProperty<?>> edgeProps,
                                    boolean overwrite)
                             throws java.util.concurrent.ExecutionException,
                                    java.lang.InterruptedException
```
    Blocking version of storeAsync(ProviderFormat, String, int, Collection, Collection, boolean). Calls storeAsync(ProviderFormat, String, int, 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.
    
    Since:
    
    19.4.0
  - store
```
public PartitionedGraphConfig store(ProviderFormat targetFormat,
                                    java.lang.String targetBasePath,
                                    int numPartitions,
                                    java.util.Set<java.lang.String> vertexProvidersToStore,
                                    java.util.Set<java.lang.String> edgeProvidersToStore)
                             throws java.util.concurrent.ExecutionException,
                                    java.lang.InterruptedException
```
    Blocking version of storeAsync(ProviderFormat, String, int, Set, Set). Calls storeAsync(ProviderFormat, String, 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.
    
    Since:
    
    20.1
  - store
```
public PartitionedGraphConfig store(ProviderFormat targetFormat,
                                    java.lang.String targetBasePath,
                                    int numPartitions,
                                    java.util.Set<java.lang.String> vertexProvidersToStore,
                                    java.util.Set<java.lang.String> edgeProvidersToStore,
                                    boolean overwrite)
                             throws java.util.concurrent.ExecutionException,
                                    java.lang.InterruptedException
```
    Blocking version of storeAsync(ProviderFormat, String, int, Set, Set, , boolean). Calls storeAsync(ProviderFormat, String, int, 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.
    
    Since:
    
    20.1
  - store
```
public PartitionedGraphConfig store(ProviderFormat targetFormat,
                                    java.lang.String targetBasePath,
                                    int numPartitions,
                                    java.util.Set<java.lang.String> vertexProvidersToStore,
                                    java.util.Set<java.lang.String> edgeProvidersToStore,
                                    java.util.Collection<VertexProperty<?,?>> vertexProps,
                                    java.util.Collection<EdgeProperty<?>> edgeProps,
                                    boolean overwrite)
                             throws java.util.concurrent.ExecutionException,
                                    java.lang.InterruptedException
```
    Blocking version of storeAsync(ProviderFormat, String, int, Set, Set, Collection, Collection, boolean). Calls storeAsync(ProviderFormat, String, int, 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.
    
    Since:
    
    20.1
  - store
```
public PartitionedGraphConfig store(ProviderFormat targetFormat,
                                    java.lang.String targetBasePath,
                                    java.util.Set<java.lang.String> vertexProvidersToStore,
                                    java.util.Set<java.lang.String> edgeProvidersToStore)
                             throws java.util.concurrent.ExecutionException,
                                    java.lang.InterruptedException
```
    Blocking version of storeAsync(ProviderFormat, String, Set ,Set). Calls storeAsync(ProviderFormat, 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.
    
    Since:
    
    20.1
  - store
```
public PartitionedGraphConfig store(ProviderFormat targetFormat,
                                    java.lang.String targetBasePath,
                                    java.util.Set<java.lang.String> vertexProvidersToStore,
                                    java.util.Set<java.lang.String> edgeProvidersToStore,
                                    boolean overwrite)
                             throws java.util.concurrent.ExecutionException,
                                    java.lang.InterruptedException
```
    Blocking version of storeAsync(ProviderFormat, String, boolean). Calls storeAsync(ProviderFormat, String, Set, Set, 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.
    
    Since:
    
    20.1
  - store
```
public PartitionedGraphConfig store(ProviderFormat targetFormat,
                                    java.lang.String targetBasePath,
                                    java.util.Set<java.lang.String> vertexProvidersToStore,
                                    java.util.Set<java.lang.String> edgeProvidersToStore,
                                    java.util.Collection<VertexProperty<?,?>> vertexProps,
                                    java.util.Collection<EdgeProperty<?>> edgeProps,
                                    boolean overwrite)
                             throws java.util.concurrent.ExecutionException,
                                    java.lang.InterruptedException
```
    Blocking version of storeAsync(ProviderFormat, String, Set, Set, 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.
    
    Since:
    
    20.1
  - storeAsync
```
public PgxFuture<FileGraphConfig> storeAsync(Format targetFormat,
                                             FileGraphStoringConfig storingConfig)
```
    Stores this graph in a given file format in multiple partitions on a file system. This is a convenience method around store(Format, FileGraphStoringConfig, boolean), setting the overwrite flag to false.
    
    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.
    
    storingConfig - the storing configuration to use for writing the graph.
    
    Returns:
    
    A graph config object which can be used to load the stored graph back into memory.
  - storeAsync
```
public PgxFuture<FileGraphConfig> storeAsync(Format targetFormat,
                                             FileGraphStoringConfig storingConfig,
                                             boolean overwrite)
```
    Stores this graph in a given file format in multiple partitions on a file system. This is a convenience method around storeAsync(Format, FileGraphStoringConfig, 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 file formats with vertices and edge combined in same file are supported.
    
    storingConfig - the storing configuration to use for writing the 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:
    
    A graph config object which can be used to load the stored graph back into memory.
  - storeAsync
```
public PgxFuture<FileGraphConfig> storeAsync(Format targetFormat,
                                             FileGraphStoringConfig storingConfig,
                                             java.util.Collection<VertexProperty<?,?>> vertexProps,
                                             java.util.Collection<EdgeProperty<?>> edgeProps,
                                             boolean overwrite)
```
    Stores this graph in a given file format in multiple partitions 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.
    
    storingConfig - the storing configuration to use for writing the graph.
    
    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<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 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.
    
    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 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.
    
    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<FileGraphConfig> storeAsync(Format targetFormat,
                                             java.lang.String targetBasePath,
                                             int numPartitions)
```
    Stores this graph in a given file format in multiple partitions on a file system. This is a convenience method around store(Format, String, int, boolean), setting the overwrite flag to false.
    
    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.
    
    targetBasePath - the base path to use for writing the graph. Use schemes to write to a specific file system.
    
    numPartitions - the number of partitions in which to write the graph.
    
    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 targetBasePath,
                                             int numPartitions,
                                             boolean overwrite)
```
    Stores this graph in a given file format in multiple partitions on a file system. This is a convenience method around storeAsync(Format, String, int, 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 file formats with vertices and edge combined in same file are supported.
    
    targetBasePath - the base path to use for writing the graph. Use schemes to write to a specific file system.
    
    numPartitions - the number of partitions in which to write the 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:
    
    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 targetBasePath,
                                             int numPartitions,
                                             java.util.Collection<VertexProperty<?,?>> vertexProps,
                                             java.util.Collection<EdgeProperty<?>> edgeProps,
                                             boolean overwrite)
```
    Stores this graph in a given file format in multiple partitions on a file system. This is a convenience method around storeAsync(Format, FileGraphStoringConfig, Collection, Collection, boolean).
    
    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.
    
    targetBasePath - the base path to use for writing the graph. Use schemes to write to a specific file system.
    
    numPartitions - the number of partitions in which to write the graph.
    
    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.
  - storeAsync
```
public PgxFuture<GraphConfig> storeAsync(GraphConfig targetConfig,
                                         java.util.Set<java.lang.String> vertexProvidersToStore,
                                         java.util.Set<java.lang.String> edgeProvidersToStore,
                                         boolean overwrite)
```
    Stores this graph in a file or database.
    
    Parameters:
    
    targetConfig - the graph configuration describing the stored graph.
    
    vertexProvidersToStore - for partitioned graphs, the vertex providers to store
    
    edgeProvidersToStore - for partitioned graphs, the edge providers to store
    
    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.
    
    Since:
    
    20.1
  - storeAsync
```
public PgxFuture<PartitionedGraphConfig> storeAsync(ProviderFormat targetFormat,
                                                    java.util.Map<java.lang.String,FileGraphStoringConfig> vertexStoringConfigs,
                                                    java.util.Map<java.lang.String,FileGraphStoringConfig> edgeStoringConfigs)
```
    Stores this graph in a given file format in multiple partitions on a file system. This is a convenience method around storeAsync(ProviderFormat, Map, Map, boolean), setting the overwrite flag to false.
    
    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.
    
    vertexStoringConfigs - the storing configurations to use for writing the vertices from the vertex providers.
    
    edgeStoringConfigs - the storing configurations to use for writing the edges from the edge providers.
    
    Returns:
    
    A graph config object which can be used to load the stored graph back into memory.
    
    Since:
    
    19.4.0
  - storeAsync
```
public PgxFuture<PartitionedGraphConfig> storeAsync(ProviderFormat targetFormat,
                                                    java.util.Map<java.lang.String,FileGraphStoringConfig> vertexStoringConfigs,
                                                    java.util.Map<java.lang.String,FileGraphStoringConfig> edgeStoringConfigs,
                                                    boolean overwrite)
```
    Stores this graph in a given file format in multiple partitions on a file system. This is a convenience method around storeAsync(ProviderFormat, Map, Map, 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 file formats with vertices and edge combined in same file are supported.
    
    vertexStoringConfigs - the storing configurations to use for writing the vertices from the vertex providers.
    
    edgeStoringConfigs - the storing configurations to use for writing the edges from the edge providers.
    
    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.
    
    Since:
    
    19.4.0
  - storeAsync
```
public PgxFuture<PartitionedGraphConfig> storeAsync(ProviderFormat targetFormat,
                                                    java.util.Map<java.lang.String,FileGraphStoringConfig> vertexStoringConfigs,
                                                    java.util.Map<java.lang.String,FileGraphStoringConfig> edgeStoringConfigs,
                                                    java.util.Collection<VertexProperty<?,?>> vertexProps,
                                                    java.util.Collection<EdgeProperty<?>> edgeProps,
                                                    boolean overwrite)
```
    Stores this graph in a given file format in multiple partitions 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.
    
    vertexStoringConfigs - the storing configurations to use for writing the vertices from the vertex providers.
    
    edgeStoringConfigs - the storing configurations to use for writing the edges from the edge providers.
    
    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.
    
    Since:
    
    19.4.0
  - storeAsync
```
public PgxFuture<PartitionedGraphConfig> storeAsync(ProviderFormat targetFormat,
                                                    java.util.Set<java.lang.String> vertexProvidersToStore,
                                                    java.util.Set<java.lang.String> edgeProvidersToStore,
                                                    java.util.Map<java.lang.String,FileGraphStoringConfig> vertexStoringConfigs,
                                                    java.util.Map<java.lang.String,FileGraphStoringConfig> edgeStoringConfigs,
                                                    boolean overwrite)
```
    Stores this graph in a given file format in multiple partitions on a file system. This is a convenience method around storeAsync(ProviderFormat, Map, Map, 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 file formats with vertices and edge combined in same file are supported.
    
    vertexProvidersToStore - for partitioned graphs, the vertex providers to store
    
    edgeProvidersToStore - for partitioned graphs, the edge providers to store
    
    vertexStoringConfigs - the storing configurations to use for writing the vertices from the vertex providers.
    
    edgeStoringConfigs - the storing configurations to use for writing the edges from the edge providers.
    
    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.
    
    Since:
    
    20.1
  - storeAsync
```
public PgxFuture<PartitionedGraphConfig> storeAsync(ProviderFormat targetFormat,
                                                    java.util.Set<java.lang.String> vertexProvidersToStore,
                                                    java.util.Set<java.lang.String> edgeProvidersToStore,
                                                    java.util.Map<java.lang.String,FileGraphStoringConfig> vertexStoringConfigs,
                                                    java.util.Map<java.lang.String,FileGraphStoringConfig> edgeStoringConfigs,
                                                    java.util.Collection<VertexProperty<?,?>> vertexProps,
                                                    java.util.Collection<EdgeProperty<?>> edgeProps,
                                                    boolean overwrite)
```
    Stores this graph in a given file format in multiple partitions 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.
    
    vertexProvidersToStore - for partitioned graphs, the vertex providers to store
    
    edgeProvidersToStore - for partitioned graphs, the edge providers to store
    
    vertexStoringConfigs - the storing configurations to use for writing the vertices from the vertex providers.
    
    edgeStoringConfigs - the storing configurations to use for writing the edges from the edge providers.
    
    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.
    
    Since:
    
    20.1
  - storeAsync
```
public PgxFuture<PartitionedGraphConfig> storeAsync(ProviderFormat targetFormat,
                                                    java.lang.String targetBasePath)
```
    Stores this graph in a given file format on a file system. This is a convenience method around store(ProviderFormat, String, boolean), setting the overwrite flag to false.
    
    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.
    
    targetBasePath - 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.
    
    Since:
    
    19.4.0
  - storeAsync
```
public PgxFuture<PartitionedGraphConfig> storeAsync(ProviderFormat targetFormat,
                                                    java.lang.String targetBasePath,
                                                    boolean overwrite)
```
    Stores this graph in a given file format on a file system. This is a convenience method around storeAsync(ProviderFormat, 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 file formats with vertices and edge combined in same file are supported.
    
    targetBasePath - 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.
    
    Since:
    
    19.4.0
  - storeAsync
```
public PgxFuture<PartitionedGraphConfig> storeAsync(ProviderFormat targetFormat,
                                                    java.lang.String targetBasePath,
                                                    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.
    
    targetBasePath - 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.
    
    Since:
    
    19.4.0
  - storeAsync
```
public PgxFuture<PartitionedGraphConfig> storeAsync(ProviderFormat targetFormat,
                                                    java.lang.String targetBasePath,
                                                    int numPartitions)
```
    Stores this graph in a given file format in multiple partitions on a file system. This is a convenience method around storeAsync(ProviderFormat, String, int, boolean), setting the overwrite flag to false.
    
    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.
    
    targetBasePath - the base path to use for writing the graph. Use schemes to write to a specific file system.
    
    numPartitions - the number of partitions in which to write the graph.
    
    Returns:
    
    A graph config object which can be used to load the stored graph back into memory.
    
    Since:
    
    19.4.0
  - storeAsync
```
public PgxFuture<PartitionedGraphConfig> storeAsync(ProviderFormat targetFormat,
                                                    java.lang.String targetBasePath,
                                                    int numPartitions,
                                                    boolean overwrite)
```
    Stores this graph in a given file format in multiple partitions on a file system. This is a convenience method around storeAsync(ProviderFormat, String, int, 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 file formats with vertices and edge combined in same file are supported.
    
    targetBasePath - the base path to use for writing the graph. Use schemes to write to a specific file system.
    
    numPartitions - the number of partitions in which to write the 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:
    
    A graph config object which can be used to load the stored graph back into memory.
    
    Since:
    
    19.4.0
  - storeAsync
```
public PgxFuture<PartitionedGraphConfig> storeAsync(ProviderFormat targetFormat,
                                                    java.lang.String targetBasePath,
                                                    int numPartitions,
                                                    java.util.Collection<VertexProperty<?,?>> vertexProps,
                                                    java.util.Collection<EdgeProperty<?>> edgeProps,
                                                    boolean overwrite)
```
    Stores this graph in a given file format in multiple partitions on a file system. This is a convenience method around storeAsync(ProviderFormat, String, int, Set, Set, Map, Map, Collection, Collection, boolean).
    
    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.
    
    targetBasePath - the base path to use for writing the graph. Use schemes to write to a specific file system.
    
    numPartitions - the number of partitions in which to write the graph.
    
    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.
    
    Since:
    
    19.4.0
  - storeAsync
```
public PgxFuture<PartitionedGraphConfig> storeAsync(ProviderFormat targetFormat,
                                                    java.lang.String targetBasePath,
                                                    int numPartitions,
                                                    java.util.Set<java.lang.String> vertexProvidersToStore,
                                                    java.util.Set<java.lang.String> edgeProvidersToStore)
```
    Stores this graph in a given file format in multiple partitions on a file system. This is a convenience method around storeAsync(ProviderFormat, String, int, boolean), setting the overwrite flag to false.
    
    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.
    
    targetBasePath - the base path to use for writing the graph. Use schemes to write to a specific file system.
    
    numPartitions - the number of partitions in which to write the graph.
    
    vertexProvidersToStore - for partitioned graphs, the vertex providers to store
    
    edgeProvidersToStore - for partitioned graphs, the edge providers to store
    
    Returns:
    
    A graph config object which can be used to load the stored graph back into memory.
    
    Since:
    
    19.4.0
  - storeAsync
```
public PgxFuture<PartitionedGraphConfig> storeAsync(ProviderFormat targetFormat,
                                                    java.lang.String targetBasePath,
                                                    int numPartitions,
                                                    java.util.Set<java.lang.String> vertexProvidersToStore,
                                                    java.util.Set<java.lang.String> edgeProvidersToStore,
                                                    boolean overwrite)
```
    Stores this graph in a given file format in multiple partitions on a file system. This is a convenience method around storeAsync(ProviderFormat, String, int, 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 file formats with vertices and edge combined in same file are supported.
    
    targetBasePath - the base path to use for writing the graph. Use schemes to write to a specific file system.
    
    numPartitions - the number of partitions in which to write the graph.
    
    vertexProvidersToStore - the vertex providers to store
    
    edgeProvidersToStore - the edge providers to store
    
    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.
    
    Since:
    
    20.1
  - storeAsync
```
public PgxFuture<PartitionedGraphConfig> storeAsync(ProviderFormat targetFormat,
                                                    java.lang.String targetBasePath,
                                                    int numPartitions,
                                                    java.util.Set<java.lang.String> vertexProvidersToStore,
                                                    java.util.Set<java.lang.String> edgeProvidersToStore,
                                                    java.util.Collection<VertexProperty<?,?>> vertexProps,
                                                    java.util.Collection<EdgeProperty<?>> edgeProps,
                                                    boolean overwrite)
```
    Stores this graph in a given file format in multiple partitions on a file system. This is a convenience method around storeAsync(ProviderFormat, String, int, Set, Set, Map, Map, Collection, Collection, boolean).
    
    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.
    
    targetBasePath - the base path to use for writing the graph. Use schemes to write to a specific file system.
    
    numPartitions - the number of partitions in which to write the graph.
    
    vertexProvidersToStore - the vertex providers to store
    
    edgeProvidersToStore - the edge providers to store
    
    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.
    
    Since:
    
    20.1
  - storeAsync
```
public PgxFuture<PartitionedGraphConfig> storeAsync(ProviderFormat targetFormat,
                                                    java.lang.String targetBasePath,
                                                    java.util.Set<java.lang.String> vertexProvidersToStore,
                                                    java.util.Set<java.lang.String> edgeProvidersToStore)
```
    Stores this graph in a given file format on a file system. This is a convenience method around store(ProviderFormat, String, boolean), setting the overwrite flag to false.
    
    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.
    
    targetBasePath - the path the graph should be written to. Use schemes to write to a specific file system.
    
    vertexProvidersToStore - for partitioned graphs, the vertex providers to store
    
    edgeProvidersToStore - for partitioned graphs, the edge providers to store
    
    Returns:
    
    A graph config object which can be used to load the stored graph back into memory.
    
    Since:
    
    20.1
  - storeAsync
```
public PgxFuture<PartitionedGraphConfig> storeAsync(ProviderFormat targetFormat,
                                                    java.lang.String targetBasePath,
                                                    java.util.Set<java.lang.String> vertexProvidersToStore,
                                                    java.util.Set<java.lang.String> edgeProvidersToStore,
                                                    boolean overwrite)
```
    Stores this graph in a given file format on a file system. This is a convenience method around storeAsync(ProviderFormat, 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 file formats with vertices and edge combined in same file are supported.
    
    targetBasePath - the path the graph should be written to. Use schemes to write to a specific file system.
    
    vertexProvidersToStore - the vertex providers to store
    
    edgeProvidersToStore - the edge providers to store
    
    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.
    
    Since:
    
    20.1
  - storeAsync
```
public PgxFuture<PartitionedGraphConfig> storeAsync(ProviderFormat targetFormat,
                                                    java.lang.String targetBasePath,
                                                    java.util.Set<java.lang.String> vertexProvidersToStore,
                                                    java.util.Set<java.lang.String> edgeProvidersToStore,
                                                    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.
    
    targetBasePath - the path the graph should be written to. Use schemes to write to a specific file system.
    
    vertexProvidersToStore - for partitioned graphs, the vertex providers to store
    
    edgeProvidersToStore - for partitioned graphs, the edge providers to store
    
    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.
    
    Since:
    
    20.1
  - 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 getId()
    
    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 that should be kept in the mutated graph. Constants VertexProperty.ALL or VertexProperty.NONE can be used.
    
    edgeProps - edge properties that should be kept in the mutated graph. 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 getId()
    
    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 getId()
    
    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 that should be kept in the mutated graph. Constants VertexProperty.ALL or VertexProperty.NONE can be used.
    
    edgeProps - edge properties that should be kept in the mutated graph. 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.
    
    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

addRedactionRule

addRedactionRuleAsync

alterGraph

bipartiteSubGraphFromInDegree

bipartiteSubGraphFromInDegree

bipartiteSubGraphFromInDegree

bipartiteSubGraphFromInDegree

bipartiteSubGraphFromInDegreeAsync

bipartiteSubGraphFromInDegreeAsync

bipartiteSubGraphFromInDegreeAsync

bipartiteSubGraphFromInDegreeAsync

bipartiteSubGraphFromLeftSet

bipartiteSubGraphFromLeftSet

bipartiteSubGraphFromLeftSet

bipartiteSubGraphFromLeftSet

bipartiteSubGraphFromLeftSetAsync

bipartiteSubGraphFromLeftSetAsync

bipartiteSubGraphFromLeftSetAsync

bipartiteSubGraphFromLeftSetAsync

clone

clone

clone

cloneAndExecutePgql

cloneAndExecutePgql

cloneAndExecutePgqlAsync

cloneAndExecutePgqlAsync

cloneAsync

cloneAsync

cloneAsync

combineEdgePropertiesIntoVectorProperty

combineEdgePropertiesIntoVectorProperty

combineEdgePropertiesIntoVectorPropertyAsync

combineEdgePropertiesIntoVectorPropertyAsync

combineVertexPropertiesIntoVectorProperty

combineVertexPropertiesIntoVectorProperty

combineVertexPropertiesIntoVectorPropertyAsync

combineVertexPropertiesIntoVectorPropertyAsync

createAllPaths

createAllPathsAsync

createChangeSet

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

createPathAsync

createPickingStrategyBuilder

createScalar

createScalar

createScalarAsync

createScalarAsync