KeyValue (HBase - Common 0.95.0 API)

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

org.apache.hadoop.hbase
Class KeyValue

java.lang.Object
  org.apache.hadoop.hbase.KeyValue

All Implemented Interfaces:: Cloneable, Cell, HeapSize

@InterfaceAudience.Public @InterfaceStability.Evolving public class KeyValue
extends Object
implements Cell, HeapSize, Cloneable
extends Object
implements Cell, HeapSize, Cloneable

An HBase Key/Value. This is the fundamental HBase Type.

If being used client-side, the primary methods to access individual fields are getRow(), getFamily(), getQualifier(), getTimestamp(), and getValue(). These methods allocate new byte arrays and return copies. Avoid their use server-side.

Instances of this class are immutable. They do not implement Comparable but Comparators are provided. Comparators change with context, whether user table or a catalog table comparison. Its critical you use the appropriate comparator. There are Comparators for KeyValue instances and then for just the Key portion of a KeyValue used mostly by HFile.

KeyValue wraps a byte array and takes offsets and lengths into passed array at where to start interpreting the content as KeyValue. The KeyValue format inside a byte array is: <keylength> <valuelength> <key> <value> Key is further decomposed as: <rowlength> <row> <columnfamilylength> <columnfamily> <columnqualifier> <timestamp> <keytype> The rowlength maximum is Short.MAX_SIZE, column family length maximum is Byte.MAX_SIZE, and column qualifier + key length must be < Integer.MAX_SIZE. The column does not contain the family/qualifier delimiter, COLUMN_FAMILY_DELIMITER

Nested Class Summary
`static class`	`KeyValue.KeyComparator` Compare key portion of a `KeyValue`.
`static class`	`KeyValue.KVComparator` Compare KeyValues.
`static class`	`KeyValue.MetaComparator` A `KeyValue.KVComparator` for `.META.` catalog table `KeyValue`s.
`static class`	`KeyValue.MetaKeyComparator` Compare key portion of a `KeyValue` for keys in `.META.` table.
`static class`	`KeyValue.RootComparator` A `KeyValue.KVComparator` for `-ROOT-` catalog table `KeyValue`s.
`static class`	`KeyValue.RootKeyComparator` Compare key portion of a `KeyValue` for keys in `-ROOT- table.`
`static class`	`KeyValue.RowComparator` Comparator that compares row component only of a KeyValue.
`static interface`	`KeyValue.SamePrefixComparator<T>` Avoids redundant comparisons for better performance.
`static class`	`KeyValue.SplitKeyValue` Utility class that splits a KeyValue buffer into separate byte arrays.
`static class`	`KeyValue.Type` Key type.

Field Summary
`static byte[]`	`COLUMN_FAMILY_DELIM_ARRAY`
`static char`	`COLUMN_FAMILY_DELIMITER` Colon character in UTF-8
`static KeyValue.KVComparator`	`COMPARATOR` Comparator for plain key/values; i.e.
`static int`	`FAMILY_LENGTH_SIZE` Size of the family length field in bytes
`static KeyValue.KeyComparator`	`KEY_COMPARATOR` Comparator for plain key; i.e.
`static int`	`KEY_INFRASTRUCTURE_SIZE`
`static int`	`KEY_LENGTH_SIZE` Size of the key length field in bytes
`static int`	`KEYVALUE_INFRASTRUCTURE_SIZE`
`static KeyValue`	`LOWESTKEY` Lowest possible key.
`static KeyValue.KVComparator`	`META_COMPARATOR` A `KeyValue.KVComparator` for `.META.` catalog table `KeyValue`s.
`static KeyValue.KeyComparator`	`META_KEY_COMPARATOR` A `KeyValue.KVComparator` for `.META.` catalog table `KeyValue` keys.
`static KeyValue.KVComparator`	`ROOT_COMPARATOR` A `KeyValue.KVComparator` for `-ROOT-` catalog table `KeyValue`s.
`static KeyValue.KeyComparator`	`ROOT_KEY_COMPARATOR` A `KeyValue.KVComparator` for `-ROOT-` catalog table `KeyValue` keys.
`static int`	`ROW_LENGTH_SIZE` Size of the row length field in bytes
`static int`	`ROW_OFFSET`
`static int`	`TIMESTAMP_SIZE` Size of the timestamp field in bytes
`static int`	`TIMESTAMP_TYPE_SIZE`
`static int`	`TYPE_SIZE` Size of the key type field in bytes

Constructor Summary
`KeyValue()` Writable Constructor -- DO NOT USE
`KeyValue(byte[] bytes)` Creates a KeyValue from the start of the specified byte array.
`KeyValue(byte[] row, byte[] family, byte[] qualifier)` Constructs KeyValue structure filled with null value.
`KeyValue(byte[] row, byte[] family, byte[] qualifier, byte[] value)` Constructs KeyValue structure filled with null value.
`KeyValue(byte[] row, byte[] family, byte[] qualifier, int qoffset, int qlength, long timestamp, KeyValue.Type type, byte[] value, int voffset, int vlength)` Constructs KeyValue structure filled with specified values.
`KeyValue(byte[] row, byte[] family, byte[] qualifier, long timestamp, byte[] value)` Constructs KeyValue structure filled with specified values.
`KeyValue(byte[] row, byte[] family, byte[] qualifier, long timestamp, KeyValue.Type type)` Constructs KeyValue structure filled with specified values.
`KeyValue(byte[] row, byte[] family, byte[] qualifier, long timestamp, KeyValue.Type type, byte[] value)` Constructs KeyValue structure filled with specified values.
`KeyValue(byte[] buffer, byte[] row, int roffset, int rlength, byte[] family, int foffset, int flength, byte[] qualifier, int qoffset, int qlength, long timestamp, KeyValue.Type type, byte[] value, int voffset, int vlength)` Constructs KeyValue structure filled with specified values.
`KeyValue(byte[] bytes, int offset)` Creates a KeyValue from the specified byte array and offset.
`KeyValue(byte[] buffer, int boffset, byte[] row, int roffset, int rlength, byte[] family, int foffset, int flength, byte[] qualifier, int qoffset, int qlength, long timestamp, KeyValue.Type type, byte[] value, int voffset, int vlength)` Constructs KeyValue structure filled with specified values.
`KeyValue(byte[] bytes, int offset, int length)` Creates a KeyValue from the specified byte array, starting at offset, and for length `length`.
`KeyValue(byte[] row, int roffset, int rlength, byte[] family, int foffset, int flength, byte[] qualifier, int qoffset, int qlength, long timestamp, KeyValue.Type type, byte[] value, int voffset, int vlength)` Constructs KeyValue structure filled with specified values.
`KeyValue(byte[] bytes, int offset, int length, int keyLength)` Creates a KeyValue from the specified byte array, starting at offset, for length `length`, and a known `keyLength`.
`KeyValue(byte[] row, long timestamp)` Constructs KeyValue structure filled with null value.
`KeyValue(byte[] row, long timestamp, KeyValue.Type type)` Constructs KeyValue structure filled with null value.
`KeyValue(int rlength, int flength, int qlength, long timestamp, KeyValue.Type type, int vlength)` Constructs an empty KeyValue structure, with specified sizes.

Method Summary
`KeyValue`	`clone()` Clones a KeyValue.
`static KeyValue`	`create(DataInput in)`
`static KeyValue`	`create(int length, DataInput in)` Create a KeyValue reading `length` from `in`
`static KeyValue`	`createFirstDeleteFamilyOnRow(byte[] row, byte[] family)` Create a Delete Family KeyValue for the specified row and family that would be smaller than all other possible Delete Family KeyValues that have the same row and family.
`static KeyValue`	`createFirstOnRow(byte[] row)` Create a KeyValue that is smaller than all other possible KeyValues for the given row.
`static KeyValue`	`createFirstOnRow(byte[] row, byte[] family, byte[] qualifier)` Create a KeyValue for the specified row, family and qualifier that would be smaller than all other possible KeyValues that have the same row,family,qualifier.
`static KeyValue`	`createFirstOnRow(byte[] buffer, byte[] row, byte[] family, byte[] qualifier)` Create a KeyValue for the specified row, family and qualifier that would be smaller than all other possible KeyValues that have the same row, family, qualifier.
`static KeyValue`	`createFirstOnRow(byte[] row, byte[] f, byte[] q, long ts)`
`static KeyValue`	`createFirstOnRow(byte[] buffer, int boffset, byte[] row, int roffset, int rlength, byte[] family, int foffset, int flength, byte[] qualifier, int qoffset, int qlength)` Create a KeyValue for the specified row, family and qualifier that would be smaller than all other possible KeyValues that have the same row, family, qualifier.
`static KeyValue`	`createFirstOnRow(byte[] row, int roffset, int rlength, byte[] family, int foffset, int flength, byte[] qualifier, int qoffset, int qlength)` Create a KeyValue for the specified row, family and qualifier that would be smaller than all other possible KeyValues that have the same row, family, qualifier.
`static KeyValue`	`createFirstOnRow(byte[] row, int roffset, short rlength)` Create a KeyValue that is smaller than all other possible KeyValues for the given row.
`static KeyValue`	`createFirstOnRow(byte[] row, long ts)` Creates a KeyValue that is smaller than all other KeyValues that are older than the passed timestamp.
`KeyValue`	`createFirstOnRowColTS(long ts)` Creates the first KV with the row/family/qualifier of this KV and the given timestamp.
`KeyValue`	`createKeyOnly(boolean lenAsVal)` Creates a new KeyValue that only contains the key portion (the value is set to be null).
`static KeyValue`	`createKeyValueFromKey(byte[] b)`
`static KeyValue`	`createKeyValueFromKey(byte[] b, int o, int l)`
`static KeyValue`	`createKeyValueFromKey(ByteBuffer bb)`
`static KeyValue`	`createLastOnRow(byte[] row)` Creates a KeyValue that is last on the specified row id.
`static KeyValue`	`createLastOnRow(byte[] row, int roffset, int rlength, byte[] family, int foffset, int flength, byte[] qualifier, int qoffset, int qlength)` Create a KeyValue for the specified row, family and qualifier that would be larger than or equal to all other possible KeyValues that have the same row, family, qualifier.
`KeyValue`	`createLastOnRowCol()` Similar to `createLastOnRow(byte[], int, int, byte[], int, int, byte[], int, int)` but creates the last key on the row/column of this KV (the value part of the returned KV is always empty).
`boolean`	`equals(Object other)` Needed doing 'contains' on List.
`byte[]`	`getBuffer()`
`static int`	`getDelimiter(byte[] b, int offset, int length, int delimiter)`
`static int`	`getDelimiterInReverse(byte[] b, int offset, int length, int delimiter)` Find index of passed delimiter walking from end of buffer backwards.
`byte[]`	`getFamily()` Primarily for use client-side.
`byte[]`	`getFamilyArray()` Contiguous bytes composed of legal HDFS filename characters which may start at any index in the containing array.
`static int`	`getFamilyDelimiterIndex(byte[] b, int offset, int length)`
`byte`	`getFamilyLength()`
`byte`	`getFamilyLength(int foffset)`
`int`	`getFamilyOffset()`
`int`	`getFamilyOffset(int rlength)`
`byte[]`	`getKey()` Do not use unless you have to.
`static long`	`getKeyDataStructureSize(int rlength, int flength, int qlength)` Computes the number of bytes that a `KeyValue` instance with the provided characteristics would take up in its underlying data structure for the key.
`int`	`getKeyLength()`
`int`	`getKeyOffset()`
`String`	`getKeyString()`
`static long`	`getKeyValueDataStructureSize(int rlength, int flength, int qlength, int vlength)` Computes the number of bytes that a `KeyValue` instance with the provided characteristics would take up for its underlying data structure.
`int`	`getLength()`
`long`	`getMemstoreTS()` Deprecated.
`long`	`getMvccVersion()` Here be dragons
`int`	`getOffset()`
`byte[]`	`getQualifier()` Primarily for use client-side.
`byte[]`	`getQualifierArray()` Contiguous raw bytes that may start at any index in the containing array.
`int`	`getQualifierLength()`
`int`	`getQualifierLength(int rlength, int flength)`
`int`	`getQualifierOffset()`
`int`	`getQualifierOffset(int foffset)`
`byte[]`	`getRow()` Primarily for use client-side.
`byte[]`	`getRowArray()` Contiguous raw bytes that may start at any index in the containing array.
`static KeyValue.KeyComparator`	`getRowComparator(byte[] tableName)` Get the appropriate row comparator for the specified table.
`short`	`getRowLength()`
`int`	`getRowOffset()`
`long`	`getTimestamp()`
`int`	`getTimestampOffset()`
`int`	`getTimestampOffset(int keylength)`
`int`	`getTotalColumnLength()`
`int`	`getTotalColumnLength(int rlength, int foffset)`
`byte`	`getType()`
`byte`	`getTypeByte()`
`byte[]`	`getValue()` Returns value in a new byte array.
`byte[]`	`getValueArray()` Contiguous raw bytes that may start at any index in the containing array.
`ByteBuffer`	`getValueAsByteBuffer()` Returns the value wrapped in a new `ByteBuffer`.
`int`	`getValueLength()`
`int`	`getValueOffset()`
`int`	`hashCode()`
`long`	`heapSize()` HeapSize implementation We do not count the bytes in the rowCache because it should be empty for a KeyValue in the MemStore.
`static String`	`humanReadableTimestamp(long timestamp)`
`static KeyValue`	`iscreate(InputStream in)` Create a KeyValue reading from the raw InputStream.
`boolean`	`isDelete()`
`static boolean`	`isDelete(byte t)`
`boolean`	`isDeleteColumnOrFamily()`
`boolean`	`isDeleteFamily()`
`boolean`	`isDeleteType()`
`boolean`	`isEmptyColumn()`
`boolean`	`isInternal()`
`boolean`	`isLatestTimestamp()`
`static String`	`keyToString(byte[] k)`
`static String`	`keyToString(byte[] b, int o, int l)`
`void`	`loadValue(ByteBuffer dst)` Loads this object's value into the provided `ByteBuffer`.
`static byte[]`	`makeColumn(byte[] family, byte[] qualifier)` Makes a column in family:qualifier form from separate byte arrays.
`boolean`	`matchingColumn(byte[] family, byte[] qualifier)`
`boolean`	`matchingColumn(byte[] family, int foffset, int flength, byte[] qualifier, int qoffset, int qlength)` Checks if column matches.
`boolean`	`matchingColumnNoDelimiter(byte[] column)`
`boolean`	`matchingFamily(byte[] family)`
`boolean`	`matchingFamily(byte[] family, int offset, int length)`
`boolean`	`matchingFamily(KeyValue other)`
`boolean`	`matchingQualifier(byte[] qualifier)`
`boolean`	`matchingQualifier(byte[] qualifier, int offset, int length)`
`boolean`	`matchingQualifier(KeyValue other)`
`boolean`	`matchingRow(byte[] row)`
`boolean`	`matchingRow(byte[] row, int offset, int length)`
`boolean`	`matchingRow(KeyValue other)`
`boolean`	`nonNullRowAndColumn()`
`static long`	`oswrite(KeyValue kv, OutputStream out)` Write out a KeyValue in the manner in which we used to when KeyValue was a Writable but do not require a `DataOutput`, just take plain `OutputStream` Named `oswrite` so does not clash with `write(KeyValue, DataOutput)`
`static byte[][]`	`parseColumn(byte[] c)` Splits a column in family:qualifier form into separate byte arrays.
`void`	`setMemstoreTS(long memstoreTS)` Deprecated.
`void`	`setMvccVersion(long mvccVersion)`
`KeyValue`	`shallowCopy()` Creates a shallow copy of this KeyValue, reusing the data byte buffer.
`KeyValue.SplitKeyValue`	`split()`
`String`	`toString()`
`Map<String,Object>`	`toStringMap()` Produces a string map for this key/value pair.
`boolean`	`updateLatestStamp(byte[] now)`
`static long`	`write(KeyValue kv, DataOutput out)` Write out a KeyValue in the manner in which we used to when KeyValue was a Writable.

Methods inherited from class java.lang.Object
`finalize, getClass, notify, notifyAll, wait, wait, wait`

Field Detail

COLUMN_FAMILY_DELIMITER

public static final char COLUMN_FAMILY_DELIMITER

Colon character in UTF-8

See Also:: Constant Field Values

COLUMN_FAMILY_DELIM_ARRAY

public static final byte[] COLUMN_FAMILY_DELIM_ARRAY

COMPARATOR

public static final KeyValue.KVComparator COMPARATOR

Comparator for plain key/values; i.e. non-catalog table key/values.

KEY_COMPARATOR

public static final KeyValue.KeyComparator KEY_COMPARATOR

Comparator for plain key; i.e. non-catalog table key. Works on Key portion of KeyValue only.

META_COMPARATOR

public static final KeyValue.KVComparator META_COMPARATOR

A KeyValue.KVComparator for .META. catalog table KeyValues.

META_KEY_COMPARATOR

public static final KeyValue.KeyComparator META_KEY_COMPARATOR

A KeyValue.KVComparator for .META. catalog table KeyValue keys.

ROOT_COMPARATOR

public static final KeyValue.KVComparator ROOT_COMPARATOR

A KeyValue.KVComparator for -ROOT- catalog table KeyValues.

ROOT_KEY_COMPARATOR

public static final KeyValue.KeyComparator ROOT_KEY_COMPARATOR

A KeyValue.KVComparator for -ROOT- catalog table KeyValue keys.

KEY_LENGTH_SIZE

public static final int KEY_LENGTH_SIZE

Size of the key length field in bytes

See Also:: Constant Field Values

TYPE_SIZE

public static final int TYPE_SIZE

Size of the key type field in bytes

See Also:: Constant Field Values

ROW_LENGTH_SIZE

public static final int ROW_LENGTH_SIZE

Size of the row length field in bytes

See Also:: Constant Field Values

FAMILY_LENGTH_SIZE

public static final int FAMILY_LENGTH_SIZE

Size of the family length field in bytes

See Also:: Constant Field Values

TIMESTAMP_SIZE

public static final int TIMESTAMP_SIZE

Size of the timestamp field in bytes

See Also:: Constant Field Values

TIMESTAMP_TYPE_SIZE

public static final int TIMESTAMP_TYPE_SIZE

See Also:: Constant Field Values

KEY_INFRASTRUCTURE_SIZE

public static final int KEY_INFRASTRUCTURE_SIZE

See Also:: Constant Field Values

ROW_OFFSET

public static final int ROW_OFFSET

See Also:: Constant Field Values

KEYVALUE_INFRASTRUCTURE_SIZE

public static final int KEYVALUE_INFRASTRUCTURE_SIZE

See Also:: Constant Field Values

LOWESTKEY

public static final KeyValue LOWESTKEY

Lowest possible key. Makes a Key with highest possible Timestamp, empty row and column. No key can be equal or lower than this one in memstore or in store file.

Constructor Detail

KeyValue

public KeyValue()

Writable Constructor -- DO NOT USE

KeyValue

public KeyValue(byte[] bytes)

Creates a KeyValue from the start of the specified byte array. Presumes bytes content is formatted as a KeyValue blob.

Parameters:: bytes - byte array

KeyValue

public KeyValue(byte[] bytes,
                int offset)

Creates a KeyValue from the specified byte array and offset. Presumes bytes content starting at offset is formatted as a KeyValue blob.

Parameters:: bytes - byte array; offset - offset to start of KeyValue

KeyValue

public KeyValue(byte[] bytes,
                int offset,
                int length)

Creates a KeyValue from the specified byte array, starting at offset, and for length length.

Parameters:: bytes - byte array; offset - offset to start of the KeyValue; length - length of the KeyValue

KeyValue

public KeyValue(byte[] bytes,
                int offset,
                int length,
                int keyLength)

Creates a KeyValue from the specified byte array, starting at offset, for length length, and a known keyLength.

Parameters:: bytes - byte array; offset - offset to start of the KeyValue; length - length of the KeyValue; keyLength - length of the key portion of the KeyValue

KeyValue

public KeyValue(byte[] row,
                long timestamp)

Constructs KeyValue structure filled with null value. Sets type to KeyValue.Type.Maximum

Parameters:: row - - row key (arbitrary byte array); timestamp -

KeyValue

public KeyValue(byte[] row,
                long timestamp,
                KeyValue.Type type)

Constructs KeyValue structure filled with null value.

Parameters:: row - - row key (arbitrary byte array); timestamp -

KeyValue

public KeyValue(byte[] row,
                byte[] family,
                byte[] qualifier)

Constructs KeyValue structure filled with null value. Sets type to KeyValue.Type.Maximum

Parameters:: row - - row key (arbitrary byte array); family - family name; qualifier - column qualifier

KeyValue

public KeyValue(byte[] row,
                byte[] family,
                byte[] qualifier,
                byte[] value)

Constructs KeyValue structure filled with null value.

Parameters:: row - - row key (arbitrary byte array); family - family name; qualifier - column qualifier