OIndexAbstract (OrientDB 2.2.37 API)

java.lang.Object
- com.orientechnologies.orient.core.index.OIndexAbstract<T>

All Implemented Interfaces:

OIndex<T>, OIndexInternal<T>, OOrientShutdownListener, OOrientStartupListener, Comparable<OIndex<T>>

Direct Known Subclasses:

OIndexMultiValues, OIndexOneValue, OLuceneIndexNotUnique
```
public abstract class OIndexAbstract<T>
extends Object
implements OIndexInternal<T>, OOrientStartupListener, OOrientShutdownListener
```
Handles indexing when records change. The underlying lock manager for keys can be the OPartitionedLockManager, the default one, or the OOneEntryPerKeyLockManager in case of distributed. This is to avoid deadlock situation between nodes where keys have the same hash code.

Author:

Luca Garulli

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

protected static class OIndexAbstract.IndexConfiguration

protected static class OIndexAbstract.IndexTxSnapshot

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`OIndexAbstract.IndexConfiguration`
`protected static class`	`OIndexAbstract.IndexTxSnapshot`

Field Summary

Fields
Modifier and Type	Field and Description
`protected static String`	`CONFIG_CLUSTERS`
`protected static String`	`CONFIG_MAP_RID`
`protected OIndexAbstract.IndexConfiguration`	`configuration`
`protected int`	`indexId`
`protected OLockManager<Object>`	`keyLockManager`
`protected ODocument`	`metadata`
`protected OAbstractPaginatedStorage`	`storage`
`protected String`	`type`
`protected String`	`valueContainerAlgorithm`

Fields inherited from interface com.orientechnologies.orient.core.index.OIndexInternal
ALGORITHM, CONFIG_AUTOMATIC, CONFIG_KEYTYPE, CONFIG_NAME, CONFIG_TYPE, INDEX_DEFINITION, INDEX_DEFINITION_CLASS, INDEX_VERSION, METADATA, VALUE_CONTAINER_ALGORITHM

Fields inherited from interface com.orientechnologies.orient.core.index.OIndex
MERGE_KEYS

Constructor Summary

Constructors
Constructor and Description
`OIndexAbstract(String name, String type, String algorithm, String valueContainerAlgorithm, ODocument metadata, int version, OStorage storage)`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`acquireAtomicExclusiveLock(Object key)` Acquires exclusive lock in the active atomic operation running on the current thread for this index.
`protected void`	`acquireExclusiveLock()`
`protected void`	`acquireSharedLock()`
`OIndexAbstract<T>`	`addCluster(String clusterName)` Add given cluster to the list of clusters that should be automatically indexed.
`void`	`addTxOperation(OTransactionIndexChanges changes)`
`ODocument`	`checkEntry(OIdentifiable iRecord, Object iKey)` For unique indexes it will throw exception if passed in key is contained in index.
`OIndex<T>`	`clear()` Clears the index removing all the entries in one shot.
`protected void`	`clearSnapshot(OIndexAbstract.IndexTxSnapshot indexTxSnapshot)`
`void`	`close()`
`void`	`commit()`
`protected void`	`commitSnapshot(Map<Object,Object> snapshot)`
`int`	`compareTo(OIndex<T> index)`
`boolean`	`contains(Object key)` Tells if a key is contained in the index.
`long`	`count(Object iKey)` Counts the entries for the key.
`OIndexInternal<?>`	`create(OIndexDefinition indexDefinition, String clusterIndexName, Set<String> clustersToIndex, boolean rebuild, OProgressListener progressListener, OBinarySerializer valueSerializer)` Creates the index.
`OIndexInternal<T>`	`delete()` Delete the index.
`protected abstract OBinarySerializer`	`determineValueSerializer()`
`protected void`	`doReloadIndexEngine()`
`boolean`	`equals(Object o)`
`void`	`flush()` Flushes in-memory changes to disk.
`String`	`getAlgorithm()` Returns the engine of the index as string.
`Set<String>`	`getClusters()` Returns Names of clusters that will be indexed.
`Object`	`getCollatingValue(Object key)`
`ODocument`	`getConfiguration()` Returns the index configuration.
`protected ODatabaseDocumentInternal`	`getDatabase()`
`String`	`getDatabaseName()`
`OIndexDefinition`	`getDefinition()`
`protected Map<String,String>`	`getEngineProperties()`
`Object`	`getFirstKey()`
`int`	`getIndexId()`
`String`	`getIndexNameByKey(Object key)` Returns the index name for a key.
`OIndexInternal<T>`	`getInternal()` Returns the internal index used.
`OType[]`	`getKeyTypes()` Types of the keys that index can accept, if index contains composite key, list of types of elements from which this index consist will be returned, otherwise single element (key type obviously) will be returned.
`Object`	`getLastKey()`
`ODocument`	`getMetadata()`
`String`	`getName()` Returns the index name.
`long`	`getRebuildVersion()` Returns amount of times when index was rebuilt since storage was opened.
`String`	`getType()` Returns the type of the index as string.
`int`	`getVersion()` Returns binary format version for this index.
`int`	`hashCode()`
`boolean`	`hasRangeQuerySupport()`
`protected long[]`	`indexCluster(String clusterName, OProgressListener iProgressListener, long documentNum, long documentIndexed, long documentTotal)`
`protected OIndexAbstract.IndexConfiguration`	`indexConfigurationInstance(ODocument document)`
`protected Iterable<OTransactionIndexChangesPerKey.OTransactionIndexEntry>`	`interpretTxKeyChanges(OTransactionIndexChangesPerKey changes)` Interprets transaction index changes for a certain key.
`boolean`	`isAutomatic()` Tells if the index is automatic.
`boolean`	`isRebuilding()`
`boolean`	`isUnique()`
`OIndexKeyCursor`	`keyCursor()`
`boolean`	`loadFromConfiguration(ODocument config)` Loads the index giving the configuration.
`OIndexMetadata`	`loadMetadata(ODocument config)`
`static OIndexMetadata`	`loadMetadataInternal(ODocument config, String type, String algorithm, String valueContainerAlgorithm)`
`Lock[]`	`lockKeysForUpdate(Collection<Object> keys)` Applies exclusive lock on keys which prevents read/modification of this keys in following methods: `OIndex.put(Object, com.orientechnologies.orient.core.db.record.OIdentifiable)` `OIndex.checkEntry(com.orientechnologies.orient.core.db.record.OIdentifiable, Object)` `OIndex.remove(Object, com.orientechnologies.orient.core.db.record.OIdentifiable)` `OIndex.remove(Object)`
`void`	`lockKeysForUpdate(Object... key)` Applies exclusive lock on keys which prevents read/modification of this keys in following methods: `OIndex.put(Object, com.orientechnologies.orient.core.db.record.OIdentifiable)` `OIndex.checkEntry(com.orientechnologies.orient.core.db.record.OIdentifiable, Object)` `OIndex.remove(Object, com.orientechnologies.orient.core.db.record.OIdentifiable)` `OIndex.remove(Object)`
`protected void`	`onIndexEngineChange(int indexId)`
`void`	`onShutdown()`
`void`	`onStartup()`
`protected void`	`populateIndex(ODocument doc, Object fieldValue)`
`void`	`postCommit()`
`void`	`preCommit()`
`protected void`	`putInSnapshot(Object key, OIdentifiable value, Map<Object,Object> snapshot)`
`long`	`rebuild()` Rebuilds an automatic index.
`long`	`rebuild(OProgressListener iProgressListener)` Populate the index with all the existent records.
`protected void`	`releaseExclusiveLock()`
`void`	`releaseKeysForUpdate(Object... key)` Release exclusive lock on keys which prevents read/modification of this keys in following methods: `OIndex.put(Object, com.orientechnologies.orient.core.db.record.OIdentifiable)` `OIndex.checkEntry(com.orientechnologies.orient.core.db.record.OIdentifiable, Object)` `OIndex.remove(Object, com.orientechnologies.orient.core.db.record.OIdentifiable)` `OIndex.remove(Object)` This is internal method and cannot be used by end users.
`protected void`	`releaseSharedLock()`
`boolean`	`remove(Object key)` Removes an entry by its key.
`boolean`	`remove(Object key, OIdentifiable value)` Removes an entry by its key and value.
`OIndexAbstract<T>`	`removeCluster(String iClusterName)` Remove given cluster from the list of clusters that should be automatically indexed.
`protected void`	`removeFromSnapshot(Object key, Map<Object,Object> snapshot)`
`protected void`	`removeFromSnapshot(Object key, OIdentifiable value, Map<Object,Object> snapshot)`
`void`	`setRebuildingFlag()`
`void`	`setType(OType type)`
`String`	`toString()`
`ODocument`	`updateConfiguration()` Saves the index configuration to disk.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface com.orientechnologies.orient.core.index.OIndexInternal
canBeUsedInEqualityOperators

Methods inherited from interface com.orientechnologies.orient.core.index.OIndex
create, cursor, descCursor, get, getKeySize, getSize, iterateEntries, iterateEntriesBetween, iterateEntriesMajor, iterateEntriesMinor, put, supportsOrderedIterations

- Field Detail
  - CONFIG_MAP_RID
```
protected static final String CONFIG_MAP_RID
```
    See Also:
    
    Constant Field Values
  - CONFIG_CLUSTERS
```
protected static final String CONFIG_CLUSTERS
```
    See Also:
    
    Constant Field Values
  - type
```
protected final String type
```
  - keyLockManager
```
protected final OLockManager<Object> keyLockManager
```
  - configuration
```
protected volatile OIndexAbstract.IndexConfiguration configuration
```
  - metadata
```
protected final ODocument metadata
```
  - storage
```
protected final OAbstractPaginatedStorage storage
```
  - valueContainerAlgorithm
```
protected String valueContainerAlgorithm
```
  - indexId
```
protected volatile int indexId
```
- Constructor Detail
  - OIndexAbstract
```
public OIndexAbstract(String name,
                      String type,
                      String algorithm,
                      String valueContainerAlgorithm,
                      ODocument metadata,
                      int version,
                      OStorage storage)
```
- Method Detail
  - loadMetadataInternal
```
public static OIndexMetadata loadMetadataInternal(ODocument config,
                                                  String type,
                                                  String algorithm,
                                                  String valueContainerAlgorithm)
```
  - onShutdown
```
public void onShutdown()
```
    Specified by:
    
    onShutdown in interface OOrientShutdownListener
  - onStartup
```
public void onStartup()
```
    Specified by:
    
    onStartup in interface OOrientStartupListener
  - flush
```
public void flush()
```
    Description copied from interface: OIndex
    
    Flushes in-memory changes to disk.
    
    Specified by:
    
    flush in interface OIndex<T>
  - hasRangeQuerySupport
```
public boolean hasRangeQuerySupport()
```
    Specified by:
    
    hasRangeQuerySupport in interface OIndexInternal<T>
  - create
```
public OIndexInternal<?> create(OIndexDefinition indexDefinition,
                                String clusterIndexName,
                                Set<String> clustersToIndex,
                                boolean rebuild,
                                OProgressListener progressListener,
                                OBinarySerializer valueSerializer)
```
    Creates the index.
    
    Parameters:
    
    clusterIndexName - Cluster name where to place the TreeMap
    
    clustersToIndex -
    
    rebuild -
    
    progressListener -
    
    valueSerializer -
  - doReloadIndexEngine
```
protected void doReloadIndexEngine()
```
  - count
```
public long count(Object iKey)
```
    Description copied from interface: OIndex
    
    Counts the entries for the key.
    
    Specified by:
    
    count in interface OIndex<T>
  - loadFromConfiguration
```
public boolean loadFromConfiguration(ODocument config)
```
    Description copied from interface: OIndexInternal
    
    Loads the index giving the configuration.
    
    Specified by:
    
    loadFromConfiguration in interface OIndexInternal<T>
    
    Parameters:
    
    config - ODocument instance containing the configuration
  - getEngineProperties
```
protected Map<String,String> getEngineProperties()
```
  - loadMetadata
```
public OIndexMetadata loadMetadata(ODocument config)
```
    Specified by:
    
    loadMetadata in interface OIndexInternal<T>
  - contains
```
public boolean contains(Object key)
```
    Description copied from interface: OIndex
    
    Tells if a key is contained in the index.
    
    Specified by:
    
    contains in interface OIndex<T>
    
    Parameters:
    
    key - The key to search
    
    Returns:
    
    True if the key is contained, otherwise false
  - rebuild
```
public long rebuild()
```
    Rebuilds an automatic index.
    
    Specified by:
    
    rebuild in interface OIndex<T>
    
    Returns:
    
    The number of entries rebuilt
    
    See Also:
    
    OIndex.getRebuildVersion()
  - setRebuildingFlag
```
public void setRebuildingFlag()
```
    Specified by:
    
    setRebuildingFlag in interface OIndexInternal<T>
  - close
```
public void close()
```
    Specified by:
    
    close in interface OIndexInternal<T>
  - getFirstKey
```
public Object getFirstKey()
```
    Specified by:
    
    getFirstKey in interface OIndex<T>
  - getLastKey
```
public Object getLastKey()
```
    Specified by:
    
    getLastKey in interface OIndex<T>
  - getRebuildVersion
```
public long getRebuildVersion()
```
    Returns amount of times when index was rebuilt since storage was opened.
    It is used to support so called "live index rebuild" feature.
    Value of this version is increased every time when index is going to be rebuild. So if two sequential calls of this method return different numbers it means that index at least started to rebuild itself.
    If you use indexes to increase speed of fetching data from database you should follow following workflow:
    1. Read index rebuild version.
    2. Check index rebuild flag OIndex.isRebuilding(), if it is true, do not use index and fetch data directly from database clusters.
    3. Fetch data from index.
    4. Read index rebuild version again, if it is not equal to version which was read at first time, go to step 2. It is VERY important do not reorder steps 1 and 2. Such recording may lead to situation when index is rebuilding but we miss this state.
    This approach works well ONLY if you do not use methods which return OIndexCursor instance. In case of you work with cursors index rebuild may cause data inconsistency issues in both:
    1. Code which calls index methods to create cursor (can be avoided using steps are listed above)
    2. During iteration over the cursor itself
    To detect last data inconsistency issue please use cursor wrapper OIndexChangesWrapper which throws OIndexIsRebuildingException in case of index rebuild.
    Both of these approaches are used in implementation of support of "live index rebuild" for SELECT SQL queries.
    1. In case of index which we are going to use to speed up SELECT query is rebuilding we skip this index.
    2. If index is rebuilding at the moment when we iterate over the cursor we catch OIndexIsRebuildingException exception and retry whole query again.
    Specified by:
    
    getRebuildVersion in interface OIndex<T>
    
    Returns:
    
    amount of times when index was rebuilt since the start of the storage.
    
    See Also:
    
    OCommandExecutorSQLSelect.searchForIndexes(com.orientechnologies.orient.core.metadata.schema.OClass), OCommandExecutorSQLSelect.getIndexCursors(com.orientechnologies.orient.core.metadata.schema.OClass), OCommandExecutorSQLSelect.getOptimizedSortCursor(com.orientechnologies.orient.core.metadata.schema.OClass), OAbstractPaginatedStorage.command(com.orientechnologies.orient.core.command.OCommandRequestText), OIndexChangesWrapper, OIndexIsRebuildingException, ORetryQueryException
  - rebuild
```
public long rebuild(OProgressListener iProgressListener)
```
    Populate the index with all the existent records.
    
    Specified by:
    
    rebuild in interface OIndex<T>
    
    See Also:
    
    OIndex.getRebuildVersion()
  - remove
```
public boolean remove(Object key,
                      OIdentifiable value)
```
    Description copied from interface: OIndex
    
    Removes an entry by its key and value.
    
    Specified by:
    
    remove in interface OIndex<T>
    
    Parameters:
    
    key - The entry's key to remove
    
    Returns:
    
    True if the entry has been found and removed, otherwise false
  - remove
```
public boolean remove(Object key)
```
    Description copied from interface: OIndex
    
    Removes an entry by its key.
    
    Specified by:
    
    remove in interface OIndex<T>
    
    Parameters:
    
    key - The entry's key to remove
    
    Returns:
    
    True if the entry has been found and removed, otherwise false
  - lockKeysForUpdate
```
public void lockKeysForUpdate(Object... key)
```
    Description copied from interface: OIndexInternal
    Applies exclusive lock on keys which prevents read/modification of this keys in following methods:
    If you want to lock several keys in single thread, you should pass all those keys in single method call. Several calls of this method in single thread are not allowed because it may lead to deadlocks.
    This is internal method and cannot be used by end users.
    Specified by:
    
    lockKeysForUpdate in interface OIndexInternal<T>
    
    Parameters:
    
    key - Keys to lock.
  - lockKeysForUpdate
```
public Lock[] lockKeysForUpdate(Collection<Object> keys)
```
    Description copied from interface: OIndexInternal
    Applies exclusive lock on keys which prevents read/modification of this keys in following methods:
    If you want to lock several keys in single thread, you should pass all those keys in single method call. Several calls of this method in single thread are not allowed because it may lead to deadlocks.
    This is internal method and cannot be used by end users.
    Specified by:
    
    lockKeysForUpdate in interface OIndexInternal<T>
    
    Parameters:
    
    keys - Keys to lock.
    
    Returns:
    
    the array of locks which should be unlocked when done.
  - releaseKeysForUpdate
```
public void releaseKeysForUpdate(Object... key)
```
    Description copied from interface: OIndexInternal
    Release exclusive lock on keys which prevents read/modification of this keys in following methods:
    This is internal method and cannot be used by end users.
    Specified by:
    
    releaseKeysForUpdate in interface OIndexInternal<T>
    
    Parameters:
    
    key - Keys to unlock.
  - clear
```
public OIndex<T> clear()
```
    Description copied from interface: OIndex
    
    Clears the index removing all the entries in one shot.
    
    Specified by:
    
    clear in interface OIndex<T>
    
    Returns:
    
    The index instance itself to allow in chain calls
  - delete
```
public OIndexInternal<T> delete()
```
    Description copied from interface: OIndex
    
    Delete the index.
    
    Specified by:
    
    delete in interface OIndex<T>
    
    Returns:
    
    The index instance itself to allow in chain calls
  - getName
```
public String getName()
```
    Description copied from interface: OIndex
    
    Returns the index name.
    
    Specified by:
    
    getName in interface OIndex<T>
    
    Returns:
    
    The name of the index
  - getType
```
public String getType()
```
    Description copied from interface: OIndex
    
    Returns the type of the index as string.
    
    Specified by:
    
    getType in interface OIndex<T>
  - getAlgorithm
```
public String getAlgorithm()
```
    Description copied from interface: OIndex
    
    Returns the engine of the index as string.
    
    Specified by:
    
    getAlgorithm in interface OIndex<T>
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - getInternal
```
public OIndexInternal<T> getInternal()
```
    Description copied from interface: OIndex
    
    Returns the internal index used.
    
    Specified by:
    
    getInternal in interface OIndex<T>
  - getClusters
```
public Set<String> getClusters()
```
    Description copied from interface: OIndex
    
    Returns Names of clusters that will be indexed.
    
    Specified by:
    
    getClusters in interface OIndex<T>
    
    Returns:
    
    Names of clusters that will be indexed.
  - addCluster
```
public OIndexAbstract<T> addCluster(String clusterName)
```
    Description copied from interface: OIndexInternal
    
    Add given cluster to the list of clusters that should be automatically indexed.
    
    Specified by:
    
    addCluster in interface OIndexInternal<T>
    
    Parameters:
    
    clusterName - Cluster to add.
    
    Returns:
    
    Current index instance.
  - removeCluster
```
public OIndexAbstract<T> removeCluster(String iClusterName)
```
    Description copied from interface: OIndexInternal
    
    Remove given cluster from the list of clusters that should be automatically indexed.
    
    Specified by:
    
    removeCluster in interface OIndexInternal<T>
    
    Parameters:
    
    iClusterName - Cluster to remove.
    
    Returns:
    
    Current index instance.
  - checkEntry
```
public ODocument checkEntry(OIdentifiable iRecord,
                            Object iKey)
```
    Description copied from interface: OIndex
    
    For unique indexes it will throw exception if passed in key is contained in index.
    
    Specified by:
    
    checkEntry in interface OIndex<T>
  - updateConfiguration
```
public ODocument updateConfiguration()
```
    Description copied from interface: OIndexInternal
    
    Saves the index configuration to disk.
    
    Specified by:
    
    updateConfiguration in interface OIndexInternal<T>
    
    Returns:
    
    The configuration as ODocument instance
    
    See Also:
    
    OIndex.getConfiguration()
  - addTxOperation
```
public void addTxOperation(OTransactionIndexChanges changes)
```
    Specified by:
    
    addTxOperation in interface OIndexInternal<T>
  - interpretTxKeyChanges
```
protected Iterable<OTransactionIndexChangesPerKey.OTransactionIndexEntry> interpretTxKeyChanges(OTransactionIndexChangesPerKey changes)
```
    Interprets transaction index changes for a certain key. Override it to customize index behaviour on interpreting index changes. This may be viewed as an optimization, but in some cases this is a requirement. For example, if you put multiple values under the same key during the transaction for single-valued/unique index, but remove all of them except one before commit, there is no point in throwing ORecordDuplicatedException while applying index changes.
    
    Parameters:
    
    changes - the changes to interpret.
    
    Returns:
    
    the interpreted index key changes.
  - commit
```
public void commit()
```
    Specified by:
    
    commit in interface OIndexInternal<T>
  - preCommit
```
public void preCommit()
```
    Specified by:
    
    preCommit in interface OIndexInternal<T>
  - postCommit
```
public void postCommit()
```
    Specified by:
    
    postCommit in interface OIndexInternal<T>
  - getConfiguration
```
public ODocument getConfiguration()
```
    Description copied from interface: OIndex
    
    Returns the index configuration.
    
    Specified by:
    
    getConfiguration in interface OIndex<T>
    
    Returns:
    
    An ODocument object containing all the index properties
  - getVersion
```
public int getVersion()
```
    Description copied from interface: OIndex
    
    Returns binary format version for this index. Index format changes during system development but old formats are supported for binary compatibility. This method may be used to detect version of binary format which is used by current index and upgrade index to new one.
    
    Specified by:
    
    getVersion in interface OIndex<T>
    
    Returns:
    
    Returns binary format version for this index if possible, otherwise -1.
  - getMetadata
```
public ODocument getMetadata()
```
    Specified by:
    
    getMetadata in interface OIndex<T>
  - isUnique
```
public boolean isUnique()
```
    Specified by:
    
    isUnique in interface OIndex<T>
  - isAutomatic
```
public boolean isAutomatic()
```
    Description copied from interface: OIndex
    
    Tells if the index is automatic. Automatic means it's maintained automatically by OrientDB. This is the case of indexes created against schema properties. Automatic indexes can always been rebuilt.
    
    Specified by:
    
    isAutomatic in interface OIndex<T>
    
    Returns:
    
    True if the index is automatic, otherwise false
  - getKeyTypes
```
public OType[] getKeyTypes()
```
    Description copied from interface: OIndex
    
    Types of the keys that index can accept, if index contains composite key, list of types of elements from which this index consist will be returned, otherwise single element (key type obviously) will be returned.
    
    Specified by:
    
    getKeyTypes in interface OIndex<T>
  - keyCursor
```
public OIndexKeyCursor keyCursor()
```
    Specified by:
    
    keyCursor in interface OIndex<T>
  - getDefinition
```
public OIndexDefinition getDefinition()
```
    Specified by:
    
    getDefinition in interface OIndex<T>
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - getIndexId
```
public int getIndexId()
```
    Specified by:
    
    getIndexId in interface OIndex<T>
  - getDatabaseName
```
public String getDatabaseName()
```
    Specified by:
    
    getDatabaseName in interface OIndex<T>
  - isRebuilding
```
public boolean isRebuilding()
```
    Specified by:
    
    isRebuilding in interface OIndex<T>
    
    Returns:
    
    Indicates whether index is rebuilding at the moment.
    
    See Also:
    
    OIndex.getRebuildVersion()
  - determineValueSerializer
```
protected abstract OBinarySerializer determineValueSerializer()
```
  - populateIndex
```
protected void populateIndex(ODocument doc,
                             Object fieldValue)
```
  - getCollatingValue
```
public Object getCollatingValue(Object key)
```
    Specified by:
    
    getCollatingValue in interface OIndexInternal<T>
  - commitSnapshot
```
protected void commitSnapshot(Map<Object,Object> snapshot)
```
  - putInSnapshot
```
protected void putInSnapshot(Object key,
                             OIdentifiable value,
                             Map<Object,Object> snapshot)
```
  - removeFromSnapshot
```
protected void removeFromSnapshot(Object key,
                                  OIdentifiable value,
                                  Map<Object,Object> snapshot)
```
  - removeFromSnapshot
```
protected void removeFromSnapshot(Object key,
                                  Map<Object,Object> snapshot)
```
  - clearSnapshot
```
protected void clearSnapshot(OIndexAbstract.IndexTxSnapshot indexTxSnapshot)
```
  - compareTo
```
public int compareTo(OIndex<T> index)
```
    Specified by:
    
    compareTo in interface Comparable<OIndex<T>>
  - setType
```
public void setType(OType type)
```
    Specified by:
    
    setType in interface OIndexInternal<T>
  - getIndexNameByKey
```
public String getIndexNameByKey(Object key)
```
    Description copied from interface: OIndexInternal
    
    Returns the index name for a key. The name is always the current index name, but in cases where the index supports key-based sharding.
    
    Specified by:
    
    getIndexNameByKey in interface OIndexInternal<T>
    
    Parameters:
    
    key - the index key.
    
    Returns:
    
    The index name involved
  - acquireAtomicExclusiveLock
```
public boolean acquireAtomicExclusiveLock(Object key)
```
    Description copied from interface: OIndexInternal
    
    Acquires exclusive lock in the active atomic operation running on the current thread for this index.
    If this index supports a more narrow locking, for example key-based sharding, it may use the provided key to infer a more narrow lock scope, but that is not a requirement.
    
    Specified by:
    
    acquireAtomicExclusiveLock in interface OIndexInternal<T>
    
    Parameters:
    
    key - the index key to lock.
    
    Returns:
    
    true if this index was locked entirely, false if this index locking is sensitive to the provided key and only some subset of this index was locked.
  - getDatabase
```
protected ODatabaseDocumentInternal getDatabase()
```
  - indexCluster
```
protected long[] indexCluster(String clusterName,
                              OProgressListener iProgressListener,
                              long documentNum,
                              long documentIndexed,
                              long documentTotal)
```
  - releaseExclusiveLock
```
protected void releaseExclusiveLock()
```
  - acquireExclusiveLock
```
protected void acquireExclusiveLock()
```
  - releaseSharedLock
```
protected void releaseSharedLock()
```
  - acquireSharedLock
```
protected void acquireSharedLock()
```
  - onIndexEngineChange
```
protected void onIndexEngineChange(int indexId)
```
  - indexConfigurationInstance
```
protected OIndexAbstract.IndexConfiguration indexConfigurationInstance(ODocument document)
```

Class OIndexAbstract<T>

Nested Class Summary

Field Summary

Fields inherited from interface com.orientechnologies.orient.core.index.OIndexInternal

Fields inherited from interface com.orientechnologies.orient.core.index.OIndex

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.orientechnologies.orient.core.index.OIndexInternal

Methods inherited from interface com.orientechnologies.orient.core.index.OIndex

Field Detail

CONFIG_MAP_RID

CONFIG_CLUSTERS

type

keyLockManager

configuration

metadata

storage

valueContainerAlgorithm

indexId

Constructor Detail

OIndexAbstract

Method Detail

loadMetadataInternal

onShutdown

onStartup

flush

hasRangeQuerySupport

create

doReloadIndexEngine

count

loadFromConfiguration

getEngineProperties

loadMetadata

contains

rebuild

setRebuildingFlag

close

getFirstKey

getLastKey

getRebuildVersion

rebuild

remove

remove

lockKeysForUpdate

lockKeysForUpdate

releaseKeysForUpdate

clear

delete

getName

getType

getAlgorithm

toString

getInternal

getClusters

addCluster

removeCluster

checkEntry

updateConfiguration

addTxOperation

interpretTxKeyChanges

commit

preCommit

postCommit

getConfiguration

getVersion

getMetadata

isUnique

isAutomatic

getKeyTypes

keyCursor

getDefinition

equals

hashCode

getIndexId

getDatabaseName

isRebuilding

determineValueSerializer

populateIndex

getCollatingValue