36a5f8ed7f
- Replace raw slice comparison with a call to user comparator.
Added test for custom comparators.
- Fix end of namespace comments.
- Fixed bug in picking inputs for a level-0 compaction.
When finding overlapping files, the covered range may expand
as files are added to the input set. We now correctly expand
the range when this happens instead of continuing to use the
old range. For example, suppose L0 contains files with the
following ranges:
F1: a .. d
F2: c .. g
F3: f .. j
and the initial compaction target is F3. We used to search
for range f..j which yielded {F2,F3}. However we now expand
the range as soon as another file is added. In this case,
when F2 is added, we expand the range to c..j and restart the
search. That picks up file F1 as well.
This change fixes a bug related to deleted keys showing up
incorrectly after a compaction as described in Issue 44.
(Sync with upstream @25072954)
104 lines
2.9 KiB
C++
104 lines
2.9 KiB
C++
// 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.
|
|
|
|
#ifndef STORAGE_LEVELDB_TABLE_FORMAT_H_
|
|
#define STORAGE_LEVELDB_TABLE_FORMAT_H_
|
|
|
|
#include <string>
|
|
#include <stdint.h>
|
|
#include "leveldb/slice.h"
|
|
#include "leveldb/status.h"
|
|
#include "leveldb/table_builder.h"
|
|
|
|
namespace leveldb {
|
|
|
|
class Block;
|
|
class RandomAccessFile;
|
|
struct ReadOptions;
|
|
|
|
// BlockHandle is a pointer to the extent of a file that stores a data
|
|
// block or a meta block.
|
|
class BlockHandle {
|
|
public:
|
|
BlockHandle();
|
|
|
|
// The offset of the block in the file.
|
|
uint64_t offset() const { return offset_; }
|
|
void set_offset(uint64_t offset) { offset_ = offset; }
|
|
|
|
// The size of the stored block
|
|
uint64_t size() const { return size_; }
|
|
void set_size(uint64_t size) { size_ = size; }
|
|
|
|
void EncodeTo(std::string* dst) const;
|
|
Status DecodeFrom(Slice* input);
|
|
|
|
// Maximum encoding length of a BlockHandle
|
|
enum { kMaxEncodedLength = 10 + 10 };
|
|
|
|
private:
|
|
uint64_t offset_;
|
|
uint64_t size_;
|
|
};
|
|
|
|
// Footer encapsulates the fixed information stored at the tail
|
|
// end of every table file.
|
|
class Footer {
|
|
public:
|
|
Footer() { }
|
|
|
|
// The block handle for the metaindex block of the table
|
|
const BlockHandle& metaindex_handle() const { return metaindex_handle_; }
|
|
void set_metaindex_handle(const BlockHandle& h) { metaindex_handle_ = h; }
|
|
|
|
// The block handle for the index block of the table
|
|
const BlockHandle& index_handle() const {
|
|
return index_handle_;
|
|
}
|
|
void set_index_handle(const BlockHandle& h) {
|
|
index_handle_ = h;
|
|
}
|
|
|
|
void EncodeTo(std::string* dst) const;
|
|
Status DecodeFrom(Slice* input);
|
|
|
|
// Encoded length of a Footer. Note that the serialization of a
|
|
// Footer will always occupy exactly this many bytes. It consists
|
|
// of two block handles and a magic number.
|
|
enum {
|
|
kEncodedLength = 2*BlockHandle::kMaxEncodedLength + 8
|
|
};
|
|
|
|
private:
|
|
BlockHandle metaindex_handle_;
|
|
BlockHandle index_handle_;
|
|
};
|
|
|
|
// kTableMagicNumber was picked by running
|
|
// echo http://code.google.com/p/leveldb/ | sha1sum
|
|
// and taking the leading 64 bits.
|
|
static const uint64_t kTableMagicNumber = 0xdb4775248b80fb57ull;
|
|
|
|
// 1-byte type + 32-bit crc
|
|
static const size_t kBlockTrailerSize = 5;
|
|
|
|
// Read the block identified by "handle" from "file". On success,
|
|
// store a pointer to the heap-allocated result in *block and return
|
|
// OK. On failure store NULL in *block and return non-OK.
|
|
extern Status ReadBlock(RandomAccessFile* file,
|
|
const ReadOptions& options,
|
|
const BlockHandle& handle,
|
|
Block** block);
|
|
|
|
// Implementation details follow. Clients should ignore,
|
|
|
|
inline BlockHandle::BlockHandle()
|
|
: offset_(~static_cast<uint64_t>(0)),
|
|
size_(~static_cast<uint64_t>(0)) {
|
|
}
|
|
|
|
} // namespace leveldb
|
|
|
|
#endif // STORAGE_LEVELDB_TABLE_FORMAT_H_
|