DefaultRecordStore (Hazelcast Root 3.12.12 API)

java.lang.Object
- com.hazelcast.map.impl.recordstore.AbstractEvictableRecordStore
- - com.hazelcast.map.impl.recordstore.DefaultRecordStore

All Implemented Interfaces:

RecordStore<Record>
```
public class DefaultRecordStore
extends AbstractEvictableRecordStore
```
Default implementation of record-store.

Nested Class Summary
- Nested classes/interfaces inherited from class com.hazelcast.map.impl.recordstore.AbstractEvictableRecordStore
  AbstractEvictableRecordStore.ReadOnlyRecordIterator

Field Summary

Fields
Modifier and Type	Field and Description
`protected InMemoryFormat`	`inMemoryFormat`
`protected MapKeyLoader`	`keyLoader`
`protected Collection<Future>`	`loadingFutures` A collection of futures representing pending completion of the key and value loading tasks.
`protected LockStore`	`lockStore`
`protected ILogger`	`logger`
`protected MapContainer`	`mapContainer`
`protected MapDataStore<Data,Object>`	`mapDataStore`
`protected MapServiceContext`	`mapServiceContext`
`protected MapStoreContext`	`mapStoreContext`
`protected RecordStoreMutationObserver<Record>`	`mutationObserver`
`protected String`	`name`
`protected int`	`partitionId`
`protected RecordFactory`	`recordFactory`
`protected com.hazelcast.map.impl.recordstore.RecordStoreLoader`	`recordStoreLoader`
`protected SerializationService`	`serializationService`
`protected LocalRecordStoreStatsImpl`	`stats`
`protected Storage<Data,Record>`	`storage`
`protected ValueComparator`	`valueComparator`

Fields inherited from class com.hazelcast.map.impl.recordstore.AbstractEvictableRecordStore
clearExpiredRecordsTask, eventService, expirationIterator, expiredKeys, expiryDelayMillis, hasEntryWithCustomExpiration, mapEventPublisher, thisAddress

Fields inherited from interface com.hazelcast.map.impl.recordstore.RecordStore
DEFAULT_MAX_IDLE, DEFAULT_TTL

Constructor Summary

Constructors
Constructor and Description
`DefaultRecordStore(MapContainer mapContainer, int partitionId, MapKeyLoader keyLoader, ILogger logger)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`addMapEntrySet(Map<Object,Object> entries, MapEntries mapEntries)`
`protected void`	`addMapEntrySet(Object key, Object value, MapEntries mapEntries)`
`boolean`	`canAcquireLock(Data key, String caller, long threadId)`
`void`	`checkIfLoaded()`
`int`	`clear()` Called by `IMap.clear()`.
`void`	`clearOtherDataThanStorage(boolean onShutdown, boolean onStorageDestroy)` Only cleans the data other than storage-data that is held on this record store.
`void`	`clearPartition(boolean onShutdown, boolean onStorageDestroy)` Called by `DistributedObject.destroy()` or `MapMigrationAwareService` Clears internal partition data.
`boolean`	`containsKey(Data key, Address callerAddress)`
`boolean`	`containsValue(Object value)`
`protected LockStore`	`createLockStore()`
`Record`	`createRecord(Data key, Object value, long ttlMillis, long maxIdle, long now)`
`protected com.hazelcast.map.impl.recordstore.RecordStoreLoader`	`createRecordStoreLoader(MapStoreContext mapStoreContext)`
`Storage`	`createStorage(RecordFactory recordFactory, InMemoryFormat memoryFormat)`
`boolean`	`delete(Data key, CallerProvenance provenance)`
`void`	`destroy()` Called by `DistributedObject.destroy()`.
`void`	`destroyStorageAfterClear(boolean isDuringShutdown, boolean internal)` Calls also `clearStorage(boolean)` to release allocated HD memory of key+value pairs because `destroyStorageImmediate(boolean, boolean)` only releases internal resources of backing data structure.
`void`	`disposeDeferredBlocks()` This can be used to release unused resources.
`Object`	`evict(Data key, boolean backup)`
`int`	`evictAll(boolean backup)` Evicts all keys except locked ones.
`protected int`	`evictRecords(Collection<Record> recordsToEvict)`
`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 key, boolean backup, Address callerAddress, boolean touch)` Gets record from `RecordStore`.
`MapEntries`	`getAll(Set<Data> keys, Address callerAddress)`
`protected List<Data>`	`getKeysFromRecords(Collection<Record> clearableRecords)`
`Collection<Future>`	`getLoadingFutures()`
`LocalRecordStoreStats`	`getLocalRecordStoreStats()`
`int`	`getLockedEntryCount()`
`String`	`getLockOwnerInfo(Data key)`
`MapContainer`	`getMapContainer()`
`MapDataStore<Data,Object>`	`getMapDataStore()`
`String`	`getName()`
`protected Collection<Record>`	`getNotLockedRecords()`
`protected long`	`getNow()`
`long`	`getOwnedEntryCost()`
`int`	`getPartitionId()` Returns the partition id this RecordStore belongs to.
`Record`	`getRecord(Data key)`
`Record`	`getRecordOrNull(Data key)` Returns live record or null if record is already expired.
`protected Record`	`getRecordOrNull(Data key, long now, boolean backup)`
`Storage<Data,? extends Record>`	`getStorage()`
`boolean`	`hasQueryCache()`
`void`	`init()` Initialize the recordStore after creation
`boolean`	`isEmpty()`
`protected boolean`	`isKeyAndValueLoadable(Data key, Object value)`
`boolean`	`isKeyLoadFinished()`
`boolean`	`isLoaded()` Returns `true` if all key and value loading tasks have completed on this record store.
`boolean`	`isLocked(Data dataKey)`
`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.
`protected Map<Data,Object>`	`loadEntries(Set<Data> keys, Address callerAddress)`
`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 key, EntryView mergingEntry, MapMergePolicy mergePolicy)`
`boolean`	`merge(Data key, 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`.
`protected void`	`onStore(Record record)`
`protected boolean`	`persistenceEnabledFor(CallerProvenance provenance)`
`Object`	`put(Data key, Object value, long ttl, long maxIdle)`
`Record`	`putBackup(Data key, Object value, CallerProvenance provenance)`
`Record`	`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 key, Object value, long ttl, long maxIdle, Address callerAddress)`
`protected Object`	`putInternal(Data key, Object value, long ttl, long maxIdle, boolean loadFromStore, boolean countAsAccess)`
`void`	`putRecord(Data key, Record record)` Puts a data key and a record value to record-store.
`Object`	`putTransient(Data key, Object value, long ttl, long maxIdle)`
`Data`	`readBackupData(Data key)` This method is called directly by user threads, in other words it is called outside of the partition threads.
`Object`	`remove(Data key, CallerProvenance provenance)`
`boolean`	`remove(Data key, Object testValue)`
`void`	`removeBackup(Data key, CallerProvenance provenance)` Similar to `RecordStore##remove(Data, CallerProvenance)` except removeBackup doesn't touch mapstore since it does not return previous value.
`protected void`	`removeIndex(Collection<Record> records)`
`protected void`	`removeIndex(Record record)`
`protected Object`	`removeRecord(Data key, Record record, long now, CallerProvenance provenance)`
`protected int`	`removeRecords(Collection<Record> recordsToRemove)`
`Object`	`replace(Data key, Object update)`
`boolean`	`replace(Data key, 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.
`protected void`	`saveIndex(Record record, Object oldValue)`
`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.
`void`	`setSizeEstimator(EntryCostEstimator entryCostEstimator)`
`boolean`	`setTtl(Data key, long ttl)`
`boolean`	`setWithUncountedAccess(Data dataKey, Object value, long ttl, long maxIdle)` Does exactly the same thing as `RecordStore.set(Data, Object, long, long)` except the invocation is not counted as a read access while updating the access statics.
`int`	`size()` Size may not give precise size at a specific moment due to the expiration logic.
`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.
`protected Data`	`toData(Object value)`
`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`.
`protected void`	`updateRecord(Data key, Record record, Object value, long now, boolean countAsAccess)`
`protected void`	`updateStatsOnGet(long now)`
`protected void`	`updateStatsOnPut(boolean countAsAccess, long now)`
`protected void`	`updateStatsOnPut(long hits)`

Methods inherited from class com.hazelcast.map.impl.recordstore.AbstractEvictableRecordStore
accessRecord, doPostEvictionOperations, evictEntries, evictExpiredEntries, get, getExpiredKeysQueue, getOrNullIfExpired, isExpirable, isExpired, isMaxIdleDefined, isTtlDefined, markRecordStoreExpirable, mergeRecordExpiration, mergeRecordExpiration, sampleAndForceRemoveEntries, shouldEvict

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

Field Detail

logger
```
protected final ILogger logger
```

recordStoreLoader

protected final com.hazelcast.map.impl.recordstore.RecordStoreLoader recordStoreLoader

keyLoader
```
protected final MapKeyLoader keyLoader
```

loadingFutures
```
protected final Collection<Future> loadingFutures
```
A collection of futures representing pending completion of the key and value loading tasks. The loadingFutures are modified by partition threads and can be accessed by query threads.

See Also:

loadAll(boolean), loadAllFromStore(List, boolean)

partitionId
```
protected final int partitionId
```

name
```
protected final String name
```

lockStore
```
protected final LockStore lockStore
```

mapContainer

protected final MapContainer mapContainer

recordFactory

protected final RecordFactory recordFactory

inMemoryFormat

protected final InMemoryFormat inMemoryFormat

mapStoreContext

protected final MapStoreContext mapStoreContext

valueComparator

protected final ValueComparator valueComparator

mapServiceContext

protected final MapServiceContext mapServiceContext

serializationService

protected final SerializationService serializationService

mapDataStore

protected final MapDataStore<Data,Object> mapDataStore

stats

protected final LocalRecordStoreStatsImpl stats

mutationObserver

protected final RecordStoreMutationObserver<Record> mutationObserver

storage
```
protected Storage<Data,Record> storage
```

Constructor Detail

DefaultRecordStore

public DefaultRecordStore(MapContainer mapContainer,
                          int partitionId,
                          MapKeyLoader keyLoader,
                          ILogger logger)

Method Detail
- getMapDataStore
```
public MapDataStore<Data,Object> getMapDataStore()
```
- softFlush
```
public long softFlush()
```
  See Also:
  
  MapDataStore.softFlush()
- getRecord
```
public Record getRecord(Data key)
```
- putRecord
```
public void putRecord(Data key,
                      Record record)
```
  Description copied from interface: RecordStore
  
  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
- putBackup
```
public Record 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
```
public Record 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.
- iterator
```
public Iterator<Record> iterator()
```
  Description copied from interface: RecordStore
  
  Iterates over record store entries.
  
  Returns:
  
  read only iterator for map values.
- iterator
```
public Iterator<Record> iterator(long now,
                                 boolean backup)
```
  Description copied from interface: RecordStore
  
  Iterates over record store entries by respecting expiration.
  
  Returns:
  
  read only iterator for map values.
- fetchKeys
```
public MapKeysWithCursor fetchKeys(int tableIndex,
                                   int size)
```
  Description copied from interface: RecordStore
  
  Fetches specified number of keys from provided tableIndex.
  
  Returns:
  
  MapKeysWithCursor which is a holder for keys and next index to read from.
- fetchEntries
```
public MapEntriesWithCursor fetchEntries(int tableIndex,
                                         int size)
```
  Description copied from interface: RecordStore
  
  Fetches specified number of entries from provided tableIndex.
  
  Returns:
  
  MapEntriesWithCursor which is a holder for entries and next index to read from.
- loadAwareIterator
```
public Iterator<Record> loadAwareIterator(long now,
                                          boolean backup)
```
  Description copied from interface: RecordStore
  
  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
```
public int size()
```
  Size may not give precise size at a specific moment due to the expiration logic. But eventually, it should be correct.
  
  Returns:
  
  record store size.
- isEmpty
```
public boolean isEmpty()
```
- containsValue
```
public boolean containsValue(Object value)
```
- txnLock
```
public boolean txnLock(Data key,
                       String caller,
                       long threadId,
                       long referenceId,
                       long ttl,
                       boolean blockReads)
```
- extendLock
```
public boolean extendLock(Data key,
                          String caller,
                          long threadId,
                          long ttl)
```
- localLock
```
public boolean localLock(Data key,
                         String caller,
                         long threadId,
                         long referenceId,
                         long ttl)
```
- unlock
```
public boolean unlock(Data key,
                      String caller,
                      long threadId,
                      long referenceId)
```
- lock
```
public boolean lock(Data key,
                    String caller,
                    long threadId,
                    long referenceId,
                    long ttl)
```
- forceUnlock
```
public boolean forceUnlock(Data dataKey)
```
- isLocked
```
public boolean isLocked(Data dataKey)
```
- isTransactionallyLocked
```
public boolean isTransactionallyLocked(Data key)
```
- canAcquireLock
```
public boolean canAcquireLock(Data key,
                              String caller,
                              long threadId)
```
- isLockedBy
```
public boolean isLockedBy(Data key,
                          String caller,
                          long threadId)
```
- getLockOwnerInfo
```
public String getLockOwnerInfo(Data key)
```
- loadRecordOrNull
```
public Record loadRecordOrNull(Data key,
                               boolean backup,
                               Address callerAddress)
```
- getKeysFromRecords
```
protected List<Data> getKeysFromRecords(Collection<Record> clearableRecords)
```
- removeRecords
```
protected int removeRecords(Collection<Record> recordsToRemove)
```
- evictRecords
```
protected int evictRecords(Collection<Record> recordsToEvict)
```
- getNotLockedRecords
```
protected Collection<Record> getNotLockedRecords()
```
- evict
```
public Object evict(Data key,
                    boolean backup)
```
- evictAll
```
public int evictAll(boolean backup)
```
  Description copied from interface: RecordStore
  
  Evicts all keys except locked ones.
  
  Parameters:
  
  backup - true if a backup partition, otherwise false.
  
  Returns:
  
  number of evicted entries.
- removeBackup
```
public void removeBackup(Data key,
                         CallerProvenance provenance)
```
  Description copied from interface: RecordStore
  
  Similar to RecordStore##remove(Data, CallerProvenance) except removeBackup doesn't touch mapstore since it does not return previous value.
- delete
```
public boolean delete(Data key,
                      CallerProvenance provenance)
```
  Parameters:
  
  key - the key to be removed
  
  provenance - origin of call to this method.
  
  Returns:
  
  true if entry is deleted, otherwise returns false
- remove
```
public 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
- remove
```
public boolean remove(Data key,
                      Object testValue)
```
- get
```
public Object get(Data key,
                  boolean backup,
                  Address callerAddress,
                  boolean touch)
```
  Description copied from interface: RecordStore
  
  Gets record from RecordStore. Loads missing keys from map store.
  
  Parameters:
  
  key - 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
- readBackupData
```
public Data readBackupData(Data key)
```
  This method is called directly by user threads, in other words it is called outside of the partition threads.
  
  Parameters:
  
  key - key to be accessed
  
  Returns:
  
  value as Data independent of InMemoryFormat
- getAll
```
public MapEntries getAll(Set<Data> keys,
                         Address callerAddress)
```
- loadEntries
```
protected Map<Data,Object> loadEntries(Set<Data> keys,
                                       Address callerAddress)
```
- addMapEntrySet
```
protected void addMapEntrySet(Object key,
                              Object value,
                              MapEntries mapEntries)
```
- addMapEntrySet
```
protected void addMapEntrySet(Map<Object,Object> entries,
                              MapEntries mapEntries)
```
- existInMemory
```
public boolean existInMemory(Data key)
```
  Description copied from interface: RecordStore
  
  Checks if the key exist in memory without trying to load data from map-loader
- containsKey
```
public boolean containsKey(Data key,
                           Address callerAddress)
```
- hasQueryCache
```
public boolean hasQueryCache()
```
  Returns:
  
  true if this IMap has any query-cache, otherwise return false
- setTtl
```
public boolean setTtl(Data key,
                      long ttl)
```
- set
```
public 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
```
public Object put(Data key,
                  Object value,
                  long ttl,
                  long maxIdle)
```
  Returns:
  
  oldValue if it exists in memory otherwise tries to load oldValue by using MapLoader
- putInternal
```
protected Object putInternal(Data key,
                             Object value,
                             long ttl,
                             long maxIdle,
                             boolean loadFromStore,
                             boolean countAsAccess)
```
- merge
```
public boolean merge(SplitBrainMergeTypes.MapMergeTypes mergingEntry,
                     SplitBrainMergePolicy<Data,SplitBrainMergeTypes.MapMergeTypes> mergePolicy)
```
- merge
```
public boolean merge(SplitBrainMergeTypes.MapMergeTypes mergingEntry,
                     SplitBrainMergePolicy<Data,SplitBrainMergeTypes.MapMergeTypes> mergePolicy,
                     CallerProvenance provenance)
```
  Description copied from interface: RecordStore
  
  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
```
public boolean merge(Data key,
                     EntryView mergingEntry,
                     MapMergePolicy mergePolicy)
```
- merge
```
public boolean merge(Data key,
                     EntryView mergingEntry,
                     MapMergePolicy mergePolicy,
                     CallerProvenance provenance)
```
  Description copied from interface: RecordStore
  
  Merges the given EntryView via the given MapMergePolicy.
  
  Parameters:
  
  key - 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
- replace
```
public Object replace(Data key,
                      Object update)
```
- replace
```
public boolean replace(Data key,
                       Object expect,
                       Object update)
```
  Description copied from interface: RecordStore
  
  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:
  
  key - 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
```
public Object putTransient(Data key,
                           Object value,
                           long ttl,
                           long maxIdle)
```
- putFromLoad
```
public Object putFromLoad(Data key,
                          Object value,
                          Address callerAddress)
```
  Description copied from interface: RecordStore
  
  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
```
public Object putFromLoadBackup(Data key,
                                Object value)
```
  Description copied from interface: RecordStore
  
  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
- isKeyAndValueLoadable
```
protected boolean isKeyAndValueLoadable(Data key,
                                        Object value)
```
- setWithUncountedAccess
```
public boolean setWithUncountedAccess(Data dataKey,
                                      Object value,
                                      long ttl,
                                      long maxIdle)
```
  Description copied from interface: RecordStore
  
  Does exactly the same thing as RecordStore.set(Data, Object, long, long) except the invocation is not counted as a read access while updating the access statics.
- putIfAbsent
```
public Object putIfAbsent(Data key,
                          Object value,
                          long ttl,
                          long maxIdle,
                          Address callerAddress)
```
- removeRecord
```
protected Object removeRecord(Data key,
                              @Nonnull
                              Record record,
                              long now,
                              CallerProvenance provenance)
```
- getRecordOrNull
```
public Record getRecordOrNull(Data key)
```
  Description copied from interface: RecordStore
  
  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:
  
  RecordStore.get(com.hazelcast.nio.serialization.Data, boolean, com.hazelcast.nio.Address, boolean)
- getRecordOrNull
```
protected Record getRecordOrNull(Data key,
                                 long now,
                                 boolean backup)
```
- onStore
```
protected void onStore(Record record)
```
- isKeyLoadFinished
```
public boolean isKeyLoadFinished()
```
  Returns:
  
  true if the key loading and dispatching has finished on this record store
- checkIfLoaded
```
public void checkIfLoaded()
```
- isLoaded
```
public boolean isLoaded()
```
  Description copied from interface: RecordStore
  
  Returns true if all key and value loading tasks have completed on this record store.
- getLoadingFutures
```
public Collection<Future> getLoadingFutures()
```
- startLoading
```
public void startLoading()
```
  Description copied from interface: RecordStore
  
  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
```
public void setPreMigrationLoadedStatus(boolean loaded)
```
  Description copied from interface: RecordStore
  
  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 RecordStore.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.
- loadAll
```
public void loadAll(boolean replaceExistingValues)
```
  Description copied from interface: RecordStore
  
  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
- loadAllFromStore
```
public void loadAllFromStore(List<Data> keys,
                             boolean replaceExistingValues)
```
  Description copied from interface: RecordStore
  
  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
```
public void updateLoadStatus(boolean lastBatch,
                             Throwable exception)
```
  Description copied from interface: RecordStore
  
  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
- maybeDoInitialLoad
```
public void maybeDoInitialLoad()
```
  Description copied from interface: RecordStore
  
  Resets the map loader state if necessary and triggers initial key and value loading if it has not been done before.
- clear
```
public int clear()
```
  Description copied from interface: RecordStore
  
  Called by IMap.clear(). Clears data in this record store.
  
  Returns:
  
  number of cleared entries.
- reset
```
public void reset()
```
  Description copied from interface: RecordStore
  
  Resets the record store to it's initial state. Used in replication operations.
  
  See Also:
  
  RecordStore.putRecord(Data, Record)
- destroy
```
public void destroy()
```
  Description copied from interface: RecordStore
  
  Called by DistributedObject.destroy(). Destroys data in this record store.
- clearPartition
```
public void clearPartition(boolean onShutdown,
                           boolean onStorageDestroy)
```
  Description copied from interface: RecordStore
  
  Called by DistributedObject.destroy() or MapMigrationAwareService Clears internal partition data.
  
  Parameters:
  
  onShutdown - true if close is called during MapService shutdown, false otherwise.
  
  onStorageDestroy - true if record-store will be destroyed, otherwise false.
- clearOtherDataThanStorage
```
public void clearOtherDataThanStorage(boolean onShutdown,
                                      boolean onStorageDestroy)
```
  Only cleans the data other than storage-data that is held on this record store. Other services data like lock-service-data is not cleared here.
- destroyStorageAfterClear
```
public void destroyStorageAfterClear(boolean isDuringShutdown,
                                     boolean internal)
```
  Calls also clearStorage(boolean) to release allocated HD memory of key+value pairs because destroyStorageImmediate(boolean, boolean) only releases internal resources of backing data structure.
  
  Parameters:
  
  isDuringShutdown - Storage.clear(boolean)
  
  internal - see RecordStoreMutationObserver.onDestroy(boolean)}
- persistenceEnabledFor
```
protected boolean persistenceEnabledFor(@Nonnull
                                        CallerProvenance provenance)
```
- getLocalRecordStoreStats
```
public LocalRecordStoreStats getLocalRecordStoreStats()
```
  Specified by:
  
  getLocalRecordStoreStats in interface RecordStore<Record>
- init
```
public void init()
```
  Description copied from interface: RecordStore
  
  Initialize the recordStore after creation
  
  Specified by:
  
  init in interface RecordStore<Record>
- createRecord
```
public Record createRecord(Data key,
                           Object value,
                           long ttlMillis,
                           long maxIdle,
                           long now)
```
  Specified by:
  
  createRecord in interface RecordStore<Record>
- createStorage
```
public Storage createStorage(RecordFactory recordFactory,
                             InMemoryFormat memoryFormat)
```
  Specified by:
  
  createStorage in interface RecordStore<Record>
- getName
```
public String getName()
```
  Specified by:
  
  getName in interface RecordStore<Record>
- getMapContainer
```
public MapContainer getMapContainer()
```
  Specified by:
  
  getMapContainer in interface RecordStore<Record>
- getOwnedEntryCost
```
public long getOwnedEntryCost()
```
  Specified by:
  
  getOwnedEntryCost in interface RecordStore<Record>
- getNow
```
protected long getNow()
```
- updateRecord
```
protected void updateRecord(Data key,
                            Record record,
                            Object value,
                            long now,
                            boolean countAsAccess)
```
- getPartitionId
```
public int getPartitionId()
```
  Description copied from interface: RecordStore
  
  Returns the partition id this RecordStore belongs to.
  
  Specified by:
  
  getPartitionId in interface RecordStore<Record>
  
  Returns:
  
  the partition id.
- saveIndex
```
protected void saveIndex(Record record,
                         Object oldValue)
```
- removeIndex
```
protected void removeIndex(Record record)
```
- removeIndex
```
protected void removeIndex(Collection<Record> records)
```
- createLockStore
```
protected LockStore createLockStore()
```
- getLockedEntryCount
```
public int getLockedEntryCount()
```
  Specified by:
  
  getLockedEntryCount in interface RecordStore<Record>
- createRecordStoreLoader
```
protected com.hazelcast.map.impl.recordstore.RecordStoreLoader createRecordStoreLoader(MapStoreContext mapStoreContext)
```
- toData
```
protected Data toData(Object value)
```
- setSizeEstimator
```
public void setSizeEstimator(EntryCostEstimator entryCostEstimator)
```
- disposeDeferredBlocks
```
public void disposeDeferredBlocks()
```
  Description copied from interface: RecordStore
  
  This can be used to release unused resources.
  
  Specified by:
  
  disposeDeferredBlocks in interface RecordStore<Record>
- getStorage
```
public Storage<Data,? extends Record> getStorage()
```
  Specified by:
  
  getStorage in interface RecordStore<Record>
- updateStatsOnPut
```
protected void updateStatsOnPut(boolean countAsAccess,
                                long now)
```
- updateStatsOnPut
```
protected void updateStatsOnPut(long hits)
```
- updateStatsOnGet
```
protected void updateStatsOnGet(long now)
```

Class DefaultRecordStore

Nested Class Summary

Nested classes/interfaces inherited from class com.hazelcast.map.impl.recordstore.AbstractEvictableRecordStore

Field Summary

Fields inherited from class com.hazelcast.map.impl.recordstore.AbstractEvictableRecordStore

Fields inherited from interface com.hazelcast.map.impl.recordstore.RecordStore

Constructor Summary

Method Summary

Methods inherited from class com.hazelcast.map.impl.recordstore.AbstractEvictableRecordStore

Methods inherited from class java.lang.Object

Field Detail

logger

recordStoreLoader

keyLoader

loadingFutures

partitionId

name

lockStore

mapContainer

recordFactory

inMemoryFormat

mapStoreContext

valueComparator

mapServiceContext

serializationService

mapDataStore

stats

mutationObserver

storage

Constructor Detail

DefaultRecordStore

Method Detail

getMapDataStore

softFlush

getRecord

putRecord

putBackup

putBackup

iterator

iterator

fetchKeys

fetchEntries

loadAwareIterator

size

isEmpty

containsValue

txnLock

extendLock

localLock

unlock

lock

forceUnlock

isLocked

isTransactionallyLocked

canAcquireLock

isLockedBy

getLockOwnerInfo

loadRecordOrNull

getKeysFromRecords

removeRecords

evictRecords

getNotLockedRecords

evict

evictAll

removeBackup

delete

remove

remove

get

readBackupData

getAll

loadEntries

addMapEntrySet

addMapEntrySet

existInMemory

containsKey

hasQueryCache

setTtl

set

put