Node (Neo4j Community 2.1.0-M01 API)
Date: 2014-02-20

org.neo4j.graphdb

## Interface Node

- All Superinterfaces:
    PropertyContainer

      public interface Node
      extends PropertyContainer

  A node in the graph with properties and relationships to other entities. Along with `relationships`, nodes are the core building blocks of the Neo4j data representation model. Nodes are created by invoking the `GraphDatabaseService.createNode()` method.

  Node has three major groups of operations: operations that deal with relationships, operations that deal with properties (see `PropertyContainer`) and operations that create `traversers`.

  The relationship operations provide a number of overloaded accessors (such as `getRelationships(...)` with "filters" for type, direction, etc), as well as the factory method `createRelationshipTo(...)` that connects two nodes with a relationship. It also includes the convenience method `getSingleRelationship(...)` for accessing the commonly occurring one-to-zero-or-one association.

  The property operations give access to the key-value property pairs. Property keys are always strings. Valid property value types are all the Java primitives (`int`, `byte`, `float`, etc), `java.lang.String`s and arrays of primitives and Strings.

  Please note that Neo4j does NOT accept arbitrary objects as property values. `setProperty()` takes a `java.lang.Object` only to avoid an explosion of overloaded `setProperty()` methods. For further documentation see `PropertyContainer`.

  The traversal factory methods instantiate a `traverser` that starts traversing from this node.

  A node's id is unique, but note the following: Neo4j reuses its internal ids when nodes and relationships are deleted, which means it's bad practice to refer to them this way. Instead, use application generated ids.

- - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addLabel(Label label)` Adds a `Label` to this node.
    `Relationship` | `createRelationshipTo(Node otherNode, RelationshipType type)` Creates a relationship between this node and another node.
    `void` | `delete()` Deletes this node if it has no relationships attached to it.
    `int` | `getDegree()` Returns the number of relationships connected to this node regardless of direction or type.
    `int` | `getDegree(Direction direction)` Returns the number of relationships of a given `direction` connected to this node.
    `int` | `getDegree(RelationshipType type)` Returns the number of relationships of a given `type` connected to this node.
    `int` | `getDegree(RelationshipType type, Direction direction)` Returns the number of relationships of a given `type` and `direction` connected to this node.
    `long` | `getId()` Returns the unique id of this node.
    `Iterable<Label>` | `getLabels()` Lists all labels attached to this node.
    `Iterable<Relationship>` | `getRelationships()` Returns all the relationships attached to this node.
    `Iterable<Relationship>` | `getRelationships(Direction dir)` Returns all `OUTGOING` or `INCOMING` relationships from this node.
    `Iterable<Relationship>` | `getRelationships(Direction direction, RelationshipType... types)` Returns all the relationships of any of the types in `types` that are attached to this node and have the given `direction`.
    `Iterable<Relationship>` | `getRelationships(RelationshipType... types)` Returns all the relationships of any of the types in `types` that are attached to this node, regardless of direction.
    `Iterable<Relationship>` | `getRelationships(RelationshipType type, Direction dir)` Returns all relationships with the given type and direction that are attached to this node.
    `Iterable<RelationshipType>` | `getRelationshipTypes()` Returns relationship types which this node has one more relationships for.
    `Relationship` | `getSingleRelationship(RelationshipType type, Direction dir)` Returns the only relationship of a given type and direction that is attached to this node, or `null`.
    `boolean` | `hasLabel(Label label)` Checks whether or not this node has the given label.
    `boolean` | `hasRelationship()` Returns `true` if there are any relationships attached to this node, `false` otherwise.
    `boolean` | `hasRelationship(Direction dir)` Returns `true` if there are any relationships in the given direction attached to this node, `false` otherwise.
    `boolean` | `hasRelationship(Direction direction, RelationshipType... types)` Returns `true` if there are any relationships of any of the types in `types` attached to this node (for the given `direction`), `false` otherwise.
    `boolean` | `hasRelationship(RelationshipType... types)` Returns `true` if there are any relationships of any of the types in `types` attached to this node (regardless of direction), `false` otherwise.
    `boolean` | `hasRelationship(RelationshipType type, Direction dir)` Returns `true` if there are any relationships of the given relationship type and direction attached to this node, `false` otherwise.
    `void` | `removeLabel(Label label)` Removes a `Label` from this node.
    `Traverser` | `traverse(Traverser.Order traversalOrder, StopEvaluator stopEvaluator, ReturnableEvaluator returnableEvaluator, Object... relationshipTypesAndDirections)` Deprecated. because of an unnatural and too tight coupling with `Node`. Also because of the introduction of a new traversal framework. The new way of doing traversals is by creating a new `TraversalDescription` from `Traversal.traversal()`, add rules and behaviors to it and then calling `TraversalDescription.traverse(Node...)`
    `Traverser` | `traverse(Traverser.Order traversalOrder, StopEvaluator stopEvaluator, ReturnableEvaluator returnableEvaluator, RelationshipType relationshipType, Direction direction)` Deprecated. because of an unnatural and too tight coupling with `Node`. Also because of the introduction of a new traversal framework. The new way of doing traversals is by creating a new `TraversalDescription` from `Traversal.traversal()`, add rules and behaviors to it and then calling `TraversalDescription.traverse(Node...)`
    `Traverser` | `traverse(Traverser.Order traversalOrder, StopEvaluator stopEvaluator, ReturnableEvaluator returnableEvaluator, RelationshipType firstRelationshipType, Direction firstDirection, RelationshipType secondRelationshipType, Direction secondDirection)` Deprecated. because of an unnatural and too tight coupling with `Node`. Also because of the introduction of a new traversal framework. The new way of doing traversals is by creating a new `TraversalDescription` from `Traversal.traversal()`, add rules and behaviors to it and then calling `TraversalDescription.traverse(Node...)`

    - ### Methods inherited from interface org.neo4j.graphdb.PropertyContainer

      `getGraphDatabase, getProperty, getProperty, getPropertyKeys, hasProperty, removeProperty, setProperty`

- - ### Method Detail

    - #### getId

          long getId()

      Returns the unique id of this node. Ids are garbage collected over time so they are only guaranteed to be unique during a specific time span: if the node is deleted, it's likely that a new node at some point will get the old id. Note: this makes node ids brittle as public APIs.
      Returns:
        the id of this node

    - #### delete

          void delete()

      Deletes this node if it has no relationships attached to it. If `delete()` is invoked on a node with relationships, an unchecked exception will be raised when the transaction is committing. Invoking any methods on this node after `delete()` has returned is invalid and will lead to unspecified behavior.

    - #### getRelationships

          Iterable<Relationship> getRelationships()

      Returns all the relationships attached to this node. If no relationships are attached to this node, an empty iterable will be returned.
      Returns:
        all relationships attached to this node

    - #### hasRelationship

          boolean hasRelationship()

      Returns `true` if there are any relationships attached to this node, `false` otherwise.
      Returns:
        `true` if there are any relationships attached to this node, `false` otherwise

    - #### getRelationships

          Iterable<Relationship> getRelationships(RelationshipType... types)

      Returns all the relationships of any of the types in `types` that are attached to this node, regardless of direction. If no relationships of the given types are attached to this node, an empty iterable will be returned.
      Parameters:
        `types` - the given relationship type(s)
      Returns:
        all relationships of the given type(s) that are attached to this node

    - #### getRelationships

          Iterable<Relationship> getRelationships(Direction direction,
                                                RelationshipType... types)

      Returns all the relationships of any of the types in `types` that are attached to this node and have the given `direction`. If no relationships of the given types are attached to this node, an empty iterable will be returned.
      Parameters:
        `types` - the given relationship type(s)
        `direction` - the direction of the relationships to return.
      Returns:
        all relationships of the given type(s) that are attached to this node

    - #### hasRelationship

          boolean hasRelationship(RelationshipType... types)

      Returns `true` if there are any relationships of any of the types in `types` attached to this node (regardless of direction), `false` otherwise.
      Parameters:
        `types` - the given relationship type(s)
      Returns:
        `true` if there are any relationships of any of the types in `types` attached to this node, `false` otherwise

    - #### hasRelationship

          boolean hasRelationship(Direction direction,
                                RelationshipType... types)

      Returns `true` if there are any relationships of any of the types in `types` attached to this node (for the given `direction`), `false` otherwise.
      Parameters:
        `types` - the given relationship type(s)
        `direction` - the direction to check relationships for
      Returns:
        `true` if there are any relationships of any of the types in `types` attached to this node, `false` otherwise

    - #### getRelationships

          Iterable<Relationship> getRelationships(Direction dir)

      Returns all `OUTGOING` or `INCOMING` relationships from this node. If there are no relationships with the given direction attached to this node, an empty iterable will be returned. If `BOTH` is passed in as a direction, relationships of both directions are returned (effectively turning this into `getRelationships()`).
      Parameters:
        `dir` - the given direction, where `Direction.OUTGOING` means all relationships that have this node as `start node` and `Direction.INCOMING` means all relationships that have this node as `end node`
      Returns:
        all relationships with the given direction that are attached to this node

    - #### hasRelationship

          boolean hasRelationship(Direction dir)

      Returns `true` if there are any relationships in the given direction attached to this node, `false` otherwise. If `BOTH` is passed in as a direction, relationships of both directions are matched (effectively turning this into `hasRelationships()`).
      Parameters:
        `dir` - the given direction, where `Direction.OUTGOING` means all relationships that have this node as `start node` and `Direction.INCOMING` means all relationships that have this node as `end node`
      Returns:
        `true` if there are any relationships in the given direction attached to this node, `false` otherwise

    - #### getRelationships

          Iterable<Relationship> getRelationships(RelationshipType type,
                                                Direction dir)

      Returns all relationships with the given type and direction that are attached to this node. If there are no matching relationships, an empty iterable will be returned.
      Parameters:
        `type` - the given type
        `dir` - the given direction, where `Direction.OUTGOING` means all relationships that have this node as `start node` and `Direction.INCOMING` means all relationships that have this node as `end node`
      Returns:
        all relationships attached to this node that match the given type and direction

    - #### hasRelationship

          boolean hasRelationship(RelationshipType type,
                                Direction dir)

      Returns `true` if there are any relationships of the given relationship type and direction attached to this node, `false` otherwise.
      Parameters:
        `type` - the given type
        `dir` - the given direction, where `Direction.OUTGOING` means all relationships that have this node as `start node` and `Direction.INCOMING` means all relationships that have this node as `end node`
      Returns:
        `true` if there are any relationships of the given relationship type and direction attached to this node, `false` otherwise

    - #### getSingleRelationship

          Relationship getSingleRelationship(RelationshipType type,
                                           Direction dir)

      Returns the only relationship of a given type and direction that is attached to this node, or `null`. This is a convenience method that is used in the commonly occuring situation where a node has exactly zero or one relationships of a given type and direction to another node. Typically this invariant is maintained by the rest of the code: if at any time more than one such relationships exist, it is a fatal error that should generate an unchecked exception. This method reflects that semantics and returns either:

      1. `null` if there are zero relationships of the given type and direction,
      2. the relationship if there's exactly one, or
      3. throws an unchecked exception in all other cases.

      This method should be used only in situations with an invariant as described above. In those situations, a "state-checking" method (e.g. `hasSingleRelationship(...)`) is not required, because this method behaves correctly "out of the box."

      Parameters:
        `type` - the type of the wanted relationship
        `dir` - the direction of the wanted relationship (where `Direction.OUTGOING` means a relationship that has this node as `start node` and `Direction.INCOMING` means a relationship that has this node as `end node`) or `Direction.BOTH` if direction is irrelevant
      Returns:
        the single relationship matching the given type and direction if exactly one such relationship exists, or `null` if exactly zero such relationships exists
      Throws:
        `RuntimeException` - if more than one relationship matches the given type and direction

    - #### createRelationshipTo

          Relationship createRelationshipTo(Node otherNode,
                                          RelationshipType type)

      Creates a relationship between this node and another node. The relationship is of type `type`. It starts at this node and ends at `otherNode`.

      A relationship is equally well traversed in both directions so there's no need to create another relationship in the opposite direction (in regards to traversal or performance).

      Parameters:
        `otherNode` - the end node of the new relationship
        `type` - the type of the new relationship
      Returns:
        the newly created relationship

    - #### getRelationshipTypes

          Iterable<RelationshipType> getRelationshipTypes()

      Returns relationship types which this node has one more relationships for. If this node doesn't have any relationships an empty `Iterable` will be returned.
      Returns:
        relationship types which this node has one more relationships for.

    - #### getDegree

          int getDegree()

      Returns the number of relationships connected to this node regardless of direction or type. This operation is always O(1).
      Returns:
        the number of relationships connected to this node.

    - #### getDegree

          int getDegree(RelationshipType type)

      Returns the number of relationships of a given `type` connected to this node. If the degree of this node is less than (TODO) dense node threshold this method will have to load all relationships, if not already loaded, to be able to give the answer. If the number of relationships connected to this node is greater than or equal to the (TODO) dense node threshold this lookup will be O(1).
      Returns:
        the number of relationships of a given `type` connected to this node.

    - #### getDegree

          int getDegree(Direction direction)

      Returns the number of relationships of a given `direction` connected to this node. If the degree of this node is less than (TODO) dense node threshold this method will have to load all relationships, if not already loaded, to be able to give the answer. If the number of relationships connected to this is node greater than or equal to the (TODO) dense node threshold this lookup will be O(1).
      Returns:
        the number of relationships of a given `direction` for this node.

    - #### getDegree

          int getDegree(RelationshipType type,
                      Direction direction)

      Returns the number of relationships of a given `type` and `direction` connected to this node. If the degree of this node is less than (TODO) dense node threshold this method will have to load all relationships, if not already loaded, to be able to give the answer. If the number of relationships connected to this node is greater than or equal to the (TODO) dense node threshold this lookup will be O(1).
      Returns:
        the number of relationships of a given `type` and `direction` for this node.

    - #### traverse

          @Deprecated
          Traverser traverse(Traverser.Order traversalOrder,
                                      StopEvaluator stopEvaluator,
                                      ReturnableEvaluator returnableEvaluator,
                                      RelationshipType relationshipType,
                                      Direction direction)

      Deprecated. because of an unnatural and too tight coupling with `Node`. Also because of the introduction of a new traversal framework. The new way of doing traversals is by creating a new `TraversalDescription` from `Traversal.traversal()`, add rules and behaviors to it and then calling `TraversalDescription.traverse(Node...)`
      Instantiates a traverser that will start at this node and traverse according to the given order and evaluators along the specified relationship type and direction. If the traverser should traverse more than one `RelationshipType`/`Direction` pair, use one of the overloaded variants of this method. The created traverser will iterate over each node that can be reached from this node by the spanning tree formed by the given relationship types (with direction) exactly once. For more information about traversal, see the `Traverser` documentation.
      Parameters:
        `traversalOrder` - the traversal order
        `stopEvaluator` - an evaluator instructing the new traverser about when to stop traversing, either a predefined evaluator such as `StopEvaluator.END_OF_GRAPH` or a custom-written evaluator
        `returnableEvaluator` - an evaluator instructing the new traverser about whether a specific node should be returned from the traversal, either a predefined evaluator such as `ReturnableEvaluator.ALL` or a customer-written evaluator
        `relationshipType` - the relationship type that the traverser will traverse along
        `direction` - the direction in which the relationships of type `relationshipType` will be traversed
      Returns:
        a new traverser, configured as above

    - #### traverse

          @Deprecated
          Traverser traverse(Traverser.Order traversalOrder,
                                      StopEvaluator stopEvaluator,
                                      ReturnableEvaluator returnableEvaluator,
                                      RelationshipType firstRelationshipType,
                                      Direction firstDirection,
                                      RelationshipType secondRelationshipType,
                                      Direction secondDirection)

      Deprecated. because of an unnatural and too tight coupling with `Node`. Also because of the introduction of a new traversal framework. The new way of doing traversals is by creating a new `TraversalDescription` from `Traversal.traversal()`, add rules and behaviors to it and then calling `TraversalDescription.traverse(Node...)`
      Instantiates a traverser that will start at this node and traverse according to the given order and evaluators along the two specified relationship type and direction pairs. If the traverser should traverse more than two `RelationshipType`/`Direction` pairs, use the overloaded `varargs variant` of this method. The created traverser will iterate over each node that can be reached from this node by the spanning tree formed by the given relationship types (with direction) exactly once. For more information about traversal, see the `Traverser` documentation.
      Parameters:
        `traversalOrder` - the traversal order
        `stopEvaluator` - an evaluator instructing the new traverser about when to stop traversing, either a predefined evaluator such as `StopEvaluator.END_OF_GRAPH` or a custom-written evaluator
        `returnableEvaluator` - an evaluator instructing the new traverser about whether a specific node should be returned from the traversal, either a predefined evaluator such as `ReturnableEvaluator.ALL` or a customer-written evaluator
        `firstRelationshipType` - the first of the two relationship types that the traverser will traverse along
        `firstDirection` - the direction in which the first relationship type will be traversed
        `secondRelationshipType` - the second of the two relationship types that the traverser will traverse along
        `secondDirection` - the direction that the second relationship type will be traversed
      Returns:
        a new traverser, configured as above

    - #### traverse

          @Deprecated
          Traverser traverse(Traverser.Order traversalOrder,
                                      StopEvaluator stopEvaluator,
                                      ReturnableEvaluator returnableEvaluator,
                                      Object... relationshipTypesAndDirections)

      Deprecated. because of an unnatural and too tight coupling with `Node`. Also because of the introduction of a new traversal framework. The new way of doing traversals is by creating a new `TraversalDescription` from `Traversal.traversal()`, add rules and behaviors to it and then calling `TraversalDescription.traverse(Node...)`
      Instantiates a traverser that will start at this node and traverse according to the given order and evaluators along the specified relationship type and direction pairs. Unlike the overloaded variants of this method, the relationship types and directions are passed in as a "varargs" variable-length argument which means that an arbitrary set of relationship type and direction pairs can be specified. The variable-length argument list should be every other relationship type and direction, starting with relationship type, e.g:

      `node.traverse( BREADTH_FIRST, stopEval, returnableEval, MyRels.REL1, Direction.OUTGOING, MyRels.REL2, Direction.OUTGOING, MyRels.REL3, Direction.BOTH, MyRels.REL4, Direction.INCOMING );`

      Unfortunately, the compiler cannot enforce this so an unchecked exception is raised if the variable-length argument has a different constitution.

      The created traverser will iterate over each node that can be reached from this node by the spanning tree formed by the given relationship types (with direction) exactly once. For more information about traversal, see the `Traverser` documentation.

      Parameters:
        `traversalOrder` - the traversal order
        `stopEvaluator` - an evaluator instructing the new traverser about when to stop traversing, either a predefined evaluator such as `StopEvaluator.END_OF_GRAPH` or a custom-written evaluator
        `returnableEvaluator` - an evaluator instructing the new traverser about whether a specific node should be returned from the traversal, either a predefined evaluator such as `ReturnableEvaluator.ALL` or a customer-written evaluator
        `relationshipTypesAndDirections` - a variable-length list of relationship types and their directions, where the first argument is a relationship type, the second argument the first type's direction, the third a relationship type, the fourth its direction, etc
      Returns:
        a new traverser, configured as above
      Throws:
        `RuntimeException` - if the variable-length relationship type / direction list is not as described above

    - #### addLabel

          void addLabel(Label label)

      Adds a `Label` to this node. If this node doesn't already have this label it will be added. If it already has the label, nothing will happen.
      Parameters:
        `label` - the label to add to this node.

    - #### removeLabel

          void removeLabel(Label label)

      Removes a `Label` from this node. If this node doesn't have this label, nothing will happen.
      Parameters:
        `label` - the label to remove from this node.

    - #### hasLabel

          boolean hasLabel(Label label)

      Checks whether or not this node has the given label.
      Parameters:
        `label` - the label to check for.
      Returns:
        `true` if this node has the given label, otherwise `false`.

    - #### getLabels

          Iterable<Label> getLabels()

      Lists all labels attached to this node. If this node has no labels an empty `Iterable` will be returned.
      Returns:
        all labels attached to this node.

Copyright © 2002–2014 The Neo4j Graph Database Project. All rights reserved.