RecordStore (Hazelcast Root 3.10 API)

All Known Implementing Classes:

DefaultRecordStore
```
public interface RecordStore<R extends Record>
```
Defines a record-store.

Field Summary

Fields
Modifier and Type Field and Description

static long DEFAULT_TTL
Default TTL value of a record.

Fields
Modifier and Type	Field and Description
`static long`	`DEFAULT_TTL` Default TTL value of a record.

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`boolean`	`canAcquireLock(Data key, String caller, long threadId)`
`void`	`checkIfLoaded()`
`int`	`clear()`
`void`	`clearPartition(boolean onShutdown)` Clears internal partition data.
`boolean`	`containsKey(Data dataKey)`
`boolean`	`containsValue(Object testValue)`
`Record`	`createRecord(Object value, long ttlMillis, long now)`
`Storage`	`createStorage(RecordFactory<R> recordFactory, InMemoryFormat memoryFormat)`
`boolean`	`delete(Data dataKey)`
`void`	`destroy()`
`void`	`destroyInternals()` Like `destroy()` but does not touch state on other services like lock service or event journal service.
`void`	`disposeDeferredBlocks()` This can be used to release unused resources.
`void`	`doPostEvictionOperations(Record record, boolean backup)` Does post eviction operations like sending events
`Object`	`evict(Data key, boolean backup)`
`int`	`evictAll(boolean backup)` Evicts all keys except locked ones.
`void`	`evictEntries(Data excludedKey)` Evicts entries from this record-store.
`void`	`evictExpiredEntries(int percentage, boolean backup)` Do expiration operations.
`boolean`	`existInMemory(Data key)` Checks if the key exist in memory without trying to load data from map-loader
`boolean`	`extendLock(Data key, String caller, long threadId, long ttl)`
`MapEntriesWithCursor`	`fetchEntries(int tableIndex, int size)` Fetches specified number of entries from provided tableIndex.
`MapKeysWithCursor`	`fetchKeys(int tableIndex, int size)` Fetches specified number of keys from provided tableIndex.
`boolean`	`forceUnlock(Data dataKey)`
`Object`	`get(Data dataKey, boolean backup)` Gets record from `RecordStore`.
`MapEntries`	`getAll(Set<Data> keySet)`
`InvalidationQueue<ExpiredKey>`	`getExpiredKeys()`
`LocalRecordStoreStats`	`getLocalRecordStoreStats()`
`int`	`getLockedEntryCount()`
`String`	`getLockOwnerInfo(Data key)`
`MapContainer`	`getMapContainer()`
`MapDataStore<Data,Object>`	`getMapDataStore()`
`String`	`getName()`
`long`	`getOwnedEntryCost()`
`int`	`getPartitionId()` Returns the partition id this RecordStore belongs to.
`R`	`getRecord(Data key)`
`R`	`getRecordOrNull(Data key)` Returns live record or null if record is already expired.
`Storage`	`getStorage()`
`boolean`	`hasQueryCache()`
`void`	`init()` Initialize the recordStore after creation
`boolean`	`isEmpty()`
`boolean`	`isExpirable()`
`boolean`	`isExpired(R record, long now, boolean backup)` Checks whether a record is expired or not.
`boolean`	`isKeyLoadFinished()`
`boolean`	`isLoaded()` Returns `true` if all key and value loading tasks have completed on this record store.
`boolean`	`isLocked(Data key)`
`boolean`	`isLockedBy(Data key, String caller, long threadId)`
`boolean`	`isTransactionallyLocked(Data key)`
`Iterator<Record>`	`iterator()` Iterates over record store entries.
`Iterator<Record>`	`iterator(long now, boolean backup)` Iterates over record store entries by respecting expiration.
`void`	`loadAll(boolean replaceExistingValues)` Triggers key and value loading if there is no ongoing or completed key loading task, otherwise does nothing.
`void`	`loadAllFromStore(List<Data> keys, boolean replaceExistingValues)` Triggers loading values for the given `keys` from the defined `MapLoader`.
`Iterator<Record>`	`loadAwareIterator(long now, boolean backup)` Iterates over record store entries but first waits map store to load.
`Record`	`loadRecordOrNull(Data key, boolean backup)`
`boolean`	`localLock(Data key, String caller, long threadId, long referenceId, long ttl)`
`boolean`	`lock(Data key, String caller, long threadId, long referenceId, long ttl)`
`void`	`maybeDoInitialLoad()` Resets the map loader state if necessary and triggers initial key and value loading if it has not been done before.
`boolean`	`merge(Data dataKey, EntryView mergingEntry, MapMergePolicy mergePolicy)` Merges the given `EntryView` via the given `MapMergePolicy`.
`boolean`	`merge(SplitBrainMergeTypes.MapMergeTypes mergingEntry, SplitBrainMergePolicy<Data,SplitBrainMergeTypes.MapMergeTypes> mergePolicy)` Merges the given `SplitBrainMergeTypes.MapMergeTypes` via the given `SplitBrainMergePolicy`.
`Object`	`put(Data dataKey, Object dataValue, long ttl)`
`R`	`putBackup(Data key, Object value)`
`R`	`putBackup(Data key, Object value, long ttl, boolean putTransient)`
`Object`	`putFromLoad(Data key, Object value)` Puts key-value pair to map which is the result of a load from map store operation.
`Object`	`putFromLoadBackup(Data key, Object value)` Puts key-value pair to map which is the result of a load from map store operation on backup.
`Object`	`putIfAbsent(Data dataKey, Object value, long ttl)`
`void`	`putRecord(Data key, R record)` Puts a data key and a record value to record-store.
`Object`	`putTransient(Data dataKey, Object value, long ttl)`
`Data`	`readBackupData(Data key)` Called when `MapConfig.isReadBackupData()` is `true` from `MapProxySupport.getInternal(java.lang.Object)` Returns corresponding value for key as `Data`.
`Object`	`remove(Data dataKey)`
`boolean`	`remove(Data dataKey, Object testValue)`
`void`	`removeBackup(Data dataKey)` Similar to `remove(com.hazelcast.nio.serialization.Data)` except removeBackup doesn't touch mapstore since it does not return previous value.
`Object`	`replace(Data dataKey, Object update)`
`boolean`	`replace(Data dataKey, Object expect, Object update)` Sets the value to the given updated value if `RecordComparator.isEqual(java.lang.Object, java.lang.Object)` comparison of current value and expected value is `true`.
`void`	`reset()` Resets the record store to it's initial state.
`Object`	`set(Data dataKey, Object value, long ttl)`
`void`	`setPreMigrationLoadedStatus(boolean loaded)` Informs this recordStore about the loading status of the recordStore that this store is migrated from.
`boolean`	`setWithUncountedAccess(Data dataKey, Object value, long ttl)` Does exactly the same thing as `set(Data, Object, long)` except the invocation is not counted as a read access while updating the access statics.
`boolean`	`shouldEvict()` Returns `true` if eviction is allowed on this record-store, otherwise `false`
`int`	`size()`
`long`	`softFlush()`
`void`	`startLoading()` Starts the map loader if there is a configured and enabled `MapLoader` and the key loading has not already been started.
`boolean`	`txnLock(Data key, String caller, long threadId, long referenceId, long ttl, boolean blockReads)`
`boolean`	`unlock(Data key, String caller, long threadId, long referenceId)`
`void`	`updateLoadStatus(boolean lastBatch, Throwable exception)` Advances the state of the map key loader for this partition and sets the key loading future result if the `lastBatch` is `true`.

- Field Detail
  - DEFAULT_TTL
```
static final long DEFAULT_TTL
```
    Default TTL value of a record.
    
    See Also:
    
    Constant Field Values
- Method Detail
  - getLocalRecordStoreStats
```
LocalRecordStoreStats getLocalRecordStoreStats()
```
  - getName
```
String getName()
```
  - set
```
Object set(Data dataKey,
           Object value,
           long ttl)
```
    Returns:
    
    oldValue only if it exists in memory, otherwise just returns null and doesn't try to load it from MapLoader
  - put
```
Object put(Data dataKey,
           Object dataValue,
           long ttl)
```
    Returns:
    
    oldValue if it exists in memory otherwise tries to load oldValue by using MapLoader
  - putIfAbsent
```
Object putIfAbsent(Data dataKey,
                   Object value,
                   long ttl)
```
  - putBackup
```
R putBackup(Data key,
            Object value)
```
  - putBackup
```
R putBackup(Data key,
            Object value,
            long ttl,
            boolean putTransient)
```
    Parameters:
    
    key - the key to be processed.
    
    value - the value to be processed.
    
    ttl - milliseconds. Check out MapProxySupport.putInternal(java.lang.Object, com.hazelcast.nio.serialization.Data, long, java.util.concurrent.TimeUnit)
    
    putTransient - true if putting transient entry, otherwise false
    
    Returns:
    
    previous record if exists otherwise null.
  - setWithUncountedAccess
```
boolean setWithUncountedAccess(Data dataKey,
                               Object value,
                               long ttl)
```
    Does exactly the same thing as set(Data, Object, long) except the invocation is not counted as a read access while updating the access statics.
  - remove
```
Object remove(Data dataKey)
```
  - delete
```
boolean delete(Data dataKey)
```
  - remove
```
boolean remove(Data dataKey,
               Object testValue)
```
  - removeBackup
```
void removeBackup(Data dataKey)
```
    Similar to remove(com.hazelcast.nio.serialization.Data) except removeBackup doesn't touch mapstore since it does not return previous value.
  - get
```
Object get(Data dataKey,
           boolean backup)
```
    Gets record from RecordStore. Loads missing keys from map store.
    
    Parameters:
    
    dataKey - key.
    
    backup - true if a backup partition, otherwise false.
    
    Returns:
    
    value of an entry in RecordStore
  - readBackupData
```
Data readBackupData(Data key)
```
    Called when MapConfig.isReadBackupData() is true from MapProxySupport.getInternal(java.lang.Object)
    Returns corresponding value for key as Data. This adds an extra serialization step. For the reason of this behaviour please see issue 1292 on github.
    
    Parameters:
    
    key - key to be accessed
    
    Returns:
    
    value as Data independent of InMemoryFormat
  - getAll
```
MapEntries getAll(Set<Data> keySet)
```
  - existInMemory
```
boolean existInMemory(Data key)
```
    Checks if the key exist in memory without trying to load data from map-loader
  - containsKey
```
boolean containsKey(Data dataKey)
```
  - getLockedEntryCount
```
int getLockedEntryCount()
```
  - replace
```
Object replace(Data dataKey,
               Object update)
```
  - replace
```
boolean replace(Data dataKey,
                Object expect,
                Object update)
```
    Sets the value to the given updated value if RecordComparator.isEqual(java.lang.Object, java.lang.Object) comparison of current value and expected value is true.
    
    Parameters:
    
    dataKey - key which's value is requested to be replaced.
    
    expect - the expected value
    
    update - the new value
    
    Returns:
    
    true if successful. False return indicates that the actual value was not equal to the expected value.
  - putTransient
```
Object putTransient(Data dataKey,
                    Object value,
                    long ttl)
```
  - putFromLoad
```
Object putFromLoad(Data key,
                   Object value)
```
    Puts key-value pair to map which is the result of a load from map store operation.
    
    Parameters:
    
    key - key to put.
    
    value - to put.
    
    Returns:
    
    the previous value associated with key, or null if there was no mapping for key.
    
    See Also:
    
    PutFromLoadAllOperation
  - putFromLoadBackup
```
Object putFromLoadBackup(Data key,
                         Object value)
```
    Puts key-value pair to map which is the result of a load from map store operation on backup.
    
    Parameters:
    
    key - key to put.
    
    value - to put.
    
    Returns:
    
    the previous value associated with key, or null if there was no mapping for key.
    
    See Also:
    
    PutFromLoadAllBackupOperation
  - merge
```
boolean merge(SplitBrainMergeTypes.MapMergeTypes mergingEntry,
              SplitBrainMergePolicy<Data,SplitBrainMergeTypes.MapMergeTypes> mergePolicy)
```
    Merges the given SplitBrainMergeTypes.MapMergeTypes via the given SplitBrainMergePolicy.
    
    Parameters:
    
    mergingEntry - the SplitBrainMergeTypes.MapMergeTypes instance to merge
    
    mergePolicy - the SplitBrainMergePolicy instance to apply
    
    Returns:
    
    true if merge is applied, otherwise false
  - merge
```
boolean merge(Data dataKey,
              EntryView mergingEntry,
              MapMergePolicy mergePolicy)
```
    Merges the given EntryView via the given MapMergePolicy.
    
    Parameters:
    
    mergingEntry - the EntryView instance to merge
    
    mergePolicy - the MapMergePolicy instance to apply
    
    Returns:
    
    true if merge is applied, otherwise false
  - getRecord
```
R getRecord(Data key)
```
  - putRecord
```
void putRecord(Data key,
               R record)
```
    Puts a data key and a record value to record-store. Used in replication operations.
    
    Parameters:
    
    key - the data key to put record store.
    
    record - the value for record store.
    
    See Also:
    
    MapReplicationOperation
  - iterator
```
Iterator<Record> iterator()
```
    Iterates over record store entries.
    
    Returns:
    
    read only iterator for map values.
  - iterator
```
Iterator<Record> iterator(long now,
                          boolean backup)
```
    Iterates over record store entries by respecting expiration.
    
    Returns:
    
    read only iterator for map values.
  - fetchKeys
```
MapKeysWithCursor fetchKeys(int tableIndex,
                            int size)
```
    Fetches specified number of keys from provided tableIndex.
    
    Returns:
    
    MapKeysWithCursor which is a holder for keys and next index to read from.
  - fetchEntries
```
MapEntriesWithCursor fetchEntries(int tableIndex,
                                  int size)
```
    Fetches specified number of entries from provided tableIndex.
    
    Returns:
    
    MapEntriesWithCursor which is a holder for entries and next index to read from.
  - loadAwareIterator
```
Iterator<Record> loadAwareIterator(long now,
                                   boolean backup)
```
    Iterates over record store entries but first waits map store to load. If an operation needs to wait a data source load like query operations IMap.keySet(com.hazelcast.query.Predicate), this method can be used to return a read-only iterator.
    
    Parameters:
    
    now - current time in millis
    
    backup - true if a backup partition, otherwise false.
    
    Returns:
    
    read only iterator for map values.
  - size
```
int size()
```
  - txnLock
```
boolean txnLock(Data key,
                String caller,
                long threadId,
                long referenceId,
                long ttl,
                boolean blockReads)
```
  - extendLock
```
boolean extendLock(Data key,
                   String caller,
                   long threadId,
                   long ttl)
```
  - localLock
```
boolean localLock(Data key,
                  String caller,
                  long threadId,
                  long referenceId,
                  long ttl)
```
  - lock
```
boolean lock(Data key,
             String caller,
             long threadId,
             long referenceId,
             long ttl)
```
  - isLockedBy
```
boolean isLockedBy(Data key,
                   String caller,
                   long threadId)
```
  - unlock
```
boolean unlock(Data key,
               String caller,
               long threadId,
               long referenceId)
```
  - isLocked
```
boolean isLocked(Data key)
```
  - isTransactionallyLocked
```
boolean isTransactionallyLocked(Data key)
```
  - canAcquireLock
```
boolean canAcquireLock(Data key,
                       String caller,
                       long threadId)
```
  - getLockOwnerInfo
```
String getLockOwnerInfo(Data key)
```
  - containsValue
```
boolean containsValue(Object testValue)
```
  - evict
```
Object evict(Data key,
             boolean backup)
```
  - evictAll
```
int evictAll(boolean backup)
```
    Evicts all keys except locked ones.
    
    Parameters:
    
    backup - true if a backup partition, otherwise false.
    
    Returns:
    
    number of evicted entries.
  - getMapContainer
```
MapContainer getMapContainer()
```
  - softFlush
```
long softFlush()
```
    See Also:
    
    MapDataStore.softFlush()
  - clearPartition
```
void clearPartition(boolean onShutdown)
```
    Clears internal partition data.
    
    Parameters:
    
    onShutdown - true if close is called during MapService shutdown, false otherwise.
  - reset
```
void reset()
```
    Resets the record store to it's initial state. Used in replication operations.
    
    See Also:
    
    putRecord(Data, Record)
  - forceUnlock
```
boolean forceUnlock(Data dataKey)
```
  - getOwnedEntryCost
```
long getOwnedEntryCost()
```
  - clear
```
int clear()
```
  - isEmpty
```
boolean isEmpty()
```
  - evictExpiredEntries
```
void evictExpiredEntries(int percentage,
                         boolean backup)
```
    Do expiration operations.
    
    Parameters:
    
    percentage - of max expirables according to the record store size.
    
    backup - true if a backup partition, otherwise false.
  - isExpirable
```
boolean isExpirable()
```
    Returns:
    
    true if record store has at least one candidate entry for expiration else return false.
  - isExpired
```
boolean isExpired(R record,
                  long now,
                  boolean backup)
```
    Checks whether a record is expired or not.
    
    Parameters:
    
    record - the record from record-store.
    
    now - current time in millis
    
    backup - true if a backup partition, otherwise false.
    
    Returns:
    
    true if the record is expired, false otherwise.
  - doPostEvictionOperations
```
void doPostEvictionOperations(Record record,
                              boolean backup)
```
    Does post eviction operations like sending events
    
    Parameters:
    
    record - record to process
    
    backup - true if a backup partition, otherwise false.
  - getMapDataStore
```
MapDataStore<Data,Object> getMapDataStore()
```
  - getExpiredKeys
```
InvalidationQueue<ExpiredKey> getExpiredKeys()
```
  - getPartitionId
```
int getPartitionId()
```
    Returns the partition id this RecordStore belongs to.
    
    Returns:
    
    the partition id.
  - getRecordOrNull
```
R getRecordOrNull(Data key)
```
    Returns live record or null if record is already expired. Does not load missing keys from a map store.
    
    Parameters:
    
    key - key to be accessed
    
    Returns:
    
    live record or null
    
    See Also:
    
    get(com.hazelcast.nio.serialization.Data, boolean)
  - evictEntries
```
void evictEntries(Data excludedKey)
```
    Evicts entries from this record-store.
    
    Parameters:
    
    excludedKey - this key has lowest priority to be selected for eviction
  - shouldEvict
```
boolean shouldEvict()
```
    Returns true if eviction is allowed on this record-store, otherwise false
    
    Returns:
    
    true if eviction is allowed on this record-store, otherwise false
  - createStorage
```
Storage createStorage(RecordFactory<R> recordFactory,
                      InMemoryFormat memoryFormat)
```
  - createRecord
```
Record createRecord(Object value,
                    long ttlMillis,
                    long now)
```
  - loadRecordOrNull
```
Record loadRecordOrNull(Data key,
                        boolean backup)
```
  - disposeDeferredBlocks
```
void disposeDeferredBlocks()
```
    This can be used to release unused resources.
  - destroy
```
void destroy()
```
  - destroyInternals
```
void destroyInternals()
```
    Like destroy() but does not touch state on other services like lock service or event journal service.
  - init
```
void init()
```
    Initialize the recordStore after creation
  - getStorage
```
Storage getStorage()
```
  - startLoading
```
void startLoading()
```
    Starts the map loader if there is a configured and enabled MapLoader and the key loading has not already been started. The loading may start again if there was a migration and the record store on the migration source has started but not completed the loading.
  - setPreMigrationLoadedStatus
```
void setPreMigrationLoadedStatus(boolean loaded)
```
    Informs this recordStore about the loading status of the recordStore that this store is migrated from. If the record store on the migration source has been loaded then this record store should NOT trigger the load again. Will be taken into account only if invoked before startLoading(), otherwise has no effect.
    This method should be deleted when the map's lifecycle has been cleaned-up. Currently it's impossible to pass additional state when the record store is created, thus this state has to be passed in post-creation setters which is cumbersome and error-prone.
  - isKeyLoadFinished
```
boolean isKeyLoadFinished()
```
    Returns:
    
    true if the key loading and dispatching has finished on this record store
  - isLoaded
```
boolean isLoaded()
```
    Returns true if all key and value loading tasks have completed on this record store.
  - checkIfLoaded
```
void checkIfLoaded()
            throws RetryableHazelcastException
```
    Throws:
    
    RetryableHazelcastException
  - loadAll
```
void loadAll(boolean replaceExistingValues)
```
    Triggers key and value loading if there is no ongoing or completed key loading task, otherwise does nothing. The actual loading is done on a separate thread.
    
    Parameters:
    
    replaceExistingValues - if the existing entries for the loaded keys should be replaced
  - maybeDoInitialLoad
```
void maybeDoInitialLoad()
```
    Resets the map loader state if necessary and triggers initial key and value loading if it has not been done before.
  - loadAllFromStore
```
void loadAllFromStore(List<Data> keys,
                      boolean replaceExistingValues)
```
    Triggers loading values for the given keys from the defined MapLoader. The values will be loaded asynchronously and this method will return as soon as the value loading task has been offloaded to a different thread.
    
    Parameters:
    
    keys - the keys for which values will be loaded
    
    replaceExistingValues - if the existing entries for the keys should be replaced with the loaded values
  - updateLoadStatus
```
void updateLoadStatus(boolean lastBatch,
                      Throwable exception)
```
    Advances the state of the map key loader for this partition and sets the key loading future result if the lastBatch is true.
    If there was an exception during key loading, you may pass it as the exception paramter and it will be set as the result of the future.
    
    Parameters:
    
    lastBatch - if the last key batch was sent
    
    exception - an exception that occurred during key loading
  - hasQueryCache
```
boolean hasQueryCache()
```
    Returns:
    
    true if there is a QueryCache defined for this map.

Interface RecordStore<R extends Record>

Field Summary

Method Summary

Field Detail

DEFAULT_TTL

Method Detail

getLocalRecordStoreStats

getName

set

put

putIfAbsent

putBackup

putBackup

setWithUncountedAccess

remove

delete

remove

removeBackup

get

readBackupData

getAll

existInMemory

containsKey

getLockedEntryCount

replace

replace

putTransient

putFromLoad

putFromLoadBackup

merge

merge

getRecord

putRecord

iterator

iterator

fetchKeys

fetchEntries

loadAwareIterator

size

txnLock

extendLock

localLock

lock

isLockedBy

unlock

isLocked

isTransactionallyLocked

canAcquireLock

getLockOwnerInfo

containsValue

evict

evictAll

getMapContainer

softFlush

clearPartition

reset

forceUnlock

getOwnedEntryCost

clear

isEmpty

evictExpiredEntries

isExpirable

isExpired

doPostEvictionOperations

getMapDataStore

getExpiredKeys

getPartitionId

getRecordOrNull

evictEntries

shouldEvict

createStorage

createRecord

loadRecordOrNull

disposeDeferredBlocks

destroy

destroyInternals

init

getStorage

startLoading

setPreMigrationLoadedStatus