org.apache.tinkerpop.gremlin.structure

## Interface Graph

- All Superinterfaces:
    AutoCloseable, Host
  All Known Implementing Classes:
    ComputerGraph, EmptyGraph, HadoopGraph, Neo4jGraph, RemoteGraph, StarGraph, TinkerGraph

      public interface Graph
      extends AutoCloseable, Host

  A `Graph` is a container object for a collection of `Vertex`, `Edge`, `VertexProperty`, and `Property` objects.
  Author:
    Marko A. Rodriguez (http://markorodriguez.com), Stephen Mallette (http://stephen.genoprime.com), Pieter Martin

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Interface and Description
    --- | ---
    `static class` | `Graph.Exceptions` Common exceptions to use with a graph.
    `static interface` | `Graph.Features` An interface that represents the capabilities of a `Graph` implementation.
    `static class` | `Graph.Hidden` This should only be used by providers to create keys, labels, etc.
    `static interface` | `Graph.OptIn` Defines the test suite that the implementer has decided to support and represents publicly as "passing".
    `static interface` | `Graph.OptIns` Holds a collection of `Graph.OptIn` enabling multiple `Graph.OptIn` to be applied to a single suite.
    `static interface` | `Graph.OptOut` Defines a test in the suite that the implementer does not want to run.
    `static interface` | `Graph.OptOuts` Holds a collection of `Graph.OptOut` enabling multiple `Graph.OptOut` to be applied to a single suite.
    `static interface` | `Graph.Variables` Graph variables are a set of key/value pairs associated with the graph.

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static String` | `GRAPH` Configuration key used by `GraphFactory`} to determine which graph to instantiate.

  - ### Method Summary

    All Methods Instance Methods Abstract Methods Default Methods Deprecated Methods
    Modifier and Type | Method and Description
    --- | ---
    `Vertex` | `addVertex(Object... keyValues)` Add a `Vertex` to the graph given an optional series of key/value pairs.
    `default Vertex` | `addVertex(String label)` Add a `Vertex` to the graph with provided vertex label.
    `void` | `close()` Closing a `Graph` is equivalent to "shutdown" and implies that no further operations can be executed on the instance.
    `GraphComputer` | `compute()` Generate a `GraphComputer` using the default engine of the underlying graph system.
    `<C extends GraphComputer> C` | `compute(Class<C> graphComputerClass)` Declare the `GraphComputer` to use for OLAP operations on the graph.
    `Configuration` | `configuration()` Get the `Configuration` associated with the construction of this graph.
    `Iterator<Edge>` | `edges(Object... edgeIds)` Get the `Edge` objects in this graph with the provided edge ids or `Edge` objects.
    `default Graph.Features` | `features()` Gets the `Graph.Features` exposed by the underlying `Graph` implementation.
    `default <I extends Io> I` | `io(Io.Builder<I> builder)` Deprecated. As of release 3.4.0, partially replaced by `GraphTraversalSource.io(String)`. Notice `GraphTraversalSource.io(String)` doesn't support read operation from `java.io.InputStream` or write operation to `java.io.OutputStream`. Thus for readers or writers which need this functionality are safe to use this deprecated method. There is no intention to remove this method unless all the functionality is replaced by the `io` step of `GraphTraversalSource`.
    `default GraphTraversalSource` | `traversal()` Generate a reusable `GraphTraversalSource` instance.
    `default <C extends TraversalSource> C` | `traversal(Class<C> traversalSourceClass)` Generate a `TraversalSource` using the specified `TraversalSource` class.
    `Transaction` | `tx()` Configure and control the transactions for those graphs that support this feature.
    `Graph.Variables` | `variables()` A collection of global `Graph.Variables` associated with the graph.
    `Iterator<Vertex>` | `vertices(Object... vertexIds)` Get the `Vertex` objects in this graph with the provided vertex ids or `Vertex` objects themselves.

    - ### Methods inherited from interface org.apache.tinkerpop.gremlin.structure.util.Host

      `getHostingVertex`

- - ### Field Detail

    - #### GRAPH

          static final String GRAPH

      Configuration key used by `GraphFactory`} to determine which graph to instantiate.
      See Also:
        Constant Field Values

  - ### Method Detail

    - #### addVertex

          Vertex addVertex(Object... keyValues)

      Add a `Vertex` to the graph given an optional series of key/value pairs. These key/values must be provided in an even number where the odd numbered arguments are `String` property keys and the even numbered arguments are the related property values.
      Parameters:
        `keyValues` - The key/value pairs to turn into vertex properties
      Returns:
        The newly created vertex

    - #### addVertex

          default Vertex addVertex(String label)

      Add a `Vertex` to the graph with provided vertex label.
      Parameters:
        `label` - the label of the vertex
      Returns:
        The newly created labeled vertex

    - #### compute

          <C extends GraphComputer> C compute(Class<C> graphComputerClass)
                                       throws IllegalArgumentException

      Declare the `GraphComputer` to use for OLAP operations on the graph. If the graph does not support graph computer then an `UnsupportedOperationException` is thrown.
      Parameters:
        `graphComputerClass` - The graph computer class to use.
      Returns:
        A graph computer for processing this graph
      Throws:
        `IllegalArgumentException` - if the provided `GraphComputer` class is not supported.

    - #### compute

          GraphComputer compute()
                         throws IllegalArgumentException

      Generate a `GraphComputer` using the default engine of the underlying graph system. This is a shorthand method for the more involved method that uses `compute(Class)`.
      Returns:
        A default graph computer
      Throws:
        `IllegalArgumentException` - if there is no default graph computer

    - #### traversal

          default <C extends TraversalSource> C traversal(Class<C> traversalSourceClass)

      Generate a `TraversalSource` using the specified `TraversalSource` class. The reusable `TraversalSource` provides methods for spawning `Traversal` instances.
      Type Parameters:
        `C` - The traversal source class
      Parameters:
        `traversalSourceClass` - The traversal source class

    - #### traversal

          default GraphTraversalSource traversal()

      Generate a reusable `GraphTraversalSource` instance. The `GraphTraversalSource` provides methods for creating `GraphTraversal` instances.
      Returns:
        A graph traversal source

    - #### vertices

          Iterator<Vertex> vertices(Object... vertexIds)

      Get the `Vertex` objects in this graph with the provided vertex ids or `Vertex` objects themselves. If no ids are provided, get all vertices. Note that a vertex identifier does not need to correspond to the actual id used in the graph. It needs to be a bit more flexible than that in that given the `Graph.Features` around id support, multiple arguments might be applicable here.

      If the graph return `true` for `Graph.Features.ElementFeatures.supportsNumericIds()` then it should support filters as with:
      - g.vertices(v)
      - g.vertices(v.id())
      - g.vertices(1)
      - g.vertices(1L)
      - g.vertices(1.0d)
      - g.vertices(1.0f)
      - g.vertices("1")

      If the graph return `true` for `Graph.Features.ElementFeatures.supportsCustomIds()` ()} then it should support filters as with:
      - g.vertices(v)
      - g.vertices(v.id())
      - g.vertices(v.id().toString())

      If the graph return `true` for `Graph.Features.ElementFeatures.supportsAnyIds()` ()} then it should support filters as with:
      - g.vertices(v)
      - g.vertices(v.id())

      If the graph return `true` for `Graph.Features.ElementFeatures.supportsStringIds()` ()} then it should support filters as with:
      - g.vertices(v)
      - g.vertices(v.id().toString())
      - g.vertices("id")

      If the graph return `true` for `Graph.Features.ElementFeatures.supportsStringIds()` ()} then it should support filters as with:
      - g.vertices(v)
      - g.vertices(v.id().toString())
      - g.vertices("id")
      Parameters:
        `vertexIds` - the ids of the vertices to get
      Returns:
        an `Iterator` of vertices that match the provided vertex ids

    - #### edges

          Iterator<Edge> edges(Object... edgeIds)

      Get the `Edge` objects in this graph with the provided edge ids or `Edge` objects. If no ids are provided, get all edges. Note that an edge identifier does not need to correspond to the actual id used in the graph. It needs to be a bit more flexible than that in that given the `Graph.Features` around id support, multiple arguments might be applicable here.

      If the graph return `true` for `Graph.Features.ElementFeatures.supportsNumericIds()` then it should support filters as with:
      - g.edges(e)
      - g.edges(e.id())
      - g.edges(1)
      - g.edges(1L)
      - g.edges(1.0d)
      - g.edges(1.0f)
      - g.edges("1")

      If the graph return `true` for `Graph.Features.ElementFeatures.supportsCustomIds()` ()} then it should support filters as with:
      - g.edges(e)
      - g.edges(e.id())
      - g.edges(e.id().toString())

      If the graph return `true` for `Graph.Features.ElementFeatures.supportsAnyIds()` ()} then it should support filters as with:
      - g.edges(e)
      - g.edges(e.id())

      If the graph return `true` for `Graph.Features.ElementFeatures.supportsStringIds()` ()} then it should support filters as with:
      - g.edges(e)
      - g.edges(e.id().toString())
      - g.edges("id")
      Parameters:
        `edgeIds` - the ids of the edges to get
      Returns:
        an `Iterator` of edges that match the provided edge ids

    - #### tx

          Transaction tx()

      Configure and control the transactions for those graphs that support this feature. Note that this method does not indicate the creation of a "transaction" object. A `Transaction` in the TinkerPop context is a transaction "factory" or "controller" that helps manage transactions owned by the underlying graph database.

    - #### close

          void close()
              throws Exception

      Closing a `Graph` is equivalent to "shutdown" and implies that no further operations can be executed on the instance. Users should consult the documentation of the underlying graph database implementation for what this "shutdown" will mean in general and, if supported, how open transactions are handled. It will typically be the end user's responsibility to synchronize the thread that calls `close()` with other threads that are accessing open transactions. In other words, be sure that all work performed on the `Graph` instance is complete prior to calling this method.

      TinkerPop does not enforce any particular semantics with respect to "shutdown". It is up to the graph provider to decide what this method will do.
      Specified by:
        `close` in interface `AutoCloseable`
      Throws:
        `Exception`

    - #### io

          @Deprecated
          default <I extends Io> I io(Io.Builder<I> builder)

      Deprecated. As of release 3.4.0, partially replaced by `GraphTraversalSource.io(String)`. Notice `GraphTraversalSource.io(String)` doesn't support read operation from `java.io.InputStream` or write operation to `java.io.OutputStream`. Thus for readers or writers which need this functionality are safe to use this deprecated method. There is no intention to remove this method unless all the functionality is replaced by the `io` step of `GraphTraversalSource`.
      Construct a particular `Io` implementation for reading and writing the `Graph` and other data. End-users will "select" the `Io` implementation that they want to use by supplying the `Io.Builder` that constructs it. In this way, `Graph` vendors can supply their `IoRegistry` to that builder thus allowing for custom serializers to be auto-configured into the `Io` instance. Registering custom serializers is particularly useful for those graphs that have complex types for `Element` identifiers. For those graphs that do not need to register any custom serializers, the default implementation should suffice. If the default is overridden, take care to register the current graph via the `Io.Builder.graph(Graph)` method.

    - #### variables

          Graph.Variables variables()

      A collection of global `Graph.Variables` associated with the graph. Variables are used for storing metadata about the graph.
      Returns:
        The variables associated with this graph

    - #### configuration

          Configuration configuration()

      Get the `Configuration` associated with the construction of this graph. Whatever configuration was passed to `GraphFactory.open(Configuration)` is what should be returned by this method.
      Returns:
        the configuration used during graph construction.

    - #### features

          default Graph.Features features()

      Gets the `Graph.Features` exposed by the underlying `Graph` implementation.

Copyright © 2013–2022 Apache Software Foundation. All rights reserved.