Uses of Interface
org.apache.hadoop.hbase.CellComparator

Packages that use CellComparator

Package	Description
org.apache.hadoop.hbase
org.apache.hadoop.hbase.io.encoding
org.apache.hadoop.hbase.io.hfile	Provides implementations of HFile and HFile BlockCache.
org.apache.hadoop.hbase.regionserver
org.apache.hadoop.hbase.regionserver.compactions
org.apache.hadoop.hbase.regionserver.querymatcher
org.apache.hadoop.hbase.security.visibility
org.apache.hadoop.hbase.util

Uses of CellComparator in org.apache.hadoop.hbase

Classes in org.apache.hadoop.hbase that implement CellComparator

Modifier and Type	Class	Description
class	CellComparatorImpl	Compare two HBase cells.
class	InnerStoreCellComparator	Compare two HBase cells inner store, skip compare family for better performance.
class	MetaCellComparator	A CellComparatorImpl for hbase:meta catalog table KeyValues.

Methods in org.apache.hadoop.hbase that return CellComparator

Modifier and Type	Method	Description
static CellComparator	CellComparatorImpl.getCellComparator(byte[] tableName)	Utility method that makes a guess at comparator to use based off passed tableName.
static CellComparator	CellComparatorImpl.getCellComparator(TableName tableName)	Utility method that makes a guess at comparator to use based off passed tableName.
static CellComparator	InnerStoreCellComparator.getInnerStoreCellComparator(byte[] tableName)	Utility method that makes a guess at comparator to use based off passed tableName.
static CellComparator	InnerStoreCellComparator.getInnerStoreCellComparator(TableName tableName)	Utility method that makes a guess at comparator to use based off passed tableName.
static CellComparator	CellComparator.getInstance()	A comparator for ordering cells in user-space tables.

Methods in org.apache.hadoop.hbase with parameters of type CellComparator

Modifier and Type	Method	Description
static final int	PrivateCellUtil.compare(CellComparator comparator, ExtendedCell left, byte[] key, int offset, int length)	Used when a cell needs to be compared with a key byte[] such as cases of finding the index from the index block, bloom keys from the bloom blocks This byte[] is expected to be serialized in the KeyValue serialization format If the KeyValue (Cell's) serialization format changes this method cannot be used.
static final int	PrivateCellUtil.compareKeyBasedOnColHint(CellComparator comparator, ExtendedCell nextIndexedCell, ExtendedCell currentCell, int foff, int flen, byte[] colHint, int coff, int clen, long ts, byte type)	Used to compare two cells based on the column hint provided.
static final int	PrivateCellUtil.compareKeyIgnoresMvcc(CellComparator comparator, Cell left, Cell right)	Compares only the key portion of a cell.
(package private) static final int	PrivateCellUtil.compareWithoutRow(CellComparator comparator, ExtendedCell left, byte[] right, int roffset, int rlength, short rowlength)	Compare columnFamily, qualifier, timestamp, and key type (everything except the row).

Uses of CellComparator in org.apache.hadoop.hbase.io.encoding

Fields in org.apache.hadoop.hbase.io.encoding declared as CellComparator

Modifier and Type	Field	Description
private final CellComparator	RowIndexSeekerV1.cellComparator

Methods in org.apache.hadoop.hbase.io.encoding with parameters of type CellComparator

Modifier and Type	Method	Description
int	BufferedDataBlockEncoder.BufferedEncodedSeeker.compareKey(CellComparator comparator, ExtendedCell key)
int	DataBlockEncoder.EncodedSeeker.compareKey(CellComparator comparator, ExtendedCell key)	Compare the given key against the current key
int	RowIndexSeekerV1.compareKey(CellComparator comparator, ExtendedCell key)

Uses of CellComparator in org.apache.hadoop.hbase.io.hfile

Fields in org.apache.hadoop.hbase.io.hfile declared as CellComparator

Modifier and Type	Field	Description
private CellComparator	HFileContext.cellComparator
private CellComparator	HFileContextBuilder.cellComparator
protected CellComparator	CompoundBloomFilterBase.comparator	Comparator used to compare Bloom filter keys
protected CellComparator	HFileBlockIndex.CellBasedKeyBlockIndexReader.comparator	Needed doing lookup on blocks.
private CellComparator	NoOpIndexBlockEncoder.NoOpEncodedSeeker.comparator

Methods in org.apache.hadoop.hbase.io.hfile that return CellComparator

Modifier and Type	Method	Description
CellComparator	FixedFileTrailer.createComparator()
(package private) static CellComparator	FixedFileTrailer.createComparator(String comparatorClassName)
CellComparator	HFileContext.getCellComparator()
CellComparator	HFile.Reader.getComparator()
CellComparator	HFileReaderImpl.getComparator()	Returns comparator

Methods in org.apache.hadoop.hbase.io.hfile that return types with arguments of type CellComparator

Modifier and Type	Method	Description
private static Class<? extends CellComparator>	FixedFileTrailer.getComparatorClass(String comparatorClassName)

Methods in org.apache.hadoop.hbase.io.hfile with parameters of type CellComparator

Modifier and Type	Method	Description
(package private) static int	HFileBlockIndex.BlockIndexReader.binarySearchNonRootIndex(Cell key, ByteBuff nonRootIndex, CellComparator comparator)	Performs a binary search over a non-root level index block.
int	HFileReaderImpl.EncodedScanner.compareKey(CellComparator comparator, ExtendedCell key)
int	HFileReaderImpl.HFileScannerImpl.compareKey(CellComparator comparator, ExtendedCell key)
static ExtendedCell	HFileWriterImpl.getMidpoint(CellComparator comparator, ExtendedCell left, ExtendedCell right)	Try to return a Cell that falls between left and right but that is shorter; i.e.
void	HFileIndexBlockEncoder.EncodedSeeker.initRootIndex(HFileBlock blk, int numEntries, CellComparator comparator, int treeLevel)
void	NoOpIndexBlockEncoder.NoOpEncodedSeeker.initRootIndex(HFileBlock blk, int numEntries, CellComparator comparator, int treeLevel)
static int	HFileBlockIndex.BlockIndexReader.locateNonRootIndexEntry(ByteBuff nonRootBlock, Cell key, CellComparator comparator)	Search for one key using the secondary index in a non-root block.
abstract int	HFileBlockIndex.BlockIndexReader.rootBlockContainingKey(byte[] key, int offset, int length, CellComparator comp)	Finds the root-level index block containing the given key.
int	HFileBlockIndex.ByteArrayKeyBlockIndexReader.rootBlockContainingKey(byte[] key, int offset, int length, CellComparator comp)
int	HFileBlockIndex.CellBasedKeyBlockIndexReader.rootBlockContainingKey(byte[] key, int offset, int length, CellComparator comp)
HFileContextBuilder	HFileContextBuilder.withCellComparator(CellComparator cellComparator)

Method parameters in org.apache.hadoop.hbase.io.hfile with type arguments of type CellComparator

Modifier and Type	Method	Description
void	FixedFileTrailer.setComparatorClass(Class<? extends CellComparator> klass)

Constructors in org.apache.hadoop.hbase.io.hfile with parameters of type CellComparator

Modifier	Constructor	Description
	CellBasedKeyBlockIndexReader(CellComparator c, int treeLevel)
	CellBasedKeyBlockIndexReaderV2(CellComparator c, int treeLevel)
	CellBasedKeyBlockIndexReaderV2(CellComparator c, int treeLevel, HFileIndexBlockEncoder indexBlockEncoder)
	CompoundBloomFilterWriter(int chunkByteSizeHint, float errorRate, int hashType, int maxFold, boolean cacheOnWrite, CellComparator comparator, BloomType bloomType)	each chunk's size in bytes.
(package private)	HFileContext(boolean useHBaseChecksum, boolean includesMvcc, boolean includesTags, Compression.Algorithm compressAlgo, Compression.HFileDecompressionContext decompressionContext, boolean compressTags, ChecksumType checksumType, int bytesPerChecksum, int blockSize, DataBlockEncoding encoding, Encryption.Context cryptoContext, long fileCreateTime, String hfileName, byte[] columnFamily, byte[] tableName, CellComparator cellComparator, IndexBlockEncoding indexBlockEncoding)

Uses of CellComparator in org.apache.hadoop.hbase.regionserver

Fields in org.apache.hadoop.hbase.regionserver declared as CellComparator

Modifier and Type	Field	Description
private final CellComparator	DefaultStoreFileManager.cellComparator
private final CellComparator	HRegion.cellComparator
private final CellComparator	StripeStoreFileManager.cellComparator
private final CellComparator	AbstractMemStore.comparator
private CellComparator	HStoreFile.comparator
protected final CellComparator	RegionScannerImpl.comparator
private CellComparator	ScanInfo.comparator
private final CellComparator	Segment.comparator
private CellComparator	StoreContext.Builder.comparator
private final CellComparator	StoreContext.comparator
private CellComparator	StoreFileWriter.Builder.comparator
private final CellComparator	StoreFileWriter.comparator
private final CellComparator	StoreScanner.comparator
protected final CellComparator	StripeMultiFileWriter.comparator
protected final CellComparator	StripeStoreFlusher.StripeFlushRequest.comparator
protected CellComparator	KeyValueHeap.KVScannerComparator.kvComparator

Methods in org.apache.hadoop.hbase.regionserver that return CellComparator

Modifier and Type	Method	Description
CellComparator	HRegion.getCellComparator()
CellComparator	Region.getCellComparator()	The comparator to be used with the region
protected CellComparator	AbstractMemStore.getComparator()
CellComparator	HStore.getComparator()
CellComparator	HStoreFile.getComparator()
CellComparator	KeyValueHeap.KVScannerComparator.getComparator()
CellComparator	ScanInfo.getComparator()
protected CellComparator	Segment.getComparator()	Returns the Cell comparator used by this segment
CellComparator	Store.getComparator()
CellComparator	StoreContext.getComparator()
CellComparator	StoreFile.getComparator()	Get the comparator for comparing two cells.
CellComparator	StoreFileReader.getComparator()
(package private) CellComparator	StoreFileScanner.getComparator()

Methods in org.apache.hadoop.hbase.regionserver with parameters of type CellComparator

Modifier and Type	Method	Description
protected void	ReversedStoreScanner.checkScanOrder(Cell prevKV, Cell kv, CellComparator comparator)
protected void	StoreScanner.checkScanOrder(Cell prevKV, Cell kv, CellComparator comparator)	Check whether scan as expected order
static StoreEngine<?,?,?,?>	StoreEngine.create(HStore store, org.apache.hadoop.conf.Configuration conf, CellComparator cellComparator)	Create the StoreEngine configured for the given Store.
protected void	CustomTieredStoreEngine.createComponents(org.apache.hadoop.conf.Configuration conf, HStore store, CellComparator kvComparator)
protected void	DateTieredStoreEngine.createComponents(org.apache.hadoop.conf.Configuration conf, HStore store, CellComparator kvComparator)
protected void	DefaultStoreEngine.createComponents(org.apache.hadoop.conf.Configuration conf, HStore store, CellComparator kvComparator)
protected abstract void	StoreEngine.createComponents(org.apache.hadoop.conf.Configuration conf, HStore store, CellComparator cellComparator)	Create the StoreEngine's components.
protected void	StripeStoreEngine.createComponents(org.apache.hadoop.conf.Configuration conf, HStore store, CellComparator comparator)
protected final void	StoreEngine.createComponentsOnce(org.apache.hadoop.conf.Configuration conf, HStore store, CellComparator cellComparator)
CompositeImmutableSegment	SegmentFactory.createCompositeImmutableSegment(CellComparator comparator, List<ImmutableSegment> segments)
private ImmutableSegment	SegmentFactory.createImmutableSegment(org.apache.hadoop.conf.Configuration conf, CellComparator comparator, MemStoreSegmentsIterator iterator, MemStoreLAB memStoreLAB, int numOfCells, MemStoreCompactionStrategy.Action action, CompactingMemStore.IndexType idxType)
ImmutableSegment	SegmentFactory.createImmutableSegment(CellComparator comparator)	create empty immutable segment for initializations This ImmutableSegment is used as a place holder for snapshot in Memstore.
ImmutableSegment	SegmentFactory.createImmutableSegmentByCompaction(org.apache.hadoop.conf.Configuration conf, CellComparator comparator, MemStoreSegmentsIterator iterator, int numOfCells, CompactingMemStore.IndexType idxType, MemStoreCompactionStrategy.Action action)
ImmutableSegment	SegmentFactory.createImmutableSegmentByMerge(org.apache.hadoop.conf.Configuration conf, CellComparator comparator, MemStoreSegmentsIterator iterator, int numOfCells, List<ImmutableSegment> segments, CompactingMemStore.IndexType idxType, MemStoreCompactionStrategy.Action action)
MutableSegment	SegmentFactory.createMutableSegment(org.apache.hadoop.conf.Configuration conf, CellComparator comparator, MemStoreSizing memstoreSizing)
protected StoreEngine<?,?,?,?>	HMobStore.createStoreEngine(HStore store, org.apache.hadoop.conf.Configuration conf, CellComparator cellComparator)	Creates the mob store engine.
protected StoreEngine<?,?,?,?>	HStore.createStoreEngine(HStore store, org.apache.hadoop.conf.Configuration conf, CellComparator kvComparator)	Creates the store engine configured for the given Store.
private MutableSegment	SegmentFactory.generateMutableSegment(org.apache.hadoop.conf.Configuration conf, CellComparator comparator, MemStoreLAB memStoreLAB, MemStoreSizing memstoreSizing)
(package private) static Optional<byte[]>	StoreUtils.getFileSplitPoint(HStoreFile file, CellComparator comparator)	Gets the approximate mid-point of the given file that is optimal for use in splitting it.
(package private) static Optional<byte[]>	StoreUtils.getSplitPoint(Collection<HStoreFile> storefiles, CellComparator comparator)	Gets the mid point of the largest file passed in as split point.
protected KeyValueHeap	ReversedStoreScanner.newKVHeap(List<? extends KeyValueScanner> scanners, CellComparator comparator)
protected KeyValueHeap	StoreScanner.newKVHeap(List<? extends KeyValueScanner> scanners, CellComparator comparator)
protected void	StoreScanner.resetKVHeap(List<? extends KeyValueScanner> scanners, CellComparator comparator)
StoreContext.Builder	StoreContext.Builder.withCellComparator(CellComparator comparator)
StoreFileWriter.Builder	StoreFileWriter.Builder.withCellComparator(CellComparator comparator)

Constructors in org.apache.hadoop.hbase.regionserver with parameters of type CellComparator

Modifier	Constructor	Description
protected	AbstractMemStore(org.apache.hadoop.conf.Configuration conf, CellComparator c, RegionServicesForStores regionServices)
	BoundaryMultiWriter(CellComparator comparator, List<byte[]> targetBoundaries, byte[] majorRangeFrom, byte[] majorRangeTo)
	BoundaryStripeFlushRequest(CellComparator comparator, List<byte[]> targetBoundaries)
protected	CellArrayImmutableSegment(CellComparator comparator, MemStoreSegmentsIterator iterator, MemStoreLAB memStoreLAB, int numOfCells, MemStoreCompactionStrategy.Action action)	------------------------------------------------------------------------ C-tor to be used when new CellArrayImmutableSegment is a result of compaction of a list of older ImmutableSegments.
protected	CellChunkImmutableSegment(CellComparator comparator, MemStoreSegmentsIterator iterator, MemStoreLAB memStoreLAB, int numOfCells, MemStoreCompactionStrategy.Action action)	------------------------------------------------------------------------ C-tor to be used when new CellChunkImmutableSegment is built as a result of compaction/merge of a list of older ImmutableSegments.
	CellSet(CellComparator c)
	CompactingMemStore(org.apache.hadoop.conf.Configuration conf, CellComparator c, HStore store, RegionServicesForStores regionServices, MemoryCompactionPolicy compactionPolicy)
	CompositeImmutableSegment(CellComparator comparator, List<ImmutableSegment> segments)
	DefaultMemStore(org.apache.hadoop.conf.Configuration conf, CellComparator c)	Constructor.
	DefaultMemStore(org.apache.hadoop.conf.Configuration conf, CellComparator c, RegionServicesForStores regionServices)	Constructor.
	DefaultStoreFileManager(CellComparator cellComparator, Comparator<HStoreFile> storeFileComparator, org.apache.hadoop.conf.Configuration conf, CompactionConfiguration comConf)
protected	ImmutableSegment(CellComparator comparator)	------------------------------------------------------------------------ Empty C-tor to be used only for CompositeImmutableSegment
protected	ImmutableSegment(CellComparator comparator, List<ImmutableSegment> segments)
protected	ImmutableSegment(CellSet cs, CellComparator comparator, MemStoreLAB memStoreLAB)	------------------------------------------------------------------------ C-tor to be used to build the derived classes
	KeyValueHeap(List<? extends KeyValueScanner> scanners, CellComparator comparator)	Constructor.
	KVScannerComparator(CellComparator kvComparator)	Constructor
	MemStoreCompactorSegmentsIterator(List<ImmutableSegment> segments, CellComparator comparator, int compactionKVMax, HStore store)
	MemStoreMergerSegmentsIterator(List<ImmutableSegment> segments, CellComparator comparator, int compactionKVMax)
protected	MutableSegment(CellSet<ExtendedCell> cellSet, CellComparator comparator, MemStoreLAB memStoreLAB, MemStoreSizing memstoreSizing)
	ReversedKeyValueHeap(List<? extends KeyValueScanner> scanners, CellComparator comparator)
	ReversedKVScannerComparator(CellComparator kvComparator)	Constructor
private	ScanInfo(byte[] family, int minVersions, int maxVersions, long ttl, KeepDeletedCells keepDeletedCells, long timeToPurgeDeletes, CellComparator comparator, long tableMaxRowSize, boolean usePread, long cellsPerTimeoutCheck, boolean parallelSeekEnabled, long preadMaxBytes, boolean newVersionBehavior)
	ScanInfo(org.apache.hadoop.conf.Configuration conf, byte[] family, int minVersions, int maxVersions, long ttl, KeepDeletedCells keepDeletedCells, long blockSize, long timeToPurgeDeletes, CellComparator comparator, boolean newVersionBehavior)
	ScanInfo(org.apache.hadoop.conf.Configuration conf, ColumnFamilyDescriptor family, long ttl, long timeToPurgeDeletes, CellComparator comparator)
protected	Segment(CellComparator comparator, List<ImmutableSegment> segments, TimeRangeTracker trt)
protected	Segment(CellComparator comparator, TimeRangeTracker trt)
protected	Segment(CellSet<ExtendedCell> cellSet, CellComparator comparator, MemStoreLAB memStoreLAB, TimeRangeTracker trt)
	SizeMultiWriter(CellComparator comparator, int targetCount, long targetKvs, byte[] left, byte[] right)
	SizeStripeFlushRequest(CellComparator comparator, int targetCount, long targetKvs)
private	StoreFileWriter(org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.fs.Path liveFilePath, org.apache.hadoop.fs.Path historicalFilePath, org.apache.hadoop.conf.Configuration conf, CacheConfig cacheConf, BloomType bloomType, long maxKeys, InetSocketAddress[] favoredNodes, HFileContext fileContext, boolean shouldDropCacheBehind, Supplier<Collection<HStoreFile>> compactedFilesSupplier, CellComparator comparator, int maxVersions, boolean newVersionBehavior)	Creates an HFile.Writer that also write helpful meta data.
	StripeFlushRequest(CellComparator comparator)
	StripeMultiFileWriter(CellComparator comparator)
	StripeStoreFileManager(CellComparator kvComparator, org.apache.hadoop.conf.Configuration conf, StripeStoreConfig config)

Uses of CellComparator in org.apache.hadoop.hbase.regionserver.compactions

Methods in org.apache.hadoop.hbase.regionserver.compactions with parameters of type CellComparator

Modifier and Type	Method	Description
StripeStoreFlusher.StripeFlushRequest	StripeCompactionPolicy.selectFlush(CellComparator comparator, StripeCompactionPolicy.StripeInformationProvider si, int kvCount)

Uses of CellComparator in org.apache.hadoop.hbase.regionserver.querymatcher

Fields in org.apache.hadoop.hbase.regionserver.querymatcher declared as CellComparator

Modifier and Type	Field	Description
private CellComparator	NewVersionBehaviorTracker.comparator
protected final CellComparator	ScanDeleteTracker.comparator
private final CellComparator	ScanWildcardColumnTracker.comparator
protected final CellComparator	ScanQueryMatcher.rowComparator	Row comparator for the region this query is for

Methods in org.apache.hadoop.hbase.regionserver.querymatcher that return CellComparator

Modifier and Type	Method	Description
CellComparator	DeleteTracker.getCellComparator()	Return the comparator passed to this delete tracker
CellComparator	NewVersionBehaviorTracker.getCellComparator()
CellComparator	ScanDeleteTracker.getCellComparator()

Constructors in org.apache.hadoop.hbase.regionserver.querymatcher with parameters of type CellComparator

Modifier	Constructor	Description
	NewVersionBehaviorTracker(NavigableSet<byte[]> columns, CellComparator comparartor, int minVersion, int maxVersion, int resultMaxVersions, long oldestUnexpiredTS)	Note maxVersion and minVersion must set according to cf's conf, not user's scan parameter.
	ScanDeleteTracker(CellComparator comparator)
	ScanWildcardColumnTracker(int minVersion, int maxVersion, long oldestUnexpiredTS, CellComparator comparator)	Return maxVersions of every row.

Uses of CellComparator in org.apache.hadoop.hbase.security.visibility

Constructors in org.apache.hadoop.hbase.security.visibility with parameters of type CellComparator

Modifier	Constructor	Description
	VisibilityNewVersionBehaivorTracker(NavigableSet<byte[]> columns, CellComparator cellComparator, int minVersion, int maxVersion, int resultMaxVersions, long oldestUnexpiredTS)
	VisibilityScanDeleteTracker(CellComparator comparator)

Uses of CellComparator in org.apache.hadoop.hbase.util

Fields in org.apache.hadoop.hbase.util declared as CellComparator

Modifier and Type	Field	Description
protected CellComparator	BloomContext.comparator
(package private) final CellComparator	CollectionBackedScanner.comparator

Methods in org.apache.hadoop.hbase.util with parameters of type CellComparator

Modifier and Type	Method	Description
static int	Bytes.binarySearch(Cell[] arr, Cell key, CellComparator comparator)	Binary search for keys in indexes.

Constructors in org.apache.hadoop.hbase.util with parameters of type CellComparator

Modifier	Constructor	Description
	BloomContext(BloomFilterWriter bloomFilterWriter, CellComparator comparator)
	CollectionBackedScanner(List<ExtendedCell> list, CellComparator comparator)
	CollectionBackedScanner(SortedSet<ExtendedCell> set, CellComparator comparator)
	CollectionBackedScanner(CellComparator comparator, ExtendedCell... array)
	RowBloomContext(BloomFilterWriter bloomFilterWriter, CellComparator comparator)
	RowColBloomContext(BloomFilterWriter generalBloomFilterWriter, CellComparator comparator)
	RowPrefixFixedLengthBloomContext(BloomFilterWriter bloomFilterWriter, CellComparator comparator, int prefixLength)