OChainedIndexProxy (OrientDB 3.0.44 API)

java.lang.Object
- com.orientechnologies.orient.core.sql.OChainedIndexProxy<T>

All Implemented Interfaces:

OIndex<T>, Comparable<OIndex<T>>
```
public class OChainedIndexProxy<T>
extends Object
implements OIndex<T>
```
There are some cases when we need to create index for some class by traversed property. Unfortunately, such functionality is not supported yet. But we can do that by creating index for each element of OSQLFilterItemField.FieldChain (which define "way" to our property), and then process operations consequently using previously created indexes.

This class provides possibility to find optimal chain of indexes and then use it just like it was index for traversed property.

IMPORTANT: this class is only for internal usage!

Author:

Artem Orobets

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

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`OIndex<T>`	`clear()` Clears the index removing all the entries in one shot.
`int`	`compareTo(OIndex<T> o)`
`boolean`	`contains(Object iKey)` Tells if a key is contained in the index.
`long`	`count(Object iKey)` Counts the entries for the key.
`OIndex<T>`	`create(String name, OIndexDefinition indexDefinition, String clusterIndexName, Set<String> clustersToIndex, boolean rebuild, OProgressListener progressListener)` Creates the index.
`static <T> Collection<OChainedIndexProxy<T>>`	`createProxies(OClass iSchemaClass, OSQLFilterItemField.FieldChain longChain)` Create proxies that support maximum number of different operations.
`OIndexCursor`	`cursor()`
`OIndex<T>`	`delete()` Delete the index.
`OIndexCursor`	`descCursor()`
`protected static OIndex<?>`	`findBestIndex(Iterable<OIndex<?>> indexes)` Finds the index that fits better as a base index in chain.
`void`	`flush()` Flushes in-memory changes to disk.
`T`	`get(Object iKey)` Gets the set of records associated with the passed key.
`String`	`getAlgorithm()` Returns the engine of the index as string.
`Set<String>`	`getClusters()` Returns Names of clusters that will be indexed.
`ODocument`	`getConfiguration()` Returns the index configuration.
`String`	`getDatabaseName()`
`OIndexDefinition`	`getDefinition()`
`Object`	`getFirstKey()`
`ORID`	`getIdentity()`
`int`	`getIndexId()`
`List<String>`	`getIndexNames()`
`OIndexInternal<T>`	`getInternal()` Returns internal index of last chain index, because proxy applicable to all operations that last index applicable.
`long`	`getKeySize()`
`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.
`long`	`getSize()`
`String`	`getType()` Returns the type of the index as string.
`int`	`getVersion()` Returns binary format version for this index.
`static boolean`	`isAppropriateAsBase(OIndex<?> index)` Checks if index can be used as base index.
`boolean`	`isAutomatic()` Tells if the index is automatic.
`boolean`	`isRebuilding()`
`boolean`	`isUnique()`
`OIndexCursor`	`iterateEntries(Collection<?> keys, boolean ascSortOrder)` Returns cursor which presents data associated with passed in keys.
`OIndexCursor`	`iterateEntriesBetween(Object fromKey, boolean fromInclusive, Object toKey, boolean toInclusive, boolean ascOrder)` Returns cursor which presents subset of index data between passed in keys.
`OIndexCursor`	`iterateEntriesMajor(Object fromKey, boolean fromInclusive, boolean ascOrder)` Returns cursor which presents subset of data which associated with key which is greater than passed in key.
`OIndexCursor`	`iterateEntriesMinor(Object toKey, boolean toInclusive, boolean ascOrder)` Returns cursor which presents subset of data which associated with key which is less than passed in key.
`Iterator<Map.Entry<Object,T>>`	`iterator()`
`OIndexKeyCursor`	`keyCursor()`
`Iterable<Object>`	`keys()`
`OIndex<T>`	`put(Object iKey, OIdentifiable iValue)` Inserts a new entry in the index.
`long`	`rebuild()` Rebuilds an automatic index.
`long`	`rebuild(OProgressListener iProgressListener)` Populate the index with all the existent records.
`boolean`	`remove(Object key)` Removes an entry by its key.
`boolean`	`remove(Object iKey, OIdentifiable iRID)` Removes an entry by its key and value.
`boolean`	`supportsOrderedIterations()`

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

- Method Detail
  - createProxies
```
public static <T> Collection<OChainedIndexProxy<T>> createProxies(OClass iSchemaClass,
                                                                  OSQLFilterItemField.FieldChain longChain)
```
    Create proxies that support maximum number of different operations. In case when several different indexes which support different operations (e.g. indexes of UNIQUE and FULLTEXT types) are possible, the creates the only one index of each type.
    
    Parameters:
    
    longChain - - property chain from the query, which should be evaluated
    
    Returns:
    
    proxies needed to process query.
  - findBestIndex
```
protected static OIndex<?> findBestIndex(Iterable<OIndex<?>> indexes)
```
    Finds the index that fits better as a base index in chain. Requirements to the base index:
    - Should be unique or not unique. Other types cannot be used to get all documents with required links.
    - Should not be composite hash index. As soon as hash index does not support partial match search.
    - Composite index that ignores null values should not be used.
    - Hash index is better than tree based indexes.
    - Non composite indexes is better that composite.
    Parameters:
    
    indexes - where search
    
    Returns:
    
    the index that fits better as a base index in chain
  - isAppropriateAsBase
```
public static boolean isAppropriateAsBase(OIndex<?> index)
```
    Checks if index can be used as base index. Requirements to the base index:
    - Should be unique or not unique. Other types cannot be used to get all documents with required links.
    - Should not be composite hash index. As soon as hash index does not support partial match search.
    - Composite index that ignores null values should not be used.
    Parameters:
    
    index - to check
    
    Returns:
    
    true if index usage is allowed as base index.
  - 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:
    
    OAbstractPaginatedStorage.command(com.orientechnologies.orient.core.command.OCommandRequestText), OIndexChangesWrapper, OIndexIsRebuildingException, ORetryQueryException
  - getDatabaseName
```
public String getDatabaseName()
```
    Specified by:
    
    getDatabaseName in interface OIndex<T>
  - getIndexNames
```
public List<String> getIndexNames()
```
  - 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
  - get
```
public T get(Object iKey)
```
    Gets the set of records associated with the passed key.
    
    Specified by:
    
    get in interface OIndex<T>
    
    Parameters:
    
    iKey - The key to search
    
    Returns:
    
    The Record set if found, otherwise an empty Set
  - getInternal
```
public OIndexInternal<T> getInternal()
```
    Returns internal index of last chain index, because proxy applicable to all operations that last index applicable.
    
    Specified by:
    
    getInternal in interface OIndex<T>
  - getDefinition
```
public OIndexDefinition getDefinition()
```
    Specified by:
    
    getDefinition in interface OIndex<T>
  - create
```
public OIndex<T> create(String name,
                        OIndexDefinition indexDefinition,
                        String clusterIndexName,
                        Set<String> clustersToIndex,
                        boolean rebuild,
                        OProgressListener progressListener)
```
    Description copied from interface: OIndex
    
    Creates the index.
    
    Specified by:
    
    create in interface OIndex<T>
    
    clusterIndexName - Cluster name where to place the TreeMap
  - contains
```
public boolean contains(Object iKey)
```
    Description copied from interface: OIndex
    
    Tells if a key is contained in the index.
    
    Specified by:
    
    contains in interface OIndex<T>
    
    Parameters:
    
    iKey - The key to search
    
    Returns:
    
    True if the key is contained, 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>
  - iterator
```
public Iterator<Map.Entry<Object,T>> iterator()
```
  - put
```
public OIndex<T> put(Object iKey,
                     OIdentifiable iValue)
```
    Description copied from interface: OIndex
    
    Inserts a new entry in the index. The behaviour depends by the index implementation.
    
    Specified by:
    
    put in interface OIndex<T>
    
    Parameters:
    
    iKey - Entry's key
    
    iValue - Entry's value as OIdentifiable instance
    
    Returns:
    
    The index instance itself to allow in chain calls
  - 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
  - remove
```
public boolean remove(Object iKey,
                      OIdentifiable iRID)
```
    Description copied from interface: OIndex
    
    Removes an entry by its key and value.
    
    Specified by:
    
    remove in interface OIndex<T>
    
    Parameters:
    
    iKey - The entry's key to remove
    
    Returns:
    
    True if the entry has been found and removed, otherwise false
  - 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
  - keys
```
public Iterable<Object> keys()
```
  - getSize
```
public long getSize()
```
    Specified by:
    
    getSize in interface OIndex<T>
    
    Returns:
    
    number of entries in the index.
  - count
```
public long count(Object iKey)
```
    Description copied from interface: OIndex
    
    Counts the entries for the key.
    
    Specified by:
    
    count in interface OIndex<T>
  - getKeySize
```
public long getKeySize()
```
    Specified by:
    
    getKeySize in interface OIndex<T>
    
    Returns:
    
    Number of keys in index
  - flush
```
public void flush()
```
    Description copied from interface: OIndex
    
    Flushes in-memory changes to disk.
    
    Specified by:
    
    flush in interface OIndex<T>
  - delete
```
public OIndex<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
  - 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>
  - 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
  - rebuild
```
public long rebuild()
```
    Description copied from interface: OIndex
    
    Rebuilds an automatic index.
    
    Specified by:
    
    rebuild in interface OIndex<T>
    
    Returns:
    
    The number of entries rebuilt
    
    See Also:
    
    OIndex.getRebuildVersion()
  - rebuild
```
public long rebuild(OProgressListener iProgressListener)
```
    Description copied from interface: OIndex
    
    Populate the index with all the existent records.
    
    Specified by:
    
    rebuild in interface OIndex<T>
    
    See Also:
    
    OIndex.getRebuildVersion()
  - 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
  - getMetadata
```
public ODocument getMetadata()
```
    Specified by:
    
    getMetadata in interface OIndex<T>
  - getIdentity
```
public ORID getIdentity()
```
  - 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.
  - getFirstKey
```
public Object getFirstKey()
```
    Specified by:
    
    getFirstKey in interface OIndex<T>
  - getLastKey
```
public Object getLastKey()
```
    Specified by:
    
    getLastKey in interface OIndex<T>
  - getIndexId
```
public int getIndexId()
```
    Specified by:
    
    getIndexId in interface OIndex<T>
  - isUnique
```
public boolean isUnique()
```
    Specified by:
    
    isUnique in interface OIndex<T>
  - cursor
```
public OIndexCursor cursor()
```
    Specified by:
    
    cursor in interface OIndex<T>
  - descCursor
```
public OIndexCursor descCursor()
```
    Specified by:
    
    descCursor in interface OIndex<T>
  - keyCursor
```
public OIndexKeyCursor keyCursor()
```
    Specified by:
    
    keyCursor in interface OIndex<T>
  - 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.
  - supportsOrderedIterations
```
public boolean supportsOrderedIterations()
```
    Specified by:
    
    supportsOrderedIterations in interface OIndex<T>
  - iterateEntries
```
public OIndexCursor iterateEntries(Collection<?> keys,
                                   boolean ascSortOrder)
```
    Description copied from interface: OIndex
    
    Returns cursor which presents data associated with passed in keys.
    
    Specified by:
    
    iterateEntries in interface OIndex<T>
    
    Parameters:
    
    keys - Keys data of which should be returned.
    
    ascSortOrder - Flag which determines whether data iterated by cursor should be in ascending or descending order.
    
    Returns:
    
    cursor which presents data associated with passed in keys.
  - iterateEntriesBetween
```
public OIndexCursor iterateEntriesBetween(Object fromKey,
                                          boolean fromInclusive,
                                          Object toKey,
                                          boolean toInclusive,
                                          boolean ascOrder)
```
    Description copied from interface: OIndex
    
    Returns cursor which presents subset of index data between passed in keys.
    
    Specified by:
    
    iterateEntriesBetween in interface OIndex<T>
    
    Parameters:
    
    fromKey - Lower border of index data.
    
    fromInclusive - Indicates whether lower border should be inclusive or exclusive.
    
    toKey - Upper border of index data.
    
    toInclusive - Indicates whether upper border should be inclusive or exclusive.
    
    ascOrder - Flag which determines whether data iterated by cursor should be in ascending or descending order.
    
    Returns:
    
    Cursor which presents subset of index data between passed in keys.
  - iterateEntriesMajor
```
public OIndexCursor iterateEntriesMajor(Object fromKey,
                                        boolean fromInclusive,
                                        boolean ascOrder)
```
    Description copied from interface: OIndex
    
    Returns cursor which presents subset of data which associated with key which is greater than passed in key.
    
    Specified by:
    
    iterateEntriesMajor in interface OIndex<T>
    
    Parameters:
    
    fromKey - Lower border of index data.
    
    fromInclusive - Indicates whether lower border should be inclusive or exclusive.
    
    ascOrder - Flag which determines whether data iterated by cursor should be in ascending or descending order.
    
    Returns:
    
    cursor which presents subset of data which associated with key which is greater than passed in key.
  - iterateEntriesMinor
```
public OIndexCursor iterateEntriesMinor(Object toKey,
                                        boolean toInclusive,
                                        boolean ascOrder)
```
    Description copied from interface: OIndex
    
    Returns cursor which presents subset of data which associated with key which is less than passed in key.
    
    Specified by:
    
    iterateEntriesMinor in interface OIndex<T>
    
    Parameters:
    
    toKey - Upper border of index data.
    
    toInclusive - Indicates Indicates whether upper border should be inclusive or exclusive.
    
    ascOrder - Flag which determines whether data iterated by cursor should be in ascending or descending order.
    
    Returns:
    
    cursor which presents subset of data which associated with key which is less than passed in key.
  - isRebuilding
```
public boolean isRebuilding()
```
    Specified by:
    
    isRebuilding in interface OIndex<T>
    
    Returns:
    
    Indicates whether index is rebuilding at the moment.
    
    See Also:
    
    OIndex.getRebuildVersion()
  - compareTo
```
public int compareTo(OIndex<T> o)
```
    Specified by:
    
    compareTo in interface Comparable<OIndex<T>>

Class OChainedIndexProxy<T>

Field Summary

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

Method Summary

Methods inherited from class java.lang.Object

Method Detail

createProxies

findBestIndex

isAppropriateAsBase

getRebuildVersion

getDatabaseName

getIndexNames

getName

get

getInternal

getDefinition

create

contains

getKeyTypes

iterator

put

remove

remove

clear

keys

getSize

count

getKeySize

flush

delete

getType

getAlgorithm

isAutomatic

rebuild

rebuild

getConfiguration

getMetadata

getIdentity

getClusters

getFirstKey

getLastKey

getIndexId

isUnique

cursor

descCursor

keyCursor

getVersion

supportsOrderedIterations

iterateEntries

iterateEntriesBetween

iterateEntriesMajor

iterateEntriesMinor

isRebuilding

compareTo