Line data    Source code

       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       37176 :   void Ref() { ++refs_; }
      28             : 
      29             :   // Drop reference count.  Delete if no more references exist.
      30       37176 :   void Unref() {
      31       37176 :     --refs_;
      32       37176 :     assert(refs_ >= 0);
      33       37176 :     if (refs_ <= 0) {
      34         359 :       delete this;
      35             :     }
      36       37176 :   }
      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        2872 :   struct KeyComparator {
      70             :     const InternalKeyComparator comparator;
      71         359 :     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_