NextGraph
/
rocksdb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Adapt key-value checksum for timestamp-suffixed keys (#8914)

Browse Source 
Summary:
After https://github.com/facebook/rocksdb/issues/8725, keys added to `WriteBatch` may be timestamp-suffixed, while `WriteBatch` has no awareness of the timestamp size. Therefore, `WriteBatch` can no longer calculate timestamp checksum separately from the rest of the key's checksum in all cases.

This PR changes the definition of key in KV checksum to include the timestamp suffix. That way we do not need to worry about where the timestamp begins within the key. I believe the only practical effect of this change is now `AssignTimestamp()` requires recomputing the whole key checksum (`UpdateK()`) rather than just the timestamp portion (`UpdateT()`).

Pull Request resolved: https://github.com/facebook/rocksdb/pull/8914

Test Plan:
run stress command that used to fail

```
$ ./db_stress --batch_protection_bytes_per_key=8 -clear_column_family_one_in=0 -test_batches_snapshots=1
```

Reviewed By: riversand963

Differential Revision: D30925715

Pulled By: ajkr

fbshipit-source-id: c143f7ccb46c0efb390ad57ef415c250d754deff
main
Andrew Kryczka 3 years ago committed by Facebook GitHub Bot
parent e10e4162c8
commit d648cb47b9
5 changed files with 170 additions and 199 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 211
      db/kv_checksum.h
  2. 25
      db/memtable.cc
  3. 8
      db/memtable.h
  4. 123
      db/write_batch.cc
  5. 2
      db/write_batch_internal.h

211
db/kv_checksum.h
Unescape View File

@ -11,13 +11,12 @@
// K = key // K = key
// V = value // V = value
// O = optype aka value type // O = optype aka value type
// T = timestamp
// S = seqno // S = seqno
// C = CF ID // C = CF ID
// //
// Then, for example, a class that protects an entry consisting of key, value, // Then, for example, a class that protects an entry consisting of key, value,
// optype, timestamp, and CF ID (i.e., a `WriteBatch` entry) would be named // optype, and CF ID (i.e., a `WriteBatch` entry) would be named
// `ProtectionInfoKVOTC`. // `ProtectionInfoKVOC`.
// //
// The `ProtectionInfo.*` classes are templated on the integer type used to hold // The `ProtectionInfo.*` classes are templated on the integer type used to hold
// the XOR of hashes for each field. Only unsigned integer types are supported, // the XOR of hashes for each field. Only unsigned integer types are supported,
@ -42,17 +41,17 @@ namespace ROCKSDB_NAMESPACE {
template <typename T> template <typename T>
class ProtectionInfo; class ProtectionInfo;
template <typename T> template <typename T>
class ProtectionInfoKVOT; class ProtectionInfoKVO;
template <typename T> template <typename T>
class ProtectionInfoKVOTC; class ProtectionInfoKVOC;
template <typename T> template <typename T>
class ProtectionInfoKVOTS; class ProtectionInfoKVOS;
// Aliases for 64-bit protection infos. // Aliases for 64-bit protection infos.
using ProtectionInfo64 = ProtectionInfo<uint64_t>; using ProtectionInfo64 = ProtectionInfo<uint64_t>;
using ProtectionInfoKVOT64 = ProtectionInfoKVOT<uint64_t>; using ProtectionInfoKVO64 = ProtectionInfoKVO<uint64_t>;
using ProtectionInfoKVOTC64 = ProtectionInfoKVOTC<uint64_t>; using ProtectionInfoKVOC64 = ProtectionInfoKVOC<uint64_t>;
using ProtectionInfoKVOTS64 = ProtectionInfoKVOTS<uint64_t>; using ProtectionInfoKVOS64 = ProtectionInfoKVOS<uint64_t>;
template <typename T> template <typename T>
class ProtectionInfo { class ProtectionInfo {
@ -60,16 +59,16 @@ class ProtectionInfo {
ProtectionInfo<T>() = default; ProtectionInfo<T>() = default;
Status GetStatus() const; Status GetStatus() const;
ProtectionInfoKVOT<T> ProtectKVOT(const Slice& key, const Slice& value, ProtectionInfoKVO<T> ProtectKVO(const Slice& key, const Slice& value,
ValueType op_type) const; ValueType op_type) const;
ProtectionInfoKVOT<T> ProtectKVOT(const SliceParts& key, ProtectionInfoKVO<T> ProtectKVO(const SliceParts& key,
const SliceParts& value, const SliceParts& value,
ValueType op_type) const; ValueType op_type) const;
private: private:
friend class ProtectionInfoKVOT<T>; friend class ProtectionInfoKVO<T>;
friend class ProtectionInfoKVOTS<T>; friend class ProtectionInfoKVOS<T>;
friend class ProtectionInfoKVOTC<T>; friend class ProtectionInfoKVOC<T>;
// Each field is hashed with an independent value so we can catch fields being // Each field is hashed with an independent value so we can catch fields being
// swapped. Per the `NPHash64()` docs, using consecutive seeds is a pitfall, // swapped. Per the `NPHash64()` docs, using consecutive seeds is a pitfall,
@ -81,9 +80,8 @@ class ProtectionInfo {
static const uint64_t kSeedK = 0; static const uint64_t kSeedK = 0;
static const uint64_t kSeedV = 0xD28AAD72F49BD50B; static const uint64_t kSeedV = 0xD28AAD72F49BD50B;
static const uint64_t kSeedO = 0xA5155AE5E937AA16; static const uint64_t kSeedO = 0xA5155AE5E937AA16;
static const uint64_t kSeedT = 0x77A00858DDD37F21; static const uint64_t kSeedS = 0x77A00858DDD37F21;
static const uint64_t kSeedS = 0x4A2AB5CBD26F542C; static const uint64_t kSeedC = 0x4A2AB5CBD26F542C;
static const uint64_t kSeedC = 0x1CB5633EC70B2937;
ProtectionInfo<T>(T val) : val_(val) { ProtectionInfo<T>(T val) : val_(val) {
static_assert(sizeof(ProtectionInfo<T>) == sizeof(T), ""); static_assert(sizeof(ProtectionInfo<T>) == sizeof(T), "");
@ -96,32 +94,31 @@ class ProtectionInfo {
}; };
template <typename T> template <typename T>
class ProtectionInfoKVOT { class ProtectionInfoKVO {
public: public:
ProtectionInfoKVOT<T>() = default; ProtectionInfoKVO<T>() = default;
ProtectionInfo<T> StripKVOT(const Slice& key, const Slice& value, ProtectionInfo<T> StripKVO(const Slice& key, const Slice& value,
ValueType op_type, const Slice& timestamp) const; ValueType op_type) const;
ProtectionInfo<T> StripKVOT(const SliceParts& key, const SliceParts& value, ProtectionInfo<T> StripKVO(const SliceParts& key, const SliceParts& value,
ValueType op_type, const Slice& timestamp) const; ValueType op_type) const;
ProtectionInfoKVOTC<T> ProtectC(ColumnFamilyId column_family_id) const; ProtectionInfoKVOC<T> ProtectC(ColumnFamilyId column_family_id) const;
ProtectionInfoKVOTS<T> ProtectS(SequenceNumber sequence_number) const; ProtectionInfoKVOS<T> ProtectS(SequenceNumber sequence_number) const;
void UpdateK(const Slice& old_key, const Slice& new_key); void UpdateK(const Slice& old_key, const Slice& new_key);
void UpdateK(const SliceParts& old_key, const SliceParts& new_key); void UpdateK(const SliceParts& old_key, const SliceParts& new_key);
void UpdateV(const Slice& old_value, const Slice& new_value); void UpdateV(const Slice& old_value, const Slice& new_value);
void UpdateV(const SliceParts& old_value, const SliceParts& new_value); void UpdateV(const SliceParts& old_value, const SliceParts& new_value);
void UpdateO(ValueType old_op_type, ValueType new_op_type); void UpdateO(ValueType old_op_type, ValueType new_op_type);
void UpdateT(const Slice& old_timestamp, const Slice& new_timestamp);
private: private:
friend class ProtectionInfo<T>; friend class ProtectionInfo<T>;
friend class ProtectionInfoKVOTS<T>; friend class ProtectionInfoKVOS<T>;
friend class ProtectionInfoKVOTC<T>; friend class ProtectionInfoKVOC<T>;
ProtectionInfoKVOT<T>(T val) : info_(val) { ProtectionInfoKVO<T>(T val) : info_(val) {
static_assert(sizeof(ProtectionInfoKVOT<T>) == sizeof(T), ""); static_assert(sizeof(ProtectionInfoKVO<T>) == sizeof(T), "");
} }
T GetVal() const { return info_.GetVal(); } T GetVal() const { return info_.GetVal(); }
@ -131,85 +128,79 @@ class ProtectionInfoKVOT {
}; };
template <typename T> template <typename T>
class ProtectionInfoKVOTC { class ProtectionInfoKVOC {
public: public:
ProtectionInfoKVOTC<T>() = default; ProtectionInfoKVOC<T>() = default;
ProtectionInfoKVOT<T> StripC(ColumnFamilyId column_family_id) const; ProtectionInfoKVO<T> StripC(ColumnFamilyId column_family_id) const;
void UpdateK(const Slice& old_key, const Slice& new_key) { void UpdateK(const Slice& old_key, const Slice& new_key) {
kvot_.UpdateK(old_key, new_key); kvo_.UpdateK(old_key, new_key);
} }
void UpdateK(const SliceParts& old_key, const SliceParts& new_key) { void UpdateK(const SliceParts& old_key, const SliceParts& new_key) {
kvot_.UpdateK(old_key, new_key); kvo_.UpdateK(old_key, new_key);
} }
void UpdateV(const Slice& old_value, const Slice& new_value) { void UpdateV(const Slice& old_value, const Slice& new_value) {
kvot_.UpdateV(old_value, new_value); kvo_.UpdateV(old_value, new_value);
} }
void UpdateV(const SliceParts& old_value, const SliceParts& new_value) { void UpdateV(const SliceParts& old_value, const SliceParts& new_value) {
kvot_.UpdateV(old_value, new_value); kvo_.UpdateV(old_value, new_value);
} }
void UpdateO(ValueType old_op_type, ValueType new_op_type) { void UpdateO(ValueType old_op_type, ValueType new_op_type) {
kvot_.UpdateO(old_op_type, new_op_type); kvo_.UpdateO(old_op_type, new_op_type);
}
void UpdateT(const Slice& old_timestamp, const Slice& new_timestamp) {
kvot_.UpdateT(old_timestamp, new_timestamp);
} }
void UpdateC(ColumnFamilyId old_column_family_id, void UpdateC(ColumnFamilyId old_column_family_id,
ColumnFamilyId new_column_family_id); ColumnFamilyId new_column_family_id);
private: private:
friend class ProtectionInfoKVOT<T>; friend class ProtectionInfoKVO<T>;
ProtectionInfoKVOTC<T>(T val) : kvot_(val) { ProtectionInfoKVOC<T>(T val) : kvo_(val) {
static_assert(sizeof(ProtectionInfoKVOTC<T>) == sizeof(T), ""); static_assert(sizeof(ProtectionInfoKVOC<T>) == sizeof(T), "");
} }
T GetVal() const { return kvot_.GetVal(); } T GetVal() const { return kvo_.GetVal(); }
void SetVal(T val) { kvot_.SetVal(val); } void SetVal(T val) { kvo_.SetVal(val); }
ProtectionInfoKVOT<T> kvot_; ProtectionInfoKVO<T> kvo_;
}; };
template <typename T> template <typename T>
class ProtectionInfoKVOTS { class ProtectionInfoKVOS {
public: public:
ProtectionInfoKVOTS<T>() = default; ProtectionInfoKVOS<T>() = default;
ProtectionInfoKVOT<T> StripS(SequenceNumber sequence_number) const; ProtectionInfoKVO<T> StripS(SequenceNumber sequence_number) const;
void UpdateK(const Slice& old_key, const Slice& new_key) { void UpdateK(const Slice& old_key, const Slice& new_key) {
kvot_.UpdateK(old_key, new_key); kvo_.UpdateK(old_key, new_key);
} }
void UpdateK(const SliceParts& old_key, const SliceParts& new_key) { void UpdateK(const SliceParts& old_key, const SliceParts& new_key) {
kvot_.UpdateK(old_key, new_key); kvo_.UpdateK(old_key, new_key);
} }
void UpdateV(const Slice& old_value, const Slice& new_value) { void UpdateV(const Slice& old_value, const Slice& new_value) {
kvot_.UpdateV(old_value, new_value); kvo_.UpdateV(old_value, new_value);
} }
void UpdateV(const SliceParts& old_value, const SliceParts& new_value) { void UpdateV(const SliceParts& old_value, const SliceParts& new_value) {
kvot_.UpdateV(old_value, new_value); kvo_.UpdateV(old_value, new_value);
} }
void UpdateO(ValueType old_op_type, ValueType new_op_type) { void UpdateO(ValueType old_op_type, ValueType new_op_type) {
kvot_.UpdateO(old_op_type, new_op_type); kvo_.UpdateO(old_op_type, new_op_type);
}
void UpdateT(const Slice& old_timestamp, const Slice& new_timestamp) {
kvot_.UpdateT(old_timestamp, new_timestamp);
} }
void UpdateS(SequenceNumber old_sequence_number, void UpdateS(SequenceNumber old_sequence_number,
SequenceNumber new_sequence_number); SequenceNumber new_sequence_number);
private: private:
friend class ProtectionInfoKVOT<T>; friend class ProtectionInfoKVO<T>;
ProtectionInfoKVOTS<T>(T val) : kvot_(val) { ProtectionInfoKVOS<T>(T val) : kvo_(val) {
static_assert(sizeof(ProtectionInfoKVOTS<T>) == sizeof(T), ""); static_assert(sizeof(ProtectionInfoKVOS<T>) == sizeof(T), "");
} }
T GetVal() const { return kvot_.GetVal(); } T GetVal() const { return kvo_.GetVal(); }
void SetVal(T val) { kvot_.SetVal(val); } void SetVal(T val) { kvo_.SetVal(val); }
ProtectionInfoKVOT<T> kvot_; ProtectionInfoKVO<T> kvo_;
}; };
template <typename T> template <typename T>
@ -221,9 +212,9 @@ Status ProtectionInfo<T>::GetStatus() const {
} }
template <typename T> template <typename T>
ProtectionInfoKVOT<T> ProtectionInfo<T>::ProtectKVOT(const Slice& key, ProtectionInfoKVO<T> ProtectionInfo<T>::ProtectKVO(const Slice& key,
const Slice& value, const Slice& value,
ValueType op_type) const { ValueType op_type) const {
T val = GetVal(); T val = GetVal();
val = val ^ static_cast<T>(GetSliceNPHash64(key, ProtectionInfo<T>::kSeedK)); val = val ^ static_cast<T>(GetSliceNPHash64(key, ProtectionInfo<T>::kSeedK));
val = val =
@ -231,13 +222,13 @@ ProtectionInfoKVOT<T> ProtectionInfo<T>::ProtectKVOT(const Slice& key,
val = val ^ val = val ^
static_cast<T>(NPHash64(reinterpret_cast<char*>(&op_type), static_cast<T>(NPHash64(reinterpret_cast<char*>(&op_type),
sizeof(op_type), ProtectionInfo<T>::kSeedO)); sizeof(op_type), ProtectionInfo<T>::kSeedO));
return ProtectionInfoKVOT<T>(val); return ProtectionInfoKVO<T>(val);
} }
template <typename T> template <typename T>
ProtectionInfoKVOT<T> ProtectionInfo<T>::ProtectKVOT(const SliceParts& key, ProtectionInfoKVO<T> ProtectionInfo<T>::ProtectKVO(const SliceParts& key,
const SliceParts& value, const SliceParts& value,
ValueType op_type) const { ValueType op_type) const {
T val = GetVal(); T val = GetVal();
val = val ^ val = val ^
static_cast<T>(GetSlicePartsNPHash64(key, ProtectionInfo<T>::kSeedK)); static_cast<T>(GetSlicePartsNPHash64(key, ProtectionInfo<T>::kSeedK));
@ -246,12 +237,11 @@ ProtectionInfoKVOT<T> ProtectionInfo<T>::ProtectKVOT(const SliceParts& key,
val = val ^ val = val ^
static_cast<T>(NPHash64(reinterpret_cast<char*>(&op_type), static_cast<T>(NPHash64(reinterpret_cast<char*>(&op_type),
sizeof(op_type), ProtectionInfo<T>::kSeedO)); sizeof(op_type), ProtectionInfo<T>::kSeedO));
return ProtectionInfoKVOT<T>(val); return ProtectionInfoKVO<T>(val);
} }
template <typename T> template <typename T>
void ProtectionInfoKVOT<T>::UpdateK(const Slice& old_key, void ProtectionInfoKVO<T>::UpdateK(const Slice& old_key, const Slice& new_key) {
const Slice& new_key) {
T val = GetVal(); T val = GetVal();
val = val ^ val = val ^
static_cast<T>(GetSliceNPHash64(old_key, ProtectionInfo<T>::kSeedK)); static_cast<T>(GetSliceNPHash64(old_key, ProtectionInfo<T>::kSeedK));
@ -261,8 +251,8 @@ void ProtectionInfoKVOT<T>::UpdateK(const Slice& old_key,
} }
template <typename T> template <typename T>
void ProtectionInfoKVOT<T>::UpdateK(const SliceParts& old_key, void ProtectionInfoKVO<T>::UpdateK(const SliceParts& old_key,
const SliceParts& new_key) { const SliceParts& new_key) {
T val = GetVal(); T val = GetVal();
val = val ^ static_cast<T>( val = val ^ static_cast<T>(
GetSlicePartsNPHash64(old_key, ProtectionInfo<T>::kSeedK)); GetSlicePartsNPHash64(old_key, ProtectionInfo<T>::kSeedK));
@ -272,8 +262,8 @@ void ProtectionInfoKVOT<T>::UpdateK(const SliceParts& old_key,
} }
template <typename T> template <typename T>
void ProtectionInfoKVOT<T>::UpdateV(const Slice& old_value, void ProtectionInfoKVO<T>::UpdateV(const Slice& old_value,
const Slice& new_value) { const Slice& new_value) {
T val = GetVal(); T val = GetVal();
val = val ^ val = val ^
static_cast<T>(GetSliceNPHash64(old_value, ProtectionInfo<T>::kSeedV)); static_cast<T>(GetSliceNPHash64(old_value, ProtectionInfo<T>::kSeedV));
@ -283,8 +273,8 @@ void ProtectionInfoKVOT<T>::UpdateV(const Slice& old_value,
} }
template <typename T> template <typename T>
void ProtectionInfoKVOT<T>::UpdateV(const SliceParts& old_value, void ProtectionInfoKVO<T>::UpdateV(const SliceParts& old_value,
const SliceParts& new_value) { const SliceParts& new_value) {
T val = GetVal(); T val = GetVal();
val = val ^ static_cast<T>( val = val ^ static_cast<T>(
GetSlicePartsNPHash64(old_value, ProtectionInfo<T>::kSeedV)); GetSlicePartsNPHash64(old_value, ProtectionInfo<T>::kSeedV));
@ -294,8 +284,8 @@ void ProtectionInfoKVOT<T>::UpdateV(const SliceParts& old_value,
} }
template <typename T> template <typename T>
void ProtectionInfoKVOT<T>::UpdateO(ValueType old_op_type, void ProtectionInfoKVO<T>::UpdateO(ValueType old_op_type,
ValueType new_op_type) { ValueType new_op_type) {
T val = GetVal(); T val = GetVal();
val = val ^ static_cast<T>(NPHash64(reinterpret_cast<char*>(&old_op_type), val = val ^ static_cast<T>(NPHash64(reinterpret_cast<char*>(&old_op_type),
sizeof(old_op_type), sizeof(old_op_type),
@ -307,20 +297,9 @@ void ProtectionInfoKVOT<T>::UpdateO(ValueType old_op_type,
} }
template <typename T> template <typename T>
void ProtectionInfoKVOT<T>::UpdateT(const Slice& old_timestamp, ProtectionInfo<T> ProtectionInfoKVO<T>::StripKVO(const Slice& key,
const Slice& new_timestamp) { const Slice& value,
T val = GetVal(); ValueType op_type) const {
val = val ^ static_cast<T>(
GetSliceNPHash64(old_timestamp, ProtectionInfo<T>::kSeedT));
val = val ^ static_cast<T>(
GetSliceNPHash64(new_timestamp, ProtectionInfo<T>::kSeedT));
SetVal(val);
}
template <typename T>
ProtectionInfo<T> ProtectionInfoKVOT<T>::StripKVOT(
const Slice& key, const Slice& value, ValueType op_type,
const Slice& timestamp) const {
T val = GetVal(); T val = GetVal();
val = val ^ static_cast<T>(GetSliceNPHash64(key, ProtectionInfo<T>::kSeedK)); val = val ^ static_cast<T>(GetSliceNPHash64(key, ProtectionInfo<T>::kSeedK));
val = val =
@ -328,15 +307,13 @@ ProtectionInfo<T> ProtectionInfoKVOT<T>::StripKVOT(
val = val ^ val = val ^
static_cast<T>(NPHash64(reinterpret_cast<char*>(&op_type), static_cast<T>(NPHash64(reinterpret_cast<char*>(&op_type),
sizeof(op_type), ProtectionInfo<T>::kSeedO)); sizeof(op_type), ProtectionInfo<T>::kSeedO));
val = val ^
static_cast<T>(GetSliceNPHash64(timestamp, ProtectionInfo<T>::kSeedT));
return ProtectionInfo<T>(val); return ProtectionInfo<T>(val);
} }
template <typename T> template <typename T>
ProtectionInfo<T> ProtectionInfoKVOT<T>::StripKVOT( ProtectionInfo<T> ProtectionInfoKVO<T>::StripKVO(const SliceParts& key,
const SliceParts& key, const SliceParts& value, ValueType op_type, const SliceParts& value,
const Slice& timestamp) const { ValueType op_type) const {
T val = GetVal(); T val = GetVal();
val = val ^ val = val ^
static_cast<T>(GetSlicePartsNPHash64(key, ProtectionInfo<T>::kSeedK)); static_cast<T>(GetSlicePartsNPHash64(key, ProtectionInfo<T>::kSeedK));
@ -345,34 +322,32 @@ ProtectionInfo<T> ProtectionInfoKVOT<T>::StripKVOT(
val = val ^ val = val ^
static_cast<T>(NPHash64(reinterpret_cast<char*>(&op_type), static_cast<T>(NPHash64(reinterpret_cast<char*>(&op_type),
sizeof(op_type), ProtectionInfo<T>::kSeedO)); sizeof(op_type), ProtectionInfo<T>::kSeedO));
val = val ^
static_cast<T>(GetSliceNPHash64(timestamp, ProtectionInfo<T>::kSeedT));
return ProtectionInfo<T>(val); return ProtectionInfo<T>(val);
} }
template <typename T> template <typename T>
ProtectionInfoKVOTC<T> ProtectionInfoKVOT<T>::ProtectC( ProtectionInfoKVOC<T> ProtectionInfoKVO<T>::ProtectC(
ColumnFamilyId column_family_id) const { ColumnFamilyId column_family_id) const {
T val = GetVal(); T val = GetVal();
val = val ^ static_cast<T>(NPHash64( val = val ^ static_cast<T>(NPHash64(
reinterpret_cast<char*>(&column_family_id), reinterpret_cast<char*>(&column_family_id),
sizeof(column_family_id), ProtectionInfo<T>::kSeedC)); sizeof(column_family_id), ProtectionInfo<T>::kSeedC));
return ProtectionInfoKVOTC<T>(val); return ProtectionInfoKVOC<T>(val);
} }
template <typename T> template <typename T>
ProtectionInfoKVOT<T> ProtectionInfoKVOTC<T>::StripC( ProtectionInfoKVO<T> ProtectionInfoKVOC<T>::StripC(
ColumnFamilyId column_family_id) const { ColumnFamilyId column_family_id) const {
T val = GetVal(); T val = GetVal();
val = val ^ static_cast<T>(NPHash64( val = val ^ static_cast<T>(NPHash64(
reinterpret_cast<char*>(&column_family_id), reinterpret_cast<char*>(&column_family_id),
sizeof(column_family_id), ProtectionInfo<T>::kSeedC)); sizeof(column_family_id), ProtectionInfo<T>::kSeedC));
return ProtectionInfoKVOT<T>(val); return ProtectionInfoKVO<T>(val);
} }
template <typename T> template <typename T>
void ProtectionInfoKVOTC<T>::UpdateC(ColumnFamilyId old_column_family_id, void ProtectionInfoKVOC<T>::UpdateC(ColumnFamilyId old_column_family_id,
ColumnFamilyId new_column_family_id) { ColumnFamilyId new_column_family_id) {
T val = GetVal(); T val = GetVal();
val = val ^ static_cast<T>(NPHash64( val = val ^ static_cast<T>(NPHash64(
reinterpret_cast<char*>(&old_column_family_id), reinterpret_cast<char*>(&old_column_family_id),
@ -384,28 +359,28 @@ void ProtectionInfoKVOTC<T>::UpdateC(ColumnFamilyId old_column_family_id,
} }
template <typename T> template <typename T>
ProtectionInfoKVOTS<T> ProtectionInfoKVOT<T>::ProtectS( ProtectionInfoKVOS<T> ProtectionInfoKVO<T>::ProtectS(
SequenceNumber sequence_number) const { SequenceNumber sequence_number) const {
T val = GetVal(); T val = GetVal();
val = val ^ static_cast<T>(NPHash64(reinterpret_cast<char*>(&sequence_number), val = val ^ static_cast<T>(NPHash64(reinterpret_cast<char*>(&sequence_number),
sizeof(sequence_number), sizeof(sequence_number),
ProtectionInfo<T>::kSeedS)); ProtectionInfo<T>::kSeedS));
return ProtectionInfoKVOTS<T>(val); return ProtectionInfoKVOS<T>(val);
} }
template <typename T> template <typename T>
ProtectionInfoKVOT<T> ProtectionInfoKVOTS<T>::StripS( ProtectionInfoKVO<T> ProtectionInfoKVOS<T>::StripS(
SequenceNumber sequence_number) const { SequenceNumber sequence_number) const {
T val = GetVal(); T val = GetVal();
val = val ^ static_cast<T>(NPHash64(reinterpret_cast<char*>(&sequence_number), val = val ^ static_cast<T>(NPHash64(reinterpret_cast<char*>(&sequence_number),
sizeof(sequence_number), sizeof(sequence_number),
ProtectionInfo<T>::kSeedS)); ProtectionInfo<T>::kSeedS));
return ProtectionInfoKVOT<T>(val); return ProtectionInfoKVO<T>(val);
} }
template <typename T> template <typename T>
void ProtectionInfoKVOTS<T>::UpdateS(SequenceNumber old_sequence_number, void ProtectionInfoKVOS<T>::UpdateS(SequenceNumber old_sequence_number,
SequenceNumber new_sequence_number) { SequenceNumber new_sequence_number) {
T val = GetVal(); T val = GetVal();
val = val ^ static_cast<T>(NPHash64( val = val ^ static_cast<T>(NPHash64(
reinterpret_cast<char*>(&old_sequence_number), reinterpret_cast<char*>(&old_sequence_number),

25
db/memtable.cc
Unescape View File

@ -487,7 +487,7 @@ MemTable::MemTableStats MemTable::ApproximateStats(const Slice& start_ikey,
} }
Status MemTable::VerifyEncodedEntry(Slice encoded, Status MemTable::VerifyEncodedEntry(Slice encoded,
const ProtectionInfoKVOTS64& kv_prot_info) { const ProtectionInfoKVOS64& kv_prot_info) {
uint32_t ikey_len = 0; uint32_t ikey_len = 0;
if (!GetVarint32(&encoded, &ikey_len)) { if (!GetVarint32(&encoded, &ikey_len)) {
return Status::Corruption("Unable to parse internal key length"); return Status::Corruption("Unable to parse internal key length");
@ -500,12 +500,9 @@ Status MemTable::VerifyEncodedEntry(Slice encoded,
return Status::Corruption("Internal key length too long"); return Status::Corruption("Internal key length too long");
} }
uint32_t value_len = 0; uint32_t value_len = 0;
const size_t key_without_ts_len = ikey_len - ts_sz - 8; const size_t user_key_len = ikey_len - 8;
Slice key(encoded.data(), key_without_ts_len); Slice key(encoded.data(), user_key_len);
encoded.remove_prefix(key_without_ts_len); encoded.remove_prefix(user_key_len);
Slice timestamp(encoded.data(), ts_sz);
encoded.remove_prefix(ts_sz);
uint64_t packed = DecodeFixed64(encoded.data()); uint64_t packed = DecodeFixed64(encoded.data());
ValueType value_type = kMaxValue; ValueType value_type = kMaxValue;
@ -525,14 +522,14 @@ Status MemTable::VerifyEncodedEntry(Slice encoded,
Slice value(encoded.data(), value_len); Slice value(encoded.data(), value_len);
return kv_prot_info.StripS(sequence_number) return kv_prot_info.StripS(sequence_number)
.StripKVOT(key, value, value_type, timestamp) .StripKVO(key, value, value_type)
.GetStatus(); .GetStatus();
} }
Status MemTable::Add(SequenceNumber s, ValueType type, Status MemTable::Add(SequenceNumber s, ValueType type,
const Slice& key, /* user key */ const Slice& key, /* user key */
const Slice& value, const Slice& value,
const ProtectionInfoKVOTS64* kv_prot_info, const ProtectionInfoKVOS64* kv_prot_info,
bool allow_concurrent, bool allow_concurrent,
MemTablePostProcessInfo* post_process_info, void** hint) { MemTablePostProcessInfo* post_process_info, void** hint) {
// Format of an entry is concatenation of: // Format of an entry is concatenation of:
@ -1036,7 +1033,7 @@ void MemTable::MultiGet(const ReadOptions& read_options, MultiGetRange* range,
Status MemTable::Update(SequenceNumber seq, const Slice& key, Status MemTable::Update(SequenceNumber seq, const Slice& key,
const Slice& value, const Slice& value,
const ProtectionInfoKVOTS64* kv_prot_info) { const ProtectionInfoKVOS64* kv_prot_info) {
LookupKey lkey(key, seq); LookupKey lkey(key, seq);
Slice mem_key = lkey.memtable_key(); Slice mem_key = lkey.memtable_key();
@ -1081,7 +1078,7 @@ Status MemTable::Update(SequenceNumber seq, const Slice& key,
VarintLength(value.size()) + value.size())); VarintLength(value.size()) + value.size()));
RecordTick(moptions_.statistics, NUMBER_KEYS_UPDATED); RecordTick(moptions_.statistics, NUMBER_KEYS_UPDATED);
if (kv_prot_info != nullptr) { if (kv_prot_info != nullptr) {
ProtectionInfoKVOTS64 updated_kv_prot_info(*kv_prot_info); ProtectionInfoKVOS64 updated_kv_prot_info(*kv_prot_info);
// `seq` is swallowed and `existing_seq` prevails. // `seq` is swallowed and `existing_seq` prevails.
updated_kv_prot_info.UpdateS(seq, existing_seq); updated_kv_prot_info.UpdateS(seq, existing_seq);
Slice encoded(entry, p + value.size() - entry); Slice encoded(entry, p + value.size() - entry);
@ -1099,7 +1096,7 @@ Status MemTable::Update(SequenceNumber seq, const Slice& key,
Status MemTable::UpdateCallback(SequenceNumber seq, const Slice& key, Status MemTable::UpdateCallback(SequenceNumber seq, const Slice& key,
const Slice& delta, const Slice& delta,
const ProtectionInfoKVOTS64* kv_prot_info) { const ProtectionInfoKVOS64* kv_prot_info) {
LookupKey lkey(key, seq); LookupKey lkey(key, seq);
Slice memkey = lkey.memtable_key(); Slice memkey = lkey.memtable_key();
@ -1154,7 +1151,7 @@ Status MemTable::UpdateCallback(SequenceNumber seq, const Slice& key,
RecordTick(moptions_.statistics, NUMBER_KEYS_UPDATED); RecordTick(moptions_.statistics, NUMBER_KEYS_UPDATED);
UpdateFlushState(); UpdateFlushState();
if (kv_prot_info != nullptr) { if (kv_prot_info != nullptr) {
ProtectionInfoKVOTS64 updated_kv_prot_info(*kv_prot_info); ProtectionInfoKVOS64 updated_kv_prot_info(*kv_prot_info);
// `seq` is swallowed and `existing_seq` prevails. // `seq` is swallowed and `existing_seq` prevails.
updated_kv_prot_info.UpdateS(seq, existing_seq); updated_kv_prot_info.UpdateS(seq, existing_seq);
updated_kv_prot_info.UpdateV(delta, updated_kv_prot_info.UpdateV(delta,
@ -1166,7 +1163,7 @@ Status MemTable::UpdateCallback(SequenceNumber seq, const Slice& key,
} else if (status == UpdateStatus::UPDATED) { } else if (status == UpdateStatus::UPDATED) {
Status s; Status s;
if (kv_prot_info != nullptr) { if (kv_prot_info != nullptr) {
ProtectionInfoKVOTS64 updated_kv_prot_info(*kv_prot_info); ProtectionInfoKVOS64 updated_kv_prot_info(*kv_prot_info);
updated_kv_prot_info.UpdateV(delta, str_value); updated_kv_prot_info.UpdateV(delta, str_value);
s = Add(seq, kTypeValue, key, Slice(str_value), s = Add(seq, kTypeValue, key, Slice(str_value),
&updated_kv_prot_info); &updated_kv_prot_info);

8
db/memtable.h
Unescape View File

@ -199,7 +199,7 @@ class MemTable {
const ReadOptions& read_options, SequenceNumber read_seq); const ReadOptions& read_options, SequenceNumber read_seq);
Status VerifyEncodedEntry(Slice encoded, Status VerifyEncodedEntry(Slice encoded,
const ProtectionInfoKVOTS64& kv_prot_info); const ProtectionInfoKVOS64& kv_prot_info);
// Add an entry into memtable that maps key to value at the // Add an entry into memtable that maps key to value at the
// specified sequence number and with the specified type. // specified sequence number and with the specified type.
@ -212,7 +212,7 @@ class MemTable {
// in the memtable and `MemTableRepFactory::CanHandleDuplicatedKey()` is true. // in the memtable and `MemTableRepFactory::CanHandleDuplicatedKey()` is true.
// The next attempt should try a larger value for `seq`. // The next attempt should try a larger value for `seq`.
Status Add(SequenceNumber seq, ValueType type, const Slice& key, Status Add(SequenceNumber seq, ValueType type, const Slice& key,
const Slice& value, const ProtectionInfoKVOTS64* kv_prot_info, const Slice& value, const ProtectionInfoKVOS64* kv_prot_info,
bool allow_concurrent = false, bool allow_concurrent = false,
MemTablePostProcessInfo* post_process_info = nullptr, MemTablePostProcessInfo* post_process_info = nullptr,
void** hint = nullptr); void** hint = nullptr);
@ -278,7 +278,7 @@ class MemTable {
// REQUIRES: external synchronization to prevent simultaneous // REQUIRES: external synchronization to prevent simultaneous
// operations on the same MemTable. // operations on the same MemTable.
Status Update(SequenceNumber seq, const Slice& key, const Slice& value, Status Update(SequenceNumber seq, const Slice& key, const Slice& value,
const ProtectionInfoKVOTS64* kv_prot_info); const ProtectionInfoKVOS64* kv_prot_info);
// If `key` exists in current memtable with type `kTypeValue` and the existing // If `key` exists in current memtable with type `kTypeValue` and the existing
// value is at least as large as the new value, updates it in-place. Otherwise // value is at least as large as the new value, updates it in-place. Otherwise
@ -296,7 +296,7 @@ class MemTable {
// operations on the same MemTable. // operations on the same MemTable.
Status UpdateCallback(SequenceNumber seq, const Slice& key, Status UpdateCallback(SequenceNumber seq, const Slice& key,
const Slice& delta, const Slice& delta,
const ProtectionInfoKVOTS64* kv_prot_info); const ProtectionInfoKVOS64* kv_prot_info);
// Returns the number of successive merge entries starting from the newest // Returns the number of successive merge entries starting from the newest
// entry for the key up to the last non-merge entry or last entry for the // entry for the key up to the last non-merge entry or last entry for the

123
db/write_batch.cc
Unescape View File

@ -217,11 +217,14 @@ class TimestampAssigner : public WriteBatch::Handler {
// This key does not have timestamp, so skip. // This key does not have timestamp, so skip.
return; return;
} }
char* ptr = const_cast<char*>(key.data() + key.size() - ts_sz);
if (prot_info_ != nullptr) { if (prot_info_ != nullptr) {
Slice old_ts(ptr, ts_sz), new_ts(ts.data(), ts_sz); SliceParts old_key(&key, 1);
prot_info_->entries_[idx_].UpdateT(old_ts, new_ts); Slice key_no_ts(key.data(), key.size() - ts_sz);
std::array<Slice, 2> new_key_cmpts{{key_no_ts, ts}};
SliceParts new_key(new_key_cmpts.data(), 2);
prot_info_->entries_[idx_].UpdateK(old_key, new_key);
} }
char* ptr = const_cast<char*>(key.data() + key.size() - ts_sz);
memcpy(ptr, ts.data(), ts_sz); memcpy(ptr, ts.data(), ts_sz);
} }
@ -808,10 +811,9 @@ Status WriteBatchInternal::Put(WriteBatch* b, uint32_t column_family_id,
// (a missing/extra encoded CF ID would corrupt another field). It is // (a missing/extra encoded CF ID would corrupt another field). It is
// convenient to consolidate on `kTypeValue` here as that is what will be // convenient to consolidate on `kTypeValue` here as that is what will be
// inserted into memtable. // inserted into memtable.
b->prot_info_->entries_.emplace_back( b->prot_info_->entries_.emplace_back(ProtectionInfo64()
ProtectionInfo64() .ProtectKVO(key, value, kTypeValue)
.ProtectKVOT(key, value, kTypeValue) .ProtectC(column_family_id));
.ProtectC(column_family_id));
} }
return save.commit(); return save.commit();
} }
@ -864,11 +866,10 @@ Status WriteBatchInternal::Put(WriteBatch* b, uint32_t column_family_id,
std::memory_order_relaxed); std::memory_order_relaxed);
if (b->prot_info_ != nullptr) { if (b->prot_info_ != nullptr) {
// See comment in first `WriteBatchInternal::Put()` overload concerning the // See comment in first `WriteBatchInternal::Put()` overload concerning the
// `ValueType` argument passed to `ProtectKVOT()`. // `ValueType` argument passed to `ProtectKVO()`.
b->prot_info_->entries_.emplace_back( b->prot_info_->entries_.emplace_back(ProtectionInfo64()
ProtectionInfo64() .ProtectKVO(key, value, kTypeValue)
.ProtectKVOT(key, value, kTypeValue) .ProtectC(column_family_id));
.ProtectC(column_family_id));
} }
return save.commit(); return save.commit();
} }
@ -950,10 +951,10 @@ Status WriteBatchInternal::Delete(WriteBatch* b, uint32_t column_family_id,
std::memory_order_relaxed); std::memory_order_relaxed);
if (b->prot_info_ != nullptr) { if (b->prot_info_ != nullptr) {
// See comment in first `WriteBatchInternal::Put()` overload concerning the // See comment in first `WriteBatchInternal::Put()` overload concerning the
// `ValueType` argument passed to `ProtectKVOT()`. // `ValueType` argument passed to `ProtectKVO()`.
b->prot_info_->entries_.emplace_back( b->prot_info_->entries_.emplace_back(
ProtectionInfo64() ProtectionInfo64()
.ProtectKVOT(key, "" /* value */, kTypeDeletion) .ProtectKVO(key, "" /* value */, kTypeDeletion)
.ProtectC(column_family_id)); .ProtectC(column_family_id));
} }
return save.commit(); return save.commit();
@ -980,12 +981,12 @@ Status WriteBatchInternal::Delete(WriteBatch* b, uint32_t column_family_id,
std::memory_order_relaxed); std::memory_order_relaxed);
if (b->prot_info_ != nullptr) { if (b->prot_info_ != nullptr) {
// See comment in first `WriteBatchInternal::Put()` overload concerning the // See comment in first `WriteBatchInternal::Put()` overload concerning the
// `ValueType` argument passed to `ProtectKVOT()`. // `ValueType` argument passed to `ProtectKVO()`.
b->prot_info_->entries_.emplace_back( b->prot_info_->entries_.emplace_back(
ProtectionInfo64() ProtectionInfo64()
.ProtectKVOT(key, .ProtectKVO(key,
SliceParts(nullptr /* _parts */, 0 /* _num_parts */), SliceParts(nullptr /* _parts */, 0 /* _num_parts */),
kTypeDeletion) kTypeDeletion)
.ProtectC(column_family_id)); .ProtectC(column_family_id));
} }
return save.commit(); return save.commit();
@ -1014,10 +1015,10 @@ Status WriteBatchInternal::SingleDelete(WriteBatch* b,
std::memory_order_relaxed); std::memory_order_relaxed);
if (b->prot_info_ != nullptr) { if (b->prot_info_ != nullptr) {
// See comment in first `WriteBatchInternal::Put()` overload concerning the // See comment in first `WriteBatchInternal::Put()` overload concerning the
// `ValueType` argument passed to `ProtectKVOT()`. // `ValueType` argument passed to `ProtectKVO()`.
b->prot_info_->entries_.emplace_back( b->prot_info_->entries_.emplace_back(
ProtectionInfo64() ProtectionInfo64()
.ProtectKVOT(key, "" /* value */, kTypeSingleDeletion) .ProtectKVO(key, "" /* value */, kTypeSingleDeletion)
.ProtectC(column_family_id)); .ProtectC(column_family_id));
} }
return save.commit(); return save.commit();
@ -1046,13 +1047,13 @@ Status WriteBatchInternal::SingleDelete(WriteBatch* b,
std::memory_order_relaxed); std::memory_order_relaxed);
if (b->prot_info_ != nullptr) { if (b->prot_info_ != nullptr) {
// See comment in first `WriteBatchInternal::Put()` overload concerning the // See comment in first `WriteBatchInternal::Put()` overload concerning the
// `ValueType` argument passed to `ProtectKVOT()`. // `ValueType` argument passed to `ProtectKVO()`.
b->prot_info_->entries_.emplace_back( b->prot_info_->entries_.emplace_back(
ProtectionInfo64() ProtectionInfo64()
.ProtectKVOT(key, .ProtectKVO(key,
SliceParts(nullptr /* _parts */, SliceParts(nullptr /* _parts */,
0 /* _num_parts */) /* value */, 0 /* _num_parts */) /* value */,
kTypeSingleDeletion) kTypeSingleDeletion)
.ProtectC(column_family_id)); .ProtectC(column_family_id));
} }
return save.commit(); return save.commit();
@ -1082,11 +1083,11 @@ Status WriteBatchInternal::DeleteRange(WriteBatch* b, uint32_t column_family_id,
std::memory_order_relaxed); std::memory_order_relaxed);
if (b->prot_info_ != nullptr) { if (b->prot_info_ != nullptr) {
// See comment in first `WriteBatchInternal::Put()` overload concerning the // See comment in first `WriteBatchInternal::Put()` overload concerning the
// `ValueType` argument passed to `ProtectKVOT()`. // `ValueType` argument passed to `ProtectKVO()`.
// In `DeleteRange()`, the end key is treated as the value. // In `DeleteRange()`, the end key is treated as the value.
b->prot_info_->entries_.emplace_back( b->prot_info_->entries_.emplace_back(
ProtectionInfo64() ProtectionInfo64()
.ProtectKVOT(begin_key, end_key, kTypeRangeDeletion) .ProtectKVO(begin_key, end_key, kTypeRangeDeletion)
.ProtectC(column_family_id)); .ProtectC(column_family_id));
} }
return save.commit(); return save.commit();
@ -1116,11 +1117,11 @@ Status WriteBatchInternal::DeleteRange(WriteBatch* b, uint32_t column_family_id,
std::memory_order_relaxed); std::memory_order_relaxed);
if (b->prot_info_ != nullptr) { if (b->prot_info_ != nullptr) {
// See comment in first `WriteBatchInternal::Put()` overload concerning the // See comment in first `WriteBatchInternal::Put()` overload concerning the
// `ValueType` argument passed to `ProtectKVOT()`. // `ValueType` argument passed to `ProtectKVO()`.
// In `DeleteRange()`, the end key is treated as the value. // In `DeleteRange()`, the end key is treated as the value.
b->prot_info_->entries_.emplace_back( b->prot_info_->entries_.emplace_back(
ProtectionInfo64() ProtectionInfo64()
.ProtectKVOT(begin_key, end_key, kTypeRangeDeletion) .ProtectKVO(begin_key, end_key, kTypeRangeDeletion)
.ProtectC(column_family_id)); .ProtectC(column_family_id));
} }
return save.commit(); return save.commit();
@ -1157,11 +1158,10 @@ Status WriteBatchInternal::Merge(WriteBatch* b, uint32_t column_family_id,
std::memory_order_relaxed); std::memory_order_relaxed);
if (b->prot_info_ != nullptr) { if (b->prot_info_ != nullptr) {
// See comment in first `WriteBatchInternal::Put()` overload concerning the // See comment in first `WriteBatchInternal::Put()` overload concerning the
// `ValueType` argument passed to `ProtectKVOT()`. // `ValueType` argument passed to `ProtectKVO()`.
b->prot_info_->entries_.emplace_back( b->prot_info_->entries_.emplace_back(ProtectionInfo64()
ProtectionInfo64() .ProtectKVO(key, value, kTypeMerge)
.ProtectKVOT(key, value, kTypeMerge) .ProtectC(column_family_id));
.ProtectC(column_family_id));
} }
return save.commit(); return save.commit();
} }
@ -1195,11 +1195,10 @@ Status WriteBatchInternal::Merge(WriteBatch* b, uint32_t column_family_id,
std::memory_order_relaxed); std::memory_order_relaxed);
if (b->prot_info_ != nullptr) { if (b->prot_info_ != nullptr) {
// See comment in first `WriteBatchInternal::Put()` overload concerning the // See comment in first `WriteBatchInternal::Put()` overload concerning the
// `ValueType` argument passed to `ProtectKVOT()`. // `ValueType` argument passed to `ProtectKVO()`.
b->prot_info_->entries_.emplace_back( b->prot_info_->entries_.emplace_back(ProtectionInfo64()
ProtectionInfo64() .ProtectKVO(key, value, kTypeMerge)
.ProtectKVOT(key, value, kTypeMerge) .ProtectC(column_family_id));
.ProtectC(column_family_id));
} }
return save.commit(); return save.commit();
} }
@ -1228,10 +1227,10 @@ Status WriteBatchInternal::PutBlobIndex(WriteBatch* b,
std::memory_order_relaxed); std::memory_order_relaxed);
if (b->prot_info_ != nullptr) { if (b->prot_info_ != nullptr) {
// See comment in first `WriteBatchInternal::Put()` overload concerning the // See comment in first `WriteBatchInternal::Put()` overload concerning the
// `ValueType` argument passed to `ProtectKVOT()`. // `ValueType` argument passed to `ProtectKVO()`.
b->prot_info_->entries_.emplace_back( b->prot_info_->entries_.emplace_back(
ProtectionInfo64() ProtectionInfo64()
.ProtectKVOT(key, value, kTypeBlobIndex) .ProtectKVO(key, value, kTypeBlobIndex)
.ProtectC(column_family_id)); .ProtectC(column_family_id));
} }
return save.commit(); return save.commit();
@ -1380,8 +1379,8 @@ class MemTableInserter : public WriteBatch::Handler {
(&duplicate_detector_)->IsDuplicateKeySeq(column_family_id, key, sequence_); (&duplicate_detector_)->IsDuplicateKeySeq(column_family_id, key, sequence_);
} }
const ProtectionInfoKVOTC64* NextProtectionInfo() { const ProtectionInfoKVOC64* NextProtectionInfo() {
const ProtectionInfoKVOTC64* res = nullptr; const ProtectionInfoKVOC64* res = nullptr;
if (prot_info_ != nullptr) { if (prot_info_ != nullptr) {
assert(prot_info_idx_ < prot_info_->entries_.size()); assert(prot_info_idx_ < prot_info_->entries_.size());
res = &prot_info_->entries_[prot_info_idx_]; res = &prot_info_->entries_[prot_info_idx_];
@ -1534,10 +1533,10 @@ class MemTableInserter : public WriteBatch::Handler {
Status PutCFImpl(uint32_t column_family_id, const Slice& key, Status PutCFImpl(uint32_t column_family_id, const Slice& key,
const Slice& value, ValueType value_type, const Slice& value, ValueType value_type,
const ProtectionInfoKVOTS64* kv_prot_info) { const ProtectionInfoKVOS64* kv_prot_info) {
// optimize for non-recovery mode // optimize for non-recovery mode
if (UNLIKELY(write_after_commit_ && rebuilding_trx_ != nullptr)) { if (UNLIKELY(write_after_commit_ && rebuilding_trx_ != nullptr)) {
// TODO(ajkr): propagate `ProtectionInfoKVOTS64`. // TODO(ajkr): propagate `ProtectionInfoKVOS64`.
return WriteBatchInternal::Put(rebuilding_trx_, column_family_id, key, return WriteBatchInternal::Put(rebuilding_trx_, column_family_id, key,
value); value);
// else insert the values to the memtable right away // else insert the values to the memtable right away
@ -1549,7 +1548,7 @@ class MemTableInserter : public WriteBatch::Handler {
assert(!write_after_commit_); assert(!write_after_commit_);
// The CF is probably flushed and hence no need for insert but we still // The CF is probably flushed and hence no need for insert but we still
// need to keep track of the keys for upcoming rollback/commit. // need to keep track of the keys for upcoming rollback/commit.
// TODO(ajkr): propagate `ProtectionInfoKVOTS64`. // TODO(ajkr): propagate `ProtectionInfoKVOS64`.
ret_status = WriteBatchInternal::Put(rebuilding_trx_, column_family_id, ret_status = WriteBatchInternal::Put(rebuilding_trx_, column_family_id,
key, value); key, value);
if (ret_status.ok()) { if (ret_status.ok()) {
@ -1620,7 +1619,7 @@ class MemTableInserter : public WriteBatch::Handler {
if (update_status == UpdateStatus::UPDATED_INPLACE) { if (update_status == UpdateStatus::UPDATED_INPLACE) {
assert(get_status.ok()); assert(get_status.ok());
if (kv_prot_info != nullptr) { if (kv_prot_info != nullptr) {
ProtectionInfoKVOTS64 updated_kv_prot_info(*kv_prot_info); ProtectionInfoKVOS64 updated_kv_prot_info(*kv_prot_info);
updated_kv_prot_info.UpdateV(value, updated_kv_prot_info.UpdateV(value,
Slice(prev_buffer, prev_size)); Slice(prev_buffer, prev_size));
// prev_value is updated in-place with final value. // prev_value is updated in-place with final value.
@ -1637,7 +1636,7 @@ class MemTableInserter : public WriteBatch::Handler {
} }
} else if (update_status == UpdateStatus::UPDATED) { } else if (update_status == UpdateStatus::UPDATED) {
if (kv_prot_info != nullptr) { if (kv_prot_info != nullptr) {
ProtectionInfoKVOTS64 updated_kv_prot_info(*kv_prot_info); ProtectionInfoKVOS64 updated_kv_prot_info(*kv_prot_info);
updated_kv_prot_info.UpdateV(value, merged_value); updated_kv_prot_info.UpdateV(value, merged_value);
// merged_value contains the final value. // merged_value contains the final value.
ret_status = mem->Add(sequence_, value_type, key, ret_status = mem->Add(sequence_, value_type, key,
@ -1670,7 +1669,7 @@ class MemTableInserter : public WriteBatch::Handler {
// away. So we only need to add to it when `ret_status.ok()`. // away. So we only need to add to it when `ret_status.ok()`.
if (UNLIKELY(ret_status.ok() && rebuilding_trx_ != nullptr)) { if (UNLIKELY(ret_status.ok() && rebuilding_trx_ != nullptr)) {
assert(!write_after_commit_); assert(!write_after_commit_);
// TODO(ajkr): propagate `ProtectionInfoKVOTS64`. // TODO(ajkr): propagate `ProtectionInfoKVOS64`.
ret_status = WriteBatchInternal::Put(rebuilding_trx_, column_family_id, ret_status = WriteBatchInternal::Put(rebuilding_trx_, column_family_id,
key, value); key, value);
} }
@ -1693,7 +1692,7 @@ class MemTableInserter : public WriteBatch::Handler {
Status DeleteImpl(uint32_t /*column_family_id*/, const Slice& key, Status DeleteImpl(uint32_t /*column_family_id*/, const Slice& key,
const Slice& value, ValueType delete_type, const Slice& value, ValueType delete_type,
const ProtectionInfoKVOTS64* kv_prot_info) { const ProtectionInfoKVOS64* kv_prot_info) {
Status ret_status; Status ret_status;
MemTable* mem = cf_mems_->GetMemTable(); MemTable* mem = cf_mems_->GetMemTable();
ret_status = ret_status =
@ -1715,7 +1714,7 @@ class MemTableInserter : public WriteBatch::Handler {
const auto* kv_prot_info = NextProtectionInfo(); const auto* kv_prot_info = NextProtectionInfo();
// optimize for non-recovery mode // optimize for non-recovery mode
if (UNLIKELY(write_after_commit_ && rebuilding_trx_ != nullptr)) { if (UNLIKELY(write_after_commit_ && rebuilding_trx_ != nullptr)) {
// TODO(ajkr): propagate `ProtectionInfoKVOTS64`. // TODO(ajkr): propagate `ProtectionInfoKVOS64`.
return WriteBatchInternal::Delete(rebuilding_trx_, column_family_id, key); return WriteBatchInternal::Delete(rebuilding_trx_, column_family_id, key);
// else insert the values to the memtable right away // else insert the values to the memtable right away
} }
@ -1726,7 +1725,7 @@ class MemTableInserter : public WriteBatch::Handler {
assert(!write_after_commit_); assert(!write_after_commit_);
// The CF is probably flushed and hence no need for insert but we still // The CF is probably flushed and hence no need for insert but we still
// need to keep track of the keys for upcoming rollback/commit. // need to keep track of the keys for upcoming rollback/commit.
// TODO(ajkr): propagate `ProtectionInfoKVOTS64`. // TODO(ajkr): propagate `ProtectionInfoKVOS64`.
ret_status = ret_status =
WriteBatchInternal::Delete(rebuilding_trx_, column_family_id, key); WriteBatchInternal::Delete(rebuilding_trx_, column_family_id, key);
if (ret_status.ok()) { if (ret_status.ok()) {
@ -1762,7 +1761,7 @@ class MemTableInserter : public WriteBatch::Handler {
// away. So we only need to add to it when `ret_status.ok()`. // away. So we only need to add to it when `ret_status.ok()`.
if (UNLIKELY(ret_status.ok() && rebuilding_trx_ != nullptr)) { if (UNLIKELY(ret_status.ok() && rebuilding_trx_ != nullptr)) {
assert(!write_after_commit_); assert(!write_after_commit_);
// TODO(ajkr): propagate `ProtectionInfoKVOTS64`. // TODO(ajkr): propagate `ProtectionInfoKVOS64`.
ret_status = ret_status =
WriteBatchInternal::Delete(rebuilding_trx_, column_family_id, key); WriteBatchInternal::Delete(rebuilding_trx_, column_family_id, key);
} }
@ -1773,7 +1772,7 @@ class MemTableInserter : public WriteBatch::Handler {
const auto* kv_prot_info = NextProtectionInfo(); const auto* kv_prot_info = NextProtectionInfo();
// optimize for non-recovery mode // optimize for non-recovery mode
if (UNLIKELY(write_after_commit_ && rebuilding_trx_ != nullptr)) { if (UNLIKELY(write_after_commit_ && rebuilding_trx_ != nullptr)) {
// TODO(ajkr): propagate `ProtectionInfoKVOTS64`. // TODO(ajkr): propagate `ProtectionInfoKVOS64`.
return WriteBatchInternal::SingleDelete(rebuilding_trx_, column_family_id, return WriteBatchInternal::SingleDelete(rebuilding_trx_, column_family_id,
key); key);
// else insert the values to the memtable right away // else insert the values to the memtable right away
@ -1785,7 +1784,7 @@ class MemTableInserter : public WriteBatch::Handler {
assert(!write_after_commit_); assert(!write_after_commit_);
// The CF is probably flushed and hence no need for insert but we still // The CF is probably flushed and hence no need for insert but we still
// need to keep track of the keys for upcoming rollback/commit. // need to keep track of the keys for upcoming rollback/commit.
// TODO(ajkr): propagate `ProtectionInfoKVOTS64`. // TODO(ajkr): propagate `ProtectionInfoKVOS64`.
ret_status = WriteBatchInternal::SingleDelete(rebuilding_trx_, ret_status = WriteBatchInternal::SingleDelete(rebuilding_trx_,
column_family_id, key); column_family_id, key);
if (ret_status.ok()) { if (ret_status.ok()) {
@ -1814,7 +1813,7 @@ class MemTableInserter : public WriteBatch::Handler {
// away. So we only need to add to it when `ret_status.ok()`. // away. So we only need to add to it when `ret_status.ok()`.
if (UNLIKELY(ret_status.ok() && rebuilding_trx_ != nullptr)) { if (UNLIKELY(ret_status.ok() && rebuilding_trx_ != nullptr)) {
assert(!write_after_commit_); assert(!write_after_commit_);
// TODO(ajkr): propagate `ProtectionInfoKVOTS64`. // TODO(ajkr): propagate `ProtectionInfoKVOS64`.
ret_status = WriteBatchInternal::SingleDelete(rebuilding_trx_, ret_status = WriteBatchInternal::SingleDelete(rebuilding_trx_,
column_family_id, key); column_family_id, key);
} }
@ -1826,7 +1825,7 @@ class MemTableInserter : public WriteBatch::Handler {
const auto* kv_prot_info = NextProtectionInfo(); const auto* kv_prot_info = NextProtectionInfo();
// optimize for non-recovery mode // optimize for non-recovery mode
if (UNLIKELY(write_after_commit_ && rebuilding_trx_ != nullptr)) { if (UNLIKELY(write_after_commit_ && rebuilding_trx_ != nullptr)) {
// TODO(ajkr): propagate `ProtectionInfoKVOTS64`. // TODO(ajkr): propagate `ProtectionInfoKVOS64`.
return WriteBatchInternal::DeleteRange(rebuilding_trx_, column_family_id, return WriteBatchInternal::DeleteRange(rebuilding_trx_, column_family_id,
begin_key, end_key); begin_key, end_key);
// else insert the values to the memtable right away // else insert the values to the memtable right away
@ -1838,7 +1837,7 @@ class MemTableInserter : public WriteBatch::Handler {
assert(!write_after_commit_); assert(!write_after_commit_);
// The CF is probably flushed and hence no need for insert but we still // The CF is probably flushed and hence no need for insert but we still
// need to keep track of the keys for upcoming rollback/commit. // need to keep track of the keys for upcoming rollback/commit.
// TODO(ajkr): propagate `ProtectionInfoKVOTS64`. // TODO(ajkr): propagate `ProtectionInfoKVOS64`.
ret_status = WriteBatchInternal::DeleteRange( ret_status = WriteBatchInternal::DeleteRange(
rebuilding_trx_, column_family_id, begin_key, end_key); rebuilding_trx_, column_family_id, begin_key, end_key);
if (ret_status.ok()) { if (ret_status.ok()) {
@ -1897,7 +1896,7 @@ class MemTableInserter : public WriteBatch::Handler {
// away. So we only need to add to it when `ret_status.ok()`. // away. So we only need to add to it when `ret_status.ok()`.
if (UNLIKELY(!ret_status.IsTryAgain() && rebuilding_trx_ != nullptr)) { if (UNLIKELY(!ret_status.IsTryAgain() && rebuilding_trx_ != nullptr)) {
assert(!write_after_commit_); assert(!write_after_commit_);
// TODO(ajkr): propagate `ProtectionInfoKVOTS64`. // TODO(ajkr): propagate `ProtectionInfoKVOS64`.
ret_status = WriteBatchInternal::DeleteRange( ret_status = WriteBatchInternal::DeleteRange(
rebuilding_trx_, column_family_id, begin_key, end_key); rebuilding_trx_, column_family_id, begin_key, end_key);
} }
@ -1909,7 +1908,7 @@ class MemTableInserter : public WriteBatch::Handler {
const auto* kv_prot_info = NextProtectionInfo(); const auto* kv_prot_info = NextProtectionInfo();
// optimize for non-recovery mode // optimize for non-recovery mode
if (UNLIKELY(write_after_commit_ && rebuilding_trx_ != nullptr)) { if (UNLIKELY(write_after_commit_ && rebuilding_trx_ != nullptr)) {
// TODO(ajkr): propagate `ProtectionInfoKVOTS64`. // TODO(ajkr): propagate `ProtectionInfoKVOS64`.
return WriteBatchInternal::Merge(rebuilding_trx_, column_family_id, key, return WriteBatchInternal::Merge(rebuilding_trx_, column_family_id, key,
value); value);
// else insert the values to the memtable right away // else insert the values to the memtable right away
@ -1921,7 +1920,7 @@ class MemTableInserter : public WriteBatch::Handler {
assert(!write_after_commit_); assert(!write_after_commit_);
// The CF is probably flushed and hence no need for insert but we still // The CF is probably flushed and hence no need for insert but we still
// need to keep track of the keys for upcoming rollback/commit. // need to keep track of the keys for upcoming rollback/commit.
// TODO(ajkr): propagate `ProtectionInfoKVOTS64`. // TODO(ajkr): propagate `ProtectionInfoKVOS64`.
ret_status = WriteBatchInternal::Merge(rebuilding_trx_, ret_status = WriteBatchInternal::Merge(rebuilding_trx_,
column_family_id, key, value); column_family_id, key, value);
if (ret_status.ok()) { if (ret_status.ok()) {
@ -2047,7 +2046,7 @@ class MemTableInserter : public WriteBatch::Handler {
// away. So we only need to add to it when `ret_status.ok()`. // away. So we only need to add to it when `ret_status.ok()`.
if (UNLIKELY(ret_status.ok() && rebuilding_trx_ != nullptr)) { if (UNLIKELY(ret_status.ok() && rebuilding_trx_ != nullptr)) {
assert(!write_after_commit_); assert(!write_after_commit_);
// TODO(ajkr): propagate `ProtectionInfoKVOTS64`. // TODO(ajkr): propagate `ProtectionInfoKVOS64`.
ret_status = WriteBatchInternal::Merge(rebuilding_trx_, column_family_id, ret_status = WriteBatchInternal::Merge(rebuilding_trx_, column_family_id,
key, value); key, value);
} }

2
db/write_batch_internal.h
Unescape View File

@ -66,7 +66,7 @@ class ColumnFamilyMemTablesDefault : public ColumnFamilyMemTables {
struct WriteBatch::ProtectionInfo { struct WriteBatch::ProtectionInfo {
// `WriteBatch` usually doesn't contain a huge number of keys so protecting // `WriteBatch` usually doesn't contain a huge number of keys so protecting
// with a fixed, non-configurable eight bytes per key may work well enough. // with a fixed, non-configurable eight bytes per key may work well enough.
autovector<ProtectionInfoKVOTC64> entries_; autovector<ProtectionInfoKVOC64> entries_;
size_t GetBytesPerKey() const { return 8; } size_t GetBytesPerKey() const { return 8; }
}; };

Write Preview
Loading…
Cancel
Save