0014-sql-make-VirtualCursor-standard-layout-type.patch 9.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244
  1. From 6444f8022d02a946a654b5456170ab1343e20e1d Mon Sep 17 00:00:00 2001
  2. From: Stephan Hartmann <stha09@googlemail.com>
  3. Date: Fri, 29 Jul 2022 05:08:08 +0000
  4. Subject: [PATCH 14/68] sql: make VirtualCursor standard layout type
  5. sql::recover::VirtualCursor needs to be a standard layout type, but
  6. has members of type std::unique_ptr. However, std::unique_ptr is not
  7. guaranteed to be standard layout. Compiling with clang combined with
  8. gcc-11 libstdc++ fails because of this. Replace std::unique_ptr with
  9. raw pointers.
  10. Bug: 1189788
  11. Change-Id: Ia6dc388cc5ef1c0f2afc75f8ca45b9f12687ca9c
  12. Signed-off-by: Stephan Hartmann <stha09@googlemail.com>
  13. Signed-off-by: Rebecca Chang Swee Fun <rebecca.chang@starfivetech.com>
  14. ---
  15. sql/recover_module/btree.cc | 21 +++++++++++++++------
  16. sql/recover_module/btree.h | 17 +++++++++++++----
  17. sql/recover_module/cursor.cc | 24 ++++++++++++------------
  18. sql/recover_module/cursor.h | 2 +-
  19. sql/recover_module/pager.cc | 7 +++----
  20. sql/recover_module/pager.h | 5 +++--
  21. 6 files changed, 47 insertions(+), 29 deletions(-)
  22. diff --git a/sql/recover_module/btree.cc b/sql/recover_module/btree.cc
  23. index cc9420e5c05c..62fcaaf79edc 100644
  24. --- a/sql/recover_module/btree.cc
  25. +++ b/sql/recover_module/btree.cc
  26. @@ -136,16 +136,25 @@ static_assert(std::is_trivially_destructible<LeafPageDecoder>::value,
  27. "Move the destructor to the .cc file if it's non-trival");
  28. #endif // !DCHECK_IS_ON()
  29. -LeafPageDecoder::LeafPageDecoder(DatabasePageReader* db_reader) noexcept
  30. - : page_id_(db_reader->page_id()),
  31. - db_reader_(db_reader),
  32. - cell_count_(ComputeCellCount(db_reader)),
  33. - next_read_index_(0),
  34. - last_record_size_(0) {
  35. +void LeafPageDecoder::Initialize(DatabasePageReader* db_reader) {
  36. + DCHECK(db_reader);
  37. DCHECK(IsOnValidPage(db_reader));
  38. + page_id_ = db_reader->page_id();
  39. + db_reader_ = db_reader;
  40. + cell_count_ = ComputeCellCount(db_reader);
  41. + next_read_index_ = 0;
  42. + last_record_size_ = 0;
  43. DCHECK(DatabasePageReader::IsValidPageId(page_id_));
  44. }
  45. +void LeafPageDecoder::Reset() {
  46. + db_reader_ = nullptr;
  47. + page_id_ = 0;
  48. + cell_count_ = 0;
  49. + next_read_index_ = 0;
  50. + last_record_size_ = 0;
  51. +}
  52. +
  53. bool LeafPageDecoder::TryAdvance() {
  54. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  55. DCHECK(CanAdvance());
  56. diff --git a/sql/recover_module/btree.h b/sql/recover_module/btree.h
  57. index eaa087a5c52b..78ce00e057c4 100644
  58. --- a/sql/recover_module/btree.h
  59. +++ b/sql/recover_module/btree.h
  60. @@ -103,7 +103,7 @@ class LeafPageDecoder {
  61. //
  62. // |db_reader| must have been used to read an inner page of a table B-tree.
  63. // |db_reader| must outlive this instance.
  64. - explicit LeafPageDecoder(DatabasePageReader* db_reader) noexcept;
  65. + explicit LeafPageDecoder() noexcept = default;
  66. ~LeafPageDecoder() noexcept = default;
  67. LeafPageDecoder(const LeafPageDecoder&) = delete;
  68. @@ -151,6 +151,15 @@ class LeafPageDecoder {
  69. // read as long as CanAdvance() returns true.
  70. bool TryAdvance();
  71. + // Initialize with DatabasePageReader
  72. + void Initialize(DatabasePageReader* db_reader);
  73. +
  74. + // Reset internal DatabasePageReader
  75. + void Reset();
  76. +
  77. + // True if DatabasePageReader is valid
  78. + bool IsValid() { return (db_reader_ != nullptr); }
  79. +
  80. // True if the given reader may point to an inner page in a table B-tree.
  81. //
  82. // The last ReadPage() call on |db_reader| must have succeeded.
  83. @@ -164,14 +173,14 @@ class LeafPageDecoder {
  84. static int ComputeCellCount(DatabasePageReader* db_reader);
  85. // The number of the B-tree page this reader is reading.
  86. - const int64_t page_id_;
  87. + int64_t page_id_;
  88. // Used to read the tree page.
  89. //
  90. // Raw pointer usage is acceptable because this instance's owner is expected
  91. // to ensure that the DatabasePageReader outlives this.
  92. - DatabasePageReader* const db_reader_;
  93. + DatabasePageReader* db_reader_;
  94. // Caches the ComputeCellCount() value for this reader's page.
  95. - const int cell_count_ = ComputeCellCount(db_reader_);
  96. + int cell_count_;
  97. // The reader's cursor state.
  98. //
  99. diff --git a/sql/recover_module/cursor.cc b/sql/recover_module/cursor.cc
  100. index 4f827edf1b44..240de4999fe5 100644
  101. --- a/sql/recover_module/cursor.cc
  102. +++ b/sql/recover_module/cursor.cc
  103. @@ -28,7 +28,7 @@ VirtualCursor::~VirtualCursor() {
  104. int VirtualCursor::First() {
  105. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  106. inner_decoders_.clear();
  107. - leaf_decoder_ = nullptr;
  108. + leaf_decoder_.Reset();
  109. AppendPageDecoder(table_->root_page_id());
  110. return Next();
  111. @@ -38,18 +38,18 @@ int VirtualCursor::Next() {
  112. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  113. record_reader_.Reset();
  114. - while (!inner_decoders_.empty() || leaf_decoder_.get()) {
  115. - if (leaf_decoder_.get()) {
  116. - if (!leaf_decoder_->CanAdvance()) {
  117. + while (!inner_decoders_.empty() || leaf_decoder_.IsValid()) {
  118. + if (leaf_decoder_.IsValid()) {
  119. + if (!leaf_decoder_.CanAdvance()) {
  120. // The leaf has been exhausted. Remove it from the DFS stack.
  121. - leaf_decoder_ = nullptr;
  122. + leaf_decoder_.Reset();
  123. continue;
  124. }
  125. - if (!leaf_decoder_->TryAdvance())
  126. + if (!leaf_decoder_.TryAdvance())
  127. continue;
  128. - if (!payload_reader_.Initialize(leaf_decoder_->last_record_size(),
  129. - leaf_decoder_->last_record_offset())) {
  130. + if (!payload_reader_.Initialize(leaf_decoder_.last_record_size(),
  131. + leaf_decoder_.last_record_offset())) {
  132. continue;
  133. }
  134. if (!record_reader_.Initialize())
  135. @@ -101,13 +101,13 @@ int VirtualCursor::ReadColumn(int column_index,
  136. int64_t VirtualCursor::RowId() {
  137. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  138. DCHECK(record_reader_.IsInitialized());
  139. - DCHECK(leaf_decoder_.get());
  140. - return leaf_decoder_->last_record_rowid();
  141. + DCHECK(leaf_decoder_.IsValid());
  142. + return leaf_decoder_.last_record_rowid();
  143. }
  144. void VirtualCursor::AppendPageDecoder(int page_id) {
  145. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  146. - DCHECK(leaf_decoder_.get() == nullptr)
  147. + DCHECK(!leaf_decoder_.IsValid())
  148. << __func__
  149. << " must only be called when the current path has no leaf decoder";
  150. @@ -115,7 +115,7 @@ void VirtualCursor::AppendPageDecoder(int page_id) {
  151. return;
  152. if (LeafPageDecoder::IsOnValidPage(&db_reader_)) {
  153. - leaf_decoder_ = std::make_unique<LeafPageDecoder>(&db_reader_);
  154. + leaf_decoder_.Initialize(&db_reader_);
  155. return;
  156. }
  157. diff --git a/sql/recover_module/cursor.h b/sql/recover_module/cursor.h
  158. index 845b7852648d..cc4e85f83f95 100644
  159. --- a/sql/recover_module/cursor.h
  160. +++ b/sql/recover_module/cursor.h
  161. @@ -130,7 +130,7 @@ class VirtualCursor {
  162. std::vector<std::unique_ptr<InnerPageDecoder>> inner_decoders_;
  163. // Decodes the leaf page containing records.
  164. - std::unique_ptr<LeafPageDecoder> leaf_decoder_;
  165. + LeafPageDecoder leaf_decoder_;
  166. SEQUENCE_CHECKER(sequence_checker_);
  167. };
  168. diff --git a/sql/recover_module/pager.cc b/sql/recover_module/pager.cc
  169. index 58e75de27042..5fe96204e56b 100644
  170. --- a/sql/recover_module/pager.cc
  171. +++ b/sql/recover_module/pager.cc
  172. @@ -23,8 +23,7 @@ static_assert(DatabasePageReader::kMaxPageId <= std::numeric_limits<int>::max(),
  173. "ints are not appropriate for representing page IDs");
  174. DatabasePageReader::DatabasePageReader(VirtualTable* table)
  175. - : page_data_(std::make_unique<uint8_t[]>(table->page_size())),
  176. - table_(table) {
  177. + : page_data_(), table_(table) {
  178. DCHECK(table != nullptr);
  179. DCHECK(IsValidPageSize(table->page_size()));
  180. }
  181. @@ -57,8 +56,8 @@ int DatabasePageReader::ReadPage(int page_id) {
  182. std::numeric_limits<int64_t>::max(),
  183. "The |read_offset| computation above may overflow");
  184. - int sqlite_status =
  185. - RawRead(sqlite_file, read_size, read_offset, page_data_.get());
  186. + int sqlite_status = RawRead(sqlite_file, read_size, read_offset,
  187. + const_cast<uint8_t*>(page_data_.data()));
  188. // |page_id_| needs to be set to kInvalidPageId if the read failed.
  189. // Otherwise, future ReadPage() calls with the previous |page_id_| value
  190. diff --git a/sql/recover_module/pager.h b/sql/recover_module/pager.h
  191. index 07cac3cb9891..646e0223fd78 100644
  192. --- a/sql/recover_module/pager.h
  193. +++ b/sql/recover_module/pager.h
  194. @@ -5,6 +5,7 @@
  195. #ifndef SQL_RECOVER_MODULE_PAGER_H_
  196. #define SQL_RECOVER_MODULE_PAGER_H_
  197. +#include <array>
  198. #include <cstdint>
  199. #include <memory>
  200. #include <ostream>
  201. @@ -72,7 +73,7 @@ class DatabasePageReader {
  202. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  203. DCHECK_NE(page_id_, kInvalidPageId)
  204. << "Successful ReadPage() required before accessing pager state";
  205. - return page_data_.get();
  206. + return page_data_.data();
  207. }
  208. // The number of bytes in the page read by the last ReadPage() call.
  209. @@ -139,7 +140,7 @@ class DatabasePageReader {
  210. int page_id_ = kInvalidPageId;
  211. // Stores the bytes of the last page successfully read by ReadPage().
  212. // The content is undefined if the last call to ReadPage() did not succeed.
  213. - const std::unique_ptr<uint8_t[]> page_data_;
  214. + const std::array<uint8_t, kMaxPageSize> page_data_;
  215. // Raw pointer usage is acceptable because this instance's owner is expected
  216. // to ensure that the VirtualTable outlives this.
  217. const raw_ptr<VirtualTable> table_;
  218. --
  219. 2.30.2