src/leveldb/db/memtable.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_DB_MEMTABLE_H_
   6 #define STORAGE_LEVELDB_DB_MEMTABLE_H_
   7
   8 #include <string>
   9 #include "leveldb/db.h"
  10 #include "db/dbformat.h"
  11 #include "db/skiplist.h"
  12 #include "util/arena.h"
  13
  14 namespace leveldb {
  15
  16 class InternalKeyComparator;
  17 class Mutex;
  18 class MemTableIterator;
  19
  20 class MemTable {
  21  public:
  22   // MemTables are reference counted.  The initial reference count
  23   // is zero and the caller must call Ref() at least once.
  24   explicit MemTable(const InternalKeyComparator& comparator);
  25
  26   // Increase reference count.
  27   void Ref() { ++refs_; }
  28
  29   // Drop reference count.  Delete if no more references exist.
  30   void Unref() {
  31     --refs_;
  32     assert(refs_ >= 0);
  33     if (refs_ <= 0) {
  34       delete this;
  35     }
  36   }
  37
  38   // Returns an estimate of the number of bytes of data in use by this
  39   // data structure.
  40   //
  41   // REQUIRES: external synchronization to prevent simultaneous
  42   // operations on the same MemTable.
  43   size_t ApproximateMemoryUsage();
  44
  45   // Return an iterator that yields the contents of the memtable.
  46   //
  47   // The caller must ensure that the underlying MemTable remains live
  48   // while the returned iterator is live.  The keys returned by this
  49   // iterator are internal keys encoded by AppendInternalKey in the
  50   // db/format.{h,cc} module.
  51   Iterator* NewIterator();
  52
  53   // Add an entry into memtable that maps key to value at the
  54   // specified sequence number and with the specified type.
  55   // Typically value will be empty if type==kTypeDeletion.
  56   void Add(SequenceNumber seq, ValueType type,
  57            const Slice& key,
  58            const Slice& value);
  59
  60   // If memtable contains a value for key, store it in *value and return true.
  61   // If memtable contains a deletion for key, store a NotFound() error
  62   // in *status and return true.
  63   // Else, return false.
  64   bool Get(const LookupKey& key, std::string* value, Status* s);
  65
  66  private:
  67   ~MemTable();  // Private since only Unref() should be used to delete it
  68
  69   struct KeyComparator {
  70     const InternalKeyComparator comparator;
  71     explicit KeyComparator(const InternalKeyComparator& c) : comparator(c) { }
  72     int operator()(const char* a, const char* b) const;
  73   };
  74   friend class MemTableIterator;
  75   friend class MemTableBackwardIterator;
  76
  77   typedef SkipList<const char*, KeyComparator> Table;
  78
  79   KeyComparator comparator_;
  80   int refs_;
  81   Arena arena_;
  82   Table table_;
  83
  84   // No copying allowed
  85   MemTable(const MemTable&);
  86   void operator=(const MemTable&);
  87 };
  88
  89 }  // namespace leveldb
  90
  91 #endif  // STORAGE_LEVELDB_DB_MEMTABLE_H_