1 diff --git a/sql/recover_module/btree.cc b/sql/recover_module/btree.cc
2 index 9ecaafe..839318a 100644
3 --- a/sql/recover_module/btree.cc
4 +++ b/sql/recover_module/btree.cc
5 @@ -135,16 +135,25 @@ static_assert(std::is_trivially_destructible<LeafPageDecoder>::value,
6 "Move the destructor to the .cc file if it's non-trival");
7 #endif // !DCHECK_IS_ON()
9 -LeafPageDecoder::LeafPageDecoder(DatabasePageReader* db_reader) noexcept
10 - : page_id_(db_reader->page_id()),
11 - db_reader_(db_reader),
12 - cell_count_(ComputeCellCount(db_reader)),
13 - next_read_index_(0),
14 - last_record_size_(0) {
15 +void LeafPageDecoder::Initialize(DatabasePageReader* db_reader) {
17 DCHECK(IsOnValidPage(db_reader));
18 + page_id_ = db_reader->page_id();
19 + db_reader_ = db_reader;
20 + cell_count_ = ComputeCellCount(db_reader);
21 + next_read_index_ = 0;
22 + last_record_size_ = 0;
23 DCHECK(DatabasePageReader::IsValidPageId(page_id_));
26 +void LeafPageDecoder::Reset() {
27 + db_reader_ = nullptr;
30 + next_read_index_ = 0;
31 + last_record_size_ = 0;
34 bool LeafPageDecoder::TryAdvance() {
35 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
37 diff --git a/sql/recover_module/btree.h b/sql/recover_module/btree.h
38 index d76d076..33114b0 100644
39 --- a/sql/recover_module/btree.h
40 +++ b/sql/recover_module/btree.h
41 @@ -102,7 +102,7 @@ class LeafPageDecoder {
43 // |db_reader| must have been used to read an inner page of a table B-tree.
44 // |db_reader| must outlive this instance.
45 - explicit LeafPageDecoder(DatabasePageReader* db_reader) noexcept;
46 + explicit LeafPageDecoder() noexcept = default;
47 ~LeafPageDecoder() noexcept = default;
49 LeafPageDecoder(const LeafPageDecoder&) = delete;
50 @@ -150,6 +150,15 @@ class LeafPageDecoder {
51 // read as long as CanAdvance() returns true.
54 + // Initialize with DatabasePageReader
55 + void Initialize(DatabasePageReader* db_reader);
57 + // Reset internal DatabasePageReader
60 + // True if DatabasePageReader is valid
61 + bool IsValid() { return (db_reader_ != nullptr); }
63 // True if the given reader may point to an inner page in a table B-tree.
65 // The last ReadPage() call on |db_reader| must have succeeded.
66 @@ -163,14 +172,14 @@ class LeafPageDecoder {
67 static int ComputeCellCount(DatabasePageReader* db_reader);
69 // The number of the B-tree page this reader is reading.
70 - const int64_t page_id_;
72 // Used to read the tree page.
74 // Raw pointer usage is acceptable because this instance's owner is expected
75 // to ensure that the DatabasePageReader outlives this.
76 - DatabasePageReader* const db_reader_;
77 + DatabasePageReader* db_reader_;
78 // Caches the ComputeCellCount() value for this reader's page.
79 - const int cell_count_ = ComputeCellCount(db_reader_);
82 // The reader's cursor state.
84 diff --git a/sql/recover_module/cursor.cc b/sql/recover_module/cursor.cc
85 index 0029ff9..42548bc 100644
86 --- a/sql/recover_module/cursor.cc
87 +++ b/sql/recover_module/cursor.cc
88 @@ -26,7 +26,7 @@ VirtualCursor::~VirtualCursor() {
89 int VirtualCursor::First() {
90 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
91 inner_decoders_.clear();
92 - leaf_decoder_ = nullptr;
93 + leaf_decoder_.Reset();
95 AppendPageDecoder(table_->root_page_id());
97 @@ -36,18 +36,18 @@ int VirtualCursor::Next() {
98 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
99 record_reader_.Reset();
101 - while (!inner_decoders_.empty() || leaf_decoder_.get()) {
102 - if (leaf_decoder_.get()) {
103 - if (!leaf_decoder_->CanAdvance()) {
104 + while (!inner_decoders_.empty() || leaf_decoder_.IsValid()) {
105 + if (leaf_decoder_.IsValid()) {
106 + if (!leaf_decoder_.CanAdvance()) {
107 // The leaf has been exhausted. Remove it from the DFS stack.
108 - leaf_decoder_ = nullptr;
109 + leaf_decoder_.Reset();
112 - if (!leaf_decoder_->TryAdvance())
113 + if (!leaf_decoder_.TryAdvance())
116 - if (!payload_reader_.Initialize(leaf_decoder_->last_record_size(),
117 - leaf_decoder_->last_record_offset())) {
118 + if (!payload_reader_.Initialize(leaf_decoder_.last_record_size(),
119 + leaf_decoder_.last_record_offset())) {
122 if (!record_reader_.Initialize())
123 @@ -99,13 +99,13 @@ int VirtualCursor::ReadColumn(int column_index,
124 int64_t VirtualCursor::RowId() {
125 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
126 DCHECK(record_reader_.IsInitialized());
127 - DCHECK(leaf_decoder_.get());
128 - return leaf_decoder_->last_record_rowid();
129 + DCHECK(leaf_decoder_.IsValid());
130 + return leaf_decoder_.last_record_rowid();
133 void VirtualCursor::AppendPageDecoder(int page_id) {
134 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
135 - DCHECK(leaf_decoder_.get() == nullptr)
136 + DCHECK(!leaf_decoder_.IsValid())
138 << " must only be called when the current path has no leaf decoder";
140 @@ -113,7 +113,7 @@ void VirtualCursor::AppendPageDecoder(int page_id) {
143 if (LeafPageDecoder::IsOnValidPage(&db_reader_)) {
144 - leaf_decoder_ = std::make_unique<LeafPageDecoder>(&db_reader_);
145 + leaf_decoder_.Initialize(&db_reader_);
149 diff --git a/sql/recover_module/cursor.h b/sql/recover_module/cursor.h
150 index afcd690..b15c31d 100644
151 --- a/sql/recover_module/cursor.h
152 +++ b/sql/recover_module/cursor.h
153 @@ -129,7 +129,7 @@ class VirtualCursor {
154 std::vector<std::unique_ptr<InnerPageDecoder>> inner_decoders_;
156 // Decodes the leaf page containing records.
157 - std::unique_ptr<LeafPageDecoder> leaf_decoder_;
158 + LeafPageDecoder leaf_decoder_;
160 SEQUENCE_CHECKER(sequence_checker_);
162 diff --git a/sql/recover_module/pager.cc b/sql/recover_module/pager.cc
163 index 58e75de..5fe9620 100644
164 --- a/sql/recover_module/pager.cc
165 +++ b/sql/recover_module/pager.cc
166 @@ -23,8 +23,7 @@ static_assert(DatabasePageReader::kMaxPageId <= std::numeric_limits<int>::max(),
167 "ints are not appropriate for representing page IDs");
169 DatabasePageReader::DatabasePageReader(VirtualTable* table)
170 - : page_data_(std::make_unique<uint8_t[]>(table->page_size())),
172 + : page_data_(), table_(table) {
173 DCHECK(table != nullptr);
174 DCHECK(IsValidPageSize(table->page_size()));
176 @@ -57,8 +56,8 @@ int DatabasePageReader::ReadPage(int page_id) {
177 std::numeric_limits<int64_t>::max(),
178 "The |read_offset| computation above may overflow");
180 - int sqlite_status =
181 - RawRead(sqlite_file, read_size, read_offset, page_data_.get());
182 + int sqlite_status = RawRead(sqlite_file, read_size, read_offset,
183 + const_cast<uint8_t*>(page_data_.data()));
185 // |page_id_| needs to be set to kInvalidPageId if the read failed.
186 // Otherwise, future ReadPage() calls with the previous |page_id_| value
187 diff --git a/sql/recover_module/pager.h b/sql/recover_module/pager.h
188 index 0e388dd..99314e3 100644
189 --- a/sql/recover_module/pager.h
190 +++ b/sql/recover_module/pager.h
192 #ifndef SQL_RECOVER_MODULE_PAGER_H_
193 #define SQL_RECOVER_MODULE_PAGER_H_
199 @@ -70,7 +71,7 @@ class DatabasePageReader {
200 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
201 DCHECK_NE(page_id_, kInvalidPageId)
202 << "Successful ReadPage() required before accessing pager state";
203 - return page_data_.get();
204 + return page_data_.data();
207 // The number of bytes in the page read by the last ReadPage() call.
208 @@ -137,7 +138,7 @@ class DatabasePageReader {
209 int page_id_ = kInvalidPageId;
210 // Stores the bytes of the last page successfully read by ReadPage().
211 // The content is undefined if the last call to ReadPage() did not succeed.
212 - const std::unique_ptr<uint8_t[]> page_data_;
213 + const std::array<uint8_t, kMaxPageSize> page_data_;
214 // Raw pointer usage is acceptable because this instance's owner is expected
215 // to ensure that the VirtualTable outlives this.
216 VirtualTable* const table_;