org.neo4j.graphdb.index

Interface Index<T extends PropertyContainer>

Type Parameters:

T - The type of entities this index manages. It may be either Nodes or Relationships.

All Superinterfaces:

ReadableIndex<T>

All Known Subinterfaces:

RelationshipIndex

public interface Index<T extends PropertyContainer>
extends ReadableIndex<T>

An index to associate key/value pairs with entities (Nodes or Relationships) for fast lookup and querying. Any number of key/value pairs can be associated with any number of entities using add(PropertyContainer, String, Object) and dissociated with remove(PropertyContainer, String, Object). Querting is done using ReadableIndex.get(String, Object) for exact lookups and ReadableIndex.query(Object) or ReadableIndex.query(String, Object) for more advanced querying, exposing querying capabilities from the backend which is backing this particular index. Write operations participates in transactions so committing and rolling back works the same way as usual in Neo4j.

Author:

Mattias Persson

Method Summary

Methods

Modifier and Type	Method and Description
void	add(T entity, String key, Object value) Adds a key/value pair for entity to the index.
void	delete() Clears the index and deletes the configuration associated with it.
T	putIfAbsent(T entity, String key, Object value) Add the entity to this index for the given key/value pair if this particular key/value pair doesn't already exist.
void	remove(T entity) Removes an entity from the index and all its key/value pairs which has been previously associated using add(PropertyContainer, String, Object).
void	remove(T entity, String key) Removes key/value pairs for entity where key is key from the index.
void	remove(T entity, String key, Object value) Removes a key/value pair for entity from the index.

Methods inherited from interface org.neo4j.graphdb.index.ReadableIndex

get, getEntityType, getGraphDatabase, getName, isWriteable, query, query

Method Detail

add

void add(T entity,
       String key,
       Object value)

Adds a key/value pair for entity to the index. If that key/value pair for the entity is already in the index it's up to the implementation to make it so that such an operation is idempotent.

Parameters:

entity - the entity (i.e Node or Relationship) to associate the key/value pair with.

key - the key in the key/value pair to associate with the entity.

value - the value in the key/value pair to associate with the entity.

remove

void remove(T entity,
          String key,
          Object value)

Removes a key/value pair for entity from the index. If that key/value pair isn't associated with entity in this index this operation doesn't do anything.

Parameters:

entity - the entity (i.e Node or Relationship) to dissociate the key/value pair from.

key - the key in the key/value pair to dissociate from the entity.

value - the value in the key/value pair to dissociate from the entity.

remove

void remove(T entity,
          String key)

Removes key/value pairs for entity where key is key from the index. Implementations can choose to not implement this method and should in that case throw UnsupportedOperationException.

Parameters:

entity - the entity (Node or Relationship) to remove the this index.

remove

void remove(T entity)

Removes an entity from the index and all its key/value pairs which has been previously associated using add(PropertyContainer, String, Object). Implementations can choose to not implement this method and should in that case throw UnsupportedOperationException.

Parameters:

entity - the entity (Node or Relationship) to remove the this index.

delete

void delete()

Clears the index and deletes the configuration associated with it. After this it's invalid to call any other method on this index. However if the transaction which the delete operation was called in gets rolled back it again becomes ok to use this index.

putIfAbsent

T putIfAbsent(T entity,
            String key,
            Object value)

Add the entity to this index for the given key/value pair if this particular key/value pair doesn't already exist. This ensures that only one entity will be associated with the key/value pair even if multiple transactions are trying to add it at the same time. One of those transactions will win and add it while the others will block, waiting for the winning transaction to finish. If the winning transaction was successful these other transactions will return the associated entity instead of adding it. If it wasn't successful the waiting transactions will begin a new race to add it.

Parameters:

entity - the entity (i.e Node or Relationship) to associate the key/value pair with.

key - the key in the key/value pair to associate with the entity.

value - the value in the key/value pair to associate with the entity.

Returns:

the previously indexed entity, or null if no entity was indexed before (and the specified entity was added to the index).