Spring Data Graph

org.springframework.data.graph.neo4j.template
Class Neo4jTemplate

java.lang.Object
  extended by org.springframework.data.graph.neo4j.template.Neo4jTemplate
All Implemented Interfaces:
Neo4jOperations

public class Neo4jTemplate
extends Object
implements Neo4jOperations


Constructor Summary
Neo4jTemplate(GraphDatabase graphDatabase)
           
Neo4jTemplate(GraphDatabase graphDatabase, PlatformTransactionManager transactionManager)
           
 
Method Summary
 org.neo4j.graphdb.Node createNode(Property... properties)
          Transactionally creates the node, sets the properties (if any) and indexes the given fields (if any).
 org.neo4j.graphdb.Relationship createRelationship(org.neo4j.graphdb.Node startNode, org.neo4j.graphdb.Node endNode, org.neo4j.graphdb.RelationshipType relationshipType, Property... properties)
          Transactionally creates the relationship, sets the properties (if any) and indexes the given fielss (if any) Two shortcut means of providing the properties (very short with static imports) template.createRelationship(from,to,TYPE, Property.
<T> T
exec(GraphCallback<T> callback)
          Executes the callback in a NON-transactional context.
 org.neo4j.graphdb.Node getNode(long id)
          Delegates to the GraphDatabase
 org.neo4j.graphdb.Node getReferenceNode()
          Delegates to the GraphDatabase
 org.neo4j.graphdb.Relationship getRelationship(long id)
          Delegates to the GraphDatabase
<T extends org.neo4j.graphdb.PropertyContainer>
T
index(String indexName, T element, String field, Object value)
          Indexes the given field and value for the element.
<T> org.neo4j.helpers.collection.ClosableIterable<T>
query(String indexName, PathMapper<T> pathMapper, Object queryOrQueryObject)
          Queries the supplied index with a lucene query string or query object (if the neo4j-index provider is lucene)
<T> org.neo4j.helpers.collection.ClosableIterable<T>
query(String indexName, PathMapper<T> pathMapper, String field, String value)
          Queries the supplied index with a field - value combination
 DataAccessException translateExceptionIfPossible(RuntimeException ex)
           
<T> Iterable<T>
traverseGraph(org.neo4j.graphdb.Node startNode, PathMapper<T> pathMapper, org.neo4j.graphdb.traversal.TraversalDescription traversal)
          Traverses the whole path with the given traversal descripting starting at the start node.
<T> Iterable<T>
traverseNext(org.neo4j.graphdb.Node startNode, PathMapper<T> pathMapper)
          Traverses only to all direct neighbours of the start node for all relationships
<T> Iterable<T>
traverseNext(org.neo4j.graphdb.Node startNode, PathMapper<T> pathMapper, org.neo4j.graphdb.RelationshipType... relationshipTypes)
          Traverses only to the direct neighbours of the start node for the specified relationship types
<T> Iterable<T>
traverseNext(org.neo4j.graphdb.Node startNode, PathMapper<T> pathMapper, org.neo4j.graphdb.RelationshipType relationshipType, org.neo4j.graphdb.Direction direction)
          Traverses only to the direct neighbours of the start node
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

Neo4jTemplate

public Neo4jTemplate(GraphDatabase graphDatabase,
                     PlatformTransactionManager transactionManager)
Parameters:
graphDatabase - the neo4j graph database
transactionManager - if passed in, will be used to create implicit transactions whenever needed

Neo4jTemplate

public Neo4jTemplate(GraphDatabase graphDatabase)
Parameters:
graphDatabase - the neo4j graph database
Method Detail

translateExceptionIfPossible

public DataAccessException translateExceptionIfPossible(RuntimeException ex)

exec

public <T> T exec(GraphCallback<T> callback)
Description copied from interface: Neo4jOperations
Executes the callback in a NON-transactional context.

Specified by:
exec in interface Neo4jOperations
Type Parameters:
T - return type
Parameters:
callback - for executing graph operations NON-transactionally, not null
Returns:
whatever the callback chooses to return

getReferenceNode

public org.neo4j.graphdb.Node getReferenceNode()
Description copied from interface: Neo4jOperations
Delegates to the GraphDatabase

Specified by:
getReferenceNode in interface Neo4jOperations
Returns:
the reference node of the underlying graph database

createNode

public org.neo4j.graphdb.Node createNode(Property... properties)
Description copied from interface: Neo4jOperations
Transactionally creates the node, sets the properties (if any) and indexes the given fields (if any). Two shortcut means of providing the properties (very short with static imports) template.createNode(Property._("name","value")); template.createNode(Property._("name","value","prop","anotherValue"));

Specified by:
createNode in interface Neo4jOperations
Parameters:
properties - properties to be set at node creation might be null
Returns:
the newly created node

getNode

public org.neo4j.graphdb.Node getNode(long id)
Description copied from interface: Neo4jOperations
Delegates to the GraphDatabase

Specified by:
getNode in interface Neo4jOperations
Parameters:
id - node id
Returns:
the requested node of the underlying graph database

getRelationship

public org.neo4j.graphdb.Relationship getRelationship(long id)
Description copied from interface: Neo4jOperations
Delegates to the GraphDatabase

Specified by:
getRelationship in interface Neo4jOperations
Parameters:
id - relationship id
Returns:
the requested relationship of the underlying graph database

index

public <T extends org.neo4j.graphdb.PropertyContainer> T index(String indexName,
                                                               T element,
                                                               String field,
                                                               Object value)
Description copied from interface: Neo4jOperations
Indexes the given field and value for the element.

Specified by:
index in interface Neo4jOperations
Type Parameters:
T - the provided element type
Parameters:
indexName - Name of the index, will be checked against existing indexes according to the given element assumes a "node" node index or "relationship" relationship index for a null value
element - node or relationship to index
field - field to index
value - value to index
Returns:
the provided element for convenience

query

public <T> org.neo4j.helpers.collection.ClosableIterable<T> query(String indexName,
                                                                  PathMapper<T> pathMapper,
                                                                  Object queryOrQueryObject)
Description copied from interface: Neo4jOperations
Queries the supplied index with a lucene query string or query object (if the neo4j-index provider is lucene)

Specified by:
query in interface Neo4jOperations
Parameters:
indexName - Name of the index, will be checked against existing indexes, first relationship-indexes, then node indexes assumes a "node" node index for a null value
pathMapper - a mapper that translates from the resulting paths into some domain object, might use PathMapper.WithoutResult for a callback behaviour
queryOrQueryObject - a lucene query string or query object (if the neo4j-index provider is lucene)
Returns:
a lazy (when mapped) or eagerly (when called back) iterable containing the results of the query result mapping
See Also:
for controlling eagerness of iteration

query

public <T> org.neo4j.helpers.collection.ClosableIterable<T> query(String indexName,
                                                                  PathMapper<T> pathMapper,
                                                                  String field,
                                                                  String value)
Description copied from interface: Neo4jOperations
Queries the supplied index with a field - value combination

Specified by:
query in interface Neo4jOperations
Parameters:
indexName - Name of the index, will be checked against existing indexes, first relationship-indexes, then node indexes assumes a "node" node index for a null value
pathMapper - a mapper that translates from the resulting paths into some domain object, might use PathMapper.WithoutResult for a callback behaviour
field - field to query
value - value to supply to index query
Returns:
a lazy (when mapped) or eagerly (when called back) iterable containing the results of the query result mapping
See Also:
for controlling eagerness of iteration

traverseGraph

public <T> Iterable<T> traverseGraph(org.neo4j.graphdb.Node startNode,
                                     PathMapper<T> pathMapper,
                                     org.neo4j.graphdb.traversal.TraversalDescription traversal)
Description copied from interface: Neo4jOperations
Traverses the whole path with the given traversal descripting starting at the start node.

Specified by:
traverseGraph in interface Neo4jOperations
Type Parameters:
T - expected type of result
Parameters:
startNode - start node for the traversal
pathMapper - pathMapper a mapper that translates from the resulting paths into some domain object, might use PathMapper.WithoutResult for a callback behaviour
traversal - a traversal description, possibly generated by the Traversal.description()... DSL
Returns:
a lazy (when mapped) or eagerly (when called back) iterable containing the results of the traversal result mapping

traverseNext

public <T> Iterable<T> traverseNext(org.neo4j.graphdb.Node startNode,
                                    PathMapper<T> pathMapper,
                                    org.neo4j.graphdb.RelationshipType relationshipType,
                                    org.neo4j.graphdb.Direction direction)
Description copied from interface: Neo4jOperations
Traverses only to the direct neighbours of the start node

Specified by:
traverseNext in interface Neo4jOperations
Type Parameters:
T - expected type of result
Parameters:
startNode - start node for the traversal
pathMapper - pathMapper a mapper that translates from the resulting paths into some domain object, might use PathMapper.WithoutResult for a callback behaviour
relationshipType - type of relationships to consider
direction - direction of relationship to consider (can be OUTGOING, INCOMING, BOTH)
Returns:
a lazy (when mapped) or eagerly (when called back) iterable containing the results of the traversal result mapping

traverseNext

public <T> Iterable<T> traverseNext(org.neo4j.graphdb.Node startNode,
                                    PathMapper<T> pathMapper,
                                    org.neo4j.graphdb.RelationshipType... relationshipTypes)
Description copied from interface: Neo4jOperations
Traverses only to the direct neighbours of the start node for the specified relationship types

Specified by:
traverseNext in interface Neo4jOperations
Type Parameters:
T - expected type of result
Parameters:
startNode - start node for the traversal
pathMapper - pathMapper a mapper that translates from the resulting paths into some domain object, might use PathMapper.WithoutResult for a callback behaviour
relationshipTypes - types of relationships to consider
Returns:
a lazy (when mapped) or eagerly (when called back) iterable containing the results of the traversal result mapping

traverseNext

public <T> Iterable<T> traverseNext(org.neo4j.graphdb.Node startNode,
                                    PathMapper<T> pathMapper)
Description copied from interface: Neo4jOperations
Traverses only to all direct neighbours of the start node for all relationships

Specified by:
traverseNext in interface Neo4jOperations
Type Parameters:
T - expected type of result
Parameters:
startNode - start node for the traversal
pathMapper - pathMapper a mapper that translates from the resulting paths into some domain object, might use PathMapper.WithoutResult for a callback behaviour
Returns:
a lazy (when mapped) or eagerly (when called back) iterable containing the results of the traversal result mapping

createRelationship

public org.neo4j.graphdb.Relationship createRelationship(org.neo4j.graphdb.Node startNode,
                                                         org.neo4j.graphdb.Node endNode,
                                                         org.neo4j.graphdb.RelationshipType relationshipType,
                                                         Property... properties)
Description copied from interface: Neo4jOperations
Transactionally creates the relationship, sets the properties (if any) and indexes the given fielss (if any) Two shortcut means of providing the properties (very short with static imports) template.createRelationship(from,to,TYPE, Property._("name","value")); template.createRelationship(from,to,TYPE, Property._("name","value","prop","anotherValue"));

Specified by:
createRelationship in interface Neo4jOperations
Parameters:
startNode - start-node of relationship
endNode - end-node of relationship
relationshipType - relationship type, might by an enum implementing RelationshipType or a DynamicRelationshipType.withName("name")
properties - optional initial properties
Returns:
the newly created relationship

Spring Data Graph

Copyright © 2011. All Rights Reserved.