|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
timestamp.
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.
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.
key and
value.
indexKey.
null.
node if it has been added to this
timeline.
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.
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.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.node.
Direction.INCOMING if this equals
Direction.OUTGOING, Direction.OUTGOING if this equals Direction.INCOMING or
Direction.BOTH if this equals Direction.BOTH.
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.
Isolation).
Transaction.finish() unless Transaction.failure()
has or will be invoked before then.
TimelineIndex on top of Neo4j, using
BTree for indexing.
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||