org.neo4j.kernel.api.index

Class SchemaIndexProvider

java.lang.Object

org.neo4j.kernel.lifecycle.LifecycleAdapter

org.neo4j.kernel.api.index.SchemaIndexProvider

All Implemented Interfaces:

Comparable<SchemaIndexProvider>, Lifecycle

public abstract class SchemaIndexProvider
extends LifecycleAdapter
implements Comparable<SchemaIndexProvider>

Contract for implementing an index in Neo4j. This is a sensitive thing to implement, because it manages data that is controlled by Neo4js logical log. As such, the implementation needs to behave under some rather strict rules.

Populating the index

When an index rule is added, the IndexingService is notified. It will, in turn, ask your SchemaIndexProvider for a batch index writer. A background index job is triggered, and all existing data that applies to the new rule, as well as new data from the "outside", will be inserted using the writer. You are guaranteed that usage of this writer, during population, will be single threaded. These are the rules you must adhere to here:

• You CANNOT say that the state of the index is InternalIndexState.ONLINE
• You MUST store all updates given to you
• You MAY persistently store the updates

The Flip

Once population is done, the index needs to be "flipped" to an online mode of operation. The index will be notified, through the IndexPopulator.close(boolean) method, that population is done, and that the index should turn it's state to InternalIndexState.ONLINE or InternalIndexState.FAILED depending on the value given to the close method. If the index is persisted to disk, this is a vital part of the index lifecycle. For a persisted index, the index MUST NOT store the state as online unless it first guarantees that the entire index is flushed to disk. Failure to do so could produce a situation where, after a crash, an index is believed to be online when it in fact was not yet fully populated. This would break the database recovery process. If you are implementing this interface, you can choose to not store index state. In that case, you should report index state as InternalIndexState.POPULATING upon startup. This will cause the database to re-create the index from scratch again. These are the rules you must adhere to here:

• You MUST have flushed the index to durable storage if you are to persist index state as InternalIndexState.ONLINE
• You MAY decide not to store index state
• If you don't store index state, you MUST default to InternalIndexState.POPULATING

Online operation

Once the index is online, the database will move to using the online accessor to write to the index.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	SchemaIndexProvider.Descriptor

Field Summary

Fields

Modifier and Type	Field and Description
static DependencyResolver.SelectionStrategy<SchemaIndexProvider>	HIGHEST_PRIORITIZED_OR_NONE
static SchemaIndexProvider	NO_INDEX_PROVIDER

Method Summary

Methods

Modifier and Type	Method and Description
int	compareTo(SchemaIndexProvider o)
boolean	equals(Object o)
abstract InternalIndexState	getInitialState(long indexId) Called during startup to find out which state an index is in.
abstract IndexAccessor	getOnlineAccessor(long indexId, IndexConfiguration config) Used for updating an index once initial population has completed.
abstract IndexPopulator	getPopulator(long indexId, IndexConfiguration config) Used for initially populating a created index, using batch insertion.
SchemaIndexProvider.Descriptor	getProviderDescriptor()
int	hashCode()

Methods inherited from class org.neo4j.kernel.lifecycle.LifecycleAdapter

init, shutdown, start, stop

Methods inherited from class java.lang.Object

getClass, notify, notifyAll, toString, wait, wait, wait

Field Detail

NO_INDEX_PROVIDER

public static final SchemaIndexProvider NO_INDEX_PROVIDER

HIGHEST_PRIORITIZED_OR_NONE

public static final DependencyResolver.SelectionStrategy<SchemaIndexProvider> HIGHEST_PRIORITIZED_OR_NONE

Method Detail

getPopulator

public abstract IndexPopulator getPopulator(long indexId,
                          IndexConfiguration config)

Used for initially populating a created index, using batch insertion.

getOnlineAccessor

public abstract IndexAccessor getOnlineAccessor(long indexId,
                              IndexConfiguration config)
                                         throws IOException

Used for updating an index once initial population has completed.

Throws:

IOException

getInitialState

public abstract InternalIndexState getInitialState(long indexId)

Called during startup to find out which state an index is in.

getProviderDescriptor

public SchemaIndexProvider.Descriptor getProviderDescriptor()

Returns:

a description of this index provider

compareTo

public int compareTo(SchemaIndexProvider o)

Specified by:

compareTo in interface Comparable<SchemaIndexProvider>

equals

public boolean equals(Object o)

Overrides:

equals in class Object

hashCode

public int hashCode()

Overrides:

hashCode in class Object