提供基本的ttl测试用例
25'ten fazla konu seçemezsiniz Konular bir harf veya rakamla başlamalı, kısa çizgiler ('-') içerebilir ve en fazla 35 karakter uzunluğunda olabilir.

224 satır
7.5 KiB

Release 1.18 Changes are: * Update version number to 1.18 * Replace the basic fprintf call with a call to fwrite in order to work around the apparent compiler optimization/rewrite failure that we are seeing with the new toolchain/iOS SDKs provided with Xcode6 and iOS8. * Fix ALL the header guards. * Createed a README.md with the LevelDB project description. * A new CONTRIBUTING file. * Don't implicitly convert uint64_t to size_t or int. Either preserve it as uint64_t, or explicitly cast. This fixes MSVC warnings about possible value truncation when compiling this code in Chromium. * Added a DumpFile() library function that encapsulates the guts of the "leveldbutil dump" command. This will allow clients to dump data to their log files instead of stdout. It will also allow clients to supply their own environment. * leveldb: Remove unused function 'ConsumeChar'. * leveldbutil: Remove unused member variables from WriteBatchItemPrinter. * OpenBSD, NetBSD and DragonflyBSD have _LITTLE_ENDIAN, so define PLATFORM_IS_LITTLE_ENDIAN like on FreeBSD. This fixes: * issue #143 * issue #198 * issue #249 * Switch from <cstdatomic> to <atomic>. The former never made it into the standard and doesn't exist in modern gcc versions at all. The later contains everything that leveldb was using from the former. This problem was noticed when porting to Portable Native Client where no memory barrier is defined. The fact that <cstdatomic> is missing normally goes unnoticed since memory barriers are defined for most architectures. * Make Hash() treat its input as unsigned. Before this change LevelDB files from platforms with different signedness of char were not compatible. This change fixes: issue #243 * Verify checksums of index/meta/filter blocks when paranoid_checks set. * Invoke all tools for iOS with xcrun. (This was causing problems with the new XCode 5.1.1 image on pulse.) * include <sys/stat.h> only once, and fix the following linter warning: "Found C system header after C++ system header" * When encountering a corrupted table file, return Status::Corruption instead of Status::InvalidArgument. * Support cygwin as build platform, patch is from https://code.google.com/p/leveldb/issues/detail?id=188 * Fix typo, merge patch from https://code.google.com/p/leveldb/issues/detail?id=159 * Fix typos and comments, and address the following two issues: * issue #166 * issue #241 * Add missing db synchronize after "fillseq" in the benchmark. * Removed unused variable in SeekRandom: value (issue #201)
10 yıl önce
Release 1.18 Changes are: * Update version number to 1.18 * Replace the basic fprintf call with a call to fwrite in order to work around the apparent compiler optimization/rewrite failure that we are seeing with the new toolchain/iOS SDKs provided with Xcode6 and iOS8. * Fix ALL the header guards. * Createed a README.md with the LevelDB project description. * A new CONTRIBUTING file. * Don't implicitly convert uint64_t to size_t or int. Either preserve it as uint64_t, or explicitly cast. This fixes MSVC warnings about possible value truncation when compiling this code in Chromium. * Added a DumpFile() library function that encapsulates the guts of the "leveldbutil dump" command. This will allow clients to dump data to their log files instead of stdout. It will also allow clients to supply their own environment. * leveldb: Remove unused function 'ConsumeChar'. * leveldbutil: Remove unused member variables from WriteBatchItemPrinter. * OpenBSD, NetBSD and DragonflyBSD have _LITTLE_ENDIAN, so define PLATFORM_IS_LITTLE_ENDIAN like on FreeBSD. This fixes: * issue #143 * issue #198 * issue #249 * Switch from <cstdatomic> to <atomic>. The former never made it into the standard and doesn't exist in modern gcc versions at all. The later contains everything that leveldb was using from the former. This problem was noticed when porting to Portable Native Client where no memory barrier is defined. The fact that <cstdatomic> is missing normally goes unnoticed since memory barriers are defined for most architectures. * Make Hash() treat its input as unsigned. Before this change LevelDB files from platforms with different signedness of char were not compatible. This change fixes: issue #243 * Verify checksums of index/meta/filter blocks when paranoid_checks set. * Invoke all tools for iOS with xcrun. (This was causing problems with the new XCode 5.1.1 image on pulse.) * include <sys/stat.h> only once, and fix the following linter warning: "Found C system header after C++ system header" * When encountering a corrupted table file, return Status::Corruption instead of Status::InvalidArgument. * Support cygwin as build platform, patch is from https://code.google.com/p/leveldb/issues/detail?id=188 * Fix typo, merge patch from https://code.google.com/p/leveldb/issues/detail?id=159 * Fix typos and comments, and address the following two issues: * issue #166 * issue #241 * Add missing db synchronize after "fillseq" in the benchmark. * Removed unused variable in SeekRandom: value (issue #201)
10 yıl önce
  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. #ifndef STORAGE_LEVELDB_DB_DBFORMAT_H_
  5. #define STORAGE_LEVELDB_DB_DBFORMAT_H_
  6. #include <cstddef>
  7. #include <cstdint>
  8. #include <string>
  9. #include "leveldb/comparator.h"
  10. #include "leveldb/db.h"
  11. #include "leveldb/filter_policy.h"
  12. #include "leveldb/slice.h"
  13. #include "leveldb/table_builder.h"
  14. #include "util/coding.h"
  15. #include "util/logging.h"
  16. namespace leveldb {
  17. // Grouping of constants. We may want to make some of these
  18. // parameters set via options.
  19. namespace config {
  20. static const int kNumLevels = 7;
  21. // Level-0 compaction is started when we hit this many files.
  22. static const int kL0_CompactionTrigger = 4;
  23. // Soft limit on number of level-0 files. We slow down writes at this point.
  24. static const int kL0_SlowdownWritesTrigger = 8;
  25. // Maximum number of level-0 files. We stop writes at this point.
  26. static const int kL0_StopWritesTrigger = 12;
  27. // Maximum level to which a new compacted memtable is pushed if it
  28. // does not create overlap. We try to push to level 2 to avoid the
  29. // relatively expensive level 0=>1 compactions and to avoid some
  30. // expensive manifest file operations. We do not push all the way to
  31. // the largest level since that can generate a lot of wasted disk
  32. // space if the same key space is being repeatedly overwritten.
  33. static const int kMaxMemCompactLevel = 2;
  34. // Approximate gap in bytes between samples of data read during iteration.
  35. static const int kReadBytesPeriod = 1048576;
  36. } // namespace config
  37. class InternalKey;
  38. // Value types encoded as the last component of internal keys.
  39. // DO NOT CHANGE THESE ENUM VALUES: they are embedded in the on-disk
  40. // data structures.
  41. enum ValueType { kTypeDeletion = 0x0, kTypeValue = 0x1 };
  42. // kValueTypeForSeek defines the ValueType that should be passed when
  43. // constructing a ParsedInternalKey object for seeking to a particular
  44. // sequence number (since we sort sequence numbers in decreasing order
  45. // and the value type is embedded as the low 8 bits in the sequence
  46. // number in internal keys, we need to use the highest-numbered
  47. // ValueType, not the lowest).
  48. static const ValueType kValueTypeForSeek = kTypeValue;
  49. typedef uint64_t SequenceNumber;
  50. // We leave eight bits empty at the bottom so a type and sequence#
  51. // can be packed together into 64-bits.
  52. static const SequenceNumber kMaxSequenceNumber = ((0x1ull << 56) - 1);
  53. struct ParsedInternalKey {
  54. Slice user_key;
  55. SequenceNumber sequence;
  56. ValueType type;
  57. ParsedInternalKey() {} // Intentionally left uninitialized (for speed)
  58. ParsedInternalKey(const Slice& u, const SequenceNumber& seq, ValueType t)
  59. : user_key(u), sequence(seq), type(t) {}
  60. std::string DebugString() const;
  61. };
  62. // Return the length of the encoding of "key".
  63. inline size_t InternalKeyEncodingLength(const ParsedInternalKey& key) {
  64. return key.user_key.size() + 8;
  65. }
  66. // Append the serialization of "key" to *result.
  67. void AppendInternalKey(std::string* result, const ParsedInternalKey& key);
  68. // Attempt to parse an internal key from "internal_key". On success,
  69. // stores the parsed data in "*result", and returns true.
  70. //
  71. // On error, returns false, leaves "*result" in an undefined state.
  72. bool ParseInternalKey(const Slice& internal_key, ParsedInternalKey* result);
  73. // Returns the user key portion of an internal key.
  74. inline Slice ExtractUserKey(const Slice& internal_key) {
  75. assert(internal_key.size() >= 8);
  76. return Slice(internal_key.data(), internal_key.size() - 8);
  77. }
  78. // A comparator for internal keys that uses a specified comparator for
  79. // the user key portion and breaks ties by decreasing sequence number.
  80. class InternalKeyComparator : public Comparator {
  81. private:
  82. const Comparator* user_comparator_;
  83. public:
  84. explicit InternalKeyComparator(const Comparator* c) : user_comparator_(c) {}
  85. const char* Name() const override;
  86. int Compare(const Slice& a, const Slice& b) const override;
  87. void FindShortestSeparator(std::string* start,
  88. const Slice& limit) const override;
  89. void FindShortSuccessor(std::string* key) const override;
  90. const Comparator* user_comparator() const { return user_comparator_; }
  91. int Compare(const InternalKey& a, const InternalKey& b) const;
  92. };
  93. // Filter policy wrapper that converts from internal keys to user keys
  94. class InternalFilterPolicy : public FilterPolicy {
  95. private:
  96. const FilterPolicy* const user_policy_;
  97. public:
  98. explicit InternalFilterPolicy(const FilterPolicy* p) : user_policy_(p) {}
  99. const char* Name() const override;
  100. void CreateFilter(const Slice* keys, int n, std::string* dst) const override;
  101. bool KeyMayMatch(const Slice& key, const Slice& filter) const override;
  102. };
  103. // Modules in this directory should keep internal keys wrapped inside
  104. // the following class instead of plain strings so that we do not
  105. // incorrectly use string comparisons instead of an InternalKeyComparator.
  106. class InternalKey {
  107. private:
  108. std::string rep_;
  109. public:
  110. InternalKey() {} // Leave rep_ as empty to indicate it is invalid
  111. InternalKey(const Slice& user_key, SequenceNumber s, ValueType t) {
  112. AppendInternalKey(&rep_, ParsedInternalKey(user_key, s, t));
  113. }
  114. bool DecodeFrom(const Slice& s) {
  115. rep_.assign(s.data(), s.size());
  116. return !rep_.empty();
  117. }
  118. Slice Encode() const {
  119. assert(!rep_.empty());
  120. return rep_;
  121. }
  122. Slice user_key() const { return ExtractUserKey(rep_); }
  123. void SetFrom(const ParsedInternalKey& p) {
  124. rep_.clear();
  125. AppendInternalKey(&rep_, p);
  126. }
  127. void Clear() { rep_.clear(); }
  128. std::string DebugString() const;
  129. };
  130. inline int InternalKeyComparator::Compare(const InternalKey& a,
  131. const InternalKey& b) const {
  132. return Compare(a.Encode(), b.Encode());
  133. }
  134. inline bool ParseInternalKey(const Slice& internal_key,
  135. ParsedInternalKey* result) {
  136. const size_t n = internal_key.size();
  137. if (n < 8) return false;
  138. uint64_t num = DecodeFixed64(internal_key.data() + n - 8);
  139. uint8_t c = num & 0xff;
  140. result->sequence = num >> 8;
  141. result->type = static_cast<ValueType>(c);
  142. result->user_key = Slice(internal_key.data(), n - 8);
  143. return (c <= static_cast<uint8_t>(kTypeValue));
  144. }
  145. // A helper class useful for DBImpl::Get()
  146. class LookupKey {
  147. public:
  148. // Initialize *this for looking up user_key at a snapshot with
  149. // the specified sequence number.
  150. LookupKey(const Slice& user_key, SequenceNumber sequence);
  151. LookupKey(const LookupKey&) = delete;
  152. LookupKey& operator=(const LookupKey&) = delete;
  153. ~LookupKey();
  154. // Return a key suitable for lookup in a MemTable.
  155. Slice memtable_key() const { return Slice(start_, end_ - start_); }
  156. // Return an internal key (suitable for passing to an internal iterator)
  157. Slice internal_key() const { return Slice(kstart_, end_ - kstart_); }
  158. // Return the user key
  159. Slice user_key() const { return Slice(kstart_, end_ - kstart_ - 8); }
  160. private:
  161. // We construct a char array of the form:
  162. // klength varint32 <-- start_
  163. // userkey char[klength] <-- kstart_
  164. // tag uint64
  165. // <-- end_
  166. // The array is a suitable MemTable key.
  167. // The suffix starting with "userkey" can be used as an InternalKey.
  168. const char* start_;
  169. const char* kstart_;
  170. const char* end_;
  171. char space_[200]; // Avoid allocation for short keys
  172. };
  173. inline LookupKey::~LookupKey() {
  174. if (start_ != space_) delete[] start_;
  175. }
  176. } // namespace leveldb
  177. #endif // STORAGE_LEVELDB_DB_DBFORMAT_H_