ob_memtable.h

/* Copyright (c) 2021 OceanBase and/or its affiliates. All rights reserved.
miniob is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
         http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details. */
 
#pragma once
 
#include "common/sys/rc.h"
#include "common/lang/string.h"
#include "common/lang/string_view.h"
#include "common/lang/memory.h"
#include "oblsm/memtable/ob_skiplist.h"
#include "oblsm/util/ob_comparator.h"
#include "oblsm/util/ob_arena.h"
#include "oblsm/include/ob_lsm_iterator.h"
 
namespace oceanbase {
 
class ObMemTable : public enable_shared_from_this<ObMemTable>
{
public:
  ObMemTable() : comparator_(), table_(comparator_){};
 
  ~ObMemTable() = default;
 
  shared_ptr<ObMemTable> get_shared_ptr() { return shared_from_this(); }
 
  void put(uint64_t seq, const string_view &key, const string_view &value);
 
  size_t appro_memory_usage() const { return arena_.memory_usage(); }
 
  ObLsmIterator *new_iterator();
 
private:
  friend class ObMemTableIterator;
  struct KeyComparator
  {
    const ObInternalKeyComparator comparator;
    explicit KeyComparator() {}
    int operator()(const char *a, const char *b) const;
  };
 
  // TODO: currently the memtable use skiplist as the underlying data structure,
  // it is possible to use other data structure, for example, hash table.
  typedef ObSkipList<const char *, KeyComparator> Table;
 
  KeyComparator comparator_;
 
  Table table_;
 
  ObArena arena_;
};
 
class ObMemTableIterator : public ObLsmIterator
{
public:
  explicit ObMemTableIterator(shared_ptr<ObMemTable> mem, ObMemTable::Table *table) : mem_(mem), iter_(table) {}
 
  ObMemTableIterator(const ObMemTableIterator &)            = delete;
  ObMemTableIterator &operator=(const ObMemTableIterator &) = delete;
 
  ~ObMemTableIterator() override = default;
 
  void seek(const string_view &k) override;
  void seek_to_first() override { iter_.seek_to_first(); }
  void seek_to_last() override { iter_.seek_to_last(); }
 
  bool        valid() const override { return iter_.valid(); }
  void        next() override { iter_.next(); }
  string_view key() const override;
  string_view value() const override;
 
private:
  shared_ptr<ObMemTable>      mem_;
  ObMemTable::Table::Iterator iter_;
  string                      tmp_;  // For seek key
};
 
}  // namespace oceanbase