fork of https://github.com/oxigraph/rocksdb and https://github.com/facebook/rocksdb for nextgraph and oxigraph
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
340 lines
11 KiB
340 lines
11 KiB
// Copyright (c) 2013, Facebook, Inc. All rights reserved.
|
|
// This source code is licensed under the BSD-style license found in the
|
|
// LICENSE file in the root directory of this source tree. An additional grant
|
|
// of patent rights can be found in the PATENTS file in the same directory.
|
|
//
|
|
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file. See the AUTHORS file for names of contributors.
|
|
|
|
#pragma once
|
|
#include <stdio.h>
|
|
#include "rocksdb/comparator.h"
|
|
#include "rocksdb/db.h"
|
|
#include "rocksdb/filter_policy.h"
|
|
#include "rocksdb/slice.h"
|
|
#include "rocksdb/slice_transform.h"
|
|
#include "rocksdb/table.h"
|
|
#include "rocksdb/types.h"
|
|
#include "util/coding.h"
|
|
#include "util/logging.h"
|
|
|
|
namespace rocksdb {
|
|
|
|
class InternalKey;
|
|
|
|
// Value types encoded as the last component of internal keys.
|
|
// DO NOT CHANGE THESE ENUM VALUES: they are embedded in the on-disk
|
|
// data structures.
|
|
// The highest bit of the value type needs to be reserved to SST tables
|
|
// for them to do more flexible encoding.
|
|
enum ValueType : unsigned char {
|
|
kTypeDeletion = 0x0,
|
|
kTypeValue = 0x1,
|
|
kTypeMerge = 0x2,
|
|
// Following types are used only in write ahead logs. They are not used in
|
|
// memtables or sst files:
|
|
kTypeLogData = 0x3,
|
|
kTypeColumnFamilyDeletion = 0x4,
|
|
kTypeColumnFamilyValue = 0x5,
|
|
kTypeColumnFamilyMerge = 0x6,
|
|
kMaxValue = 0x7F
|
|
};
|
|
|
|
// kValueTypeForSeek defines the ValueType that should be passed when
|
|
// constructing a ParsedInternalKey object for seeking to a particular
|
|
// sequence number (since we sort sequence numbers in decreasing order
|
|
// and the value type is embedded as the low 8 bits in the sequence
|
|
// number in internal keys, we need to use the highest-numbered
|
|
// ValueType, not the lowest).
|
|
static const ValueType kValueTypeForSeek = kTypeMerge;
|
|
|
|
// We leave eight bits empty at the bottom so a type and sequence#
|
|
// can be packed together into 64-bits.
|
|
static const SequenceNumber kMaxSequenceNumber =
|
|
((0x1ull << 56) - 1);
|
|
|
|
struct ParsedInternalKey {
|
|
Slice user_key;
|
|
SequenceNumber sequence;
|
|
ValueType type;
|
|
|
|
ParsedInternalKey() { } // Intentionally left uninitialized (for speed)
|
|
ParsedInternalKey(const Slice& u, const SequenceNumber& seq, ValueType t)
|
|
: user_key(u), sequence(seq), type(t) { }
|
|
std::string DebugString(bool hex = false) const;
|
|
};
|
|
|
|
// Return the length of the encoding of "key".
|
|
inline size_t InternalKeyEncodingLength(const ParsedInternalKey& key) {
|
|
return key.user_key.size() + 8;
|
|
}
|
|
|
|
extern uint64_t PackSequenceAndType(uint64_t seq, ValueType t);
|
|
|
|
// Append the serialization of "key" to *result.
|
|
extern void AppendInternalKey(std::string* result,
|
|
const ParsedInternalKey& key);
|
|
|
|
// Attempt to parse an internal key from "internal_key". On success,
|
|
// stores the parsed data in "*result", and returns true.
|
|
//
|
|
// On error, returns false, leaves "*result" in an undefined state.
|
|
extern bool ParseInternalKey(const Slice& internal_key,
|
|
ParsedInternalKey* result);
|
|
|
|
// Returns the user key portion of an internal key.
|
|
inline Slice ExtractUserKey(const Slice& internal_key) {
|
|
assert(internal_key.size() >= 8);
|
|
return Slice(internal_key.data(), internal_key.size() - 8);
|
|
}
|
|
|
|
inline ValueType ExtractValueType(const Slice& internal_key) {
|
|
assert(internal_key.size() >= 8);
|
|
const size_t n = internal_key.size();
|
|
uint64_t num = DecodeFixed64(internal_key.data() + n - 8);
|
|
unsigned char c = num & 0xff;
|
|
return static_cast<ValueType>(c);
|
|
}
|
|
|
|
// A comparator for internal keys that uses a specified comparator for
|
|
// the user key portion and breaks ties by decreasing sequence number.
|
|
class InternalKeyComparator : public Comparator {
|
|
private:
|
|
const Comparator* user_comparator_;
|
|
std::string name_;
|
|
public:
|
|
explicit InternalKeyComparator(const Comparator* c) : user_comparator_(c),
|
|
name_("rocksdb.InternalKeyComparator:" +
|
|
std::string(user_comparator_->Name())) {
|
|
}
|
|
virtual ~InternalKeyComparator() {}
|
|
|
|
virtual const char* Name() const;
|
|
virtual int Compare(const Slice& a, const Slice& b) const;
|
|
virtual void FindShortestSeparator(
|
|
std::string* start,
|
|
const Slice& limit) const;
|
|
virtual void FindShortSuccessor(std::string* key) const;
|
|
|
|
const Comparator* user_comparator() const { return user_comparator_; }
|
|
|
|
int Compare(const InternalKey& a, const InternalKey& b) const;
|
|
int Compare(const ParsedInternalKey& a, const ParsedInternalKey& b) const;
|
|
};
|
|
|
|
// Filter policy wrapper that converts from internal keys to user keys
|
|
class InternalFilterPolicy : public FilterPolicy {
|
|
private:
|
|
const FilterPolicy* const user_policy_;
|
|
public:
|
|
explicit InternalFilterPolicy(const FilterPolicy* p) : user_policy_(p) { }
|
|
virtual const char* Name() const;
|
|
virtual void CreateFilter(const Slice* keys, int n, std::string* dst) const;
|
|
virtual bool KeyMayMatch(const Slice& key, const Slice& filter) const;
|
|
};
|
|
|
|
// Modules in this directory should keep internal keys wrapped inside
|
|
// the following class instead of plain strings so that we do not
|
|
// incorrectly use string comparisons instead of an InternalKeyComparator.
|
|
class InternalKey {
|
|
private:
|
|
std::string rep_;
|
|
public:
|
|
InternalKey() { } // Leave rep_ as empty to indicate it is invalid
|
|
InternalKey(const Slice& user_key, SequenceNumber s, ValueType t) {
|
|
AppendInternalKey(&rep_, ParsedInternalKey(user_key, s, t));
|
|
}
|
|
|
|
void DecodeFrom(const Slice& s) { rep_.assign(s.data(), s.size()); }
|
|
Slice Encode() const {
|
|
assert(!rep_.empty());
|
|
return rep_;
|
|
}
|
|
|
|
Slice user_key() const { return ExtractUserKey(rep_); }
|
|
|
|
void SetFrom(const ParsedInternalKey& p) {
|
|
rep_.clear();
|
|
AppendInternalKey(&rep_, p);
|
|
}
|
|
|
|
void Clear() { rep_.clear(); }
|
|
|
|
std::string DebugString(bool hex = false) const;
|
|
};
|
|
|
|
inline int InternalKeyComparator::Compare(
|
|
const InternalKey& a, const InternalKey& b) const {
|
|
return Compare(a.Encode(), b.Encode());
|
|
}
|
|
|
|
inline bool ParseInternalKey(const Slice& internal_key,
|
|
ParsedInternalKey* result) {
|
|
const size_t n = internal_key.size();
|
|
if (n < 8) return false;
|
|
uint64_t num = DecodeFixed64(internal_key.data() + n - 8);
|
|
unsigned char c = num & 0xff;
|
|
result->sequence = num >> 8;
|
|
result->type = static_cast<ValueType>(c);
|
|
assert(result->type <= ValueType::kMaxValue);
|
|
result->user_key = Slice(internal_key.data(), n - 8);
|
|
return (c <= static_cast<unsigned char>(kValueTypeForSeek));
|
|
}
|
|
|
|
// Update the sequence number in the internal key
|
|
inline void UpdateInternalKey(char* internal_key,
|
|
const size_t internal_key_size,
|
|
uint64_t seq, ValueType t) {
|
|
assert(internal_key_size >= 8);
|
|
char* seqtype = internal_key + internal_key_size - 8;
|
|
uint64_t newval = (seq << 8) | t;
|
|
EncodeFixed64(seqtype, newval);
|
|
}
|
|
|
|
// Get the sequence number from the internal key
|
|
inline uint64_t GetInternalKeySeqno(const Slice& internal_key) {
|
|
const size_t n = internal_key.size();
|
|
assert(n >= 8);
|
|
uint64_t num = DecodeFixed64(internal_key.data() + n - 8);
|
|
return num >> 8;
|
|
}
|
|
|
|
|
|
// A helper class useful for DBImpl::Get()
|
|
class LookupKey {
|
|
public:
|
|
// Initialize *this for looking up user_key at a snapshot with
|
|
// the specified sequence number.
|
|
LookupKey(const Slice& user_key, SequenceNumber sequence);
|
|
|
|
~LookupKey();
|
|
|
|
// Return a key suitable for lookup in a MemTable.
|
|
Slice memtable_key() const { return Slice(start_, end_ - start_); }
|
|
|
|
// Return an internal key (suitable for passing to an internal iterator)
|
|
Slice internal_key() const { return Slice(kstart_, end_ - kstart_); }
|
|
|
|
// Return the user key
|
|
Slice user_key() const { return Slice(kstart_, end_ - kstart_ - 8); }
|
|
|
|
private:
|
|
// We construct a char array of the form:
|
|
// klength varint32 <-- start_
|
|
// userkey char[klength] <-- kstart_
|
|
// tag uint64
|
|
// <-- end_
|
|
// The array is a suitable MemTable key.
|
|
// The suffix starting with "userkey" can be used as an InternalKey.
|
|
const char* start_;
|
|
const char* kstart_;
|
|
const char* end_;
|
|
char space_[200]; // Avoid allocation for short keys
|
|
|
|
// No copying allowed
|
|
LookupKey(const LookupKey&);
|
|
void operator=(const LookupKey&);
|
|
};
|
|
|
|
inline LookupKey::~LookupKey() {
|
|
if (start_ != space_) delete[] start_;
|
|
}
|
|
|
|
class IterKey {
|
|
public:
|
|
IterKey() : key_(space_), buf_size_(sizeof(space_)), key_size_(0) {}
|
|
|
|
~IterKey() { ResetBuffer(); }
|
|
|
|
Slice GetKey() const { return Slice(key_, key_size_); }
|
|
|
|
void Clear() { key_size_ = 0; }
|
|
|
|
void SetUserKey(const Slice& user_key) {
|
|
size_t size = user_key.size();
|
|
EnlargeBufferIfNeeded(size);
|
|
memcpy(key_, user_key.data(), size);
|
|
key_size_ = size;
|
|
}
|
|
|
|
void SetInternalKey(const Slice& user_key, SequenceNumber s,
|
|
ValueType value_type = kValueTypeForSeek) {
|
|
size_t usize = user_key.size();
|
|
EnlargeBufferIfNeeded(usize + sizeof(uint64_t));
|
|
memcpy(key_, user_key.data(), usize);
|
|
EncodeFixed64(key_ + usize, PackSequenceAndType(s, value_type));
|
|
key_size_ = usize + sizeof(uint64_t);
|
|
}
|
|
|
|
void SetInternalKey(const ParsedInternalKey& parsed_key) {
|
|
SetInternalKey(parsed_key.user_key, parsed_key.sequence, parsed_key.type);
|
|
}
|
|
|
|
private:
|
|
char* key_;
|
|
size_t buf_size_;
|
|
size_t key_size_;
|
|
char space_[32]; // Avoid allocation for short keys
|
|
|
|
void ResetBuffer() {
|
|
if (key_ != nullptr && key_ != space_) {
|
|
delete[] key_;
|
|
}
|
|
key_ = space_;
|
|
buf_size_ = sizeof(space_);
|
|
key_size_ = 0;
|
|
}
|
|
|
|
// Enlarge the buffer size if needed based on key_size.
|
|
// By default, static allocated buffer is used. Once there is a key
|
|
// larger than the static allocated buffer, another buffer is dynamically
|
|
// allocated, until a larger key buffer is requested. In that case, we
|
|
// reallocate buffer and delete the old one.
|
|
void EnlargeBufferIfNeeded(size_t key_size) {
|
|
// If size is smaller than buffer size, continue using current buffer,
|
|
// or the static allocated one, as default
|
|
if (key_size > buf_size_) {
|
|
// Need to enlarge the buffer.
|
|
ResetBuffer();
|
|
key_ = new char[key_size];
|
|
buf_size_ = key_size;
|
|
}
|
|
}
|
|
|
|
// No copying allowed
|
|
IterKey(const IterKey&) = delete;
|
|
void operator=(const IterKey&) = delete;
|
|
};
|
|
|
|
class InternalKeySliceTransform : public SliceTransform {
|
|
public:
|
|
explicit InternalKeySliceTransform(const SliceTransform* transform)
|
|
: transform_(transform) {}
|
|
|
|
virtual const char* Name() const { return transform_->Name(); }
|
|
|
|
virtual Slice Transform(const Slice& src) const {
|
|
auto user_key = ExtractUserKey(src);
|
|
return transform_->Transform(user_key);
|
|
}
|
|
|
|
virtual bool InDomain(const Slice& src) const {
|
|
auto user_key = ExtractUserKey(src);
|
|
return transform_->InDomain(user_key);
|
|
}
|
|
|
|
virtual bool InRange(const Slice& dst) const {
|
|
auto user_key = ExtractUserKey(dst);
|
|
return transform_->InRange(user_key);
|
|
}
|
|
|
|
const SliceTransform* user_prefix_extractor() const { return transform_; }
|
|
|
|
private:
|
|
// Like comparator, InternalKeySliceTransform will not take care of the
|
|
// deletion of transform_
|
|
const SliceTransform* const transform_;
|
|
};
|
|
|
|
} // namespace rocksdb
|
|
|