src/leveldb/include/leveldb/table.h

   1 // Copyright (c) 2011 The LevelDB Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file. See the AUTHORS file for names of contributors.
   4
   5 #ifndef STORAGE_LEVELDB_INCLUDE_TABLE_H_
   6 #define STORAGE_LEVELDB_INCLUDE_TABLE_H_
   7
   8 #include <stdint.h>
   9 #include "leveldb/iterator.h"
  10
  11 namespace leveldb {
  12
  13 class Block;
  14 class BlockHandle;
  15 class Footer;
  16 struct Options;
  17 class RandomAccessFile;
  18 struct ReadOptions;
  19 class TableCache;
  20
  21 // A Table is a sorted map from strings to strings.  Tables are
  22 // immutable and persistent.  A Table may be safely accessed from
  23 // multiple threads without external synchronization.
  24 class Table {
  25  public:
  26   // Attempt to open the table that is stored in bytes [0..file_size)
  27   // of "file", and read the metadata entries necessary to allow
  28   // retrieving data from the table.
  29   //
  30   // If successful, returns ok and sets "*table" to the newly opened
  31   // table.  The client should delete "*table" when no longer needed.
  32   // If there was an error while initializing the table, sets "*table"
  33   // to NULL and returns a non-ok status.  Does not take ownership of
  34   // "*source", but the client must ensure that "source" remains live
  35   // for the duration of the returned table's lifetime.
  36   //
  37   // *file must remain live while this Table is in use.
  38   static Status Open(const Options& options,
  39                      RandomAccessFile* file,
  40                      uint64_t file_size,
  41                      Table** table);
  42
  43   ~Table();
  44
  45   // Returns a new iterator over the table contents.
  46   // The result of NewIterator() is initially invalid (caller must
  47   // call one of the Seek methods on the iterator before using it).
  48   Iterator* NewIterator(const ReadOptions&) const;
  49
  50   // Given a key, return an approximate byte offset in the file where
  51   // the data for that key begins (or would begin if the key were
  52   // present in the file).  The returned value is in terms of file
  53   // bytes, and so includes effects like compression of the underlying data.
  54   // E.g., the approximate offset of the last key in the table will
  55   // be close to the file length.
  56   uint64_t ApproximateOffsetOf(const Slice& key) const;
  57
  58  private:
  59   struct Rep;
  60   Rep* rep_;
  61
  62   explicit Table(Rep* rep) { rep_ = rep; }
  63   static Iterator* BlockReader(void*, const ReadOptions&, const Slice&);
  64
  65   // Calls (*handle_result)(arg, ...) with the entry found after a call
  66   // to Seek(key).  May not make such a call if filter policy says
  67   // that key is not present.
  68   friend class TableCache;
  69   Status InternalGet(
  70       const ReadOptions&, const Slice& key,
  71       void* arg,
  72       void (*handle_result)(void* arg, const Slice& k, const Slice& v));
  73
  74
  75   void ReadMeta(const Footer& footer);
  76   void ReadFilter(const Slice& filter_handle_value);
  77
  78   // No copying allowed
  79   Table(const Table&);
  80   void operator=(const Table&);
  81 };
  82
  83 }  // namespace leveldb
  84
  85 #endif  // STORAGE_LEVELDB_INCLUDE_TABLE_H_