|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
RelationshipType to the Expander.
RelationshipType with a Direction to the
Expander.
entity to the index.
entity to the index.
timestamp.
Node filter.
Relationship filter.
iterator to collection.
iterator to collection.
AbstractGraphDatabase to a destination
directory.
AbstractGraphDatabase to another running
AbstractGraphDatabase.
iterator as an Iterable.
PathFinder which uses the A* algorithm to find the
cheapest path between two nodes.
Evaluator which only includes positions at depth
and prunes everything deeper than that.
BatchInserter version of Index.BatchInserterIndexs from a certain index provider.BranchSelector instances with a starting point to base
the first decision on.TraversalDescription.order(BranchOrderingPolicy)
where a "preorder breadth first" selector is used.
Iterator which lazily fetches and caches items from the
underlying iterator when items are requested.source as its underlying
Iterator to get items lazily from.
branch is unique, and hence can be
visited in this traversal.
ConfigurationModule.Collection, making it look (and function) like a collection
holding another type of items.TraversalBranchs with a common
head node in order to obtain an
TraversalBranch representing a path from the start node of the
source TraversalBranch to the start node of the
target TraversalBranch.
Iterables, making them look like they were
one big iterable.Iterators, making them look like they were
one big iterator.CostEvaluator and EstimateEvaluator.RemoteGraphDatabase instance.graph database client
can connect to.iterator by looping
through it.
iterable by looping through it.
BranchSelector with startBranch as the
first branch to base a decision on "where to go next".
CachingIterator.next()/CachingIterator.previous().
Iterator.next()).
AbstractGraphDatabase to a destination
directory.
AbstractGraphDatabase to another running
AbstractGraphDatabase.
LuceneIndexService.getLazySearchResultThreshold()
Path.
TraversalDescription.order(BranchOrderingPolicy)
where a "preorder depth first" selector is used.
TraversalDescription with default value for
everything so that it's OK to call
TraversalDescription.traverse(org.neo4j.graphdb.Node) without
modification.
PathFinder which uses the Dijkstra algorithm to find
the cheapest path between two nodes.
GraphAlgoFactory.dijkstra(RelationshipExpander, CostEvaluator).
RelationshipType.GraphDatabaseService that is used to embed Neo4j
in an application.GraphDatabaseService with a store located in
storeDir, which will be created if it doesn't already exist.
GraphDatabaseService
with a set of configuration parameters.
EmbeddedGraphDatabase.GraphDatabaseService with a store located in
storeDir.
GraphDatabaseService
with a set of configuration parameters.
Expander which, if not modified, will expand
all relationships when asked to expand a Node.
key) so
that the maxNumberOfCachedEntries number of results found with
LuceneIndexService.getNodes(String, Object) are cached for faster consecutive
lookups.
key) so
that the maxNumberOfCachedEntries number of results found with
LuceneReadOnlyIndexService.getNodes(String, Object) are cached for faster consecutive
lookups.
FileHandler
enable_remote_shell = trueIn your configuration and it will be started with default port and RMI name. If you'd like to control the port and RMI name of the shell instead put:
enable_remote_shell = port=1337,name=shell
enable_remote_shell = port=1337,name=shellIn your configuration and it will be started with the supplied port and RMI name. If you instead would like to use default parameters, put:
enable_remote_shell = true
java.lang.Object.
Path and returns an Evaluation containing
information about whether or not to include it in the traversal result,
i.e return it from the Traverser.
Evaluator.evaluate(org.neo4j.graphdb.Path).TraversalDescription.filter(Predicate) and TraversalDescription.prune(PruneEvaluator).
Evaluators useful during common traversals.indexName.
indexName.
RelationshipExpander as the expander of relationships,
discarding all previous calls to
TraversalDescription.relationships(RelationshipType) and
TraversalDescription.relationships(RelationshipType, Direction).
RelationshipExpander interface
that makes it possible to build customized versions of an Expander.RelationshipExpander wrapped as an Expander.
RelationshipExpander which expands relationships
of all types and directions.
RelationshipExpander which expands relationships
of all types in the given direction.
RelationshipExpander which is set to expand
relationships with type and direction.
RelationshipExpander which is set to expand
relationships with type in any direction.
RelationshipExpander which is set to expand
relationships with two different types and directions.
RelationshipExpander which is set to expand
relationships with multiple types and directions.
Transaction.finish() is called.
Evaluator. Use
TraversalDescription.evaluator(Evaluator) instead which combines
TraversalDescription.filter(Predicate) and TraversalDescription.prune(PruneEvaluator). The supplied
Predicate will be wrapped by an Evaluator internally.
start and end nodes.
start and end
nodes.
Transaction.success() or Transaction.failure() has been previously invoked.
null if no
element found.
null if no
element found.
BatchInserterIndex.get(String, Object),
BatchInserterIndex.query(String, Object) and BatchInserterIndex.query(Object) so that they
are guaranteed to return correct results.
Index for Nodes with the name indexName.
Index for Nodes with the name indexName.
Index for Relationships with the name indexName.
Index for Relationships with the name indexName.
Evaluator which only includes positions from depth
and deeper and never prunes anything.
Map of key/value pairs.
Map.
TimelineIndex.getAllNodes(),
TimelineIndex.getAllNodesAfter(long), TimelineIndex.getAllNodesBefore(long) and
TimelineIndex.getAllNodesBetween(long, long) in a single method.
timestamp ordered by
increasing timestamp.
timestamp ordered by
increasing timestamp.
afterTimestamp and before
(exclusive) beforeTimestamp ordered by increasing timestamp.
index.
key.
null if there's no nodes in the timeline.
GraphDatabaseService that this Node or
Relationship belongs to.
null if there's no nodes in the timeline.
LuceneIndexService.getNodes(String, Object) will return very fast and all the
reading and fetching of nodes is done lazily before each step in the
iteration of the returned result.
LuceneIndexService.getLazySearchResultThreshold()
Returns the threshold for when a result is considered big enough to skip
cache and be returned as a fully lazy iterator so that
LuceneReadOnlyIndexService.getNodes(String, Object) will return very fast and all the
reading and fetching of nodes is done lazily before each step in the
iteration of the returned result.
key and value.
value is treated as a lucene query,
http://lucene.apache.org/java/2_9_1/queryparsersyntax.html
So if you've indexed node (1) with value "Andy Wachowski" and node (2)
with "Larry Wachowski" you can expect this behaviour if you query for:
"andy" --> (1)
"Andy" --> (1)
"wachowski" --> (1), (2)
"+wachow* +larry" --> (2)
"andy AND larry" -->
"andy OR larry" --> (1), (2)
"larry Wachowski" --> (1), (2)
The default AND/OR behaviour can be changed by overriding
LuceneFulltextQueryIndexService.getDefaultQueryOperator(String, Object).
key and value
.
key and value.
LuceneIndexService.getNodes(String, Object)).
LuceneIndexService.getNodes(String, Object), but with sorted result.
LuceneReadOnlyIndexService.getNodes(String, Object), but with sorted result.
timestamp.
Nodes sent to the client in an
iteration.
LuceneFulltextIndexService.getNodes(String, Object) using exact matching, so that
it for this call behaves like LuceneIndexService.
LuceneIndexService.getNodes(String, Object) using exact
matching.
indexKey
PropertyContainer.getPropertyKeys() in combination
with PropertyContainer.getProperty(String).
types
that are attached to this node, regardless of direction.
OUTGOING or
INCOMING relationships from this node.
Relationships sent to the
client in an iteration.
null
if no specific resource is associated with this handler or if it isn't
desirable to expose it.
null there was none.
key and
value.
LuceneIndexService.getSingleNode(String, Object) using exact
matching.
indexKey.
null.
node if it has been added to this
timeline.
RelationshipTypes sent to the
client in an iteration.
java.lang.Object.
CachingIterator.next() will be able to return
an item or not.
PrefetchingIterator.next() will remember it and won't
try to fetch it again.
CachingIterator.previous() will be able to
return an item or not.
true if this property container has a property
accessible through the given key, false otherwise.
true if there are any relationships attached to this
node, false otherwise.
true if there are any relationships of any of the
types in types attached to this node (regardless of
direction), false otherwise.
true if there are any relationships in the given
direction attached to this node, false otherwise.
true if there are any relationships of the given
relationship type and direction attached to this node, false
otherwise.
Evaluator which only includes positions between
depths minDepth and maxDepth.
IndexManager paired with this graph database service
and is the entry point for managing indexes coupled with this database.
Nodes or
Relationships) for fast lookup and querying.IndexService.node with key and value.
node with key and value.
Iterator with additional IndexHits.size() and IndexHits.close()
methods on it, used for iterating over index query results.Iterator with additional IndexHits.size() and IndexHits.close()
methods on it, used for iterating over index query results.Indexs for Nodes
and Relationships.Indexs.node is deleted in this transaction.
relationship is deleted in this transaction.
true if the current position is the start node,
false otherwise.
type.
Iterable so that it returns items of another type.Nodes and Relationships of this
path in order.
Paths.
Iterator representing the traversal of the graph.
Iterators and
Iterables.Iterator so that it returns items of another type.KernelEventHandler.ExecutionOrder.BEFORE,
KernelEventHandler.ExecutionOrder.AFTER another handler, or if it
KernelEventHandler.ExecutionOrder.DOESNT_MATTER.null if no
element found.
null if no
element found.
Relationship in this path.
Map from a Reader assuming strings as keys
and values.
Map from an InputStream assuming strings as keys
and values.
Map from a File assuming strings as keys
and values.
Map.
Map.
Map from a Reader assuming strings as keys
and values.
Map from an InputStream assuming strings as keys
and values.
Map from a File assuming strings as keys
and values.
ConnectionTarget that isn't really remote.ConnectionTarget.
ConnectionTarget.
Transport that creates LocalGraphDatabases.Transport for the file:// protocol.
Analyzer for fulltext parsing.
XaDataSource optimized for the LuceneIndexService.LuceneFulltextDataSource.
LuceneFulltextIndexService.LuceneIndexService which indexes the values with fulltext indexing.LuceneFulltextIndexService which treats the value in
LuceneFulltextQueryIndexService.getNodes(String, Object) as a Lucene query, given in the
Lucene query syntax.LuceneIndexService.LuceneIndexBatchInserter.IndexService which uses Lucene as backend.LuceneReadOnlyIndexService.LuceneIndexService which is read-only and will throw
ReadOnlyIndexException in
IndexService.index(Node, String, Object) and
IndexService.removeIndex(Node, String, Object).LuceneDataSource.Map of key/value pairs where
keys are Strings and values are Objects.
Map of key/value pairs where
keys are Strings and values are Objects.
Maps.AbstractGraphDatabase to a destination
directory.
AbstractGraphDatabase to another running
AbstractGraphDatabase.
rules.
CachingIterator.position().
PrefetchingIterator.hasNext() to try to fetch the next item and returns it
if found, otherwise it throws a NoSuchElementException.
Iterator instance which exposes the current page
as its own iterator, which fetches items lazily from the underlying
iterator.
BatchInserterIndex for Nodes for the name
indexName with the given config.
Index for Nodes for the name
indexName with the given config.
Node indexes.
Node.
Nodes.
Node.PruneEvaluator, does not prune any parts of the
traversal.
true if the current position is anywhere except on
the start node, false if it is on the start node.
BranchOrderingPolicy to use.
GraphAlgoFactory.Maps.CachingIterator which can more easily divide the items
into pages, where optionally each page can be seen as its own
Iterator instance for convenience using PagingIterator.nextPage().source as its underlying
Iterator to lazily get items from.
TraversalBranch.
Path, using
the given builder.
PrefetchingIterator.hasNext() method will look up the next object and
cache it with PrefetchingIterator.setPrefetchedNext(Object).nodes and
relationships.Evaluator. Use
TraversalDescription.evaluator(Evaluator) instead which combines
TraversalDescription.filter(Predicate) and TraversalDescription.prune(PruneEvaluator). The supplied
PruneEvaluator will be wrapped by an Evaluator internally.
position.
Evaluator. The equivalent
is Evaluators.toDepth(int).
Evaluator which combines
PruneEvaluator and filtering (Predicate of Paths).key and
query object, which can be a query string or an implementation-specific
query object.
key and
query object, which can be a query string or an implementation-specific
query object.
key and
query object, which can be a query string or an implementation-specific
query object.
IndexService.index(org.neo4j.graphdb.Node, String, Object) or
IndexService.removeIndex(org.neo4j.graphdb.Node, String, Object)
methods.GraphDatabaseService as an RMI service with a given name.
GraphDatabaseService as an RMI service with a given name on
a given port.
GraphDatabaseService as an RMI service with a given name on
a given port.
handler as a handler for kernel events which
are generated from different places in the lifecycle of the kernel.
ConnectionTarget implementation with a specified protocol.
handler as a handler for transaction events which
are generated from different places in the lifecycle of each
transaction.
BatchInserterIndex for Relationships for the name
indexName with the given config.
Index for Relationships for the name
indexName with the given config.
Index interface with additional get/query methods which
are specific to Relationships.Relationship indexes.
Relationship.
type to the list of relationship types to traverse.
type to the list of relationship types to traverse in
the given direction.
Relationships.
Relationship.Relationship serialization.
Graph Database
instance, providing access to the Neo4j Graph Database API.IndexService for the client side of
RemoteGraphDatabase.IndexService.
RemoteConnection.RemoteResponse objects.RelationshipType from the Expander.
entity from the index.
node.
key.
key is part of, i.e.
RemoteResponse object, used for
getting state from a RemoteResponse.Evaluator. The equivalent
is Evaluators.all().
Evaluator. The equivalent
is Evaluators.excludeStartPosition().
Direction.INCOMING if this equals
Direction.OUTGOING, Direction.OUTGOING if this equals Direction.INCOMING or
Direction.BOTH if this equals Direction.BOTH.
RelationshipTypes, but
with all directions reversed (see Direction.reverse()).
Transport that communicates with a remote graph database using RMI.Transport for the rmi:// protocol.
Service, that compares keys
using case insensitive comparison instead of exact comparison.key.
LuceneIndexService#formQuery(String, Object)
can be used when getting stuff from inside a transaction.
LuceneIndexService.getNodes(String, Object) will return very fast and all the
reading and fetching of nodes is done lazily before each step in the
iteration of the returned result.
LuceneIndexService.setLazySearchResultThreshold(int)
)
Sets the threshold for when a result is considered big enough to skip
cache and be returned as a fully lazy iterator so that
LuceneReadOnlyIndexService.getNodes(String, Object) will return very fast and all the
reading and fetching of nodes is done lazily before each step in the
iteration of the returned result.
value.
Path.length() as possible) between two nodes.
Path.
Path.
null if no
element found.
null if no
element found.
Map of key/value pairs where
both keys and values are Strings.
Map of key/value pairs where
both keys and values are Strings.
Transaction.finish() unless Transaction.failure()
has or will be invoked before then.
TimelineIndex on top of Neo4j, using
BTree for indexing.Evaluator which includes positions down to depth
and prunes everything deeper than that.
ConnectionTarget can handle,
and can create instances of that ConnectionTarget.Transport that supports the protocols
specified by the supplied protocol schema identifiers.
Traversal.PathDescriptor used in common toString()
representations in classes implementing Path.Path.position and a RelationshipExpander with a
traversal context, for example parent and an iterator of relationships to go
next.startNode based on all the rules and
behavior in this description.
UniquenessFactory for creating the
UniquenessFilter to use.
UniquenessFactory for creating the
UniquenessFilter to use.
handler from the list of kernel event handlers.
handler from the list of transaction event handlers.
entity to the index.
Path that has an associated weight.
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||