| Interface | Description |
|---|---|
| AbstractMultiFileWriter.WriterFactory | |
| CellSink |
A sink of cells that allows appending cells to the Writers that implement it.
|
| ChangedReadersObserver |
If set of MapFile.Readers in Store change, implementors are notified.
|
| CompactSplit.CompactionCompleteTracker | |
| FavoredNodesForRegion |
Abstraction that allows different modules in RegionServer to update/get
the favored nodes information for regions.
|
| FlushLifeCycleTracker |
Used to track flush execution.
|
| FlushRequester |
Request a flush.
|
| FlushRequestListener |
Listener which will get notified regarding flush requests of regions.
|
| HeapMemoryManager.HeapMemoryTuneObserver |
Every class that wants to observe heap memory tune actions must implement this interface.
|
| HeapMemoryTuner |
Makes the decision regarding proper sizing of the heap memory.
|
| HRegion.BatchOperation.Visitor |
Visitor interface for batch operations
|
| HRegion.BulkLoadListener |
Listener class to enable callers of
bulkLoadHFile() to perform any necessary
pre/post processing of a given bulkload call
|
| HRegion.FlushResult | |
| InternalScanner |
Internal scanners differ from client-side scanners in that they operate on
HStoreKeys and byte[] instead of RowResults.
|
| KeyValueScanner |
Scanner that returns the next KeyValue.
|
| LastSequenceId |
Last flushed sequence Ids for the regions and their stores on region server
|
| LeaseListener |
LeaseListener is an interface meant to be implemented by users of the Leases
class.
|
| MemStore |
The MemStore holds in-memory modifications to the Store.
|
| MemStoreFlusher.FlushQueueEntry | |
| MemStoreLAB |
A memstore-local allocation buffer.
|
| MemStoreSizing |
Accounting of current heap and data sizes.
|
| MetricsHeapMemoryManagerSource |
This interface will be implemented by a MetricsSource that will export metrics from
HeapMemoryManager in RegionServer into the hadoop metrics system.
|
| MetricsRegionAggregateSource |
This interface will be implemented by a MetricsSource that will export metrics from
multiple regions into the hadoop metrics system.
|
| MetricsRegionServerQuotaSource |
A collection of exposed metrics for space quotas from an HBase RegionServer.
|
| MetricsRegionServerSource |
Interface for classes that expose metrics about the regionserver.
|
| MetricsRegionServerSourceFactory |
Interface of a factory to create Metrics Sources used inside of regionservers.
|
| MetricsRegionServerWrapper |
This is the interface that will expose RegionServer information to hadoop1/hadoop2
implementations of the MetricsRegionServerSource.
|
| MetricsRegionSource |
This interface will be implemented to allow single regions to push metrics into
MetricsRegionAggregateSource that will in turn push data to the Hadoop metrics system.
|
| MetricsRegionWrapper |
Interface of class that will wrap an HRegion and export numbers so they can be
used in MetricsRegionSource
|
| MetricsTableAggregateSource |
This interface will be implemented by a MetricsSource that will export metrics from
multiple regions of a table into the hadoop metrics system.
|
| MetricsTableLatencies |
Latency metrics for a specific table in a RegionServer.
|
| MetricsTableQueryMeter |
Query Per Second for each table in a RegionServer.
|
| MetricsTableSource |
This interface will be implemented to allow region server to push table metrics into
MetricsRegionAggregateSource that will in turn push data to the Hadoop metrics system.
|
| MetricsTableWrapperAggregate |
Interface of class that will wrap a MetricsTableSource and export numbers so they can be
used in MetricsTableSource
|
| MetricsUserAggregate | |
| MetricsUserAggregateSource |
This interface will be implemented by a MetricsSource that will export metrics from
multiple users into the hadoop metrics system.
|
| MetricsUserSource | |
| MetricsUserSource.ClientMetrics | |
| MutableOnlineRegions |
Interface to Map of online regions.
|
| OnlineRegions |
Provides read-only access to the Regions presently online on the
current RegionServer
|
| Region |
Region is a subset of HRegion with operations required for the
Coprocessors. |
| Region.RowLock |
Row lock held by a given thread.
|
| RegionScanner |
RegionScanner describes iterators over rows in an HRegion.
|
| RegionServerServices |
A curated subset of services provided by
HRegionServer. |
| ReplicationService |
Gateway to Cluster Replication.
|
| ReplicationSinkService |
A sink for a replication stream has to expose this service.
|
| ReplicationSourceService |
A source for a replication stream has to expose this service.
|
| RowProcessor<S extends com.google.protobuf.Message,T extends com.google.protobuf.Message> | Deprecated
As of release 2.0.0, this will be removed in HBase 3.0.0.
|
| RpcSchedulerFactory |
A factory class that constructs an
RpcScheduler. |
| RSRpcServices.LogDelegate | |
| ScanOptions |
This class gives you the ability to change the max versions and TTL options before opening a
scanner for a Store.
|
| SequenceId |
Interface which abstracts implementations on log sequenceId assignment
|
| Shipper |
This interface denotes a scanner as one which can ship cells.
|
| ShipperListener |
Implementors of this interface are the ones who needs to do some action when the
Shipper.shipped() is called |
| SplitLogWorker.TaskExecutor |
Objects implementing this interface actually do the task that has been
acquired by a
SplitLogWorker. |
| Store |
Interface for objects that hold a column family in a Region.
|
| StoreConfigInformation |
A more restricted interface for HStore.
|
| StoreFile |
An interface to describe a store data file.
|
| StoreFileManager |
Manages the store files and basic metadata about that that determines the logical structure
(e.g.
|
| StoreFlushContext |
A package protected interface for a store flushing.
|
| Class | Description |
|---|---|
| AbstractMemStore |
An abstract class, which implements the behaviour shared by all concrete memstore instances.
|
| AbstractMultiFileWriter |
Base class for cell sink that separates the provided cells into multiple files.
|
| AdaptiveMemStoreCompactionStrategy |
Adaptive is a heuristic that chooses whether to apply data compaction or not based on the
level of redundancy in the data.
|
| AnnotationReadingPriorityFunction |
Reads special method annotations and table names to figure a priority for use by QoS facility in
ipc; e.g: rpcs to hbase:meta get priority.
|
| BaseRowProcessor<S extends com.google.protobuf.Message,T extends com.google.protobuf.Message> |
Base class for RowProcessor with some default implementations.
|
| BasicMemStoreCompactionStrategy |
Basic strategy chooses between two actions: flattening a segment or merging indices of all
segments in the pipeline.
|
| BusyRegionSplitPolicy |
This class represents a split policy which makes the split decision based
on how busy a region is.
|
| ByteBufferChunkKeyValue |
ByteBuffer based cell which has the chunkid at the 0th offset
|
| CellArrayImmutableSegment |
CellArrayImmutableSegment extends the API supported by a
Segment,
and ImmutableSegment. |
| CellArrayMap |
CellArrayMap is a simple array of Cells and cannot be allocated off-heap.
|
| CellChunkImmutableSegment |
CellChunkImmutableSegment extends the API supported by a
Segment,
and ImmutableSegment. |
| CellChunkMap |
CellChunkMap is an array of serialized representations of Cell
(pointing to Chunks with full Cell data) and can be allocated both off-heap and on-heap.
|
| CellFlatMap |
CellFlatMap stores a constant number of elements and is immutable after creation stage.
|
| CellFlatMap.CellFlatMapEntry | |
| CellSet | |
| Chunk |
A chunk of memory out of which allocations are sliced.
|
| ChunkCreator |
Does the management of memstoreLAB chunk creations.
|
| CompactedHFilesDischargeHandler |
Event handler that handles the removal and archival of the compacted hfiles
|
| CompactedHFilesDischarger |
A chore service that periodically cleans up the compacted files when there are no active readers
using those compacted files and also helps in clearing the block cache of these compacted
file entries.
|
| CompactingMemStore |
A memstore implementation which supports in-memory compaction.
|
| CompactionPipeline |
The compaction pipeline of a
CompactingMemStore, is a FIFO queue of segments. |
| CompactionTool | |
| CompactionTool.CompactionInputFormat |
Input format that uses store files block location as input split locality.
|
| CompactionTool.CompactionMapper | |
| CompactionTool.CompactionWorker |
Class responsible to execute the Compaction on the specified path.
|
| CompactSplit |
Compact region on request and then run split if appropriate
|
| CompactSplit.AggregatingCompleteTracker | |
| CompactSplit.Rejection |
Cleanup class to use when rejecting a compaction request from the queue.
|
| CompositeImmutableSegment |
The CompositeImmutableSegments is created as a collection of ImmutableSegments and supports
the interface of a single ImmutableSegments.
|
| ConstantSizeRegionSplitPolicy |
A
RegionSplitPolicy implementation which splits a region
as soon as any of its store files exceeds a maximum configurable
size. |
| CSLMImmutableSegment |
CSLMImmutableSegment is an abstract class that extends the API supported by a
Segment,
and ImmutableSegment. |
| CustomizedScanInfoBuilder |
Helper class for CP hooks to change max versions and TTL.
|
| DateTieredMultiFileWriter |
class for cell sink that separates the provided cells into multiple files for date tiered
compaction.
|
| DateTieredStoreEngine |
HBASE-15400 This store engine allows us to store data in date tiered layout with exponential
sizing so that the more recent data has more granularity.
|
| DefaultHeapMemoryTuner |
The default implementation for the HeapMemoryTuner.
|
| DefaultMemStore |
The MemStore holds in-memory modifications to the Store.
|
| DefaultStoreEngine |
Default StoreEngine creates the default compactor, policy, and store file manager, or
their derivatives.
|
| DefaultStoreFileManager |
Default implementation of StoreFileManager.
|
| DefaultStoreFlusher |
Default implementation of StoreFlusher.
|
| DelimitedKeyPrefixRegionSplitPolicy |
A custom RegionSplitPolicy implementing a SplitPolicy that groups
rows by a prefix of the row-key with a delimiter.
|
| DisabledRegionSplitPolicy |
A
RegionSplitPolicy that disables region splits. |
| DumpRegionServerMetrics |
Utility for doing JSON and MBeans.
|
| EagerMemStoreCompactionStrategy | |
| FifoRpcSchedulerFactory |
Factory to use when you want to use the
FifoRpcScheduler |
| FlushAllLargeStoresPolicy |
A
FlushPolicy that only flushes store larger a given threshold. |
| FlushAllStoresPolicy |
A
FlushPolicy that always flushes all stores for a given region. |
| FlushLargeStoresPolicy |
A
FlushPolicy that only flushes store larger a given threshold. |
| FlushNonSloppyStoresFirstPolicy |
A
FlushPolicy that only flushes store larger than a given threshold. |
| FlushPolicy |
A flush policy determines the stores that need to be flushed when flushing a region.
|
| FlushPolicyFactory |
The class that creates a flush policy from a conf and HTableDescriptor.
|
| HeapMemoryManager |
Manages tuning of Heap memory using
HeapMemoryTuner. |
| HeapMemoryManager.TunerContext |
POJO to pass all the relevant information required to do the heap memory tuning.
|
| HeapMemoryManager.TunerResult |
POJO which holds the result of memory tuning done by HeapMemoryTuner implementation.
|
| HMobStore |
The store implementation to save MOBs (medium objects), it extends the HStore.
|
| HRegion |
Regions store data for a certain region of a table.
|
| HRegion.BatchOperation<T> |
Class that tracks the progress of a batch operations, accumulating status codes and tracking
the index at which processing is proceeding.
|
| HRegion.FlushResultImpl |
Objects from this class are created when flushing to describe all the different states that
that method ends up in.
|
| HRegion.MutationBatchOperation |
Batch of mutation operations.
|
| HRegion.ObservedExceptionsInBatch |
A class that tracks exceptions that have been observed in one batch.
|
| HRegion.PrepareFlushResult |
A result object from prepare flush cache stage
|
| HRegion.ReplayBatchOperation |
Batch of mutations for replay.
|
| HRegion.RowLockImpl |
Class used to represent a lock on a row.
|
| HRegion.WriteState | |
| HRegionFileSystem |
View to an on-disk Region.
|
| HRegionServer |
HRegionServer makes a set of HRegions available to clients.
|
| HRegionServer.CompactionChecker |
Inner class that runs on a long period checking if regions need compaction.
|
| HRegionServer.MovedRegionInfo | |
| HRegionServer.MovedRegionsCleaner |
Creates a Chore thread to clean the moved region cache.
|
| HRegionServer.PeriodicMemStoreFlusher | |
| HRegionServer.SystemExitWhenAbortTimeout |
Force to terminate region server when abort timeout.
|
| HRegionServerCommandLine |
Class responsible for parsing the command line and starting the
RegionServer.
|
| HRegionWALFileSystem |
A Wrapper for the region FileSystem operations adding WAL specific operations
|
| HStore |
A Store holds a column family in a Region.
|
| HStoreFile |
A Store data file.
|
| ImmutableMemStoreLAB |
A MemStoreLAB implementation which wraps N MemStoreLABs.
|
| ImmutableSegment |
ImmutableSegment is an abstract class that extends the API supported by a
Segment,
and is not needed for a MutableSegment. |
| IncreasingToUpperBoundRegionSplitPolicy |
Split size is the number of regions that are on this server that all are
of the same table, cubed, times 2x the region flush size OR the maximum
region split size, whichever is smaller.
|
| InternalScan |
Special scanner, currently used for increment operations to
allow additional server-side arguments for Scan operations.
|
| KeyPrefixRegionSplitPolicy |
A custom RegionSplitPolicy implementing a SplitPolicy that groups
rows by a prefix of the row-key
This ensures that a region is not split "inside" a prefix of a row key.
|
| KeyValueHeap |
Implements a heap merge across any number of KeyValueScanners.
|
| KeyValueHeap.KVScannerComparator | |
| LeaseManager |
Leases
There are several server classes in HBase that need to track external
clients that occasionally send heartbeats.
|
| LeaseManager.Lease |
This class tracks a single Lease.
|
| LogRoller |
Runs periodically to determine if the WAL should be rolled.
|
| MasterFifoRpcSchedulerFactory |
Factory to use when you want to use the
MasterFifoRpcScheduler |
| MemStoreCompactionStrategy |
MemStoreCompactionStrategy is the root of a class hierarchy which defines the strategy for
choosing the next action to apply in an (in-memory) memstore compaction.
|
| MemStoreCompactor |
The ongoing MemStore Compaction manager, dispatches a solo running compaction and interrupts
the compaction if requested.
|
| MemStoreCompactorSegmentsIterator |
The MemStoreCompactorSegmentsIterator extends MemStoreSegmentsIterator
and performs the scan for compaction operation meaning it is based on SQM
|
| MemStoreFlusher |
Thread that flushes cache on request
NOTE: This class extends Thread rather than Chore because the sleep time
can be interrupted when there is something to do, rather than the Chore
sleep time which is invariant.
|
| MemStoreFlusher.FlushRegionEntry |
Datastructure used in the flush queue.
|
| MemStoreLABImpl |
A memstore-local allocation buffer.
|
| MemStoreMergerSegmentsIterator |
The MemStoreMergerSegmentsIterator extends MemStoreSegmentsIterator
and performs the scan for simple merge operation meaning it is NOT based on SQM
|
| MemStoreSegmentsIterator |
The MemStoreSegmentsIterator is designed to perform one iteration over given list of segments
For another iteration new instance of MemStoreSegmentsIterator needs to be created
The iterator is not thread-safe and must have only one instance per MemStore
in each period of time
|
| MemStoreSize |
Data structure of three longs.
|
| MemStoreSnapshot |
Holds details of the snapshot taken on a MemStore.
|
| MetricsHeapMemoryManager |
This class is for maintaining the various regionserver's heap memory manager statistics and
publishing them through the metrics interfaces.
|
| MetricsHeapMemoryManagerSourceImpl |
Hadoop2 implementation of MetricsHeapMemoryManagerSource.
|
| MetricsRegion |
This is the glue between the HRegion and whatever hadoop shim layer
is loaded (hbase-hadoop1-compat or hbase-hadoop2-compat).
|
| MetricsRegionAggregateSourceImpl | |
| MetricsRegionServer |
This class is for maintaining the various regionserver statistics
and publishing them through the metrics interfaces.
|
| MetricsRegionServerQuotaSourceImpl |
Implementation of
MetricsRegionServerQuotaSource. |
| MetricsRegionServerSourceFactoryImpl |
Factory to create MetricsRegionServerSource when given a MetricsRegionServerWrapper
|
| MetricsRegionServerSourceImpl |
Hadoop2 implementation of MetricsRegionServerSource.
|
| MetricsRegionServerWrapperImpl |
Impl for exposing HRegionServer Information through Hadoop's metrics 2 system.
|
| MetricsRegionSourceImpl | |
| MetricsRegionWrapperImpl | |
| MetricsTable | |
| MetricsTableAggregateSourceImpl | |
| MetricsTableLatenciesImpl |
Implementation of
MetricsTableLatencies to track latencies for one table in a
RegionServer. |
| MetricsTableLatenciesImpl.TableHistograms | |
| MetricsTableQueryMeterImpl |
Implementation of
MetricsTableQueryMeter to track query per second for each table in
a RegionServer. |
| MetricsTableQueryMeterImpl.TableMeters | |
| MetricsTableSourceImpl | |
| MetricsTableWrapperAggregateImpl | |
| MetricsTableWrapperAggregateImpl.MetricsTableValues | |
| MetricsUserAggregateFactory | |
| MetricsUserAggregateImpl | |
| MetricsUserAggregateSourceImpl | |
| MetricsUserSourceImpl | |
| MetricsUserSourceImpl.ClientMetricsImpl | |
| MiniBatchOperationInProgress<T> |
Wraps together the mutations which are applied as a batch to the region and their operation
status and WALEdits.
|
| MobReferenceOnlyFilter |
A filter that returns the cells which have mob reference tags.
|
| MobStoreScanner |
Scanner scans both the memstore and the MOB Store.
|
| MultiVersionConcurrencyControl |
Manages the read/write consistency.
|
| MultiVersionConcurrencyControl.WriteEntry |
Write number and whether write has completed given out at start of a write transaction.
|
| MutableSegment |
A mutable segment in memstore, specifically the active segment.
|
| NoLimitScannerContext |
This is a special
ScannerContext subclass that is designed to be used globally when
limits should not be enforced during invocations of InternalScanner.next(java.util.List)
or InternalScanner.next(java.util.List). |
| NonLazyKeyValueScanner |
A "non-lazy" scanner which always does a real seek operation.
|
| NonReversedNonLazyKeyValueScanner |
A "non-reversed & non-lazy" scanner which does not support backward scanning
and always does a real seek operation.
|
| NonThreadSafeMemStoreSizing |
Accounting of current heap and data sizes.
|
| NoTagByteBufferChunkKeyValue |
ByteBuffer based cell which has the chunkid at the 0th offset and with no tags
|
| OffheapChunk |
An off heap chunk implementation.
|
| OnheapChunk |
An on heap chunk implementation.
|
| OperationStatus |
This class stores the Operation status code and the exception message
that occurs in case of failure of operations like put, delete, etc.
|
| RegionCoprocessorHost |
Implements the coprocessor environment and runtime support for coprocessors
loaded within a
Region. |
| RegionCoprocessorHost.RegionEnvironment |
Encapsulation of the environment of each coprocessor
|
| RegionCoprocessorHost.RegionEnvironmentForCoreCoprocessors |
Special version of RegionEnvironment that exposes RegionServerServices for Core
Coprocessors only.
|
| RegionCoprocessorHost.TableCoprocessorAttribute | |
| RegionServerAccounting |
RegionServerAccounting keeps record of some basic real time information about
the Region Server.
|
| RegionServerCoprocessorHost | |
| RegionServerCoprocessorHost.RegionServerEnvironment |
Coprocessor environment extension providing access to region server
related services.
|
| RegionServerCoprocessorHost.RegionServerEnvironmentForCoreCoprocessors |
Special version of RegionServerEnvironment that exposes RegionServerServices for Core
Coprocessors only.
|
| RegionServerServices.PostOpenDeployContext |
Context for postOpenDeployTasks().
|
| RegionServerServices.RegionStateTransitionContext | |
| RegionServerTableMetrics |
Captures operation metrics by table.
|
| RegionServicesForStores |
Services a Store needs from a Region.
|
| RegionSplitPolicy |
A split policy determines when a Region should be split.
|
| RemoteProcedureResultReporter |
A thread which calls
reportProcedureDone to tell master the result of a remote procedure. |
| ReversedKeyValueHeap |
ReversedKeyValueHeap is used for supporting reversed scanning.
|
| ReversedKeyValueHeap.ReversedKVScannerComparator |
In ReversedKVScannerComparator, we compare the row of scanners' peek values
first, sort bigger one before the smaller one.
|
| ReversedMobStoreScanner |
ReversedMobStoreScanner extends from ReversedStoreScanner, and is used to support reversed
scanning in both the memstore and the MOB store.
|
| ReversedRegionScannerImpl |
ReversibleRegionScannerImpl extends from RegionScannerImpl, and is used to
support reversed scanning.
|
| ReversedStoreScanner |
ReversedStoreScanner extends from StoreScanner, and is used to support
reversed scanning.
|
| RSDumpServlet | |
| RSRpcServices |
Implements the regionserver RPC services.
|
| RSRpcServices.RegionScannerCloseCallBack |
An Rpc callback for closing a RegionScanner.
|
| RSRpcServices.RegionScannerHolder |
Holder class which holds the RegionScanner, nextCallSeq and RpcCallbacks together.
|
| RSRpcServices.RegionScannersCloseCallBack |
An RpcCallBack that creates a list of scanners that needs to perform callBack operation on
completion of multiGets.
|
| RSStatusServlet | |
| ScanInfo |
Immutable information for scans over a store.
|
| ScannerContext |
ScannerContext instances encapsulate limit tracking AND progress towards those limits during
invocations of
InternalScanner.next(java.util.List) and
InternalScanner.next(java.util.List). |
| ScannerContext.Builder | |
| ScannerContext.LimitFields |
The different fields that can be used as limits in calls to
InternalScanner.next(java.util.List) and InternalScanner.next(java.util.List) |
| ScannerContext.ProgressFields | |
| ScannerIdGenerator |
Generate a new style scanner id to prevent collision with previous started server or other RSs.
|
| SecureBulkLoadManager |
Bulk loads in secure mode.
|
| SecureBulkLoadManager.SecureBulkLoadListener | |
| Segment |
This is an abstraction of a segment maintained in a memstore, e.g., the active
cell set or its snapshot.
|
| SegmentFactory |
A singleton store segment factory.
|
| SegmentScanner |
A scanner of a single memstore segment.
|
| ServerNonceManager |
Implementation of nonce manager that stores nonces in a hash map and cleans them up after
some time; if nonce group/client ID is supplied, nonces are stored by client ID.
|
| ServerNonceManager.OperationContext | |
| ShutdownHook |
Manage regionserver shutdown hooks.
|
| ShutdownHook.DoNothingStoppable | |
| ShutdownHook.DoNothingThread | |
| ShutdownHook.ShutdownHookThread | |
| SimpleRpcSchedulerFactory |
Constructs a
SimpleRpcScheduler. |
| SnapshotSegmentScanner |
A basic SegmentScanner used against an ImmutableScanner snapshot
Used flushing where we do a single pass, no reverse scanning or
inserts happening.
|
| SplitLogWorker |
This worker is spawned in every regionserver, including master.
|
| SplitRequest |
Handles processing region splits.
|
| SplitWALCallable |
This callable is used to do the real split WAL task.
|
| SteppingSplitPolicy | |
| StoreEngine<SF extends StoreFlusher,CP extends CompactionPolicy,C extends Compactor,SFM extends StoreFileManager> |
StoreEngine is a factory that can create the objects necessary for HStore to operate.
|
| StoreFileComparators |
Useful comparators for comparing store files.
|
| StoreFileComparators.GetBulkTime | |
| StoreFileComparators.GetFileSize | |
| StoreFileComparators.GetMaxTimestamp | |
| StoreFileComparators.GetPathName | |
| StoreFileInfo |
Describe a StoreFile (hfile, reference, link)
|
| StoreFileReader |
Reader for a StoreFile.
|
| StorefileRefresherChore |
A chore for refreshing the store files for secondary regions hosted in the region server.
|
| StoreFileScanner |
KeyValueScanner adaptor over the Reader.
|
| StoreFileWriter |
A StoreFile writer.
|
| StoreFileWriter.Builder | |
| StoreFlusher |
Store flusher interface.
|
| StoreScanner |
Scanner scans both the memstore and the Store.
|
| StoreUtils |
Utility functions for region server storage layer.
|
| StripeMultiFileWriter |
Base class for cell sink that separates the provided cells into multiple files for stripe
compaction.
|
| StripeMultiFileWriter.BoundaryMultiWriter |
MultiWriter that separates the cells based on fixed row-key boundaries.
|
| StripeMultiFileWriter.SizeMultiWriter |
MultiWriter that separates the cells based on target cell number per file and file count.
|
| StripeStoreConfig |
Configuration class for stripe store and compactions.
|
| StripeStoreEngine |
The storage engine that implements the stripe-based store/compaction scheme.
|
| StripeStoreFileManager |
Stripe implementation of StoreFileManager.
|
| StripeStoreFileManager.KeyBeforeConcatenatedLists |
An extension of ConcatenatedLists that has several peculiar properties.
|
| StripeStoreFileManager.State |
The state class.
|
| StripeStoreFlusher |
Stripe implementation of StoreFlusher.
|
| StripeStoreFlusher.BoundaryStripeFlushRequest |
Stripe flush request wrapper based on boundaries.
|
| StripeStoreFlusher.SizeStripeFlushRequest |
Stripe flush request wrapper based on size.
|
| StripeStoreFlusher.StripeFlushRequest |
Stripe flush request wrapper that writes a non-striped file.
|
| ThreadSafeMemStoreSizing |
Accounting of current heap and data sizes.
|
| TimeRangeTracker |
Stores minimum and maximum timestamp values, it is [minimumTimestamp, maximumTimestamp] in
interval notation.
|
| TimeRangeTracker.NonSyncTimeRangeTracker | |
| TimeRangeTracker.SyncTimeRangeTracker | |
| VersionedSegmentsList |
A list of segment managers coupled with the version of the memstore (version at the time it was
created).
|
| Enum | Description |
|---|---|
| BloomType | |
| ChunkCreator.ChunkType |
Types of chunks, based on their sizes
|
| CompactingMemStore.IndexType |
Types of indexes (part of immutable segments) to be used after flattening,
compaction, or merge are applied.
|
| DefaultHeapMemoryTuner.StepDirection | |
| FlushType |
Reasons we flush.
|
| HRegion.FlushResult.Result | |
| MemStoreCompactionStrategy.Action |
Types of actions to be done on the pipeline upon MemStoreCompaction invocation.
|
| MetricsRegionServerSourceFactoryImpl.FactoryStorage | |
| Region.Operation |
Operation enum is used in
Region.startRegionOperation() and elsewhere to provide
context for various checks. |
| ScannerContext.LimitScope |
The various scopes where a limit can be enforced.
|
| ScannerContext.NextState |
The possible states a scanner may be in following a call to
InternalScanner.next(List) |
| ScanType |
Enum to distinguish general scan types.
|
| SplitLogWorker.TaskExecutor.Status | |
| TimeRangeTracker.Type |
| Exception | Description |
|---|---|
| LeaseException |
Reports a problem with a lease
|
| LeaseManager.LeaseStillHeldException |
Thrown if we are asked to create a lease but lease on passed name already
exists.
|
| NoSuchColumnFamilyException |
Thrown if request for nonexistent column family.
|
| RegionServerAbortedException |
Thrown by the region server when it is aborting.
|
| RegionServerRunningException |
Thrown if the region server log directory exists (which indicates another
region server is running at the same address)
|
| RegionServerStoppedException |
Thrown by the region server when it is in shutting down state.
|
| RowTooBigException | Deprecated
since 0.99.0.
|
| SplitWALCallable.ErrorWALSplitException | |
| SplitWALCallable.PreemptedWALSplitException | |
| SplitWALCallable.ResignedWALSplitException | |
| WrongRegionException |
Thrown when a request contains a key which is not part of this region
|
Copyright © 2007–2020 The Apache Software Foundation. All rights reserved.