|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
timestamp
.
ConfigurationModule
.RemoteGraphDatabase
instance.graph database client
can connect to.LuceneIndexService.getLazySearchResultThreshold()
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.
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.
java.lang.Object
.
Transaction.finish()
is called.
Transaction.success()
or Transaction.failure()
has been previously invoked.
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.
null
if there's no nodes in the timeline.
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)
, but with sorted result.
LuceneReadOnlyIndexService.getNodes(String, Object)
, but with sorted result.
timestamp
.
Node
s sent to the client in an
iteration.
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.
Relationship
s sent to the
client in an iteration.
key
and
value
.
indexKey
.
null
.
node
if it has been added to this
timeline.
RelationshipType
s sent to the
client in an iteration.
java.lang.Object
.
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.
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.true
if the current position is the start node,
false
otherwise.
type
.
Iterator
representing the traversal of the graph.
Map
.
Map
.
ConnectionTarget
that isn't really remote.ConnectionTarget
.
ConnectionTarget
.
Transport
that creates LocalGraphDatabase
s.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
.Node
.true
if the current position is anywhere except on
the start node, false
if it is on the start node.
nodes
and
relationships
.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.
ConnectionTarget
implementation with a specified protocol.
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.node
.
RemoteResponse
object, used for
getting state from a RemoteResponse
.Direction.INCOMING
if this equals
Direction.OUTGOING
, Direction.OUTGOING
if this equals Direction.INCOMING
or
Direction.BOTH
if this equals Direction.BOTH
.
Transport
that communicates with a remote graph database using RMI.Transport
for the rmi:// protocol.
LuceneIndexService.formQuery(String, Object)
can be used when getting stuff from inside a transaction.
RemoteIndexService
.
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
.
Isolation
).
Transaction.finish()
unless Transaction.failure()
has or will be invoked before then.
TimelineIndex
on top of Neo4j, using
BTree
for indexing.ConnectionTarget
can handle,
and can create instances of that ConnectionTarget
.Transport
that supports the protocols
specified by the supplied protocol schema identifiers.
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |