mirror of https://github.com/facebook/rocksdb.git
281 lines
9.5 KiB
C++
281 lines
9.5 KiB
C++
// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
|
|
// This source code is licensed under both the GPLv2 (found in the
|
|
// COPYING file in the root directory) and Apache 2.0 License
|
|
// (found in the LICENSE.Apache file in the root 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.
|
|
#include "db/dbformat.h"
|
|
|
|
#include <cinttypes>
|
|
#include <cstdio>
|
|
|
|
#include "db/lookup_key.h"
|
|
#include "monitoring/perf_context_imp.h"
|
|
#include "port/port.h"
|
|
#include "util/coding.h"
|
|
#include "util/string_util.h"
|
|
|
|
namespace ROCKSDB_NAMESPACE {
|
|
|
|
// 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).
|
|
const ValueType kValueTypeForSeek = kTypeValuePreferredSeqno;
|
|
const ValueType kValueTypeForSeekForPrev = kTypeDeletion;
|
|
const std::string kDisableUserTimestamp;
|
|
|
|
EntryType GetEntryType(ValueType value_type) {
|
|
switch (value_type) {
|
|
case kTypeValue:
|
|
return kEntryPut;
|
|
case kTypeDeletion:
|
|
return kEntryDelete;
|
|
case kTypeDeletionWithTimestamp:
|
|
return kEntryDeleteWithTimestamp;
|
|
case kTypeSingleDeletion:
|
|
return kEntrySingleDelete;
|
|
case kTypeMerge:
|
|
return kEntryMerge;
|
|
case kTypeRangeDeletion:
|
|
return kEntryRangeDeletion;
|
|
case kTypeBlobIndex:
|
|
return kEntryBlobIndex;
|
|
case kTypeWideColumnEntity:
|
|
return kEntryWideColumnEntity;
|
|
default:
|
|
return kEntryOther;
|
|
}
|
|
}
|
|
|
|
void AppendInternalKey(std::string* result, const ParsedInternalKey& key) {
|
|
result->append(key.user_key.data(), key.user_key.size());
|
|
PutFixed64(result, PackSequenceAndType(key.sequence, key.type));
|
|
}
|
|
|
|
void AppendInternalKeyWithDifferentTimestamp(std::string* result,
|
|
const ParsedInternalKey& key,
|
|
const Slice& ts) {
|
|
assert(key.user_key.size() >= ts.size());
|
|
result->append(key.user_key.data(), key.user_key.size() - ts.size());
|
|
result->append(ts.data(), ts.size());
|
|
PutFixed64(result, PackSequenceAndType(key.sequence, key.type));
|
|
}
|
|
|
|
void AppendUserKeyWithDifferentTimestamp(std::string* result, const Slice& key,
|
|
const Slice& ts) {
|
|
assert(key.size() >= ts.size());
|
|
result->append(key.data(), key.size() - ts.size());
|
|
result->append(ts.data(), ts.size());
|
|
}
|
|
|
|
void AppendInternalKeyFooter(std::string* result, SequenceNumber s,
|
|
ValueType t) {
|
|
PutFixed64(result, PackSequenceAndType(s, t));
|
|
}
|
|
|
|
void AppendKeyWithMinTimestamp(std::string* result, const Slice& key,
|
|
size_t ts_sz) {
|
|
assert(ts_sz > 0);
|
|
const std::string kTsMin(ts_sz, static_cast<unsigned char>(0));
|
|
result->append(key.data(), key.size());
|
|
result->append(kTsMin.data(), ts_sz);
|
|
}
|
|
|
|
void AppendKeyWithMaxTimestamp(std::string* result, const Slice& key,
|
|
size_t ts_sz) {
|
|
assert(ts_sz > 0);
|
|
const std::string kTsMax(ts_sz, static_cast<unsigned char>(0xff));
|
|
result->append(key.data(), key.size());
|
|
result->append(kTsMax.data(), ts_sz);
|
|
}
|
|
|
|
void AppendUserKeyWithMinTimestamp(std::string* result, const Slice& key,
|
|
size_t ts_sz) {
|
|
assert(ts_sz > 0);
|
|
result->append(key.data(), key.size() - ts_sz);
|
|
result->append(ts_sz, static_cast<unsigned char>(0));
|
|
}
|
|
|
|
void AppendUserKeyWithMaxTimestamp(std::string* result, const Slice& key,
|
|
size_t ts_sz) {
|
|
assert(ts_sz > 0);
|
|
result->append(key.data(), key.size() - ts_sz);
|
|
|
|
static constexpr char kTsMax[] = "\xff\xff\xff\xff\xff\xff\xff\xff\xff";
|
|
if (ts_sz < strlen(kTsMax)) {
|
|
result->append(kTsMax, ts_sz);
|
|
} else {
|
|
result->append(std::string(ts_sz, '\xff'));
|
|
}
|
|
}
|
|
|
|
void PadInternalKeyWithMinTimestamp(std::string* result, const Slice& key,
|
|
size_t ts_sz) {
|
|
assert(ts_sz > 0);
|
|
assert(key.size() >= kNumInternalBytes);
|
|
size_t user_key_size = key.size() - kNumInternalBytes;
|
|
result->reserve(key.size() + ts_sz);
|
|
result->append(key.data(), user_key_size);
|
|
result->append(ts_sz, static_cast<unsigned char>(0));
|
|
result->append(key.data() + user_key_size, kNumInternalBytes);
|
|
}
|
|
|
|
void PadInternalKeyWithMaxTimestamp(std::string* result, const Slice& key,
|
|
size_t ts_sz) {
|
|
assert(ts_sz > 0);
|
|
assert(key.size() >= kNumInternalBytes);
|
|
size_t user_key_size = key.size() - kNumInternalBytes;
|
|
result->reserve(key.size() + ts_sz);
|
|
result->append(key.data(), user_key_size);
|
|
result->append(std::string(ts_sz, '\xff'));
|
|
result->append(key.data() + user_key_size, kNumInternalBytes);
|
|
}
|
|
|
|
void StripTimestampFromInternalKey(std::string* result, const Slice& key,
|
|
size_t ts_sz) {
|
|
assert(key.size() >= ts_sz + kNumInternalBytes);
|
|
result->reserve(key.size() - ts_sz);
|
|
result->append(key.data(), key.size() - kNumInternalBytes - ts_sz);
|
|
result->append(key.data() + key.size() - kNumInternalBytes,
|
|
kNumInternalBytes);
|
|
}
|
|
|
|
void ReplaceInternalKeyWithMinTimestamp(std::string* result, const Slice& key,
|
|
size_t ts_sz) {
|
|
const size_t key_sz = key.size();
|
|
assert(key_sz >= ts_sz + kNumInternalBytes);
|
|
result->reserve(key_sz);
|
|
result->append(key.data(), key_sz - kNumInternalBytes - ts_sz);
|
|
result->append(ts_sz, static_cast<unsigned char>(0));
|
|
result->append(key.data() + key_sz - kNumInternalBytes, kNumInternalBytes);
|
|
}
|
|
|
|
std::string ParsedInternalKey::DebugString(bool log_err_key, bool hex,
|
|
const Comparator* ucmp) const {
|
|
std::string result = "'";
|
|
size_t ts_sz_for_debug = ucmp == nullptr ? 0 : ucmp->timestamp_size();
|
|
if (log_err_key) {
|
|
if (ts_sz_for_debug == 0) {
|
|
result += user_key.ToString(hex);
|
|
} else {
|
|
assert(user_key.size() >= ts_sz_for_debug);
|
|
Slice user_key_without_ts = user_key;
|
|
user_key_without_ts.remove_suffix(ts_sz_for_debug);
|
|
result += user_key_without_ts.ToString(hex);
|
|
Slice ts = Slice(user_key.data() + user_key.size() - ts_sz_for_debug,
|
|
ts_sz_for_debug);
|
|
result += "|timestamp:";
|
|
result += ucmp->TimestampToString(ts);
|
|
}
|
|
} else {
|
|
result += "<redacted>";
|
|
}
|
|
|
|
char buf[50];
|
|
snprintf(buf, sizeof(buf), "' seq:%" PRIu64 ", type:%d", sequence,
|
|
static_cast<int>(type));
|
|
|
|
result += buf;
|
|
return result;
|
|
}
|
|
|
|
std::string InternalKey::DebugString(bool hex, const Comparator* ucmp) const {
|
|
std::string result;
|
|
ParsedInternalKey parsed;
|
|
if (ParseInternalKey(rep_, &parsed, false /* log_err_key */).ok()) {
|
|
result = parsed.DebugString(true /* log_err_key */, hex, ucmp); // TODO
|
|
} else {
|
|
result = "(bad)";
|
|
result.append(EscapeString(rep_));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
int InternalKeyComparator::Compare(const ParsedInternalKey& a,
|
|
const ParsedInternalKey& b) const {
|
|
// Order by:
|
|
// increasing user key (according to user-supplied comparator)
|
|
// decreasing sequence number
|
|
// decreasing type (though sequence# should be enough to disambiguate)
|
|
int r = user_comparator_.Compare(a.user_key, b.user_key);
|
|
if (r == 0) {
|
|
if (a.sequence > b.sequence) {
|
|
r = -1;
|
|
} else if (a.sequence < b.sequence) {
|
|
r = +1;
|
|
} else if (a.type > b.type) {
|
|
r = -1;
|
|
} else if (a.type < b.type) {
|
|
r = +1;
|
|
}
|
|
}
|
|
return r;
|
|
}
|
|
|
|
int InternalKeyComparator::Compare(const Slice& a,
|
|
const ParsedInternalKey& b) const {
|
|
// Order by:
|
|
// increasing user key (according to user-supplied comparator)
|
|
// decreasing sequence number
|
|
// decreasing type (though sequence# should be enough to disambiguate)
|
|
int r = user_comparator_.Compare(ExtractUserKey(a), b.user_key);
|
|
if (r == 0) {
|
|
const uint64_t anum =
|
|
DecodeFixed64(a.data() + a.size() - kNumInternalBytes);
|
|
const uint64_t bnum = (b.sequence << 8) | b.type;
|
|
if (anum > bnum) {
|
|
r = -1;
|
|
} else if (anum < bnum) {
|
|
r = +1;
|
|
}
|
|
}
|
|
return r;
|
|
}
|
|
|
|
int InternalKeyComparator::Compare(const ParsedInternalKey& a,
|
|
const Slice& b) const {
|
|
return -Compare(b, a);
|
|
}
|
|
|
|
LookupKey::LookupKey(const Slice& _user_key, SequenceNumber s,
|
|
const Slice* ts) {
|
|
size_t usize = _user_key.size();
|
|
size_t ts_sz = (nullptr == ts) ? 0 : ts->size();
|
|
size_t needed = usize + ts_sz + 13; // A conservative estimate
|
|
char* dst;
|
|
if (needed <= sizeof(space_)) {
|
|
dst = space_;
|
|
} else {
|
|
dst = new char[needed];
|
|
}
|
|
start_ = dst;
|
|
// NOTE: We don't support users keys of more than 2GB :)
|
|
dst = EncodeVarint32(dst, static_cast<uint32_t>(usize + ts_sz + 8));
|
|
kstart_ = dst;
|
|
memcpy(dst, _user_key.data(), usize);
|
|
dst += usize;
|
|
if (nullptr != ts) {
|
|
memcpy(dst, ts->data(), ts_sz);
|
|
dst += ts_sz;
|
|
}
|
|
EncodeFixed64(dst, PackSequenceAndType(s, kValueTypeForSeek));
|
|
dst += 8;
|
|
end_ = dst;
|
|
}
|
|
|
|
void IterKey::EnlargeBuffer(size_t key_size) {
|
|
// If size is smaller than buffer size, continue using current buffer,
|
|
// or the static allocated one, as default
|
|
assert(key_size > buf_size_);
|
|
// Need to enlarge the buffer.
|
|
ResetBuffer();
|
|
buf_ = new char[key_size];
|
|
buf_size_ = key_size;
|
|
}
|
|
} // namespace ROCKSDB_NAMESPACE
|