/bitcoin/src/leveldb/db/version_edit.cc

Source
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file. See the AUTHORS file for names of contributors.

#include "db/version_edit.h"

#include "db/version_set.h"
#include "util/coding.h"

namespace leveldb {

// Tag numbers for serialized VersionEdit.  These numbers are written to
// disk and should not be changed.
enum Tag {
  kComparator = 1,
  kLogNumber = 2,
  kNextFileNumber = 3,
  kLastSequence = 4,
  kCompactPointer = 5,
  kDeletedFile = 6,
  kNewFile = 7,
  // 8 was used for large value refs
  kPrevLogNumber = 9
};

void VersionEdit::Clear() {
  comparator_.clear();
  log_number_ = 0;
  prev_log_number_ = 0;
  last_sequence_ = 0;
  next_file_number_ = 0;
  has_comparator_ = false;
  has_log_number_ = false;
  has_prev_log_number_ = false;
  has_next_file_number_ = false;
  has_last_sequence_ = false;
  deleted_files_.clear();
  new_files_.clear();
}

void VersionEdit::EncodeTo(std::string* dst) const {
  if (has_comparator_) {
    PutVarint32(dst, kComparator);
    PutLengthPrefixedSlice(dst, comparator_);
  }
  if (has_log_number_) {
    PutVarint32(dst, kLogNumber);
    PutVarint64(dst, log_number_);
  }
  if (has_prev_log_number_) {
    PutVarint32(dst, kPrevLogNumber);
    PutVarint64(dst, prev_log_number_);
  }
  if (has_next_file_number_) {
    PutVarint32(dst, kNextFileNumber);
    PutVarint64(dst, next_file_number_);
  }
  if (has_last_sequence_) {
    PutVarint32(dst, kLastSequence);
    PutVarint64(dst, last_sequence_);
  }

  for (size_t i = 0; i < compact_pointers_.size(); i++) {
    PutVarint32(dst, kCompactPointer);
    PutVarint32(dst, compact_pointers_[i].first);  // level
    PutLengthPrefixedSlice(dst, compact_pointers_[i].second.Encode());
  }

  for (const auto& deleted_file_kvp : deleted_files_) {
    PutVarint32(dst, kDeletedFile);
    PutVarint32(dst, deleted_file_kvp.first);   // level
    PutVarint64(dst, deleted_file_kvp.second);  // file number
  }

  for (size_t i = 0; i < new_files_.size(); i++) {
    const FileMetaData& f = new_files_[i].second;
    PutVarint32(dst, kNewFile);
    PutVarint32(dst, new_files_[i].first);  // level
    PutVarint64(dst, f.number);
    PutVarint64(dst, f.file_size);
    PutLengthPrefixedSlice(dst, f.smallest.Encode());
    PutLengthPrefixedSlice(dst, f.largest.Encode());
  }
}

static bool GetInternalKey(Slice* input, InternalKey* dst) {
  Slice str;
  if (GetLengthPrefixedSlice(input, &str)) {
    return dst->DecodeFrom(str);
  } else {
    return false;
  }
}

static bool GetLevel(Slice* input, int* level) {
  uint32_t v;
  if (GetVarint32(input, &v) && v < config::kNumLevels) {
    *level = v;
    return true;
  } else {
    return false;
  }
}

Status VersionEdit::DecodeFrom(const Slice& src) {
  Clear();
  Slice input = src;
  const char* msg = nullptr;
  uint32_t tag;

  // Temporary storage for parsing
  int level;
  uint64_t number;
  FileMetaData f;
  Slice str;
  InternalKey key;

  while (msg == nullptr && GetVarint32(&input, &tag)) {
    switch (tag) {
      case kComparator:
        if (GetLengthPrefixedSlice(&input, &str)) {
          comparator_ = str.ToString();
          has_comparator_ = true;
        } else {
          msg = "comparator name";
        }
        break;

      case kLogNumber:
        if (GetVarint64(&input, &log_number_)) {
          has_log_number_ = true;
        } else {
          msg = "log number";
        }
        break;

      case kPrevLogNumber:
        if (GetVarint64(&input, &prev_log_number_)) {
          has_prev_log_number_ = true;
        } else {
          msg = "previous log number";
        }
        break;

      case kNextFileNumber:
        if (GetVarint64(&input, &next_file_number_)) {
          has_next_file_number_ = true;
        } else {
          msg = "next file number";
        }
        break;

      case kLastSequence:
        if (GetVarint64(&input, &last_sequence_)) {
          has_last_sequence_ = true;
        } else {
          msg = "last sequence number";
        }
        break;

      case kCompactPointer:
        if (GetLevel(&input, &level) && GetInternalKey(&input, &key)) {
          compact_pointers_.push_back(std::make_pair(level, key));
        } else {
          msg = "compaction pointer";
        }
        break;

      case kDeletedFile:
        if (GetLevel(&input, &level) && GetVarint64(&input, &number)) {
          deleted_files_.insert(std::make_pair(level, number));
        } else {
          msg = "deleted file";
        }
        break;

      case kNewFile:
        if (GetLevel(&input, &level) && GetVarint64(&input, &f.number) &&
            GetVarint64(&input, &f.file_size) &&
            GetInternalKey(&input, &f.smallest) &&
            GetInternalKey(&input, &f.largest)) {
          new_files_.push_back(std::make_pair(level, f));
        } else {
          msg = "new-file entry";
        }
        break;

      default:
        msg = "unknown tag";
        break;
    }
  }

  if (msg == nullptr && !input.empty()) {
    msg = "invalid tag";
  }

  Status result;
  if (msg != nullptr) {
    result = Status::Corruption("VersionEdit", msg);
  }
  return result;
}

std::string VersionEdit::DebugString() const {
  std::string r;
  r.append("VersionEdit {");
  if (has_comparator_) {
    r.append("\n  Comparator: ");
    r.append(comparator_);
  }
  if (has_log_number_) {
    r.append("\n  LogNumber: ");
    AppendNumberTo(&r, log_number_);
  }
  if (has_prev_log_number_) {
    r.append("\n  PrevLogNumber: ");
    AppendNumberTo(&r, prev_log_number_);
  }
  if (has_next_file_number_) {
    r.append("\n  NextFile: ");
    AppendNumberTo(&r, next_file_number_);
  }
  if (has_last_sequence_) {
    r.append("\n  LastSeq: ");
    AppendNumberTo(&r, last_sequence_);
  }
  for (size_t i = 0; i < compact_pointers_.size(); i++) {
    r.append("\n  CompactPointer: ");
    AppendNumberTo(&r, compact_pointers_[i].first);
    r.append(" ");
    r.append(compact_pointers_[i].second.DebugString());
  }
  for (const auto& deleted_files_kvp : deleted_files_) {
    r.append("\n  DeleteFile: ");
    AppendNumberTo(&r, deleted_files_kvp.first);
    r.append(" ");
    AppendNumberTo(&r, deleted_files_kvp.second);
  }
  for (size_t i = 0; i < new_files_.size(); i++) {
    const FileMetaData& f = new_files_[i].second;
    r.append("\n  AddFile: ");
    AppendNumberTo(&r, new_files_[i].first);
    r.append(" ");
    AppendNumberTo(&r, f.number);
    r.append(" ");
    AppendNumberTo(&r, f.file_size);
    r.append(" ");
    r.append(f.smallest.DebugString());
    r.append(" .. ");
    r.append(f.largest.DebugString());
  }
  r.append("\n}\n");
  return r;
}

}  // namespace leveldb

Coverage Report

Created: 2025-06-10 13:21

Line	Count	Source
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		#include "db/version_edit.h"
6
7		#include "db/version_set.h"
8		#include "util/coding.h"
9
10		namespace leveldb {
11
12		// Tag numbers for serialized VersionEdit. These numbers are written to
13		// disk and should not be changed.
14		enum Tag {
15		kComparator = 1,
16		kLogNumber = 2,
17		kNextFileNumber = 3,
18		kLastSequence = 4,
19		kCompactPointer = 5,
20		kDeletedFile = 6,
21		kNewFile = 7,
22		// 8 was used for large value refs
23		kPrevLogNumber = 9
24		};
25
26	166k	void VersionEdit::Clear() {
27	166k	comparator_.clear();
28	166k	log_number_ = 0;
29	166k	prev_log_number_ = 0;
30	166k	last_sequence_ = 0;
31	166k	next_file_number_ = 0;
32	166k	has_comparator_ = false;
33	166k	has_log_number_ = false;
34	166k	has_prev_log_number_ = false;
35	166k	has_next_file_number_ = false;
36	166k	has_last_sequence_ = false;
37	166k	deleted_files_.clear();
38	166k	new_files_.clear();
39	166k	}
40
41	99.8k	void VersionEdit::EncodeTo(std::string* dst) const {
42	99.8k	if (has_comparator_) { Branch (42:7): [True: 66.5k, False: 33.3k]
43	66.5k	PutVarint32(dst, kComparator);
44	66.5k	PutLengthPrefixedSlice(dst, comparator_);
45	66.5k	}
46	99.8k	if (has_log_number_) { Branch (46:7): [True: 66.5k, False: 33.2k]
47	66.5k	PutVarint32(dst, kLogNumber);
48	66.5k	PutVarint64(dst, log_number_);
49	66.5k	}
50	99.8k	if (has_prev_log_number_) { Branch (50:7): [True: 33.3k, False: 66.5k]
51	33.3k	PutVarint32(dst, kPrevLogNumber);
52	33.3k	PutVarint64(dst, prev_log_number_);
53	33.3k	}
54	99.8k	if (has_next_file_number_) { Branch (54:7): [True: 66.5k, False: 33.2k]
55	66.5k	PutVarint32(dst, kNextFileNumber);
56	66.5k	PutVarint64(dst, next_file_number_);
57	66.5k	}
58	99.8k	if (has_last_sequence_) { Branch (58:7): [True: 66.5k, False: 33.2k]
59	66.5k	PutVarint32(dst, kLastSequence);
60	66.5k	PutVarint64(dst, last_sequence_);
61	66.5k	}
62
63	99.8k	for (size_t i = 0; i < compact_pointers_.size(); i++) { Branch (63:22): [True: 0, False: 99.8k]
64	0	PutVarint32(dst, kCompactPointer);
65	0	PutVarint32(dst, compact_pointers_[i].first); // level
66	0	PutLengthPrefixedSlice(dst, compact_pointers_[i].second.Encode());
67	0	}
68
69	99.8k	for (const auto& deleted_file_kvp : deleted_files_) { Branch (69:37): [True: 0, False: 99.8k]
70	0	PutVarint32(dst, kDeletedFile);
71	0	PutVarint32(dst, deleted_file_kvp.first); // level
72	0	PutVarint64(dst, deleted_file_kvp.second); // file number
73	0	}
74
75	99.8k	for (size_t i = 0; i < new_files_.size(); i++) { Branch (75:22): [True: 24, False: 99.8k]
76	24	const FileMetaData& f = new_files_[i].second;
77	24	PutVarint32(dst, kNewFile);
78	24	PutVarint32(dst, new_files_[i].first); // level
79	24	PutVarint64(dst, f.number);
80	24	PutVarint64(dst, f.file_size);
81	24	PutLengthPrefixedSlice(dst, f.smallest.Encode());
82	24	PutLengthPrefixedSlice(dst, f.largest.Encode());
83	24	}
84	99.8k	}
85
86	0	static bool GetInternalKey(Slice* input, InternalKey* dst) {
87	0	Slice str;
88	0	if (GetLengthPrefixedSlice(input, &str)) { Branch (88:7): [True: 0, False: 0]
89	0	return dst->DecodeFrom(str);
90	0	} else {
91	0	return false;
92	0	}
93	0	}
94
95	0	static bool GetLevel(Slice* input, int* level) {
96	0	uint32_t v;
97	0	if (GetVarint32(input, &v) && v < config::kNumLevels) { Branch (97:7): [True: 0, False: 0] Branch (97:33): [True: 0, False: 0]
98	0	*level = v;
99	0	return true;
100	0	} else {
101	0	return false;
102	0	}
103	0	}
104
105	33.2k	Status VersionEdit::DecodeFrom(const Slice& src) {
106	33.2k	Clear();
107	33.2k	Slice input = src;
108	33.2k	const char* msg = nullptr;
109	33.2k	uint32_t tag;
110
111		// Temporary storage for parsing
112	33.2k	int level;
113	33.2k	uint64_t number;
114	33.2k	FileMetaData f;
115	33.2k	Slice str;
116	33.2k	InternalKey key;
117
118	166k	while (msg == nullptr && GetVarint32(&input, &tag)) { Branch (118:10): [True: 166k, False: 0] Branch (118:28): [True: 133k, False: 33.2k]
119	133k	switch (tag) {
120	33.2k	case kComparator: Branch (120:7): [True: 33.2k, False: 99.8k]
121	33.2k	if (GetLengthPrefixedSlice(&input, &str)) { Branch (121:13): [True: 33.2k, False: 0]
122	33.2k	comparator_ = str.ToString();
123	33.2k	has_comparator_ = true;
124	33.2k	} else {
125	0	msg = "comparator name";
126	0	}
127	33.2k	break;
128
129	33.2k	case kLogNumber: Branch (129:7): [True: 33.2k, False: 99.8k]
130	33.2k	if (GetVarint64(&input, &log_number_)) { Branch (130:13): [True: 33.2k, False: 0]
131	33.2k	has_log_number_ = true;
132	33.2k	} else {
133	0	msg = "log number";
134	0	}
135	33.2k	break;
136
137	0	case kPrevLogNumber: Branch (137:7): [True: 0, False: 133k]
138	0	if (GetVarint64(&input, &prev_log_number_)) { Branch (138:13): [True: 0, False: 0]
139	0	has_prev_log_number_ = true;
140	0	} else {
141	0	msg = "previous log number";
142	0	}
143	0	break;
144
145	33.2k	case kNextFileNumber: Branch (145:7): [True: 33.2k, False: 99.8k]
146	33.2k	if (GetVarint64(&input, &next_file_number_)) { Branch (146:13): [True: 33.2k, False: 0]
147	33.2k	has_next_file_number_ = true;
148	33.2k	} else {
149	0	msg = "next file number";
150	0	}
151	33.2k	break;
152
153	33.2k	case kLastSequence: Branch (153:7): [True: 33.2k, False: 99.8k]
154	33.2k	if (GetVarint64(&input, &last_sequence_)) { Branch (154:13): [True: 33.2k, False: 0]
155	33.2k	has_last_sequence_ = true;
156	33.2k	} else {
157	0	msg = "last sequence number";
158	0	}
159	33.2k	break;
160
161	0	case kCompactPointer: Branch (161:7): [True: 0, False: 133k]
162	0	if (GetLevel(&input, &level) && GetInternalKey(&input, &key)) { Branch (162:13): [True: 0, False: 0] Branch (162:41): [True: 0, False: 0]
163	0	compact_pointers_.push_back(std::make_pair(level, key));
164	0	} else {
165	0	msg = "compaction pointer";
166	0	}
167	0	break;
168
169	0	case kDeletedFile: Branch (169:7): [True: 0, False: 133k]
170	0	if (GetLevel(&input, &level) && GetVarint64(&input, &number)) { Branch (170:13): [True: 0, False: 0] Branch (170:41): [True: 0, False: 0]
171	0	deleted_files_.insert(std::make_pair(level, number));
172	0	} else {
173	0	msg = "deleted file";
174	0	}
175	0	break;
176
177	0	case kNewFile: Branch (177:7): [True: 0, False: 133k]
178	0	if (GetLevel(&input, &level) && GetVarint64(&input, &f.number) && Branch (178:13): [True: 0, False: 0] Branch (178:41): [True: 0, False: 0]
179	0	GetVarint64(&input, &f.file_size) && Branch (179:13): [True: 0, False: 0]
180	0	GetInternalKey(&input, &f.smallest) && Branch (180:13): [True: 0, False: 0]
181	0	GetInternalKey(&input, &f.largest)) { Branch (181:13): [True: 0, False: 0]
182	0	new_files_.push_back(std::make_pair(level, f));
183	0	} else {
184	0	msg = "new-file entry";
185	0	}
186	0	break;
187
188	0	default: Branch (188:7): [True: 0, False: 133k]
189	0	msg = "unknown tag";
190	0	break;
191	133k	}
192	133k	}
193
194	33.2k	if (msg == nullptr && !input.empty()) { Branch (194:7): [True: 33.2k, False: 0] Branch (194:25): [True: 0, False: 33.2k]
195	0	msg = "invalid tag";
196	0	}
197
198	33.2k	Status result;
199	33.2k	if (msg != nullptr) { Branch (199:7): [True: 0, False: 33.2k]
200	0	result = Status::Corruption("VersionEdit", msg);
201	0	}
202	33.2k	return result;
203	33.2k	}
204
205	0	std::string VersionEdit::DebugString() const {
206	0	std::string r;
207	0	r.append("VersionEdit {");
208	0	if (has_comparator_) { Branch (208:7): [True: 0, False: 0]
209	0	r.append("\n Comparator: ");
210	0	r.append(comparator_);
211	0	}
212	0	if (has_log_number_) { Branch (212:7): [True: 0, False: 0]
213	0	r.append("\n LogNumber: ");
214	0	AppendNumberTo(&r, log_number_);
215	0	}
216	0	if (has_prev_log_number_) { Branch (216:7): [True: 0, False: 0]
217	0	r.append("\n PrevLogNumber: ");
218	0	AppendNumberTo(&r, prev_log_number_);
219	0	}
220	0	if (has_next_file_number_) { Branch (220:7): [True: 0, False: 0]
221	0	r.append("\n NextFile: ");
222	0	AppendNumberTo(&r, next_file_number_);
223	0	}
224	0	if (has_last_sequence_) { Branch (224:7): [True: 0, False: 0]
225	0	r.append("\n LastSeq: ");
226	0	AppendNumberTo(&r, last_sequence_);
227	0	}
228	0	for (size_t i = 0; i < compact_pointers_.size(); i++) { Branch (228:22): [True: 0, False: 0]
229	0	r.append("\n CompactPointer: ");
230	0	AppendNumberTo(&r, compact_pointers_[i].first);
231	0	r.append(" ");
232	0	r.append(compact_pointers_[i].second.DebugString());
233	0	}
234	0	for (const auto& deleted_files_kvp : deleted_files_) { Branch (234:38): [True: 0, False: 0]
235	0	r.append("\n DeleteFile: ");
236	0	AppendNumberTo(&r, deleted_files_kvp.first);
237	0	r.append(" ");
238	0	AppendNumberTo(&r, deleted_files_kvp.second);
239	0	}
240	0	for (size_t i = 0; i < new_files_.size(); i++) { Branch (240:22): [True: 0, False: 0]
241	0	const FileMetaData& f = new_files_[i].second;
242	0	r.append("\n AddFile: ");
243	0	AppendNumberTo(&r, new_files_[i].first);
244	0	r.append(" ");
245	0	AppendNumberTo(&r, f.number);
246	0	r.append(" ");
247	0	AppendNumberTo(&r, f.file_size);
248	0	r.append(" ");
249	0	r.append(f.smallest.DebugString());
250	0	r.append(" .. ");
251	0	r.append(f.largest.DebugString());
252	0	}
253	0	r.append("\n}\n");
254	0	return r;
255	0	}
256
257		} // namespace leveldb