keys

type Comparator ¶

type Comparator interface {
	// Name returns the name of this comparator. A DB created with one comparator
	// can't be opened using a comparator with different name.
	//
	// Client should switch to a new name if the comparator implementation changes
	// in a way that cause the relative order of any two keys varied.
	//
	// Names starting with "leveldb." are reserved and should not used by clients.
	Name() string

	// Compare returns a value 'less than', 'equal to' or 'greater than' 0 depending
	// on whether a is 'less than', 'equal to' or 'greater than' b.
	Compare(a, b []byte) int

	// AppendSuccessor appends a possibly shortest byte sequence in range [start, limit)
	// to dst. Empty limit acts as infinite large. In particularly, if limit equals to
	// start, it returns append(dst, start).
	AppendSuccessor(dst, start, limit []byte) []byte
}

Comparator defines a total order over keys in LevelDB database. Methods of a comparator may be called by concurrent goroutines.

type Comparer ¶

type Comparer interface {
	// Compare returns a value 'less than', 'equal to' or 'greater than' 0 depending
	// on whether a is 'less than', 'equal to' or 'greater than' b.
	Compare(a, b []byte) int
}

Comparer is a interface for algorithms to compare bytes.

type InternalComparator ¶

type InternalComparator struct {
	UserKeyComparator UserComparator
}

InternalComparator is a comparator used to compare byte slices of internal keys.

func (cmp *InternalComparator) AppendSuccessor(dst, start, limit []byte) []byte

func (cmp *InternalComparator) Compare(a, b []byte) int

func (cmp *InternalComparator) Name() string

type InternalKey ¶

type InternalKey []byte

InternalKey is a combination of user key, which comes from APIs such as DB.Get, DB.Put, etc. and Tag which is also a combination of Sequence and Kind.

func MakeInternalKey(buf []byte, key []byte, seq Sequence, kind Kind) InternalKey

func NewInternalKey(key []byte, seq Sequence, kind Kind) InternalKey

func ToInternalKey(key []byte) (InternalKey, bool)

func (ikey InternalKey) Dup() InternalKey

func (ikey InternalKey) Split() ([]byte, Sequence, Kind)

func (ikey InternalKey) Tag() Tag

func (ikey InternalKey) UserKey() []byte

type Kind ¶

type Kind int

Kind expresses usage of the ambient internal key.

const (

	// Delete represents deletion of this key.
	Delete Kind = 0
	// Value represents value setting of this key.
	Value Kind = 1

	// Seek is maximum(Value, Delete), which is a valid Kind and
	// serves as start point for keys with same sequence.
	//
	// See InternalComparator.Compare for ordering among internal keys.
	Seek = maxKind
)

func (k Kind) String() string

type ParsedInternalKey ¶

type ParsedInternalKey struct {
	UserKey  []byte
	Sequence Sequence
	Kind     Kind
}

ParsedInternalKey is a parsed or splited internal representation.

func (k *ParsedInternalKey) Append(dst []byte) []byte

func (k *ParsedInternalKey) Parse(key []byte) bool

func (k *ParsedInternalKey) Tag() Tag

type Sequence ¶

type Sequence uint64

Sequence is a monotonic value associated with every keys written to LevelDB.

At any time, once a key is written to LevelDB, no matter whether it is a key deletion or value setting, it is associated with a Sequence greater than Sequences associated to previous written keys.

For this we can conclude:

• No keys have some Sequence.
• For key with given Sequence, it is written before keys with bigger Sequences, also it is written after keys with smaller Sequences.

const (
	// MaxSequence is the maximum allowed value for Sequence.
	MaxSequence Sequence = (1 << 56) - 1
)

func (seq Sequence) Next(n uint64) Sequence

type Tag ¶

type Tag uint64

Tag is a combination of Sequence and Kind. This combination has properties:

* Tag with big Sequence is greater than tag with small Sequence. * With same Sequences, tag with Kind Seek is equal to or greater than other tags.

Thus for a combination with given Sequence and Kind Seek, we can say that:

• All keys with tag greater than this combination are written after that given Sequence.
• All keys with tag equal to or less than this combination are written before or at that given Sequence.

Also, due to the fact that no keys written to LevelDB have same Sequence, sometimes Tags are used as Sequences to determine ordering of written.

func GetTag(buf []byte) Tag

func PackTag(seq Sequence, kind Kind) Tag

type UserComparator ¶

type UserComparator interface {
	Comparator

	// MakePrefixSuccessor returns a byte sequence 'limit' such that all byte sequences
	// falling in [prefix, limit) have 'prefix' as prefix. Zero length 'limit' acts as
	// infinite large.
	MakePrefixSuccessor(start []byte) []byte
}

UserComparator is the interface exported to clients of LevelDB.

var BytewiseComparator UserComparator = bytewiseComparator{}