2016-02-10 00:12:00 +01:00
|
|
|
// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
|
2017-07-16 01:03:42 +02:00
|
|
|
// This source code is licensed under both the GPLv2 (found in the
|
|
|
|
// COPYING file in the root directory) and Apache 2.0 License
|
|
|
|
// (found in the LICENSE.Apache file in the root directory).
|
2015-02-24 02:49:23 +01:00
|
|
|
|
|
|
|
#include "rocksdb/write_batch_base.h"
|
|
|
|
|
|
|
|
#include <string>
|
|
|
|
|
|
|
|
#include "rocksdb/slice.h"
|
2017-04-11 00:38:34 +02:00
|
|
|
#include "rocksdb/status.h"
|
2015-02-24 02:49:23 +01:00
|
|
|
|
|
|
|
namespace rocksdb {
|
|
|
|
|
|
|
|
// Simple implementation of SlicePart variants of Put(). Child classes
|
|
|
|
// can override these method with more performant solutions if they choose.
|
2017-04-11 00:38:34 +02:00
|
|
|
Status WriteBatchBase::Put(ColumnFamilyHandle* column_family,
|
|
|
|
const SliceParts& key, const SliceParts& value) {
|
2015-02-24 02:49:23 +01:00
|
|
|
std::string key_buf, value_buf;
|
|
|
|
Slice key_slice(key, &key_buf);
|
|
|
|
Slice value_slice(value, &value_buf);
|
|
|
|
|
2017-04-11 00:38:34 +02:00
|
|
|
return Put(column_family, key_slice, value_slice);
|
2015-02-24 02:49:23 +01:00
|
|
|
}
|
|
|
|
|
2017-04-11 00:38:34 +02:00
|
|
|
Status WriteBatchBase::Put(const SliceParts& key, const SliceParts& value) {
|
2015-02-24 02:49:23 +01:00
|
|
|
std::string key_buf, value_buf;
|
|
|
|
Slice key_slice(key, &key_buf);
|
|
|
|
Slice value_slice(value, &value_buf);
|
|
|
|
|
2017-04-11 00:38:34 +02:00
|
|
|
return Put(key_slice, value_slice);
|
2015-02-24 02:49:23 +01:00
|
|
|
}
|
|
|
|
|
2017-04-11 00:38:34 +02:00
|
|
|
Status WriteBatchBase::Delete(ColumnFamilyHandle* column_family,
|
|
|
|
const SliceParts& key) {
|
2015-02-24 02:49:23 +01:00
|
|
|
std::string key_buf;
|
|
|
|
Slice key_slice(key, &key_buf);
|
2017-04-11 00:38:34 +02:00
|
|
|
return Delete(column_family, key_slice);
|
2015-02-24 02:49:23 +01:00
|
|
|
}
|
|
|
|
|
2017-04-11 00:38:34 +02:00
|
|
|
Status WriteBatchBase::Delete(const SliceParts& key) {
|
2015-02-24 02:49:23 +01:00
|
|
|
std::string key_buf;
|
|
|
|
Slice key_slice(key, &key_buf);
|
2017-04-11 00:38:34 +02:00
|
|
|
return Delete(key_slice);
|
2015-02-24 02:49:23 +01:00
|
|
|
}
|
|
|
|
|
2017-04-11 00:38:34 +02:00
|
|
|
Status WriteBatchBase::SingleDelete(ColumnFamilyHandle* column_family,
|
|
|
|
const SliceParts& key) {
|
Support for SingleDelete()
Summary:
This patch fixes #7460559. It introduces SingleDelete as a new database
operation. This operation can be used to delete keys that were never
overwritten (no put following another put of the same key). If an overwritten
key is single deleted the behavior is undefined. Single deletion of a
non-existent key has no effect but multiple consecutive single deletions are
not allowed (see limitations).
In contrast to the conventional Delete() operation, the deletion entry is
removed along with the value when the two are lined up in a compaction. Note:
The semantics are similar to @igor's prototype that allowed to have this
behavior on the granularity of a column family (
https://reviews.facebook.net/D42093 ). This new patch, however, is more
aggressive when it comes to removing tombstones: It removes the SingleDelete
together with the value whenever there is no snapshot between them while the
older patch only did this when the sequence number of the deletion was older
than the earliest snapshot.
Most of the complex additions are in the Compaction Iterator, all other changes
should be relatively straightforward. The patch also includes basic support for
single deletions in db_stress and db_bench.
Limitations:
- Not compatible with cuckoo hash tables
- Single deletions cannot be used in combination with merges and normal
deletions on the same key (other keys are not affected by this)
- Consecutive single deletions are currently not allowed (and older version of
this patch supported this so it could be resurrected if needed)
Test Plan: make all check
Reviewers: yhchiang, sdong, rven, anthony, yoshinorim, igor
Reviewed By: igor
Subscribers: maykov, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D43179
2015-09-17 20:42:56 +02:00
|
|
|
std::string key_buf;
|
|
|
|
Slice key_slice(key, &key_buf);
|
2017-04-11 00:38:34 +02:00
|
|
|
return SingleDelete(column_family, key_slice);
|
Support for SingleDelete()
Summary:
This patch fixes #7460559. It introduces SingleDelete as a new database
operation. This operation can be used to delete keys that were never
overwritten (no put following another put of the same key). If an overwritten
key is single deleted the behavior is undefined. Single deletion of a
non-existent key has no effect but multiple consecutive single deletions are
not allowed (see limitations).
In contrast to the conventional Delete() operation, the deletion entry is
removed along with the value when the two are lined up in a compaction. Note:
The semantics are similar to @igor's prototype that allowed to have this
behavior on the granularity of a column family (
https://reviews.facebook.net/D42093 ). This new patch, however, is more
aggressive when it comes to removing tombstones: It removes the SingleDelete
together with the value whenever there is no snapshot between them while the
older patch only did this when the sequence number of the deletion was older
than the earliest snapshot.
Most of the complex additions are in the Compaction Iterator, all other changes
should be relatively straightforward. The patch also includes basic support for
single deletions in db_stress and db_bench.
Limitations:
- Not compatible with cuckoo hash tables
- Single deletions cannot be used in combination with merges and normal
deletions on the same key (other keys are not affected by this)
- Consecutive single deletions are currently not allowed (and older version of
this patch supported this so it could be resurrected if needed)
Test Plan: make all check
Reviewers: yhchiang, sdong, rven, anthony, yoshinorim, igor
Reviewed By: igor
Subscribers: maykov, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D43179
2015-09-17 20:42:56 +02:00
|
|
|
}
|
|
|
|
|
2017-04-11 00:38:34 +02:00
|
|
|
Status WriteBatchBase::SingleDelete(const SliceParts& key) {
|
Support for SingleDelete()
Summary:
This patch fixes #7460559. It introduces SingleDelete as a new database
operation. This operation can be used to delete keys that were never
overwritten (no put following another put of the same key). If an overwritten
key is single deleted the behavior is undefined. Single deletion of a
non-existent key has no effect but multiple consecutive single deletions are
not allowed (see limitations).
In contrast to the conventional Delete() operation, the deletion entry is
removed along with the value when the two are lined up in a compaction. Note:
The semantics are similar to @igor's prototype that allowed to have this
behavior on the granularity of a column family (
https://reviews.facebook.net/D42093 ). This new patch, however, is more
aggressive when it comes to removing tombstones: It removes the SingleDelete
together with the value whenever there is no snapshot between them while the
older patch only did this when the sequence number of the deletion was older
than the earliest snapshot.
Most of the complex additions are in the Compaction Iterator, all other changes
should be relatively straightforward. The patch also includes basic support for
single deletions in db_stress and db_bench.
Limitations:
- Not compatible with cuckoo hash tables
- Single deletions cannot be used in combination with merges and normal
deletions on the same key (other keys are not affected by this)
- Consecutive single deletions are currently not allowed (and older version of
this patch supported this so it could be resurrected if needed)
Test Plan: make all check
Reviewers: yhchiang, sdong, rven, anthony, yoshinorim, igor
Reviewed By: igor
Subscribers: maykov, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D43179
2015-09-17 20:42:56 +02:00
|
|
|
std::string key_buf;
|
|
|
|
Slice key_slice(key, &key_buf);
|
2017-04-11 00:38:34 +02:00
|
|
|
return SingleDelete(key_slice);
|
Support for SingleDelete()
Summary:
This patch fixes #7460559. It introduces SingleDelete as a new database
operation. This operation can be used to delete keys that were never
overwritten (no put following another put of the same key). If an overwritten
key is single deleted the behavior is undefined. Single deletion of a
non-existent key has no effect but multiple consecutive single deletions are
not allowed (see limitations).
In contrast to the conventional Delete() operation, the deletion entry is
removed along with the value when the two are lined up in a compaction. Note:
The semantics are similar to @igor's prototype that allowed to have this
behavior on the granularity of a column family (
https://reviews.facebook.net/D42093 ). This new patch, however, is more
aggressive when it comes to removing tombstones: It removes the SingleDelete
together with the value whenever there is no snapshot between them while the
older patch only did this when the sequence number of the deletion was older
than the earliest snapshot.
Most of the complex additions are in the Compaction Iterator, all other changes
should be relatively straightforward. The patch also includes basic support for
single deletions in db_stress and db_bench.
Limitations:
- Not compatible with cuckoo hash tables
- Single deletions cannot be used in combination with merges and normal
deletions on the same key (other keys are not affected by this)
- Consecutive single deletions are currently not allowed (and older version of
this patch supported this so it could be resurrected if needed)
Test Plan: make all check
Reviewers: yhchiang, sdong, rven, anthony, yoshinorim, igor
Reviewed By: igor
Subscribers: maykov, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D43179
2015-09-17 20:42:56 +02:00
|
|
|
}
|
|
|
|
|
2017-04-11 00:38:34 +02:00
|
|
|
Status WriteBatchBase::DeleteRange(ColumnFamilyHandle* column_family,
|
|
|
|
const SliceParts& begin_key,
|
|
|
|
const SliceParts& end_key) {
|
2016-08-16 17:16:04 +02:00
|
|
|
std::string begin_key_buf, end_key_buf;
|
|
|
|
Slice begin_key_slice(begin_key, &begin_key_buf);
|
|
|
|
Slice end_key_slice(end_key, &end_key_buf);
|
2017-04-11 00:38:34 +02:00
|
|
|
return DeleteRange(column_family, begin_key_slice, end_key_slice);
|
2016-08-16 17:16:04 +02:00
|
|
|
}
|
|
|
|
|
2017-04-11 00:38:34 +02:00
|
|
|
Status WriteBatchBase::DeleteRange(const SliceParts& begin_key,
|
|
|
|
const SliceParts& end_key) {
|
2016-08-16 17:16:04 +02:00
|
|
|
std::string begin_key_buf, end_key_buf;
|
|
|
|
Slice begin_key_slice(begin_key, &begin_key_buf);
|
|
|
|
Slice end_key_slice(end_key, &end_key_buf);
|
2017-04-11 00:38:34 +02:00
|
|
|
return DeleteRange(begin_key_slice, end_key_slice);
|
2016-08-16 17:16:04 +02:00
|
|
|
}
|
|
|
|
|
2017-04-11 00:38:34 +02:00
|
|
|
Status WriteBatchBase::Merge(ColumnFamilyHandle* column_family,
|
|
|
|
const SliceParts& key, const SliceParts& value) {
|
2015-05-28 01:59:22 +02:00
|
|
|
std::string key_buf, value_buf;
|
|
|
|
Slice key_slice(key, &key_buf);
|
|
|
|
Slice value_slice(value, &value_buf);
|
|
|
|
|
2017-04-11 00:38:34 +02:00
|
|
|
return Merge(column_family, key_slice, value_slice);
|
2015-05-28 01:59:22 +02:00
|
|
|
}
|
|
|
|
|
2017-04-11 00:38:34 +02:00
|
|
|
Status WriteBatchBase::Merge(const SliceParts& key, const SliceParts& value) {
|
2015-05-28 01:59:22 +02:00
|
|
|
std::string key_buf, value_buf;
|
|
|
|
Slice key_slice(key, &key_buf);
|
|
|
|
Slice value_slice(value, &value_buf);
|
|
|
|
|
2017-04-11 00:38:34 +02:00
|
|
|
return Merge(key_slice, value_slice);
|
2015-05-28 01:59:22 +02:00
|
|
|
}
|
|
|
|
|
2015-02-24 02:49:23 +01:00
|
|
|
} // namespace rocksdb
|