|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use Store | |
---|---|
voldemort.client | The user facing interface to Voldemort. |
voldemort.cluster.failuredetector | Classes associated with client side failure detectors. |
voldemort.rest.coordinator | |
voldemort.rest.server | |
voldemort.server | The Voldemort server. |
voldemort.server.protocol | The server side of request RPC handling. |
voldemort.store | The Store interface is the primary interface for Voldemort. |
voldemort.store.bdb | A storage engine that persists data in BDB JE. |
voldemort.store.compress | Classes associated with compression on the server ( storage ) side. |
voldemort.store.configuration | A storage engine to persist metadata on a server. |
voldemort.store.gzip | Storage engine which gzips the content before delegating it down. |
voldemort.store.http | HTTP based storage engine |
voldemort.store.invalidmetadata | Server side store which checks whether the tuples coming to this node are valid. |
voldemort.store.logging | A wrapper store which deals with logging. |
voldemort.store.memory | An in-memory storage engine that serves data out of a non-persistent map. |
voldemort.store.metadata | Our in-memory metadata store on the server which is backed by the configuration files. |
voldemort.store.mysql | A storage engine that persists data in a mysql instance. |
voldemort.store.nonblockingstore | Non-blocking store which deals with async requests. |
voldemort.store.quota | |
voldemort.store.readonly | A storage engine that provides very efficient read-only access to large sorted files of data. |
voldemort.store.rebalancing | Server side wrapper stores used for redirection during rebalancing. |
voldemort.store.retention | |
voldemort.store.routed | A store implmentation that handles routing to nodes, and repairing obsolete values detected on those nodes. |
voldemort.store.routed.action | Classes representing various states for the state based routing stores. |
voldemort.store.serialized | A store implementation that handles serialization to bytes from rich objects. |
voldemort.store.slop | A store implementation that falls back on storing values in additional nodes not in the preference list when nodes are unavailable. |
voldemort.store.socket | A store implementation that works remotely over a tcp/ip socket interacting with a SocketServer on the the other side. |
voldemort.store.stats | Store wrappers which deal with statistics |
voldemort.store.versioned | Store decorators that interact with versions. |
voldemort.store.views | Classes related to Views and server side transforms |
Uses of Store in voldemort.client |
---|
Fields in voldemort.client declared as Store | |
---|---|
protected Store<K,V,java.lang.Object> |
DefaultStoreClient.store
|
Methods in voldemort.client that return Store | ||
---|---|---|
|
AbstractStoreClientFactory.getRawStore(java.lang.String storeName,
InconsistencyResolver<Versioned<V>> resolver)
|
|
|
StoreClientFactory.getRawStore(java.lang.String storeName,
InconsistencyResolver<Versioned<V>> resolver)
Get the underlying store, not the public StoreClient interface |
|
|
CachingStoreClientFactory.getRawStore(java.lang.String storeName,
InconsistencyResolver<Versioned<V>> resolver)
|
|
|
AbstractStoreClientFactory.getRawStore(java.lang.String storeName,
InconsistencyResolver<Versioned<V>> resolver,
java.lang.String customStoresXml,
java.lang.String clusterXmlString,
FailureDetector fd)
|
|
|
MockStoreClientFactory.getRawStore(java.lang.String storeName,
InconsistencyResolver<Versioned<V1>> resolver)
|
|
protected abstract Store<ByteArray,byte[],byte[]> |
AbstractStoreClientFactory.getStore(java.lang.String storeName,
java.lang.String host,
int port,
RequestFormatType type)
|
|
protected Store<ByteArray,byte[],byte[]> |
SocketStoreClientFactory.getStore(java.lang.String storeName,
java.lang.String host,
int port,
RequestFormatType type)
|
|
protected Store<ByteArray,byte[],byte[]> |
HttpStoreClientFactory.getStore(java.lang.String name,
java.lang.String host,
int port,
RequestFormatType type)
Deprecated. |
|
|
SocketStoreClientFactory.getSystemStore(java.lang.String storeName,
java.lang.String clusterXml,
FailureDetector fd)
|
Constructors in voldemort.client with parameters of type Store | |
---|---|
SystemStoreClient(java.lang.String storeName,
Store<K,V,java.lang.Object> systemStore)
Constructor that creates a system store client which can be used to interact with the system stores managed by the cluster |
Uses of Store in voldemort.cluster.failuredetector |
---|
Fields in voldemort.cluster.failuredetector with type parameters of type Store | |
---|---|
protected java.util.Map<java.lang.Integer,Store<K,V,T>> |
BasicStoreVerifier.stores
|
Methods in voldemort.cluster.failuredetector that return Store | |
---|---|
protected abstract Store<ByteArray,byte[],byte[]> |
ClientStoreVerifier.getStoreInternal(Node node)
|
Constructor parameters in voldemort.cluster.failuredetector with type arguments of type Store | |
---|---|
BasicStoreVerifier(java.util.Map<java.lang.Integer,Store<K,V,T>> stores,
K key)
|
Uses of Store in voldemort.rest.coordinator |
---|
Constructors in voldemort.rest.coordinator with parameters of type Store | |
---|---|
DynamicTimeoutStoreClient(Store<K,V,java.lang.Object> customStore)
Dummy constructor for Unit test purposes |
Uses of Store in voldemort.rest.server |
---|
Methods in voldemort.rest.server that return Store | |
---|---|
Store<ByteArray,byte[],byte[]> |
VoldemortStoreRequest.getStore()
|
protected Store<ByteArray,byte[],byte[]> |
RestServerRequestHandler.getStore(java.lang.String name,
RequestRoutingType type)
Gets the store for the store name and routing type. |
Constructors in voldemort.rest.server with parameters of type Store | |
---|---|
VoldemortStoreRequest(CompositeVoldemortRequest<ByteArray,byte[]> requestObject,
Store<ByteArray,byte[],byte[]> store,
int zoneId)
|
Uses of Store in voldemort.server |
---|
Methods in voldemort.server that return Store | |
---|---|
Store<ByteArray,byte[],byte[]> |
StoreRepository.getLocalStore(java.lang.String storeName)
|
Store<ByteArray,byte[],byte[]> |
StoreRepository.getNodeStore(java.lang.String storeName,
java.lang.Integer id)
|
Store<ByteArray,byte[],byte[]> |
StoreRepository.getRedirectingSocketStore(java.lang.String storeName,
java.lang.Integer id)
|
Store<ByteArray,byte[],byte[]> |
StoreRepository.getRoutedStore(java.lang.String storeName)
|
Store<ByteArray,byte[],byte[]> |
StoreRepository.removeLocalStore(java.lang.String storeName)
|
Store<ByteArray,byte[],byte[]> |
StoreRepository.removeNodeStore(java.lang.String storeName,
int nodeId)
|
Store<ByteArray,byte[],byte[]> |
StoreRepository.removeRoutedStore(java.lang.String storeName)
|
Store<ByteArray,byte[],byte[]> |
StoreRepository.removeStorageEngine(java.lang.String storeName)
|
Methods in voldemort.server that return types with arguments of type Store | |
---|---|
java.util.List<Store<ByteArray,byte[],byte[]>> |
StoreRepository.getAllLocalStores()
|
java.util.List<Pair<java.lang.Integer,Store<ByteArray,byte[],byte[]>>> |
StoreRepository.getAllNodeStores()
|
java.util.List<Store<ByteArray,byte[],byte[]>> |
StoreRepository.getAllRoutedStores()
|
Methods in voldemort.server with parameters of type Store | |
---|---|
void |
StoreRepository.addLocalStore(Store<ByteArray,byte[],byte[]> store)
|
void |
StoreRepository.addNodeStore(int nodeId,
Store<ByteArray,byte[],byte[]> store)
|
void |
StoreRepository.addRedirectingSocketStore(int nodeId,
Store<ByteArray,byte[],byte[]> store)
|
void |
StoreRepository.addRoutedStore(Store<ByteArray,byte[],byte[]> store)
|
Uses of Store in voldemort.server.protocol |
---|
Methods in voldemort.server.protocol that return Store | |
---|---|
protected Store<ByteArray,byte[],byte[]> |
AbstractRequestHandler.getStore(java.lang.String name,
RequestRoutingType type)
|
Uses of Store in voldemort.store |
---|
Subinterfaces of Store in voldemort.store | |
---|---|
interface |
StorageEngine<K,V,T>
A base storage class which is actually responsible for data persistence. |
Classes in voldemort.store that implement Store | |
---|---|
class |
AbstractStorageEngine<K,V,T>
|
class |
AbstractStore<K,V,T>
|
class |
DelegatingStore<K,V,T>
A Store template that delegates all operations to an inner store. |
Methods in voldemort.store that return Store | |
---|---|
Store<K,V,T> |
DelegatingStore.getInnerStore()
|
Methods in voldemort.store with parameters of type Store | ||
---|---|---|
static
|
StoreUtils.get(Store<K,V,T> storageEngine,
K key,
T transform)
Implements get by delegating to getAll. |
|
static
|
StoreUtils.getAll(Store<K,V,T> storageEngine,
java.lang.Iterable<K> keys,
java.util.Map<K,T> transforms)
Implements getAll by delegating to get. |
|
T |
StoreRequest.request(Store<ByteArray,byte[],byte[]> store)
Perform the request to the given Store . |
Constructors in voldemort.store with parameters of type Store | |
---|---|
DelegatingStore(Store<K,V,T> innerStore)
|
Uses of Store in voldemort.store.bdb |
---|
Classes in voldemort.store.bdb that implement Store | |
---|---|
class |
BdbStorageEngine
A store that uses BDB for persistence |
class |
PartitionPrefixedBdbStorageEngine
Extends BDB Storage Engine with capabilities to perform partition range scans, to speed up scan jobs, that filter on partition id |
Uses of Store in voldemort.store.compress |
---|
Classes in voldemort.store.compress that implement Store | |
---|---|
class |
CompressingStore
A Store Decorator that compresses keys and values as it stores them and uncompresses them as it reads them based on the CompressionStrategy objects provided. |
Constructors in voldemort.store.compress with parameters of type Store | |
---|---|
CompressingStore(Store<ByteArray,byte[],byte[]> innerStore,
CompressionStrategy keysCompressionStrategy,
CompressionStrategy valuesCompressionStrategy)
|
Uses of Store in voldemort.store.configuration |
---|
Classes in voldemort.store.configuration that implement Store | |
---|---|
class |
ConfigurationStorageEngine
A FileSystem based Storage Engine to persist configuration metadata. MetadataStore |
class |
FileBackedCachingStorageEngine
A Storage Engine used to persist the keys and values in a human readable format on disk. |
Uses of Store in voldemort.store.gzip |
---|
Classes in voldemort.store.gzip that implement Store | |
---|---|
class |
GzipStore<K>
A Store decorator that gzips and ungzips its contents as it stores them |
Constructors in voldemort.store.gzip with parameters of type Store | |
---|---|
GzipStore(Store<K,byte[],byte[]> innerStore)
|
Uses of Store in voldemort.store.http |
---|
Classes in voldemort.store.http that implement Store | |
---|---|
class |
HttpStore
A remote store client that transmits operations via HTTP and interacts with the VoldemortHttpServer. |
Uses of Store in voldemort.store.invalidmetadata |
---|
Classes in voldemort.store.invalidmetadata that implement Store | |
---|---|
class |
InvalidMetadataCheckingStore
An InvalidMetadataCheckingStore store is a store wrapper that delegates to an inner store, and throws InvalidMetadataException if a client requests
a partition which is not or should not be available at this node. |
Constructors in voldemort.store.invalidmetadata with parameters of type Store | |
---|---|
InvalidMetadataCheckingStore(int nodeId,
Store<ByteArray,byte[],byte[]> innerStore,
MetadataStore metadata)
Create a store which delegates its operations to its inner store and throws InvalidMetadataException if the partition for key
requested should not lie with this node. |
Uses of Store in voldemort.store.logging |
---|
Classes in voldemort.store.logging that implement Store | |
---|---|
class |
LoggingStore<K,V,T>
A store wrapper that handles debug logging. |
Constructors in voldemort.store.logging with parameters of type Store | |
---|---|
LoggingStore(Store<K,V,T> store)
Create a logging store that wraps the given store |
|
LoggingStore(Store<K,V,T> store,
java.lang.String instance,
Time time)
Create a logging store that wraps the given store |
|
LoggingStore(Store<K,V,T> store,
Time time)
Create a logging store that wraps the given store |
Uses of Store in voldemort.store.memory |
---|
Classes in voldemort.store.memory that implement Store | |
---|---|
class |
InMemoryStorageEngine<K,V,T>
A simple non-persistent, in-memory store. |
Uses of Store in voldemort.store.metadata |
---|
Classes in voldemort.store.metadata that implement Store | |
---|---|
class |
MetadataStore
MetadataStore maintains metadata for Voldemort Server. |
Constructors in voldemort.store.metadata with parameters of type Store | |
---|---|
MetadataStore(Store<java.lang.String,java.lang.String,java.lang.String> innerStore,
int nodeId)
|
|
MetadataStore(Store<java.lang.String,java.lang.String,java.lang.String> innerStore,
StorageEngine<java.lang.String,java.lang.String,java.lang.String> storeDefinitionsStorageEngine,
int nodeId)
|
Uses of Store in voldemort.store.mysql |
---|
Classes in voldemort.store.mysql that implement Store | |
---|---|
class |
MysqlStorageEngine
A StorageEngine that uses Mysql for persistence |
Uses of Store in voldemort.store.nonblockingstore |
---|
Constructors in voldemort.store.nonblockingstore with parameters of type Store | |
---|---|
ThreadPoolBasedNonblockingStoreImpl(java.util.concurrent.ExecutorService executor,
Store<ByteArray,byte[],byte[]> innerStore)
|
Uses of Store in voldemort.store.quota |
---|
Classes in voldemort.store.quota that implement Store | |
---|---|
class |
QuotaLimitingStore
|
Constructors in voldemort.store.quota with parameters of type Store | |
---|---|
QuotaLimitingStore(Store<ByteArray,byte[],byte[]> innerStore,
StoreStats storeStats,
QuotaLimitStats quotaStats,
FileBackedCachingStorageEngine quotaStore)
|
Uses of Store in voldemort.store.readonly |
---|
Classes in voldemort.store.readonly that implement Store | |
---|---|
class |
ReadOnlyStorageEngine
A read-only store that fronts a big file |
Uses of Store in voldemort.store.rebalancing |
---|
Classes in voldemort.store.rebalancing that implement Store | |
---|---|
class |
RebootstrappingStore
The RebootstrappingStore catch all InvalidMetadataException and updates the routed store with latest cluster metadata, client rebootstrapping behavior same in DefaultStoreClient for server side routing |
class |
RedirectingStore
The RedirectingStore extends DelegatingStore |
Methods in voldemort.store.rebalancing that return Store | |
---|---|
protected Store<ByteArray,byte[],byte[]> |
RedirectingStore.getRedirectingSocketStore(java.lang.String storeName,
int proxyNodeId)
Get the SocketStore to redirect to for the
proxy node, creating one if needed. |
Constructors in voldemort.store.rebalancing with parameters of type Store | |
---|---|
RedirectingStore(Store<ByteArray,byte[],byte[]> innerStore,
MetadataStore metadata,
StoreRepository storeRepository,
FailureDetector detector,
SocketStoreFactory storeFactory,
java.util.concurrent.ExecutorService proxyPutWorkerPool,
ProxyPutStats proxyPutStats)
|
Uses of Store in voldemort.store.retention |
---|
Classes in voldemort.store.retention that implement Store | |
---|---|
class |
RetentionEnforcingStore
Wraps the storage layer and ensures we don't return any values that are stale. |
Constructors in voldemort.store.retention with parameters of type Store | |
---|---|
RetentionEnforcingStore(Store<ByteArray,byte[],byte[]> innerStore,
StoreDefinition storeDef,
boolean deleteExpiredEntries,
Time time)
|
Uses of Store in voldemort.store.routed |
---|
Classes in voldemort.store.routed that implement Store | |
---|---|
class |
PipelineRoutedStore
A Store which multiplexes requests to different internal Stores |
class |
RoutedStore
A Store which multiplexes requests to different internal Stores |
class |
ThreadPoolRoutedStore
Deprecated. |
Fields in voldemort.store.routed with type parameters of type Store | |
---|---|
protected java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> |
RoutedStore.innerStores
|
protected java.util.Map<java.lang.Integer,Store<ByteArray,Slop,byte[]>> |
PipelineRoutedStore.slopStores
|
Methods in voldemort.store.routed that return types with arguments of type Store | |
---|---|
java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> |
RoutedStore.getInnerStores()
|
Methods in voldemort.store.routed with parameters of type Store | |
---|---|
NonblockingStore |
RoutedStoreFactory.toNonblockingStore(Store<ByteArray,byte[],byte[]> store)
|
Method parameters in voldemort.store.routed with type arguments of type Store | |
---|---|
RoutedStore |
RoutedStoreFactory.create(Cluster cluster,
StoreDefinition storeDefinition,
java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> nodeStores,
FailureDetector failureDetector,
RoutedStoreConfig routedStoreConfig)
|
RoutedStore |
RoutedStoreFactory.create(Cluster cluster,
StoreDefinition storeDefinition,
java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> nodeStores,
java.util.Map<java.lang.Integer,NonblockingStore> nonblockingStores,
java.util.Map<java.lang.Integer,Store<ByteArray,Slop,byte[]>> slopStores,
java.util.Map<java.lang.Integer,NonblockingStore> nonblockingSlopStores,
FailureDetector failureDetector,
RoutedStoreConfig routedStoreConfig)
|
RoutedStore |
RoutedStoreFactory.create(Cluster cluster,
StoreDefinition storeDefinition,
java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> nodeStores,
java.util.Map<java.lang.Integer,NonblockingStore> nonblockingStores,
java.util.Map<java.lang.Integer,Store<ByteArray,Slop,byte[]>> slopStores,
java.util.Map<java.lang.Integer,NonblockingStore> nonblockingSlopStores,
FailureDetector failureDetector,
RoutedStoreConfig routedStoreConfig)
|
Constructor parameters in voldemort.store.routed with type arguments of type Store | |
---|---|
PipelineRoutedStore(java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> innerStores,
java.util.Map<java.lang.Integer,NonblockingStore> nonblockingStores,
java.util.Map<java.lang.Integer,Store<ByteArray,Slop,byte[]>> slopStores,
java.util.Map<java.lang.Integer,NonblockingStore> nonblockingSlopStores,
Cluster cluster,
StoreDefinition storeDef,
FailureDetector failureDetector,
boolean repairReads,
TimeoutConfig timeoutConfig,
int clientZoneId,
boolean isJmxEnabled,
java.lang.String identifierString,
ZoneAffinity zoneAffinity)
Create a PipelineRoutedStore |
|
PipelineRoutedStore(java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> innerStores,
java.util.Map<java.lang.Integer,NonblockingStore> nonblockingStores,
java.util.Map<java.lang.Integer,Store<ByteArray,Slop,byte[]>> slopStores,
java.util.Map<java.lang.Integer,NonblockingStore> nonblockingSlopStores,
Cluster cluster,
StoreDefinition storeDef,
FailureDetector failureDetector,
boolean repairReads,
TimeoutConfig timeoutConfig,
int clientZoneId,
boolean isJmxEnabled,
java.lang.String identifierString,
ZoneAffinity zoneAffinity)
Create a PipelineRoutedStore |
|
RoutedStore(java.lang.String name,
java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> innerStores,
Cluster cluster,
StoreDefinition storeDef,
boolean repairReads,
TimeoutConfig timeoutConfig,
FailureDetector failureDetector,
Time time)
|
|
ThreadPoolRoutedStore(java.lang.String name,
java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> innerStores,
Cluster cluster,
StoreDefinition storeDef,
boolean repairReads,
java.util.concurrent.ExecutorService threadPool,
TimeoutConfig timeoutConfig,
FailureDetector failureDetector,
Time time)
Deprecated. Create a RoutedStoreClient |
|
ThreadPoolRoutedStore(java.lang.String name,
java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> innerStores,
Cluster cluster,
StoreDefinition storeDef,
int numberOfThreads,
boolean repairReads,
TimeoutConfig timeoutConfig,
FailureDetector failureDetector)
Deprecated. Create a RoutedStoreClient |
Uses of Store in voldemort.store.routed.action |
---|
Constructor parameters in voldemort.store.routed.action with type arguments of type Store | |
---|---|
PerformSerialGetAllRequests(GetAllPipelineData pipelineData,
Pipeline.Event completeEvent,
java.lang.Iterable<ByteArray> keys,
FailureDetector failureDetector,
java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> stores,
int preferred,
int required,
boolean allowPartial)
|
|
PerformSerialPutRequests(PutPipelineData pipelineData,
Pipeline.Event completeEvent,
ByteArray key,
byte[] transforms,
FailureDetector failureDetector,
java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> stores,
int required,
Versioned<byte[]> versioned,
Time time,
Pipeline.Event masterDeterminedEvent)
|
|
PerformSerialRequests(PD pipelineData,
Pipeline.Event completeEvent,
ByteArray key,
FailureDetector failureDetector,
java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> stores,
int preferred,
int required,
StoreRequest<V> storeRequest,
Pipeline.Event insufficientSuccessesEvent)
|
|
PerformZoneSerialRequests(PD pipelineData,
Pipeline.Event completeEvent,
ByteArray key,
FailureDetector failureDetector,
java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> stores,
StoreRequest<V> storeRequest)
|
Uses of Store in voldemort.store.serialized |
---|
Classes in voldemort.store.serialized that implement Store | |
---|---|
class |
SerializingStorageEngine<K,V,T>
A StorageEngine that handles serialization to bytes, transforming each request to a request to StorageEngine |
class |
SerializingStore<K,V,T>
A store that transforms requests to a Store |
Methods in voldemort.store.serialized with parameters of type Store | ||
---|---|---|
static
|
SerializingStore.wrap(Store<ByteArray,byte[],byte[]> s,
Serializer<K1> k,
Serializer<V1> v,
Serializer<T1> t)
|
Constructors in voldemort.store.serialized with parameters of type Store | |
---|---|
SerializingStore(Store<ByteArray,byte[],byte[]> store,
Serializer<K> keySerializer,
Serializer<V> valueSerializer,
Serializer<T> transformsSerializer)
|
Uses of Store in voldemort.store.slop |
---|
Classes in voldemort.store.slop that implement Store | |
---|---|
class |
SlopStorageEngine
Tracks statistics of hints that were attempted, but not successfully pushed last time a pusher job ran; also tracks hints that have been added after the last run |
Constructor parameters in voldemort.store.slop with type arguments of type Store | |
---|---|
HintedHandoff(FailureDetector failureDetector,
java.util.Map<java.lang.Integer,Store<ByteArray,Slop,byte[]>> slopStores,
java.util.Map<java.lang.Integer,NonblockingStore> nonblockingSlopStores,
HintedHandoffStrategy handoffStrategy,
java.util.List<Node> failedNodes,
long timeoutMs)
Create a Hinted Handoff object |
Uses of Store in voldemort.store.socket |
---|
Classes in voldemort.store.socket that implement Store | |
---|---|
class |
SocketStore
The client implementation of a socket store--translates each request into a network operation to be handled by the socket server on the other side. |
Uses of Store in voldemort.store.stats |
---|
Classes in voldemort.store.stats that implement Store | |
---|---|
class |
StatTrackingStore
A store wrapper that tracks basic usage statistics |
Constructors in voldemort.store.stats with parameters of type Store | |
---|---|
StatTrackingStore(Store<ByteArray,byte[],byte[]> innerStore,
StoreStats parentStats)
|
Uses of Store in voldemort.store.versioned |
---|
Classes in voldemort.store.versioned that implement Store | |
---|---|
class |
InconsistencyResolvingStore<K,V,T>
A Store that uses a InconsistencyResolver to eliminate some duplicates. |
class |
VersionIncrementingStore<K,V,T>
A wrapper that increments the version on the value for puts and delegates all other operations |
Constructors in voldemort.store.versioned with parameters of type Store | |
---|---|
InconsistencyResolvingStore(Store<K,V,T> innerStore,
InconsistencyResolver<Versioned<V>> resolver)
|
|
VersionIncrementingStore(Store<K,V,T> innerStore,
int nodeId,
Time time)
|
Uses of Store in voldemort.store.views |
---|
Classes in voldemort.store.views that implement Store | |
---|---|
class |
ViewStorageEngine
Views are transformations of other stores |
Methods in voldemort.store.views with parameters of type Store | |
---|---|
V |
View.storeToView(Store<K,S,T> targetStore,
K k,
S s,
T t)
Translate from the store type to the view type |
V |
AbstractViewTransformation.storeToView(Store<K,S,T> store,
K k,
S s,
T t)
|
S |
View.viewToStore(Store<K,S,T> targetStore,
K k,
V v,
T t)
Translate from the view type to the store type |
S |
AbstractViewTransformation.viewToStore(Store<K,S,T> store,
K k,
V v,
T t)
|
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |