Summary:
This reverts the previous commit 1d7048c598
, which broke the build.
Did a `git revert 1d7048c`.
Closes https://github.com/facebook/rocksdb/pull/2627
Differential Revision: D5476473
Pulled By: sagar0
fbshipit-source-id: 4756ff5c0dfc88c17eceb00e02c36176de728d06
499 lines
17 KiB
C++
499 lines
17 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).
|
|
|
|
#ifndef ROCKSDB_LITE
|
|
#include "table/plain_table_key_coding.h"
|
|
|
|
#include <algorithm>
|
|
#include <string>
|
|
#include "db/dbformat.h"
|
|
#include "table/plain_table_reader.h"
|
|
#include "table/plain_table_factory.h"
|
|
#include "util/file_reader_writer.h"
|
|
|
|
namespace rocksdb {
|
|
|
|
enum PlainTableEntryType : unsigned char {
|
|
kFullKey = 0,
|
|
kPrefixFromPreviousKey = 1,
|
|
kKeySuffix = 2,
|
|
};
|
|
|
|
namespace {
|
|
|
|
// Control byte:
|
|
// First two bits indicate type of entry
|
|
// Other bytes are inlined sizes. If all bits are 1 (0x03F), overflow bytes
|
|
// are used. key_size-0x3F will be encoded as a variint32 after this bytes.
|
|
|
|
const unsigned char kSizeInlineLimit = 0x3F;
|
|
|
|
// Return 0 for error
|
|
size_t EncodeSize(PlainTableEntryType type, uint32_t key_size,
|
|
char* out_buffer) {
|
|
out_buffer[0] = type << 6;
|
|
|
|
if (key_size < static_cast<uint32_t>(kSizeInlineLimit)) {
|
|
// size inlined
|
|
out_buffer[0] |= static_cast<char>(key_size);
|
|
return 1;
|
|
} else {
|
|
out_buffer[0] |= kSizeInlineLimit;
|
|
char* ptr = EncodeVarint32(out_buffer + 1, key_size - kSizeInlineLimit);
|
|
return ptr - out_buffer;
|
|
}
|
|
}
|
|
} // namespace
|
|
|
|
// Fill bytes_read with number of bytes read.
|
|
inline Status PlainTableKeyDecoder::DecodeSize(uint32_t start_offset,
|
|
PlainTableEntryType* entry_type,
|
|
uint32_t* key_size,
|
|
uint32_t* bytes_read) {
|
|
Slice next_byte_slice;
|
|
bool success = file_reader_.Read(start_offset, 1, &next_byte_slice);
|
|
if (!success) {
|
|
return file_reader_.status();
|
|
}
|
|
*entry_type = static_cast<PlainTableEntryType>(
|
|
(static_cast<unsigned char>(next_byte_slice[0]) & ~kSizeInlineLimit) >>
|
|
6);
|
|
char inline_key_size = next_byte_slice[0] & kSizeInlineLimit;
|
|
if (inline_key_size < kSizeInlineLimit) {
|
|
*key_size = inline_key_size;
|
|
*bytes_read = 1;
|
|
return Status::OK();
|
|
} else {
|
|
uint32_t extra_size;
|
|
uint32_t tmp_bytes_read;
|
|
success = file_reader_.ReadVarint32(start_offset + 1, &extra_size,
|
|
&tmp_bytes_read);
|
|
if (!success) {
|
|
return file_reader_.status();
|
|
}
|
|
assert(tmp_bytes_read > 0);
|
|
*key_size = kSizeInlineLimit + extra_size;
|
|
*bytes_read = tmp_bytes_read + 1;
|
|
return Status::OK();
|
|
}
|
|
}
|
|
|
|
Status PlainTableKeyEncoder::AppendKey(const Slice& key,
|
|
WritableFileWriter* file,
|
|
uint64_t* offset, char* meta_bytes_buf,
|
|
size_t* meta_bytes_buf_size) {
|
|
ParsedInternalKey parsed_key;
|
|
if (!ParseInternalKey(key, &parsed_key)) {
|
|
return Status::Corruption(Slice());
|
|
}
|
|
|
|
Slice key_to_write = key; // Portion of internal key to write out.
|
|
|
|
uint32_t user_key_size = static_cast<uint32_t>(key.size() - 8);
|
|
if (encoding_type_ == kPlain) {
|
|
if (fixed_user_key_len_ == kPlainTableVariableLength) {
|
|
// Write key length
|
|
char key_size_buf[5]; // tmp buffer for key size as varint32
|
|
char* ptr = EncodeVarint32(key_size_buf, user_key_size);
|
|
assert(ptr <= key_size_buf + sizeof(key_size_buf));
|
|
auto len = ptr - key_size_buf;
|
|
Status s = file->Append(Slice(key_size_buf, len));
|
|
if (!s.ok()) {
|
|
return s;
|
|
}
|
|
*offset += len;
|
|
}
|
|
} else {
|
|
assert(encoding_type_ == kPrefix);
|
|
char size_bytes[12];
|
|
size_t size_bytes_pos = 0;
|
|
|
|
Slice prefix =
|
|
prefix_extractor_->Transform(Slice(key.data(), user_key_size));
|
|
if (key_count_for_prefix_ == 0 || prefix != pre_prefix_.GetUserKey() ||
|
|
key_count_for_prefix_ % index_sparseness_ == 0) {
|
|
key_count_for_prefix_ = 1;
|
|
pre_prefix_.SetUserKey(prefix);
|
|
size_bytes_pos += EncodeSize(kFullKey, user_key_size, size_bytes);
|
|
Status s = file->Append(Slice(size_bytes, size_bytes_pos));
|
|
if (!s.ok()) {
|
|
return s;
|
|
}
|
|
*offset += size_bytes_pos;
|
|
} else {
|
|
key_count_for_prefix_++;
|
|
if (key_count_for_prefix_ == 2) {
|
|
// For second key within a prefix, need to encode prefix length
|
|
size_bytes_pos +=
|
|
EncodeSize(kPrefixFromPreviousKey,
|
|
static_cast<uint32_t>(pre_prefix_.GetUserKey().size()),
|
|
size_bytes + size_bytes_pos);
|
|
}
|
|
uint32_t prefix_len =
|
|
static_cast<uint32_t>(pre_prefix_.GetUserKey().size());
|
|
size_bytes_pos += EncodeSize(kKeySuffix, user_key_size - prefix_len,
|
|
size_bytes + size_bytes_pos);
|
|
Status s = file->Append(Slice(size_bytes, size_bytes_pos));
|
|
if (!s.ok()) {
|
|
return s;
|
|
}
|
|
*offset += size_bytes_pos;
|
|
key_to_write = Slice(key.data() + prefix_len, key.size() - prefix_len);
|
|
}
|
|
}
|
|
|
|
// Encode full key
|
|
// For value size as varint32 (up to 5 bytes).
|
|
// If the row is of value type with seqId 0, flush the special flag together
|
|
// in this buffer to safe one file append call, which takes 1 byte.
|
|
if (parsed_key.sequence == 0 && parsed_key.type == kTypeValue) {
|
|
Status s =
|
|
file->Append(Slice(key_to_write.data(), key_to_write.size() - 8));
|
|
if (!s.ok()) {
|
|
return s;
|
|
}
|
|
*offset += key_to_write.size() - 8;
|
|
meta_bytes_buf[*meta_bytes_buf_size] = PlainTableFactory::kValueTypeSeqId0;
|
|
*meta_bytes_buf_size += 1;
|
|
} else {
|
|
file->Append(key_to_write);
|
|
*offset += key_to_write.size();
|
|
}
|
|
|
|
return Status::OK();
|
|
}
|
|
|
|
Slice PlainTableFileReader::GetFromBuffer(Buffer* buffer, uint32_t file_offset,
|
|
uint32_t len) {
|
|
assert(file_offset + len <= file_info_->data_end_offset);
|
|
return Slice(buffer->buf.get() + (file_offset - buffer->buf_start_offset),
|
|
len);
|
|
}
|
|
|
|
bool PlainTableFileReader::ReadNonMmap(uint32_t file_offset, uint32_t len,
|
|
Slice* out) {
|
|
const uint32_t kPrefetchSize = 256u;
|
|
|
|
// Try to read from buffers.
|
|
for (uint32_t i = 0; i < num_buf_; i++) {
|
|
Buffer* buffer = buffers_[num_buf_ - 1 - i].get();
|
|
if (file_offset >= buffer->buf_start_offset &&
|
|
file_offset + len <= buffer->buf_start_offset + buffer->buf_len) {
|
|
*out = GetFromBuffer(buffer, file_offset, len);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
Buffer* new_buffer;
|
|
// Data needed is not in any of the buffer. Allocate a new buffer.
|
|
if (num_buf_ < buffers_.size()) {
|
|
// Add a new buffer
|
|
new_buffer = new Buffer();
|
|
buffers_[num_buf_++].reset(new_buffer);
|
|
} else {
|
|
// Now simply replace the last buffer. Can improve the placement policy
|
|
// if needed.
|
|
new_buffer = buffers_[num_buf_ - 1].get();
|
|
}
|
|
|
|
assert(file_offset + len <= file_info_->data_end_offset);
|
|
uint32_t size_to_read = std::min(file_info_->data_end_offset - file_offset,
|
|
std::max(kPrefetchSize, len));
|
|
if (size_to_read > new_buffer->buf_capacity) {
|
|
new_buffer->buf.reset(new char[size_to_read]);
|
|
new_buffer->buf_capacity = size_to_read;
|
|
new_buffer->buf_len = 0;
|
|
}
|
|
Slice read_result;
|
|
Status s = file_info_->file->Read(file_offset, size_to_read, &read_result,
|
|
new_buffer->buf.get());
|
|
if (!s.ok()) {
|
|
status_ = s;
|
|
return false;
|
|
}
|
|
new_buffer->buf_start_offset = file_offset;
|
|
new_buffer->buf_len = size_to_read;
|
|
*out = GetFromBuffer(new_buffer, file_offset, len);
|
|
return true;
|
|
}
|
|
|
|
inline bool PlainTableFileReader::ReadVarint32(uint32_t offset, uint32_t* out,
|
|
uint32_t* bytes_read) {
|
|
if (file_info_->is_mmap_mode) {
|
|
const char* start = file_info_->file_data.data() + offset;
|
|
const char* limit =
|
|
file_info_->file_data.data() + file_info_->data_end_offset;
|
|
const char* key_ptr = GetVarint32Ptr(start, limit, out);
|
|
assert(key_ptr != nullptr);
|
|
*bytes_read = static_cast<uint32_t>(key_ptr - start);
|
|
return true;
|
|
} else {
|
|
return ReadVarint32NonMmap(offset, out, bytes_read);
|
|
}
|
|
}
|
|
|
|
bool PlainTableFileReader::ReadVarint32NonMmap(uint32_t offset, uint32_t* out,
|
|
uint32_t* bytes_read) {
|
|
const char* start;
|
|
const char* limit;
|
|
const uint32_t kMaxVarInt32Size = 6u;
|
|
uint32_t bytes_to_read =
|
|
std::min(file_info_->data_end_offset - offset, kMaxVarInt32Size);
|
|
Slice bytes;
|
|
if (!Read(offset, bytes_to_read, &bytes)) {
|
|
return false;
|
|
}
|
|
start = bytes.data();
|
|
limit = bytes.data() + bytes.size();
|
|
|
|
const char* key_ptr = GetVarint32Ptr(start, limit, out);
|
|
*bytes_read =
|
|
(key_ptr != nullptr) ? static_cast<uint32_t>(key_ptr - start) : 0;
|
|
return true;
|
|
}
|
|
|
|
Status PlainTableKeyDecoder::ReadInternalKey(
|
|
uint32_t file_offset, uint32_t user_key_size, ParsedInternalKey* parsed_key,
|
|
uint32_t* bytes_read, bool* internal_key_valid, Slice* internal_key) {
|
|
Slice tmp_slice;
|
|
bool success = file_reader_.Read(file_offset, user_key_size + 1, &tmp_slice);
|
|
if (!success) {
|
|
return file_reader_.status();
|
|
}
|
|
if (tmp_slice[user_key_size] == PlainTableFactory::kValueTypeSeqId0) {
|
|
// Special encoding for the row with seqID=0
|
|
parsed_key->user_key = Slice(tmp_slice.data(), user_key_size);
|
|
parsed_key->sequence = 0;
|
|
parsed_key->type = kTypeValue;
|
|
*bytes_read += user_key_size + 1;
|
|
*internal_key_valid = false;
|
|
} else {
|
|
success = file_reader_.Read(file_offset, user_key_size + 8, internal_key);
|
|
if (!success) {
|
|
return file_reader_.status();
|
|
}
|
|
*internal_key_valid = true;
|
|
if (!ParseInternalKey(*internal_key, parsed_key)) {
|
|
return Status::Corruption(
|
|
Slice("Incorrect value type found when reading the next key"));
|
|
}
|
|
*bytes_read += user_key_size + 8;
|
|
}
|
|
return Status::OK();
|
|
}
|
|
|
|
Status PlainTableKeyDecoder::NextPlainEncodingKey(uint32_t start_offset,
|
|
ParsedInternalKey* parsed_key,
|
|
Slice* internal_key,
|
|
uint32_t* bytes_read,
|
|
bool* seekable) {
|
|
uint32_t user_key_size = 0;
|
|
Status s;
|
|
if (fixed_user_key_len_ != kPlainTableVariableLength) {
|
|
user_key_size = fixed_user_key_len_;
|
|
} else {
|
|
uint32_t tmp_size = 0;
|
|
uint32_t tmp_read;
|
|
bool success =
|
|
file_reader_.ReadVarint32(start_offset, &tmp_size, &tmp_read);
|
|
if (!success) {
|
|
return file_reader_.status();
|
|
}
|
|
assert(tmp_read > 0);
|
|
user_key_size = tmp_size;
|
|
*bytes_read = tmp_read;
|
|
}
|
|
// dummy initial value to avoid compiler complain
|
|
bool decoded_internal_key_valid = true;
|
|
Slice decoded_internal_key;
|
|
s = ReadInternalKey(start_offset + *bytes_read, user_key_size, parsed_key,
|
|
bytes_read, &decoded_internal_key_valid,
|
|
&decoded_internal_key);
|
|
if (!s.ok()) {
|
|
return s;
|
|
}
|
|
if (!file_reader_.file_info()->is_mmap_mode) {
|
|
cur_key_.SetInternalKey(*parsed_key);
|
|
parsed_key->user_key =
|
|
Slice(cur_key_.GetInternalKey().data(), user_key_size);
|
|
if (internal_key != nullptr) {
|
|
*internal_key = cur_key_.GetInternalKey();
|
|
}
|
|
} else if (internal_key != nullptr) {
|
|
if (decoded_internal_key_valid) {
|
|
*internal_key = decoded_internal_key;
|
|
} else {
|
|
// Need to copy out the internal key
|
|
cur_key_.SetInternalKey(*parsed_key);
|
|
*internal_key = cur_key_.GetInternalKey();
|
|
}
|
|
}
|
|
return Status::OK();
|
|
}
|
|
|
|
Status PlainTableKeyDecoder::NextPrefixEncodingKey(
|
|
uint32_t start_offset, ParsedInternalKey* parsed_key, Slice* internal_key,
|
|
uint32_t* bytes_read, bool* seekable) {
|
|
PlainTableEntryType entry_type;
|
|
|
|
bool expect_suffix = false;
|
|
Status s;
|
|
do {
|
|
uint32_t size = 0;
|
|
// dummy initial value to avoid compiler complain
|
|
bool decoded_internal_key_valid = true;
|
|
uint32_t my_bytes_read = 0;
|
|
s = DecodeSize(start_offset + *bytes_read, &entry_type, &size,
|
|
&my_bytes_read);
|
|
if (!s.ok()) {
|
|
return s;
|
|
}
|
|
if (my_bytes_read == 0) {
|
|
return Status::Corruption("Unexpected EOF when reading size of the key");
|
|
}
|
|
*bytes_read += my_bytes_read;
|
|
|
|
switch (entry_type) {
|
|
case kFullKey: {
|
|
expect_suffix = false;
|
|
Slice decoded_internal_key;
|
|
s = ReadInternalKey(start_offset + *bytes_read, size, parsed_key,
|
|
bytes_read, &decoded_internal_key_valid,
|
|
&decoded_internal_key);
|
|
if (!s.ok()) {
|
|
return s;
|
|
}
|
|
if (!file_reader_.file_info()->is_mmap_mode ||
|
|
(internal_key != nullptr && !decoded_internal_key_valid)) {
|
|
// In non-mmap mode, always need to make a copy of keys returned to
|
|
// users, because after reading value for the key, the key might
|
|
// be invalid.
|
|
cur_key_.SetInternalKey(*parsed_key);
|
|
saved_user_key_ = cur_key_.GetUserKey();
|
|
if (!file_reader_.file_info()->is_mmap_mode) {
|
|
parsed_key->user_key =
|
|
Slice(cur_key_.GetInternalKey().data(), size);
|
|
}
|
|
if (internal_key != nullptr) {
|
|
*internal_key = cur_key_.GetInternalKey();
|
|
}
|
|
} else {
|
|
if (internal_key != nullptr) {
|
|
*internal_key = decoded_internal_key;
|
|
}
|
|
saved_user_key_ = parsed_key->user_key;
|
|
}
|
|
break;
|
|
}
|
|
case kPrefixFromPreviousKey: {
|
|
if (seekable != nullptr) {
|
|
*seekable = false;
|
|
}
|
|
prefix_len_ = size;
|
|
assert(prefix_extractor_ == nullptr ||
|
|
prefix_extractor_->Transform(saved_user_key_).size() ==
|
|
prefix_len_);
|
|
// Need read another size flag for suffix
|
|
expect_suffix = true;
|
|
break;
|
|
}
|
|
case kKeySuffix: {
|
|
expect_suffix = false;
|
|
if (seekable != nullptr) {
|
|
*seekable = false;
|
|
}
|
|
|
|
Slice tmp_slice;
|
|
s = ReadInternalKey(start_offset + *bytes_read, size, parsed_key,
|
|
bytes_read, &decoded_internal_key_valid,
|
|
&tmp_slice);
|
|
if (!s.ok()) {
|
|
return s;
|
|
}
|
|
if (!file_reader_.file_info()->is_mmap_mode) {
|
|
// In non-mmap mode, we need to make a copy of keys returned to
|
|
// users, because after reading value for the key, the key might
|
|
// be invalid.
|
|
// saved_user_key_ points to cur_key_. We are making a copy of
|
|
// the prefix part to another string, and construct the current
|
|
// key from the prefix part and the suffix part back to cur_key_.
|
|
std::string tmp =
|
|
Slice(saved_user_key_.data(), prefix_len_).ToString();
|
|
cur_key_.Reserve(prefix_len_ + size);
|
|
cur_key_.SetInternalKey(tmp, *parsed_key);
|
|
parsed_key->user_key =
|
|
Slice(cur_key_.GetInternalKey().data(), prefix_len_ + size);
|
|
saved_user_key_ = cur_key_.GetUserKey();
|
|
} else {
|
|
cur_key_.Reserve(prefix_len_ + size);
|
|
cur_key_.SetInternalKey(Slice(saved_user_key_.data(), prefix_len_),
|
|
*parsed_key);
|
|
}
|
|
parsed_key->user_key = cur_key_.GetUserKey();
|
|
if (internal_key != nullptr) {
|
|
*internal_key = cur_key_.GetInternalKey();
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
return Status::Corruption("Un-identified size flag.");
|
|
}
|
|
} while (expect_suffix); // Another round if suffix is expected.
|
|
return Status::OK();
|
|
}
|
|
|
|
Status PlainTableKeyDecoder::NextKey(uint32_t start_offset,
|
|
ParsedInternalKey* parsed_key,
|
|
Slice* internal_key, Slice* value,
|
|
uint32_t* bytes_read, bool* seekable) {
|
|
assert(value != nullptr);
|
|
Status s = NextKeyNoValue(start_offset, parsed_key, internal_key, bytes_read,
|
|
seekable);
|
|
if (s.ok()) {
|
|
assert(bytes_read != nullptr);
|
|
uint32_t value_size;
|
|
uint32_t value_size_bytes;
|
|
bool success = file_reader_.ReadVarint32(start_offset + *bytes_read,
|
|
&value_size, &value_size_bytes);
|
|
if (!success) {
|
|
return file_reader_.status();
|
|
}
|
|
if (value_size_bytes == 0) {
|
|
return Status::Corruption(
|
|
"Unexpected EOF when reading the next value's size.");
|
|
}
|
|
*bytes_read += value_size_bytes;
|
|
success = file_reader_.Read(start_offset + *bytes_read, value_size, value);
|
|
if (!success) {
|
|
return file_reader_.status();
|
|
}
|
|
*bytes_read += value_size;
|
|
}
|
|
return s;
|
|
}
|
|
|
|
Status PlainTableKeyDecoder::NextKeyNoValue(uint32_t start_offset,
|
|
ParsedInternalKey* parsed_key,
|
|
Slice* internal_key,
|
|
uint32_t* bytes_read,
|
|
bool* seekable) {
|
|
*bytes_read = 0;
|
|
if (seekable != nullptr) {
|
|
*seekable = true;
|
|
}
|
|
Status s;
|
|
if (encoding_type_ == kPlain) {
|
|
return NextPlainEncodingKey(start_offset, parsed_key, internal_key,
|
|
bytes_read, seekable);
|
|
} else {
|
|
assert(encoding_type_ == kPrefix);
|
|
return NextPrefixEncodingKey(start_offset, parsed_key, internal_key,
|
|
bytes_read, seekable);
|
|
}
|
|
}
|
|
|
|
} // namespace rocksdb
|
|
#endif // ROCKSDB_LIT
|