rust-librocksdb-sys 0.43.0+11.0.4

Native bindings to librocksdb
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

//  Copyright (c) Meta Platforms, Inc. and affiliates.
//  This source code is licensed under both the GPLv2 (found in the
//  COPYING file in the root directory) and Apache 2.0 License
//  (found in the LICENSE.Apache file in the root directory).

#pragma once

#include "db/multi_cf_iterator_impl.h"

namespace ROCKSDB_NAMESPACE {

class CoalescingIterator : public Iterator {
 public:
  CoalescingIterator(
      const ReadOptions& read_options, const Comparator* comparator,
      std::vector<std::pair<ColumnFamilyHandle*, std::unique_ptr<Iterator>>>&&
          cfh_iter_pairs)
      : impl_(read_options, comparator, std::move(cfh_iter_pairs),
              ResetFunc(this), PopulateFunc(this)) {}
  ~CoalescingIterator() override {}

  // No copy allowed
  CoalescingIterator(const CoalescingIterator&) = delete;
  CoalescingIterator& operator=(const CoalescingIterator&) = delete;

  bool Valid() const override { return impl_.Valid(); }
  void SeekToFirst() override { impl_.SeekToFirst(); }
  void SeekToLast() override { impl_.SeekToLast(); }
  void Seek(const Slice& target) override { impl_.Seek(target); }
  void SeekForPrev(const Slice& target) override { impl_.SeekForPrev(target); }
  void Next() override { impl_.Next(); }
  void Prev() override { impl_.Prev(); }
  Slice key() const override { return impl_.key(); }
  Status status() const override { return impl_.status(); }

  Slice value() const override {
    assert(Valid());
    return value_;
  }
  const WideColumns& columns() const override {
    assert(Valid());
    return wide_columns_;
  }

  void Reset() {
    value_.clear();
    wide_columns_.clear();
  }

  bool PrepareValue() override { return impl_.PrepareValue(); }

 private:
  class ResetFunc {
   public:
    explicit ResetFunc(CoalescingIterator* iter) : iter_(iter) {}

    void operator()() const {
      assert(iter_);
      iter_->Reset();
    }

   private:
    CoalescingIterator* iter_;
  };

  class PopulateFunc {
   public:
    explicit PopulateFunc(CoalescingIterator* iter) : iter_(iter) {}

    void operator()(const autovector<MultiCfIteratorInfo>& items) const {
      assert(iter_);
      iter_->Coalesce(items);
    }

   private:
    CoalescingIterator* iter_;
  };

  MultiCfIteratorImpl<ResetFunc, PopulateFunc> impl_;
  Slice value_;
  WideColumns wide_columns_;

  struct WideColumnWithOrder {
    const WideColumn* column;
    int order;
  };

  class WideColumnWithOrderComparator {
   public:
    explicit WideColumnWithOrderComparator() {}
    bool operator()(const WideColumnWithOrder& a,
                    const WideColumnWithOrder& b) const {
      int c = a.column->name().compare(b.column->name());
      return c == 0 ? a.order - b.order > 0 : c > 0;
    }
  };

  using MinHeap =
      BinaryHeap<WideColumnWithOrder, WideColumnWithOrderComparator>;

  void Coalesce(const autovector<MultiCfIteratorInfo>& items);
};

}  // namespace ROCKSDB_NAMESPACE