#include "rocksdb/utilities/write_batch_with_index.h"
#include "rocksdb/write_buffer_manager.h"
#include "table/scoped_arena_iterator.h"
+#include "test_util/testharness.h"
#include "util/string_util.h"
-#include "util/testharness.h"
-namespace rocksdb {
+namespace ROCKSDB_NAMESPACE {
static std::string PrintContents(WriteBatch* b) {
InternalKeyComparator cmp(BytewiseComparator());
mem->Ref();
std::string state;
ColumnFamilyMemTablesDefault cf_mems_default(mem);
- Status s = WriteBatchInternal::InsertInto(b, &cf_mems_default, nullptr);
- int count = 0;
+ Status s =
+ WriteBatchInternal::InsertInto(b, &cf_mems_default, nullptr, nullptr);
+ uint32_t count = 0;
int put_count = 0;
int delete_count = 0;
int single_delete_count = 0;
for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
ParsedInternalKey ikey;
ikey.clear();
- EXPECT_TRUE(ParseInternalKey(iter->key(), &ikey));
+ EXPECT_OK(ParseInternalKey(iter->key(), &ikey, true /* log_err_key */));
switch (ikey.type) {
case kTypeValue:
state.append("Put(");
TEST_F(WriteBatchTest, Empty) {
WriteBatch batch;
ASSERT_EQ("", PrintContents(&batch));
- ASSERT_EQ(0, WriteBatchInternal::Count(&batch));
- ASSERT_EQ(0, batch.Count());
+ ASSERT_EQ(0u, WriteBatchInternal::Count(&batch));
+ ASSERT_EQ(0u, batch.Count());
}
TEST_F(WriteBatchTest, Multiple) {
WriteBatch batch;
- batch.Put(Slice("foo"), Slice("bar"));
- batch.Delete(Slice("box"));
- batch.DeleteRange(Slice("bar"), Slice("foo"));
- batch.Put(Slice("baz"), Slice("boo"));
+ ASSERT_OK(batch.Put(Slice("foo"), Slice("bar")));
+ ASSERT_OK(batch.Delete(Slice("box")));
+ ASSERT_OK(batch.DeleteRange(Slice("bar"), Slice("foo")));
+ ASSERT_OK(batch.Put(Slice("baz"), Slice("boo")));
WriteBatchInternal::SetSequence(&batch, 100);
ASSERT_EQ(100U, WriteBatchInternal::Sequence(&batch));
- ASSERT_EQ(4, WriteBatchInternal::Count(&batch));
+ ASSERT_EQ(4u, WriteBatchInternal::Count(&batch));
ASSERT_EQ(
"Put(baz, boo)@103"
"Delete(box)@101"
"Put(foo, bar)@100"
"DeleteRange(bar, foo)@102",
PrintContents(&batch));
- ASSERT_EQ(4, batch.Count());
+ ASSERT_EQ(4u, batch.Count());
}
TEST_F(WriteBatchTest, Corruption) {
WriteBatch batch;
- batch.Put(Slice("foo"), Slice("bar"));
- batch.Delete(Slice("box"));
+ ASSERT_OK(batch.Put(Slice("foo"), Slice("bar")));
+ ASSERT_OK(batch.Delete(Slice("box")));
WriteBatchInternal::SetSequence(&batch, 200);
Slice contents = WriteBatchInternal::Contents(&batch);
- WriteBatchInternal::SetContents(&batch,
- Slice(contents.data(),contents.size()-1));
+ ASSERT_OK(WriteBatchInternal::SetContents(
+ &batch, Slice(contents.data(), contents.size() - 1)));
ASSERT_EQ("Put(foo, bar)@200"
"Corruption: bad WriteBatch Delete",
PrintContents(&batch));
WriteBatch b1, b2;
WriteBatchInternal::SetSequence(&b1, 200);
WriteBatchInternal::SetSequence(&b2, 300);
- WriteBatchInternal::Append(&b1, &b2);
+ ASSERT_OK(WriteBatchInternal::Append(&b1, &b2));
ASSERT_EQ("",
PrintContents(&b1));
- ASSERT_EQ(0, b1.Count());
- b2.Put("a", "va");
- WriteBatchInternal::Append(&b1, &b2);
+ ASSERT_EQ(0u, b1.Count());
+ ASSERT_OK(b2.Put("a", "va"));
+ ASSERT_OK(WriteBatchInternal::Append(&b1, &b2));
ASSERT_EQ("Put(a, va)@200",
PrintContents(&b1));
- ASSERT_EQ(1, b1.Count());
+ ASSERT_EQ(1u, b1.Count());
b2.Clear();
- b2.Put("b", "vb");
- WriteBatchInternal::Append(&b1, &b2);
+ ASSERT_OK(b2.Put("b", "vb"));
+ ASSERT_OK(WriteBatchInternal::Append(&b1, &b2));
ASSERT_EQ("Put(a, va)@200"
"Put(b, vb)@201",
PrintContents(&b1));
- ASSERT_EQ(2, b1.Count());
- b2.Delete("foo");
- WriteBatchInternal::Append(&b1, &b2);
+ ASSERT_EQ(2u, b1.Count());
+ ASSERT_OK(b2.Delete("foo"));
+ ASSERT_OK(WriteBatchInternal::Append(&b1, &b2));
ASSERT_EQ("Put(a, va)@200"
"Put(b, vb)@202"
"Put(b, vb)@201"
"Delete(foo)@203",
PrintContents(&b1));
- ASSERT_EQ(4, b1.Count());
+ ASSERT_EQ(4u, b1.Count());
b2.Clear();
- b2.Put("c", "cc");
- b2.Put("d", "dd");
+ ASSERT_OK(b2.Put("c", "cc"));
+ ASSERT_OK(b2.Put("d", "dd"));
b2.MarkWalTerminationPoint();
- b2.Put("e", "ee");
- WriteBatchInternal::Append(&b1, &b2, /*wal only*/ true);
+ ASSERT_OK(b2.Put("e", "ee"));
+ ASSERT_OK(WriteBatchInternal::Append(&b1, &b2, /*wal only*/ true));
ASSERT_EQ(
"Put(a, va)@200"
"Put(b, vb)@202"
"Put(d, dd)@205"
"Delete(foo)@203",
PrintContents(&b1));
- ASSERT_EQ(6, b1.Count());
+ ASSERT_EQ(6u, b1.Count());
ASSERT_EQ(
"Put(c, cc)@0"
"Put(d, dd)@1"
"Put(e, ee)@2",
PrintContents(&b2));
- ASSERT_EQ(3, b2.Count());
+ ASSERT_EQ(3u, b2.Count());
}
TEST_F(WriteBatchTest, SingleDeletion) {
WriteBatch batch;
WriteBatchInternal::SetSequence(&batch, 100);
ASSERT_EQ("", PrintContents(&batch));
- ASSERT_EQ(0, batch.Count());
- batch.Put("a", "va");
+ ASSERT_EQ(0u, batch.Count());
+ ASSERT_OK(batch.Put("a", "va"));
ASSERT_EQ("Put(a, va)@100", PrintContents(&batch));
- ASSERT_EQ(1, batch.Count());
- batch.SingleDelete("a");
+ ASSERT_EQ(1u, batch.Count());
+ ASSERT_OK(batch.SingleDelete("a"));
ASSERT_EQ(
"SingleDelete(a)@101"
"Put(a, va)@100",
PrintContents(&batch));
- ASSERT_EQ(2, batch.Count());
+ ASSERT_EQ(2u, batch.Count());
}
namespace {
TEST_F(WriteBatchTest, PutNotImplemented) {
WriteBatch batch;
- batch.Put(Slice("k1"), Slice("v1"));
- ASSERT_EQ(1, batch.Count());
+ ASSERT_OK(batch.Put(Slice("k1"), Slice("v1")));
+ ASSERT_EQ(1u, batch.Count());
ASSERT_EQ("Put(k1, v1)@0", PrintContents(&batch));
WriteBatch::Handler handler;
TEST_F(WriteBatchTest, DeleteNotImplemented) {
WriteBatch batch;
- batch.Delete(Slice("k2"));
- ASSERT_EQ(1, batch.Count());
+ ASSERT_OK(batch.Delete(Slice("k2")));
+ ASSERT_EQ(1u, batch.Count());
ASSERT_EQ("Delete(k2)@0", PrintContents(&batch));
WriteBatch::Handler handler;
TEST_F(WriteBatchTest, SingleDeleteNotImplemented) {
WriteBatch batch;
- batch.SingleDelete(Slice("k2"));
- ASSERT_EQ(1, batch.Count());
+ ASSERT_OK(batch.SingleDelete(Slice("k2")));
+ ASSERT_EQ(1u, batch.Count());
ASSERT_EQ("SingleDelete(k2)@0", PrintContents(&batch));
WriteBatch::Handler handler;
TEST_F(WriteBatchTest, MergeNotImplemented) {
WriteBatch batch;
- batch.Merge(Slice("foo"), Slice("bar"));
- ASSERT_EQ(1, batch.Count());
+ ASSERT_OK(batch.Merge(Slice("foo"), Slice("bar")));
+ ASSERT_EQ(1u, batch.Count());
ASSERT_EQ("Merge(foo, bar)@0", PrintContents(&batch));
WriteBatch::Handler handler;
TEST_F(WriteBatchTest, Blob) {
WriteBatch batch;
- batch.Put(Slice("k1"), Slice("v1"));
- batch.Put(Slice("k2"), Slice("v2"));
- batch.Put(Slice("k3"), Slice("v3"));
- batch.PutLogData(Slice("blob1"));
- batch.Delete(Slice("k2"));
- batch.SingleDelete(Slice("k3"));
- batch.PutLogData(Slice("blob2"));
- batch.Merge(Slice("foo"), Slice("bar"));
- ASSERT_EQ(6, batch.Count());
+ ASSERT_OK(batch.Put(Slice("k1"), Slice("v1")));
+ ASSERT_OK(batch.Put(Slice("k2"), Slice("v2")));
+ ASSERT_OK(batch.Put(Slice("k3"), Slice("v3")));
+ ASSERT_OK(batch.PutLogData(Slice("blob1")));
+ ASSERT_OK(batch.Delete(Slice("k2")));
+ ASSERT_OK(batch.SingleDelete(Slice("k3")));
+ ASSERT_OK(batch.PutLogData(Slice("blob2")));
+ ASSERT_OK(batch.Merge(Slice("foo"), Slice("bar")));
+ ASSERT_EQ(6u, batch.Count());
ASSERT_EQ(
"Merge(foo, bar)@5"
"Put(k1, v1)@0"
PrintContents(&batch));
TestHandler handler;
- batch.Iterate(&handler);
+ ASSERT_OK(batch.Iterate(&handler));
ASSERT_EQ(
"Put(k1, v1)"
"Put(k2, v2)"
TEST_F(WriteBatchTest, PrepareCommit) {
WriteBatch batch;
- WriteBatchInternal::InsertNoop(&batch);
- batch.Put(Slice("k1"), Slice("v1"));
- batch.Put(Slice("k2"), Slice("v2"));
+ ASSERT_OK(WriteBatchInternal::InsertNoop(&batch));
+ ASSERT_OK(batch.Put(Slice("k1"), Slice("v1")));
+ ASSERT_OK(batch.Put(Slice("k2"), Slice("v2")));
batch.SetSavePoint();
- WriteBatchInternal::MarkEndPrepare(&batch, Slice("xid1"));
+ ASSERT_OK(WriteBatchInternal::MarkEndPrepare(&batch, Slice("xid1")));
Status s = batch.RollbackToSavePoint();
ASSERT_EQ(s, Status::NotFound());
- WriteBatchInternal::MarkCommit(&batch, Slice("xid1"));
- WriteBatchInternal::MarkRollback(&batch, Slice("xid1"));
- ASSERT_EQ(2, batch.Count());
+ ASSERT_OK(WriteBatchInternal::MarkCommit(&batch, Slice("xid1")));
+ ASSERT_OK(WriteBatchInternal::MarkRollback(&batch, Slice("xid1")));
+ ASSERT_EQ(2u, batch.Count());
TestHandler handler;
- batch.Iterate(&handler);
+ ASSERT_OK(batch.Iterate(&handler));
ASSERT_EQ(
"MarkBeginPrepare(false)"
"Put(k1, v1)"
TEST_F(WriteBatchTest, DISABLED_ManyUpdates) {
// Insert key and value of 3GB and push total batch size to 12GB.
static const size_t kKeyValueSize = 4u;
- static const uint32_t kNumUpdates = uint32_t(3 << 30);
+ static const uint32_t kNumUpdates = uint32_t{3} << 30;
std::string raw(kKeyValueSize, 'A');
WriteBatch batch(kNumUpdates * (4 + kKeyValueSize * 2) + 1024u);
char c = 'A';
raw[0] = c;
raw[raw.length() - 1] = c;
c++;
- batch.Put(raw, raw);
+ ASSERT_OK(batch.Put(raw, raw));
}
ASSERT_EQ(kNumUpdates, batch.Count());
bool Continue() override { return num_seen < kNumUpdates; }
} handler;
- batch.Iterate(&handler);
+ ASSERT_OK(batch.Iterate(&handler));
ASSERT_EQ(kNumUpdates, handler.num_seen);
}
for (char i = 0; i < 2; i++) {
raw[0] = 'A' + i;
raw[raw.length() - 1] = 'A' - i;
- batch.Put(raw, raw);
+ ASSERT_OK(batch.Put(raw, raw));
}
- ASSERT_EQ(2, batch.Count());
+ ASSERT_EQ(2u, batch.Count());
struct NoopHandler : public WriteBatch::Handler {
int num_seen = 0;
bool Continue() override { return num_seen < 2; }
} handler;
- batch.Iterate(&handler);
+ ASSERT_OK(batch.Iterate(&handler));
ASSERT_EQ(2, handler.num_seen);
}
bool Continue() override { return num_seen < 5; }
} handler;
- batch.Put(Slice("k1"), Slice("v1"));
- batch.Put(Slice("k2"), Slice("v2"));
- batch.PutLogData(Slice("blob1"));
- batch.Delete(Slice("k1"));
- batch.SingleDelete(Slice("k2"));
- batch.PutLogData(Slice("blob2"));
- batch.Merge(Slice("foo"), Slice("bar"));
- batch.Iterate(&handler);
+ ASSERT_OK(batch.Put(Slice("k1"), Slice("v1")));
+ ASSERT_OK(batch.Put(Slice("k2"), Slice("v2")));
+ ASSERT_OK(batch.PutLogData(Slice("blob1")));
+ ASSERT_OK(batch.Delete(Slice("k1")));
+ ASSERT_OK(batch.SingleDelete(Slice("k2")));
+ ASSERT_OK(batch.PutLogData(Slice("blob2")));
+ ASSERT_OK(batch.Merge(Slice("foo"), Slice("bar")));
+ ASSERT_OK(batch.Iterate(&handler));
ASSERT_EQ(
"Put(k1, v1)"
"Put(k2, v2)"
TEST_F(WriteBatchTest, PutGatherSlices) {
WriteBatch batch;
- batch.Put(Slice("foo"), Slice("bar"));
+ ASSERT_OK(batch.Put(Slice("foo"), Slice("bar")));
{
// Try a write where the key is one slice but the value is two
Slice key_slice("baz");
Slice value_slices[2] = { Slice("header"), Slice("payload") };
- batch.Put(SliceParts(&key_slice, 1),
- SliceParts(value_slices, 2));
+ ASSERT_OK(
+ batch.Put(SliceParts(&key_slice, 1), SliceParts(value_slices, 2)));
}
{
// One where the key is composite but the value is a single slice
Slice key_slices[3] = { Slice("key"), Slice("part2"), Slice("part3") };
Slice value_slice("value");
- batch.Put(SliceParts(key_slices, 3),
- SliceParts(&value_slice, 1));
+ ASSERT_OK(
+ batch.Put(SliceParts(key_slices, 3), SliceParts(&value_slice, 1)));
}
WriteBatchInternal::SetSequence(&batch, 100);
"Put(foo, bar)@100"
"Put(keypart2part3, value)@102",
PrintContents(&batch));
- ASSERT_EQ(3, batch.Count());
+ ASSERT_EQ(3u, batch.Count());
}
namespace {
TEST_F(WriteBatchTest, ColumnFamiliesBatchTest) {
WriteBatch batch;
ColumnFamilyHandleImplDummy zero(0), two(2), three(3), eight(8);
- batch.Put(&zero, Slice("foo"), Slice("bar"));
- batch.Put(&two, Slice("twofoo"), Slice("bar2"));
- batch.Put(&eight, Slice("eightfoo"), Slice("bar8"));
- batch.Delete(&eight, Slice("eightfoo"));
- batch.SingleDelete(&two, Slice("twofoo"));
- batch.DeleteRange(&two, Slice("3foo"), Slice("4foo"));
- batch.Merge(&three, Slice("threethree"), Slice("3three"));
- batch.Put(&zero, Slice("foo"), Slice("bar"));
- batch.Merge(Slice("omom"), Slice("nom"));
+ ASSERT_OK(batch.Put(&zero, Slice("foo"), Slice("bar")));
+ ASSERT_OK(batch.Put(&two, Slice("twofoo"), Slice("bar2")));
+ ASSERT_OK(batch.Put(&eight, Slice("eightfoo"), Slice("bar8")));
+ ASSERT_OK(batch.Delete(&eight, Slice("eightfoo")));
+ ASSERT_OK(batch.SingleDelete(&two, Slice("twofoo")));
+ ASSERT_OK(batch.DeleteRange(&two, Slice("3foo"), Slice("4foo")));
+ ASSERT_OK(batch.Merge(&three, Slice("threethree"), Slice("3three")));
+ ASSERT_OK(batch.Put(&zero, Slice("foo"), Slice("bar")));
+ ASSERT_OK(batch.Merge(Slice("omom"), Slice("nom")));
TestHandler handler;
- batch.Iterate(&handler);
+ ASSERT_OK(batch.Iterate(&handler));
ASSERT_EQ(
"Put(foo, bar)"
"PutCF(2, twofoo, bar2)"
TEST_F(WriteBatchTest, ColumnFamiliesBatchWithIndexTest) {
WriteBatchWithIndex batch;
ColumnFamilyHandleImplDummy zero(0), two(2), three(3), eight(8);
- batch.Put(&zero, Slice("foo"), Slice("bar"));
- batch.Put(&two, Slice("twofoo"), Slice("bar2"));
- batch.Put(&eight, Slice("eightfoo"), Slice("bar8"));
- batch.Delete(&eight, Slice("eightfoo"));
- batch.SingleDelete(&two, Slice("twofoo"));
- batch.DeleteRange(&two, Slice("twofoo"), Slice("threefoo"));
- batch.Merge(&three, Slice("threethree"), Slice("3three"));
- batch.Put(&zero, Slice("foo"), Slice("bar"));
- batch.Merge(Slice("omom"), Slice("nom"));
+ ASSERT_OK(batch.Put(&zero, Slice("foo"), Slice("bar")));
+ ASSERT_OK(batch.Put(&two, Slice("twofoo"), Slice("bar2")));
+ ASSERT_OK(batch.Put(&eight, Slice("eightfoo"), Slice("bar8")));
+ ASSERT_OK(batch.Delete(&eight, Slice("eightfoo")));
+ ASSERT_OK(batch.SingleDelete(&two, Slice("twofoo")));
+ ASSERT_OK(batch.Merge(&three, Slice("threethree"), Slice("3three")));
+ ASSERT_OK(batch.Put(&zero, Slice("foo"), Slice("bar")));
+ ASSERT_OK(batch.Merge(Slice("omom"), Slice("nom")));
std::unique_ptr<WBWIIterator> iter;
ASSERT_EQ(WriteType::kSingleDeleteRecord, iter->Entry().type);
ASSERT_EQ("twofoo", iter->Entry().key.ToString());
- iter->Next();
- ASSERT_OK(iter->status());
- ASSERT_TRUE(iter->Valid());
- ASSERT_EQ(WriteType::kDeleteRangeRecord, iter->Entry().type);
- ASSERT_EQ("twofoo", iter->Entry().key.ToString());
- ASSERT_EQ("threefoo", iter->Entry().value.ToString());
-
iter->Next();
ASSERT_OK(iter->status());
ASSERT_TRUE(!iter->Valid());
ASSERT_TRUE(!iter->Valid());
TestHandler handler;
- batch.GetWriteBatch()->Iterate(&handler);
+ ASSERT_OK(batch.GetWriteBatch()->Iterate(&handler));
ASSERT_EQ(
"Put(foo, bar)"
"PutCF(2, twofoo, bar2)"
"PutCF(8, eightfoo, bar8)"
"DeleteCF(8, eightfoo)"
"SingleDeleteCF(2, twofoo)"
- "DeleteRangeCF(2, twofoo, threefoo)"
"MergeCF(3, threethree, 3three)"
"Put(foo, bar)"
"Merge(omom, nom)",
WriteBatch batch;
batch.SetSavePoint();
- batch.Put("A", "a");
- batch.Put("B", "b");
+ ASSERT_OK(batch.Put("A", "a"));
+ ASSERT_OK(batch.Put("B", "b"));
batch.SetSavePoint();
- batch.Put("C", "c");
- batch.Delete("A");
+ ASSERT_OK(batch.Put("C", "c"));
+ ASSERT_OK(batch.Delete("A"));
batch.SetSavePoint();
batch.SetSavePoint();
"Put(B, b)@1",
PrintContents(&batch));
- batch.Delete("A");
- batch.Put("B", "bb");
+ ASSERT_OK(batch.Delete("A"));
+ ASSERT_OK(batch.Put("B", "bb"));
ASSERT_OK(batch.RollbackToSavePoint());
ASSERT_EQ("", PrintContents(&batch));
ASSERT_TRUE(s.IsNotFound());
ASSERT_EQ("", PrintContents(&batch));
- batch.Put("D", "d");
- batch.Delete("A");
+ ASSERT_OK(batch.Put("D", "d"));
+ ASSERT_OK(batch.Delete("A"));
batch.SetSavePoint();
- batch.Put("A", "aaa");
+ ASSERT_OK(batch.Put("A", "aaa"));
ASSERT_OK(batch.RollbackToSavePoint());
ASSERT_EQ(
batch.SetSavePoint();
- batch.Put("D", "d");
- batch.Delete("A");
+ ASSERT_OK(batch.Put("D", "d"));
+ ASSERT_OK(batch.Delete("A"));
ASSERT_OK(batch.RollbackToSavePoint());
ASSERT_EQ(
ASSERT_TRUE(s.IsNotFound());
ASSERT_EQ("", PrintContents(&batch2));
- batch2.Delete("A");
+ ASSERT_OK(batch2.Delete("A"));
batch2.SetSavePoint();
s = batch2.RollbackToSavePoint();
batch2.SetSavePoint();
- batch2.Delete("B");
+ ASSERT_OK(batch2.Delete("B"));
ASSERT_EQ("Delete(B)@0", PrintContents(&batch2));
batch2.SetSavePoint();
ASSERT_EQ("", PrintContents(&batch3));
batch3.SetSavePoint();
- batch3.Delete("A");
+ ASSERT_OK(batch3.Delete("A"));
s = batch3.PopSavePoint();
ASSERT_OK(s);
ASSERT_TRUE(s.IsMemoryLimit());
}
-} // namespace rocksdb
+} // namespace ROCKSDB_NAMESPACE
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
projects / ceph.git / blobdiff