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.
85 lines
2.9 KiB
85 lines
2.9 KiB
// 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_INCLUDE_TABLE_H_ |
|
#define STORAGE_LEVELDB_INCLUDE_TABLE_H_ |
|
|
|
#include <stdint.h> |
|
#include "leveldb/iterator.h" |
|
|
|
namespace leveldb { |
|
|
|
class Block; |
|
class BlockHandle; |
|
class Footer; |
|
struct Options; |
|
class RandomAccessFile; |
|
struct ReadOptions; |
|
class TableCache; |
|
|
|
// A Table is a sorted map from strings to strings. Tables are |
|
// immutable and persistent. A Table may be safely accessed from |
|
// multiple threads without external synchronization. |
|
class Table { |
|
public: |
|
// Attempt to open the table that is stored in bytes [0..file_size) |
|
// of "file", and read the metadata entries necessary to allow |
|
// retrieving data from the table. |
|
// |
|
// If successful, returns ok and sets "*table" to the newly opened |
|
// table. The client should delete "*table" when no longer needed. |
|
// If there was an error while initializing the table, sets "*table" |
|
// to NULL and returns a non-ok status. Does not take ownership of |
|
// "*source", but the client must ensure that "source" remains live |
|
// for the duration of the returned table's lifetime. |
|
// |
|
// *file must remain live while this Table is in use. |
|
static Status Open(const Options& options, |
|
RandomAccessFile* file, |
|
uint64_t file_size, |
|
Table** table); |
|
|
|
~Table(); |
|
|
|
// Returns a new iterator over the table contents. |
|
// The result of NewIterator() is initially invalid (caller must |
|
// call one of the Seek methods on the iterator before using it). |
|
Iterator* NewIterator(const ReadOptions&) const; |
|
|
|
// Given a key, return an approximate byte offset in the file where |
|
// the data for that key begins (or would begin if the key were |
|
// present in the file). The returned value is in terms of file |
|
// bytes, and so includes effects like compression of the underlying data. |
|
// E.g., the approximate offset of the last key in the table will |
|
// be close to the file length. |
|
uint64_t ApproximateOffsetOf(const Slice& key) const; |
|
|
|
private: |
|
struct Rep; |
|
Rep* rep_; |
|
|
|
explicit Table(Rep* rep) { rep_ = rep; } |
|
static Iterator* BlockReader(void*, const ReadOptions&, const Slice&); |
|
|
|
// Calls (*handle_result)(arg, ...) with the entry found after a call |
|
// to Seek(key). May not make such a call if filter policy says |
|
// that key is not present. |
|
friend class TableCache; |
|
Status InternalGet( |
|
const ReadOptions&, const Slice& key, |
|
void* arg, |
|
void (*handle_result)(void* arg, const Slice& k, const Slice& v)); |
|
|
|
|
|
void ReadMeta(const Footer& footer); |
|
void ReadFilter(const Slice& filter_handle_value); |
|
|
|
// No copying allowed |
|
Table(const Table&); |
|
void operator=(const Table&); |
|
}; |
|
|
|
} // namespace leveldb |
|
|
|
#endif // STORAGE_LEVELDB_INCLUDE_TABLE_H_
|
|
|