RecordStore (Hazelcast Root 3.12.13 API)

All Known Implementing Classes:

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

Field Summary

Fields
Modifier and Type Field and Description

static long DEFAULT_MAX_IDLE
Default Max Idle value of a record.

static long DEFAULT_TTL
Default TTL value of a record.

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

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`void`	`accessRecord(Record record, long now)` Touches the given record, updating its last access time to `now` and maintaining statistics.
`boolean`	`canAcquireLock(Data key, String caller, long threadId)`
`void`	`checkIfLoaded()`
`int`	`clear()` Called by `IMap.clear()`.
`void`	`clearPartition(boolean onShutdown, boolean onRecordStoreDestroy)` Called by `DistributedObject.destroy()` or `MapMigrationAwareService` Clears internal partition data.
`boolean`	`containsKey(Data dataKey, Address callerAddress)`
`boolean`	`containsValue(Object testValue)`
`Record`	`createRecord(Data key, Object value, long ttlMillis, long maxIdle, long now)`
`Storage`	`createStorage(RecordFactory<R> recordFactory, InMemoryFormat memoryFormat)`
`boolean`	`delete(Data dataKey, CallerProvenance provenance)`
`void`	`destroy()` Called by `DistributedObject.destroy()`.
`void`	`disposeDeferredBlocks()` This can be used to release unused resources.
`void`	`doPostEvictionOperations(Record record)` 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, Address callerAddress)` Same as `get(Data, boolean, Address, boolean)` with parameter `touch` set `true`.
`Object`	`get(Data dataKey, boolean backup, Address callerAddress, boolean touch)` Gets record from `RecordStore`.
`MapEntries`	`getAll(Set<Data> keySet, Address callerAddress)`
`InvalidationQueue<ExpiredKey>`	`getExpiredKeysQueue()`
`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, Address callerAddress)`
`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)`
`boolean`	`merge(Data dataKey, EntryView mergingEntry, MapMergePolicy mergePolicy, CallerProvenance provenance)` Merges the given `EntryView` via the given `MapMergePolicy`.
`boolean`	`merge(SplitBrainMergeTypes.MapMergeTypes mergingEntry, SplitBrainMergePolicy<Data,SplitBrainMergeTypes.MapMergeTypes> mergePolicy)`
`boolean`	`merge(SplitBrainMergeTypes.MapMergeTypes mergingEntry, SplitBrainMergePolicy<Data,SplitBrainMergeTypes.MapMergeTypes> mergePolicy, CallerProvenance provenance)` Merges the given `SplitBrainMergeTypes.MapMergeTypes` via the given `SplitBrainMergePolicy`.
`Object`	`put(Data dataKey, Object dataValue, long ttl, long maxIdle)`
`R`	`putBackup(Data key, Object value, CallerProvenance provenance)`
`R`	`putBackup(Data key, Object value, long ttl, long maxIdle, boolean putTransient, CallerProvenance provenance)`
`Object`	`putFromLoad(Data key, Object value, Address callerAddress)` 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, long maxIdle, Address callerAddress)`
`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, long maxIdle)`
`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 key, CallerProvenance provenance)`
`boolean`	`remove(Data dataKey, Object testValue)`
`void`	`removeBackup(Data dataKey, CallerProvenance provenance)` Similar to `RecordStore##remove(Data, CallerProvenance)` 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 `ValueComparator.isEqual(java.lang.Object, java.lang.Object, com.hazelcast.spi.serialization.SerializationService)` comparison of current value and expected value is `true`.
`void`	`reset()` Resets the record store to it's initial state.
`void`	`sampleAndForceRemoveEntries(int entryCountToRemove)`
`Object`	`set(Data dataKey, Object value, long ttl, long maxIdle)`
`void`	`setPreMigrationLoadedStatus(boolean loaded)` Informs this recordStore about the loading status of the recordStore that this store is migrated from.
`boolean`	`setTtl(Data key, long ttl)`
`boolean`	`setWithUncountedAccess(Data dataKey, Object value, long ttl, long maxIdle)` Does exactly the same thing as `set(Data, Object, long, 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
  - DEFAULT_MAX_IDLE
```
static final long DEFAULT_MAX_IDLE
```
    Default Max Idle value of a record.
    
    See Also:
    
    Constant Field Values
- Method Detail
  - getLocalRecordStoreStats
```
LocalRecordStoreStats getLocalRecordStoreStats()
```
  - accessRecord
```
void accessRecord(Record record,
                  long now)
```
    Touches the given record, updating its last access time to now and maintaining statistics.
    An implementation is not supposed to be thread safe.
    
    Parameters:
    
    record - the accessed record
    
    now - the current time
  - getName
```
String getName()
```
  - set
```
Object set(Data dataKey,
           Object value,
           long ttl,
           long maxIdle)
```
    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,
           long maxIdle)
```
    Returns:
    
    oldValue if it exists in memory otherwise tries to load oldValue by using MapLoader
  - putIfAbsent
```
Object putIfAbsent(Data dataKey,
                   Object value,
                   long ttl,
                   long maxIdle,
                   Address callerAddress)
```
  - putBackup
```
R putBackup(Data key,
            Object value,
            CallerProvenance provenance)
```
    Parameters:
    
    key - the key
    
    value - the value to put backup
    
    provenance - origin of call to this method.
    
    Returns:
    
    current record object associated to the key
  - putBackup
```
R putBackup(Data key,
            Object value,
            long ttl,
            long maxIdle,
            boolean putTransient,
            CallerProvenance provenance)
```
    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, long, java.util.concurrent.TimeUnit)
    
    maxIdle - milliseconds. Check out MapProxySupport.putInternal(java.lang.Object, com.hazelcast.nio.serialization.Data, long, java.util.concurrent.TimeUnit, long, java.util.concurrent.TimeUnit)
    
    putTransient - true if putting transient entry, otherwise false
    
    provenance - origin of call to this method.
    
    Returns:
    
    previous record if exists otherwise null.
  - setWithUncountedAccess
```
boolean setWithUncountedAccess(Data dataKey,
                               Object value,
                               long ttl,
                               long maxIdle)
```
    Does exactly the same thing as set(Data, Object, long, long) except the invocation is not counted as a read access while updating the access statics.
  - remove
```
Object remove(Data key,
              CallerProvenance provenance)
```
    Parameters:
    
    key - the key to be removed
    
    provenance - origin of call to this method.
    
    Returns:
    
    value of removed entry or null if there is no matching entry
  - delete
```
boolean delete(Data dataKey,
               CallerProvenance provenance)
```
    Parameters:
    
    dataKey - the key to be removed
    
    provenance - origin of call to this method.
    
    Returns:
    
    true if entry is deleted, otherwise returns false
  - remove
```
boolean remove(Data dataKey,
               Object testValue)
```
  - setTtl
```
boolean setTtl(Data key,
               long ttl)
```
  - removeBackup
```
void removeBackup(Data dataKey,
                  CallerProvenance provenance)
```
    Similar to RecordStore##remove(Data, CallerProvenance) except removeBackup doesn't touch mapstore since it does not return previous value.
  - get
```
Object get(Data dataKey,
           boolean backup,
           Address callerAddress,
           boolean touch)
```
    Gets record from RecordStore. Loads missing keys from map store.
    
    Parameters:
    
    dataKey - key.
    
    backup - true if a backup partition, otherwise false.
    
    touch - when true, if an existing record was found for the given key, then its last access time is updated.
    
    Returns:
    
    value of an entry in RecordStore
  - get
```
Object get(Data dataKey,
           boolean backup,
           Address callerAddress)
```
    Same as get(Data, boolean, Address, boolean) with parameter touch set true.
  - 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,
                  Address callerAddress)
```
  - 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,
                    Address callerAddress)
```
  - 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 ValueComparator.isEqual(java.lang.Object, java.lang.Object, com.hazelcast.spi.serialization.SerializationService) 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,
                    long maxIdle)
```
  - putFromLoad
```
Object putFromLoad(Data key,
                   Object value,
                   Address callerAddress)
```
    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)
```
  - merge
```
boolean merge(SplitBrainMergeTypes.MapMergeTypes mergingEntry,
              SplitBrainMergePolicy<Data,SplitBrainMergeTypes.MapMergeTypes> mergePolicy,
              CallerProvenance provenance)
```
    Merges the given SplitBrainMergeTypes.MapMergeTypes via the given SplitBrainMergePolicy.
    
    Parameters:
    
    mergingEntry - the SplitBrainMergeTypes.MapMergeTypes instance to merge
    
    mergePolicy - the SplitBrainMergePolicy instance to apply
    
    provenance - origin of call to this method.
    
    Returns:
    
    true if merge is applied, otherwise false
  - merge
```
boolean merge(Data dataKey,
              EntryView mergingEntry,
              MapMergePolicy mergePolicy)
```
  - merge
```
boolean merge(Data dataKey,
              EntryView mergingEntry,
              MapMergePolicy mergePolicy,
              CallerProvenance provenance)
```
    Merges the given EntryView via the given MapMergePolicy.
    
    Parameters:
    
    dataKey - the key to be merged
    
    mergingEntry - the EntryView instance to merge
    
    mergePolicy - the MapMergePolicy instance to apply
    
    provenance - origin of call to this method.
    
    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()
  - forceUnlock
```
boolean forceUnlock(Data dataKey)
```
  - getOwnedEntryCost
```
long getOwnedEntryCost()
```
  - 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)
```
    Does post eviction operations like sending events
    
    Parameters:
    
    record - record to process
  - getMapDataStore
```
MapDataStore<Data,Object> getMapDataStore()
```
  - getExpiredKeysQueue
```
InvalidationQueue<ExpiredKey> getExpiredKeysQueue()
```
  - 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, com.hazelcast.nio.Address, 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(Data key,
                    Object value,
                    long ttlMillis,
                    long maxIdle,
                    long now)
```
  - loadRecordOrNull
```
Record loadRecordOrNull(Data key,
                        boolean backup,
                        Address callerAddress)
```
  - disposeDeferredBlocks
```
void disposeDeferredBlocks()
```
    This can be used to release unused resources.
  - init
```
void init()
```
    Initialize the recordStore after creation
  - getStorage
```
Storage getStorage()
```
  - sampleAndForceRemoveEntries
```
void sampleAndForceRemoveEntries(int entryCountToRemove)
```
  - 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.
  - clearPartition
```
void clearPartition(boolean onShutdown,
                    boolean onRecordStoreDestroy)
```
    Called by DistributedObject.destroy() or MapMigrationAwareService Clears internal partition data.
    
    Parameters:
    
    onShutdown - true if close is called during MapService shutdown, false otherwise.
    
    onRecordStoreDestroy - true if record-store will be destroyed, otherwise false.
  - clear
```
int clear()
```
    Called by IMap.clear(). Clears data in this record store.
    
    Returns:
    
    number of cleared entries.
  - reset
```
void reset()
```
    Resets the record store to it's initial state. Used in replication operations.
    
    See Also:
    
    putRecord(Data, Record)
  - destroy
```
void destroy()
```
    Called by DistributedObject.destroy(). Destroys data in this record store.

Interface RecordStore<R extends Record>

Field Summary

Method Summary

Field Detail

DEFAULT_TTL

DEFAULT_MAX_IDLE

Method Detail

getLocalRecordStoreStats

accessRecord

getName

set

put

putIfAbsent

putBackup

putBackup

setWithUncountedAccess

remove

delete

remove

setTtl

removeBackup

get

get

readBackupData

getAll

existInMemory

containsKey

getLockedEntryCount

replace

replace

putTransient

putFromLoad

putFromLoadBackup

merge

merge

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

forceUnlock

getOwnedEntryCost

isEmpty

evictExpiredEntries

isExpirable

isExpired

doPostEvictionOperations

getMapDataStore

getExpiredKeysQueue

getPartitionId

getRecordOrNull

evictEntries

shouldEvict

createStorage

createRecord

loadRecordOrNull

disposeDeferredBlocks

init

getStorage

sampleAndForceRemoveEntries