Inside Bitcoin

1251
1252    if (options.reuse_logs) {
1253      // Need to force a memtable compaction since recovery does not do so.
1254      ASSERT_OK(dbfull()->TEST_CompactMemTable());
1255    }
1256
1257    // Check sizes across recovery by reopening a few times
1258    for (int run = 0; run < 3; run++) {
1259      Reopen(&options);
1260
1261      ASSERT_TRUE(Between(Size("", Key(0)), 0, 0));
1262      ASSERT_TRUE(Between(Size("", Key(1)), 10000, 11000));
1263      ASSERT_TRUE(Between(Size("", Key(2)), 20000, 21000));
1264      ASSERT_TRUE(Between(Size("", Key(3)), 120000, 121000));
1265      ASSERT_TRUE(Between(Size("", Key(4)), 130000, 131000));
1266      ASSERT_TRUE(Between(Size("", Key(5)), 230000, 231000));
1267      ASSERT_TRUE(Between(Size("", Key(6)), 240000, 241000));
1268      ASSERT_TRUE(Between(Size("", Key(7)), 540000, 541000));
1269      ASSERT_TRUE(Between(Size("", Key(8)), 550000, 560000));
1270
1271      ASSERT_TRUE(Between(Size(Key(3), Key(5)), 110000, 111000));
1272
1273      dbfull()->TEST_CompactRange(0, nullptr, nullptr);
1274    }
1275  } while (ChangeOptions());
1276}
1277
1278TEST(DBTest, IteratorPinsRef) {
1279  Put("foo", "hello");
1280
1281  // Get iterator that will yield the current contents of the DB.
1282  Iterator* iter = db_->NewIterator(ReadOptions());
1283
1284  // Write to force compactions
1285  Put("foo", "newvalue1");
1286  for (int i = 0; i < 100; i++) {
1287    ASSERT_OK(Put(Key(i), Key(i) + std::string(100000, 'v')));  // 100K values
1288  }
1289  Put("foo", "newvalue2");
1290
1291  iter->SeekToFirst();
1292  ASSERT_TRUE(iter->Valid());
1293  ASSERT_EQ("foo", iter->key().ToString());
1294  ASSERT_EQ("hello", iter->value().ToString());
1295  iter->Next();
1296  ASSERT_TRUE(!iter->Valid());
1297  delete iter;
1298}
1299
1300TEST(DBTest, Snapshot) {
1301  do {
1302    Put("foo", "v1");
1303    const Snapshot* s1 = db_->GetSnapshot();
1304    Put("foo", "v2");
1305    const Snapshot* s2 = db_->GetSnapshot();
1306    Put("foo", "v3");
1307    const Snapshot* s3 = db_->GetSnapshot();
1308
1309    Put("foo", "v4");
1310    ASSERT_EQ("v1", Get("foo", s1));
1311    ASSERT_EQ("v2", Get("foo", s2));
1312    ASSERT_EQ("v3", Get("foo", s3));
1313    ASSERT_EQ("v4", Get("foo"));
1314
1315    db_->ReleaseSnapshot(s3);
1316    ASSERT_EQ("v1", Get("foo", s1));
1317    ASSERT_EQ("v2", Get("foo", s2));
1318    ASSERT_EQ("v4", Get("foo"));
1319
1320    db_->ReleaseSnapshot(s1);
1321    ASSERT_EQ("v2", Get("foo", s2));
1322    ASSERT_EQ("v4", Get("foo"));
1323
1324    db_->ReleaseSnapshot(s2);
1325    ASSERT_EQ("v4", Get("foo"));
1326  } while (ChangeOptions());
1327}
1328
1329TEST(DBTest, HiddenValuesAreRemoved) {
1330  do {
1331    Random rnd(301);
1332    FillLevels("a", "z");
1333
1334    std::string big = RandomString(&rnd, 50000);
1335    Put("foo", big);
1336    Put("pastfoo", "v");
1337    const Snapshot* snapshot = db_->GetSnapshot();
1338    Put("foo", "tiny");
1339    Put("pastfoo2", "v2");  // Advance sequence number one more
1340
1341    ASSERT_OK(dbfull()->TEST_CompactMemTable());
1342    ASSERT_GT(NumTableFilesAtLevel(0), 0);
1343
1344    ASSERT_EQ(big, Get("foo", snapshot));
1345    ASSERT_TRUE(Between(Size("", "pastfoo"), 50000, 60000));
1346    db_->ReleaseSnapshot(snapshot);
1347    ASSERT_EQ(AllEntriesFor("foo"), "[ tiny, " + big + " ]");
1348    Slice x("x");
1349    dbfull()->TEST_CompactRange(0, nullptr, &x);
1350    ASSERT_EQ(AllEntriesFor("foo"), "[ tiny ]");
1351    ASSERT_EQ(NumTableFilesAtLevel(0), 0);
1352    ASSERT_GE(NumTableFilesAtLevel(1), 1);
1353    dbfull()->TEST_CompactRange(1, nullptr, &x);
1354    ASSERT_EQ(AllEntriesFor("foo"), "[ tiny ]");
1355
1356    ASSERT_TRUE(Between(Size("", "pastfoo"), 0, 1000));
1357  } while (ChangeOptions());
1358}
1359
1360TEST(DBTest, DeletionMarkers1) {
1361  Put("foo", "v1");
1362  ASSERT_OK(dbfull()->TEST_CompactMemTable());
1363  const int last = config::kMaxMemCompactLevel;
1364  ASSERT_EQ(NumTableFilesAtLevel(last), 1);  // foo => v1 is now in last level
1365
1366  // Place a table at level last-1 to prevent merging with preceding mutation
1367  Put("a", "begin");
1368  Put("z", "end");
1369  dbfull()->TEST_CompactMemTable();
1370  ASSERT_EQ(NumTableFilesAtLevel(last), 1);
1371  ASSERT_EQ(NumTableFilesAtLevel(last - 1), 1);
1372
1373  Delete("foo");
1374  Put("foo", "v2");
1375  ASSERT_EQ(AllEntriesFor("foo"), "[ v2, DEL, v1 ]");
1376  ASSERT_OK(dbfull()->TEST_CompactMemTable());  // Moves to level last-2
1377  ASSERT_EQ(AllEntriesFor("foo"), "[ v2, DEL, v1 ]");
1378  Slice z("z");
1379  dbfull()->TEST_CompactRange(last - 2, nullptr, &z);
1380  // DEL eliminated, but v1 remains because we aren't compacting that level
1381  // (DEL can be eliminated because v2 hides v1).
1382  ASSERT_EQ(AllEntriesFor("foo"), "[ v2, v1 ]");
1383  dbfull()->TEST_CompactRange(last - 1, nullptr, nullptr);
1384  // Merging last-1 w/ last, so we are the base level for "foo", so
1385  // DEL is removed.  (as is v1).
1386  ASSERT_EQ(AllEntriesFor("foo"), "[ v2 ]");
1387}
1388
1389TEST(DBTest, DeletionMarkers2) {
1390  Put("foo", "v1");
1391  ASSERT_OK(dbfull()->TEST_CompactMemTable());
1392  const int last = config::kMaxMemCompactLevel;
1393  ASSERT_EQ(NumTableFilesAtLevel(last), 1);  // foo => v1 is now in last level
1394
1395  // Place a table at level last-1 to prevent merging with preceding mutation
1396  Put("a", "begin");
1397  Put("z", "end");
1398  dbfull()->TEST_CompactMemTable();
1399  ASSERT_EQ(NumTableFilesAtLevel(last), 1);
1400  ASSERT_EQ(NumTableFilesAtLevel(last - 1), 1);
1401
1402  Delete("foo");
1403  ASSERT_EQ(AllEntriesFor("foo"), "[ DEL, v1 ]");
1404  ASSERT_OK(dbfull()->TEST_CompactMemTable());  // Moves to level last-2
1405  ASSERT_EQ(AllEntriesFor("foo"), "[ DEL, v1 ]");
1406  dbfull()->TEST_CompactRange(last - 2, nullptr, nullptr);
1407  // DEL kept: "last" file overlaps
1408  ASSERT_EQ(AllEntriesFor("foo"), "[ DEL, v1 ]");
1409  dbfull()->TEST_CompactRange(last - 1, nullptr, nullptr);
1410  // Merging last-1 w/ last, so we are the base level for "foo", so
1411  // DEL is removed.  (as is v1).
1412  ASSERT_EQ(AllEntriesFor("foo"), "[ ]");
1413}
1414
1415TEST(DBTest, OverlapInLevel0) {
1416  do {
1417    ASSERT_EQ(config::kMaxMemCompactLevel, 2) << "Fix test to match config";
1418
1419    // Fill levels 1 and 2 to disable the pushing of new memtables to levels >
1420    // 0.
1421    ASSERT_OK(Put("100", "v100"));
1422    ASSERT_OK(Put("999", "v999"));
1423    dbfull()->TEST_CompactMemTable();
1424    ASSERT_OK(Delete("100"));
1425    ASSERT_OK(Delete("999"));
1426    dbfull()->TEST_CompactMemTable();
1427    ASSERT_EQ("0,1,1", FilesPerLevel());
1428
1429    // Make files spanning the following ranges in level-0:
1430    //  files[0]  200 .. 900
1431    //  files[1]  300 .. 500
1432    // Note that files are sorted by smallest key.
1433    ASSERT_OK(Put("300", "v300"));
1434    ASSERT_OK(Put("500", "v500"));
1435    dbfull()->TEST_CompactMemTable();
1436    ASSERT_OK(Put("200", "v200"));
1437    ASSERT_OK(Put("600", "v600"));
1438    ASSERT_OK(Put("900", "v900"));
1439    dbfull()->TEST_CompactMemTable();
1440    ASSERT_EQ("2,1,1", FilesPerLevel());
1441
1442    // Compact away the placeholder files we created initially
1443    dbfull()->TEST_CompactRange(1, nullptr, nullptr);
1444    dbfull()->TEST_CompactRange(2, nullptr, nullptr);
1445    ASSERT_EQ("2", FilesPerLevel());
1446
1447    // Do a memtable compaction.  Before bug-fix, the compaction would
1448    // not detect the overlap with level-0 files and would incorrectly place
1449    // the deletion in a deeper level.
1450    ASSERT_OK(Delete("600"));
1451    dbfull()->TEST_CompactMemTable();
1452    ASSERT_EQ("3", FilesPerLevel());
1453    ASSERT_EQ("NOT_FOUND", Get("600"));
1454  } while (ChangeOptions());
1455}
1456
1457TEST(DBTest, L0_CompactionBug_Issue44_a) {
1458  Reopen();
1459  ASSERT_OK(Put("b", "v"));
1460  Reopen();
1461  ASSERT_OK(Delete("b"));
1462  ASSERT_OK(Delete("a"));
1463  Reopen();
1464  ASSERT_OK(Delete("a"));
1465  Reopen();
1466  ASSERT_OK(Put("a", "v"));
1467  Reopen();
1468  Reopen();
1469  ASSERT_EQ("(a->v)", Contents());
1470  DelayMilliseconds(1000);  // Wait for compaction to finish
1471  ASSERT_EQ("(a->v)", Contents());
1472}
1473
1474TEST(DBTest, L0_CompactionBug_Issue44_b) {
1475  Reopen();
1476  Put("", "");
1477  Reopen();
1478  Delete("e");
1479  Put("", "");
1480  Reopen();
1481  Put("c", "cv");
1482  Reopen();
1483  Put("", "");
1484  Reopen();
1485  Put("", "");
1486  DelayMilliseconds(1000);  // Wait for compaction to finish
1487  Reopen();
1488  Put("d", "dv");
1489  Reopen();
1490  Put("", "");
1491  Reopen();
1492  Delete("d");
1493  Delete("b");
1494  Reopen();
1495  ASSERT_EQ("(->)(c->cv)", Contents());
1496  DelayMilliseconds(1000);  // Wait for compaction to finish
1497  ASSERT_EQ("(->)(c->cv)", Contents());
1498}
1499
1500TEST(DBTest, Fflush_Issue474) {