def testApproximateSizes(self): db = self.db_class(leveldb.Options(), self.db_path, create_if_missing=True) self.assertEqual([0, 0, 0], db.approximateDiskSizes(("a", "z"), ("0", "9"), ("A", "Z"))) batch = leveldb.WriteBatch() for i in xrange(100): batch.Put("c%d" % i, os.urandom(4096)) db.write(leveldb.WriteOptions(), batch, sync=True) db.close() db = self.db_class(leveldb.Options(), self.db_path) sizes = db.approximateDiskSizes(("0", "9"), ("A", "Z"), ("a", "z")) self.assertEqual(sizes[0], 0) self.assertEqual(sizes[1], 0) self.assertTrue(sizes[2] >= 4096 * 100) for i in xrange(10): db.Put(leveldb.WriteOptions(), "3%d" % i, os.urandom(10)) db.close() db = self.db_class(leveldb.Options(), self.db_path) sizes = db.approximateDiskSizes(("A", "Z"), ("a", "z"), ("0", "9")) self.assertEqual(sizes[0], 0) self.assertTrue(sizes[1] >= 4096 * 100) self.assertTrue(sizes[2] < 4096 * 100) self.assertTrue(sizes[2] >= 10 * 10) db.close()
def testSegfaultFromIssue2(self, short_time=10): """https://code.google.com/p/leveldb-py/issues/detail?id=2""" # i assume the reporter meant opening a new db a bunch of times? paths = [] dbs = [] start_time = time.time() while time.time() - start_time < short_time: path = tempfile.mkdtemp() paths.append(path) db = self.db_class(leveldb.Options(), path, create_if_missing=True) batch = leveldb.WriteBatch() for x in xrange(10000): batch.Put(str(x), str(x)) db.write(leveldb.WriteOptions(), batch) dbs.append(db) for db in dbs: db.close() # maybe the reporter meant opening the same db over and over? start_time = time.time() path = tempfile.mkdtemp() paths.append(path) while time.time() - start_time < short_time: db = self.db_class(leveldb.Options(), path, create_if_missing=True) batch = leveldb.WriteBatch() for x in xrange(10000): batch.Put(str(x), str(x)) db.write(leveldb.WriteOptions(), batch) db.close() # or maybe the same db handle, but lots of write batches? start_time = time.time() path = tempfile.mkdtemp() paths.append(path) db = self.db_class(leveldb.Options(), path, create_if_missing=True) while time.time() - start_time < short_time: batch = leveldb.WriteBatch() for x in xrange(10000): batch.Put(str(x), str(x)) db.write(leveldb.WriteOptions(), batch) db.close() # or maybe it was lots of batch puts? start_time = time.time() path = tempfile.mkdtemp() paths.append(path) db = self.db_class(leveldb.Options(), path, create_if_missing=True) batch = leveldb.WriteBatch() x = 0 while time.time() - start_time < short_time: batch.Put(str(x), str(x)) x += 1 db.write(leveldb.WriteOptions(), batch) db.close() # if we got here, we haven't segfaulted, so, i dunno for path in paths: shutil.rmtree(path)
def testInit(self): self.assertRaises(leveldb.Error, self.db_class, leveldb.Options(), self.db_path) self.db_class(leveldb.Options(), self.db_path, create_if_missing=True).close() self.db_class(leveldb.Options(), self.db_path, create_if_missing=True).close() self.db_class(leveldb.Options(), self.db_path).close() self.assertRaises(leveldb.Error, self.db_class, leveldb.Options(), self.db_path, create_if_missing=True, error_if_exists=True)
def test__delitem__(self): db = self.db_class(leveldb.Options(), self.db_path, create_if_missing=True) self.assertTrue("hey" not in db) db["hey"] = "1" self.assertTrue("hey" in db) del db["hey"] self.assertTrue("hey" not in db)
def test__contains__(self): db = self.db_class(leveldb.Options(), self.db_path, create_if_missing=True) self.assertTrue("hey" not in db) with self.assertRaises(KeyError): db["hey"] db["hey"] = "1" self.assertTrue("hey" in db)
def test_iteration_with_break(self): db = self.db_class(leveldb.Options(), self.db_path, create_if_missing=True) db.Put(leveldb.WriteOptions(), 'a', 'b') db.Put(leveldb.WriteOptions(), 'c', 'd') for key, value in db: self.assertEqual((key, value), ('a', 'b')) break db.close()
def test_iteration_empty_db(self): """ Test the null condition, no entries in the database. """ db = self.db_class(leveldb.Options(), self.db_path, create_if_missing=True) for _ in db: self.fail("shouldn't happen") db.close()
def test_iteration(self): db = self.db_class(leveldb.Options(), self.db_path, create_if_missing=True) db.Put(leveldb.WriteOptions(), 'a', 'b') db.Put(leveldb.WriteOptions(), 'c', 'd') iterator = iter(db) self.assertEqual(iterator.next(), ('a', 'b')) self.assertEqual(iterator.next(), ('c', 'd')) self.assertRaises(StopIteration, iterator.next) db.close()
def test_iteration_keys_only(self): db = self.db_class(leveldb.Options(), self.db_path, create_if_missing=True) db.Put(leveldb.WriteOptions(), 'a', 'b') db.Put(leveldb.WriteOptions(), 'c', 'd') iterator = db.NewIterator(keys_only=True).SeekToFirst() self.assertEqual(iterator.next(), 'a') self.assertEqual(iterator.next(), 'c') self.assertRaises(StopIteration, iterator.next) db.close()
def test_seek_first_last(self): db = self.db_class(leveldb.Options(), self.db_path, create_if_missing=True) db.Put(leveldb.WriteOptions(), 'a', 'b') db.Put(leveldb.WriteOptions(), 'b', 'b') iterator = iter(db) iterator.SeekToLast() self.assertEqual(iterator.next(), ('b', 'b')) iterator.SeekToFirst() self.assertEqual(iterator.next(), ('a', 'b')) db.close()
def testValuesWithZeroBytes(self): db = self.db_class(leveldb.Options(), self.db_path, create_if_missing=True) value_with_zero_byte = "\x01\x00\x02\x03\x04" db.Put(leveldb.WriteOptions(), "hey", value_with_zero_byte) self.assertEqual(db.Get(leveldb.ReadOptions(), "hey"), value_with_zero_byte) it = db.NewIterator().SeekToFirst() self.assertTrue(it.Valid()) self.assertEqual(it.key(), "hey") self.assertEqual(it.value(), value_with_zero_byte) db.close()
def testKeyRewrite(self): db = self.db_class(leveldb.Options(), self.db_path, create_if_missing=True) self.assertEqual(db.Get(leveldb.ReadOptions(), "hey"), None) db.Put(leveldb.WriteOptions(), "hey", "1") self.assertEqual(db.Get(leveldb.ReadOptions(), "hey"), "1") db.Put(leveldb.WriteOptions(), "hey", "2") self.assertEqual(db.Get(leveldb.ReadOptions(), "hey"), "2") db.Put(leveldb.WriteOptions(), "hey", "2") self.assertEqual(db.Get(leveldb.ReadOptions(), "hey"), "2") db.Put(leveldb.WriteOptions(), "hey", "3") self.assertEqual(db.Get(leveldb.ReadOptions(), "hey"), "3")
def test__getsetitem__(self): db = self.db_class(leveldb.Options(), self.db_path, create_if_missing=True) db["hey"] = "1" self.assertTrue("hey" in db) self.assertEqual(db["hey"], "1") db["hey"] = "2" self.assertEqual(db["hey"], "2") db["hey"] = "2" self.assertEqual(db["hey"], "2") db["hey"] = "3" self.assertEqual(db["hey"], "3")
def test_prev(self): db = self.db_class(leveldb.Options(), self.db_path, create_if_missing=True) db.Put(leveldb.WriteOptions(), 'a', 'b') db.Put(leveldb.WriteOptions(), 'b', 'b') iterator = iter(db) entry = iterator.next() iterator.Prev() self.assertEqual(entry, iterator.next()) # it's ok to call prev when the iterator is at position 0 iterator.Prev() self.assertEqual(entry, iterator.next()) db.close()
def test_seek_last_with_leading_zero_prefix(self): db = self.db_class(leveldb.Options(), os.path.join(self.db_path, "1"), create_if_missing=True) db.Put(leveldb.WriteOptions(), "\x00\x00\x00", "1") db.Put(leveldb.WriteOptions(), "\x00\x00\xff", "2") db.Put(leveldb.WriteOptions(), "\x00\x01\x00", "3") db.Put(leveldb.WriteOptions(), "\x01\x01\x00", "4") self.assertEqual( db.NewIterator(prefix="\x00\x00\x00").SeekToLast().value(), "1") self.assertEqual( db.NewIterator(prefix="\x00\x00").SeekToLast().value(), "2") self.assertEqual( db.NewIterator(prefix="\x00").SeekToLast().value(), "3") db.close()
def test_scoped_then_iterate(self): db = self.db_class(leveldb.Options(), os.path.join(self.db_path, "1"), create_if_missing=True) for i in range(10): db.Put(leveldb.WriteOptions(), "%dfoo" % i, "bar%d" % i) it = db.NewIterator(prefix="5").SeekToFirst() self.assertTrue(it.Valid()) self.assertEqual(it.key(), "foo") self.assertEqual(it.value(), "bar5") for id_, (k, v) in enumerate(it): self.assertEqual(id_, 0) self.assertEqual(k, "foo") self.assertEqual(v, "bar5")
def testPutSync(self, size=100): db = self.db_class(leveldb.Options(), self.db_path, create_if_missing=True) for i in xrange(size): db.Put(leveldb.WriteOptions(), str(i), str(i + 1)) start_sync_time = time.time() for i in xrange(size): db.Put(leveldb.WriteOptions(), str(i), str(i + 1), sync=True) start_unsync_time = time.time() for i in xrange(size): db.Put(leveldb.WriteOptions(), str(i), str(i + 1)) end_time = time.time() sync_time = start_unsync_time - start_sync_time unsync_time = end_time - start_unsync_time self.assertTrue(sync_time > 10 * unsync_time) db.close()
def test_seek(self): """ Test seeking forwards and backwards """ db = self.db_class(leveldb.Options(), self.db_path, create_if_missing=True) db.Put(leveldb.WriteOptions(), 'a', 'b') db.Put(leveldb.WriteOptions(), 'b', 'b') db.Put(leveldb.WriteOptions(), 'ca', 'a') db.Put(leveldb.WriteOptions(), 'cb', 'b') db.Put(leveldb.WriteOptions(), 'd', 'd') iterator = iter(db).seek("c") self.assertEqual(iterator.next(), ('ca', 'a')) self.assertEqual(iterator.next(), ('cb', 'b')) # seek backwards iterator.seek('a') self.assertEqual(iterator.next(), ('a', 'b')) db.close()
def testDelete(self): db = self.db_class(leveldb.Options(), self.db_path, create_if_missing=True) self.assertTrue(db.Get(leveldb.ReadOptions(), "key1") is None) self.assertTrue(db.Get(leveldb.ReadOptions(), "key2") is None) self.assertTrue(db.Get(leveldb.ReadOptions(), "key3") is None) db.Put(leveldb.WriteOptions(), "key1", "val1") db.Put(leveldb.WriteOptions(), "key2", "val2") db.Put(leveldb.WriteOptions(), "key3", "val3") self.assertEqual(db.Get(leveldb.ReadOptions(), "key1"), "val1") self.assertEqual(db.Get(leveldb.ReadOptions(), "key2"), "val2") self.assertEqual(db.Get(leveldb.ReadOptions(), "key3"), "val3") db.delete("key1") db.delete("key2", sync=True) self.assertTrue(db.Get(leveldb.ReadOptions(), "key1") is None) self.assertTrue(db.Get(leveldb.ReadOptions(), "key2") is None) self.assertEqual(db.Get(leveldb.ReadOptions(), "key3"), "val3") db.close()
def test_multiple_iterators(self): """ Make sure that things work with multiple iterator objects alive at one time. """ db = self.db_class(leveldb.Options(), self.db_path, create_if_missing=True) entries = [('a', 'b'), ('b', 'b')] db.Put(leveldb.WriteOptions(), *entries[0]) db.Put(leveldb.WriteOptions(), *entries[1]) iter1 = iter(db) iter2 = iter(db) self.assertEqual(iter1.next(), entries[0]) # garbage collect iter1, seek iter2 past the end of the db. Make sure # everything works. del iter1 iter2.seek('z') self.assertRaises(StopIteration, iter2.next) db.close()
def testSnapshots(self): db = self.db_class(leveldb.Options(), self.db_path, create_if_missing=True) snapshot = db.snapshot() db["hey"] = "1" db["there"] = "2" self.assertEqual(len(list(db)), 2) self.assertEqual(len(list(snapshot)), 0) snapshot = db.snapshot() self.assertEqual(len(list(snapshot)), 2) self.assertEqual(snapshot["hey"], "1") self.assertEqual(snapshot["there"], "2") self.assertEqual(db["hey"], "1") self.assertEqual(db["there"], "2") db["hey"] = "3" db["there"] = "4" self.assertEqual(snapshot["hey"], "1") self.assertEqual(snapshot["there"], "2") self.assertEqual(db["hey"], "3") self.assertEqual(db["there"], "4")
def testRange(self): db = self.db_class(leveldb.Options(), self.db_path, create_if_missing=True) def keys(alphabet, length=5): if length == 0: yield "" return for char in alphabet: for prefix in keys(alphabet, length - 1): yield prefix + char for val, key in enumerate(keys(map(chr, xrange(ord('a'), ord('f'))))): db.Put(leveldb.WriteOptions(), key, str(val)) self.assertEquals([row.key for row in db.range("bbbb", "bbcb")], [ 'bbbba', 'bbbbb', 'bbbbc', 'bbbbd', 'bbbbe', 'bbbca', 'bbbcb', 'bbbcc', 'bbbcd', 'bbbce', 'bbbda', 'bbbdb', 'bbbdc', 'bbbdd', 'bbbde', 'bbbea', 'bbbeb', 'bbbec', 'bbbed', 'bbbee', 'bbcaa', 'bbcab', 'bbcac', 'bbcad', 'bbcae' ]) self.assertEquals([row.key for row in db.range("bbbbb", "bbcbb")], [ 'bbbbb', 'bbbbc', 'bbbbd', 'bbbbe', 'bbbca', 'bbbcb', 'bbbcc', 'bbbcd', 'bbbce', 'bbbda', 'bbbdb', 'bbbdc', 'bbbdd', 'bbbde', 'bbbea', 'bbbeb', 'bbbec', 'bbbed', 'bbbee', 'bbcaa', 'bbcab', 'bbcac', 'bbcad', 'bbcae', 'bbcba' ]) self.assertEquals([r.key for r in db.scope("dd").range("bb", "cb")], [ 'bba', 'bbb', 'bbc', 'bbd', 'bbe', 'bca', 'bcb', 'bcc', 'bcd', 'bce', 'bda', 'bdb', 'bdc', 'bdd', 'bde', 'bea', 'beb', 'bec', 'bed', 'bee', 'caa', 'cab', 'cac', 'cad', 'cae' ]) self.assertEquals( [r.key for r in db.scope("dd").range("bbb", "cbb")], [ 'bbb', 'bbc', 'bbd', 'bbe', 'bca', 'bcb', 'bcc', 'bcd', 'bce', 'bda', 'bdb', 'bdc', 'bdd', 'bde', 'bea', 'beb', 'bec', 'bed', 'bee', 'caa', 'cab', 'cac', 'cad', 'cae', 'cba' ])
def test_prefix(self): """ Test iterator prefixes """ batch = leveldb.WriteBatch() batch.Put('a', 'b') batch.Put('b', 'b') batch.Put('cd', 'a') batch.Put('ce', 'a') batch.Put('c', 'a') batch.Put('f', 'b') db = self.db_class(leveldb.Options(), self.db_path, create_if_missing=True) db.write(leveldb.WriteOptions(), batch) iterator = db.NewIterator(prefix="c") iterator.SeekToFirst() self.assertEqual(iterator.next(), ('', 'a')) self.assertEqual(iterator.next(), ('d', 'a')) self.assertEqual(iterator.next(), ('e', 'a')) self.assertRaises(StopIteration, iterator.next) db.close()
def testOpaqueWriteBatch(self): db = self.db_class(leveldb.Options(), self.db_path, create_if_missing=True) scoped_db = db.scope("prefix2_") scopes = [ db.scope("prefix1_"), scoped_db, scoped_db.scope("a_"), scoped_db.scope("b_"), db.scope("prefix3_") ] batch = db.newBatch() for i, scope in enumerate(scopes): scope.putTo(batch, str(i), str(i)) db.write(leveldb.WriteOptions(), batch) for i, scope in enumerate(scopes): self.assertEquals(scope.Get(leveldb.ReadOptions(), str(i)), str(i)) batch.clear() for i, scope in enumerate(scopes): scope.deleteFrom(batch, str(i)) db.write(leveldb.WriteOptions(), batch) for i, scope in enumerate(scopes): self.assertEquals(scope.Get(leveldb.ReadOptions(), str(i)), None) # same effect when done through any scope batch = random.choice(scopes).newBatch() for i, scope in enumerate(scopes): scope.putTo(batch, str(i), str(2 * (i + 1))) random.choice(scopes).write(leveldb.WriteOptions(), batch) for i, scope in enumerate(scopes): self.assertEquals(scope.Get(leveldb.ReadOptions(), str(i)), str(2 * (i + 1))) batch.clear() for i, scope in enumerate(scopes): scope.deleteFrom(batch, str(i)) random.choice(scopes).write(leveldb.WriteOptions(), batch) for i, scope in enumerate(scopes): self.assertEquals(scope.Get(leveldb.ReadOptions(), str(i)), None)
def testPutGet(self): db = self.db_class(leveldb.Options(), self.db_path, create_if_missing=True) db.Put(leveldb.WriteOptions(), "key1", "val1") db.Put(leveldb.WriteOptions(), "key2", "val2", sync=True) self.assertEqual(db.Get(leveldb.ReadOptions(), "key1"), "val1") self.assertEqual(db.Get(leveldb.ReadOptions(), "key2"), "val2") self.assertEqual( db.Get(leveldb.ReadOptions(), "key1", verify_checksums=True), "val1") self.assertEqual( db.Get(leveldb.ReadOptions(), "key2", verify_checksums=True), "val2") self.assertEqual( db.Get(leveldb.ReadOptions(), "key1", fill_cache=False), "val1") self.assertEqual( db.Get(leveldb.ReadOptions(), "key2", fill_cache=False), "val2") self.assertEqual( db.Get(leveldb.ReadOptions(), "key1", verify_checksums=True, fill_cache=False), "val1") self.assertEqual( db.Get(leveldb.ReadOptions(), "key2", verify_checksums=True, fill_cache=False), "val2") self.assertEqual(db.Get(leveldb.ReadOptions(), "key1"), "val1") self.assertEqual(db.Get(leveldb.ReadOptions(), "key2"), "val2") self.assertEqual(list(db.keys()), ["key1", "key2"]) self.assertEqual(list(db.keys(prefix="key")), ["1", "2"]) self.assertEqual(list(db.keys(prefix="key1")), [""]) self.assertEqual(list(db.values()), ["val1", "val2"]) self.assertEqual(list(db.values(prefix="key")), ["val1", "val2"]) self.assertEqual(list(db.values(prefix="key1")), ["val1"]) db.close()
def test_scoped_seek_first(self): db = self.db_class(leveldb.Options(), os.path.join(self.db_path, "1"), create_if_missing=True) db.Put(leveldb.WriteOptions(), "ba", "1") db.Put(leveldb.WriteOptions(), "bb", "2") db.Put(leveldb.WriteOptions(), "cc", "3") db.Put(leveldb.WriteOptions(), "cd", "4") db.Put(leveldb.WriteOptions(), "de", "5") db.Put(leveldb.WriteOptions(), "df", "6") it = db.scope("a").NewIterator().SeekToFirst() self.assertFalse(it.Valid()) it = db.scope("b").NewIterator().SeekToFirst() self.assertTrue(it.Valid()) self.assertEqual(it.key(), "a") it = db.scope("c").NewIterator().SeekToFirst() self.assertTrue(it.Valid()) self.assertEqual(it.key(), "c") it = db.scope("d").NewIterator().SeekToFirst() self.assertTrue(it.Valid()) self.assertEqual(it.key(), "e") it = db.scope("e").NewIterator().SeekToFirst() self.assertFalse(it.Valid()) db.close()
def testRangeOptionalEndpoints(self): db = self.db_class(leveldb.Options(), self.db_path, create_if_missing=True) db.Put(leveldb.WriteOptions(), "aa", "1") db.Put(leveldb.WriteOptions(), "bb", "2") db.Put(leveldb.WriteOptions(), "cc", "3") db.Put(leveldb.WriteOptions(), "dd", "4") db.Put(leveldb.WriteOptions(), "ee", "5") self.assertEquals([r.key for r in db.NewIterator().seek("d").range()], ["aa", "bb", "cc", "dd", "ee"]) self.assertEquals( [r.key for r in db.NewIterator().seek("d").range(start_key="bb")], ["bb", "cc", "dd", "ee"]) self.assertEquals( [r.key for r in db.NewIterator().seek("d").range(end_key="cc")], ["aa", "bb"]) self.assertEquals([ r.key for r in db.NewIterator().seek("d").range(start_key="bb", end_key="cc") ], ["bb"]) self.assertEquals( [r.key for r in db.NewIterator().seek("d").range(start_key="b")], ["bb", "cc", "dd", "ee"]) self.assertEquals( [r.key for r in db.NewIterator().seek("d").range(end_key="c")], ["aa", "bb"]) self.assertEquals([ r.key for r in db.NewIterator().seek("d").range(start_key="b", end_key="c") ], ["bb"]) self.assertEquals([ r.key for r in db.NewIterator().seek("d").range(start_key="bb", start_inclusive=True) ], ["bb", "cc", "dd", "ee"]) self.assertEquals([ r.key for r in db.NewIterator().seek("d").range(start_key="bb", start_inclusive=False) ], ["cc", "dd", "ee"]) self.assertEquals([ r.key for r in db.NewIterator().seek("d").range(end_key="cc", end_inclusive=True) ], ["aa", "bb", "cc"]) self.assertEquals([ r.key for r in db.NewIterator().seek("d").range(end_key="cc", end_inclusive=False) ], ["aa", "bb"]) self.assertEquals([ r.key for r in db.NewIterator().seek("d").range(start_key="bb", end_key="cc", start_inclusive=True, end_inclusive=True) ], ["bb", "cc"]) self.assertEquals([ r.key for r in db.NewIterator().seek("d").range(start_key="bb", end_key="cc", start_inclusive=True, end_inclusive=False) ], ["bb"]) self.assertEquals([ r.key for r in db.NewIterator().seek("d").range(start_key="bb", end_key="cc", start_inclusive=False, end_inclusive=True) ], ["cc"]) self.assertEquals([ r.key for r in db.NewIterator().seek("d").range(start_key="bb", end_key="cc", start_inclusive=False, end_inclusive=False) ], []) self.assertEquals([ r.key for r in db.NewIterator().seek("d").range(start_key="b", start_inclusive=True) ], ["bb", "cc", "dd", "ee"]) self.assertEquals([ r.key for r in db.NewIterator().seek("d").range(start_key="b", start_inclusive=False) ], ["bb", "cc", "dd", "ee"]) self.assertEquals([ r.key for r in db.NewIterator().seek("d").range(end_key="c", end_inclusive=True) ], ["aa", "bb"]) self.assertEquals([ r.key for r in db.NewIterator().seek("d").range(end_key="c", end_inclusive=False) ], ["aa", "bb"]) self.assertEquals([ r.key for r in db.NewIterator().seek("d").range(start_key="b", end_key="c", start_inclusive=True, end_inclusive=True) ], ["bb"]) self.assertEquals([ r.key for r in db.NewIterator().seek("d").range(start_key="b", end_key="c", start_inclusive=False, end_inclusive=True) ], ["bb"]) self.assertEquals([ r.key for r in db.NewIterator().seek("d").range(start_key="b", end_key="c", start_inclusive=True, end_inclusive=False) ], ["bb"]) self.assertEquals([ r.key for r in db.NewIterator().seek("d").range(start_key="b", end_key="c", start_inclusive=False, end_inclusive=False) ], ["bb"])
def test_scoped_seek_last(self): db = self.db_class(leveldb.Options(), os.path.join(self.db_path, "1"), create_if_missing=True) db.Put(leveldb.WriteOptions(), "ba", "1") db.Put(leveldb.WriteOptions(), "bb", "2") db.Put(leveldb.WriteOptions(), "cc", "3") db.Put(leveldb.WriteOptions(), "cd", "4") db.Put(leveldb.WriteOptions(), "de", "5") db.Put(leveldb.WriteOptions(), "df", "6") it = db.scope("a").NewIterator().SeekToLast() self.assertFalse(it.Valid()) it = db.scope("b").NewIterator().SeekToLast() self.assertTrue(it.Valid()) self.assertEqual(it.key(), "b") it = db.scope("c").NewIterator().SeekToLast() self.assertTrue(it.Valid()) self.assertEqual(it.key(), "d") it = db.scope("d").NewIterator().SeekToLast() self.assertTrue(it.Valid()) self.assertEqual(it.key(), "f") it = db.scope("e").NewIterator().SeekToLast() self.assertFalse(it.Valid()) db.close() db = self.db_class(leveldb.Options(), os.path.join(self.db_path, "2"), create_if_missing=True) db.Put(leveldb.WriteOptions(), "\xff\xff\xffab", "1") db.Put(leveldb.WriteOptions(), "\xff\xff\xffcd", "2") it = db.scope("\xff\xff\xff").NewIterator().SeekToLast() self.assertTrue(it.Valid()) self.assertEqual(it.key(), "cd") db.close() db = self.db_class(leveldb.Options(), os.path.join(self.db_path, "3"), create_if_missing=True) db.Put(leveldb.WriteOptions(), "\xff\xff\xfeab", "1") db.Put(leveldb.WriteOptions(), "\xff\xff\xfecd", "2") it = db.scope("\xff\xff\xff").NewIterator().SeekToLast() self.assertFalse(it.Valid()) db.close() db = self.db_class(leveldb.Options(), os.path.join(self.db_path, "4"), create_if_missing=True) db.Put(leveldb.WriteOptions(), "\xff\xff\xfeab", "1") db.Put(leveldb.WriteOptions(), "\xff\xff\xfecd", "2") it = db.scope("\xff\xff\xfe").NewIterator().SeekToLast() self.assertTrue(it.Valid()) self.assertEqual(it.key(), "cd") db.close() db = self.db_class(leveldb.Options(), os.path.join(self.db_path, "5"), create_if_missing=True) db.Put(leveldb.WriteOptions(), "\xff\xff\xfeab", "1") db.Put(leveldb.WriteOptions(), "\xff\xff\xfecd", "2") db.Put(leveldb.WriteOptions(), "\xff\xff\xffef", "1") db.Put(leveldb.WriteOptions(), "\xff\xff\xffgh", "2") it = db.scope("\xff\xff\xfe").NewIterator().SeekToLast() self.assertTrue(it.Valid()) self.assertEqual(it.key(), "cd") db.close() db = self.db_class(leveldb.Options(), os.path.join(self.db_path, "6"), create_if_missing=True) db.Put(leveldb.WriteOptions(), "\x0f\xff\xfeab", "1") db.Put(leveldb.WriteOptions(), "\x0f\xff\xfecd", "2") db.Put(leveldb.WriteOptions(), "\x0f\xff\xffef", "1") db.Put(leveldb.WriteOptions(), "\x0f\xff\xffgh", "2") it = db.scope("\x0f\xff\xfe").NewIterator().SeekToLast() self.assertTrue(it.Valid()) self.assertEqual(it.key(), "cd") db.close() db = self.db_class(leveldb.Options(), os.path.join(self.db_path, "7"), create_if_missing=True) db.Put(leveldb.WriteOptions(), "\x10\xff", "1") db.Put(leveldb.WriteOptions(), "\x11", "2") it = db.scope("\x10\xff").NewIterator().SeekToLast() self.assertTrue(it.Valid()) self.assertEqual(it.value(), "1") db.close()
def testScopedDB(self, use_writebatch=False): db = self.db_class(leveldb.Options(), self.db_path, create_if_missing=True) scoped_db_1 = db.scope("prefix1_") scoped_db_2 = db.scope("prefix2_") scoped_db_2a = scoped_db_2.scope("a_") scoped_db_2b = scoped_db_2.scope("b_") scoped_db_3 = db.scope("prefix3_") w_opts = leveldb.WriteOptions() def mod(op, db, ops): if use_writebatch: batch = leveldb.WriteBatch() for args in ops: getattr(batch, op)(*args) db.write(leveldb.WriteOptions(), batch) else: for args in ops: if op != "delete": args = list(args) args.insert(0, w_opts) getattr(db, op)(*args) mod("put", db, [("1", "2"), ("prefix2_a_13", "14")]) mod("put", scoped_db_1, [("3", "4")]) mod("put", scoped_db_2, [("5", "6")]) mod("put", scoped_db_2a, [("7", "8")]) mod("put", scoped_db_2b, [("9", "10")]) mod("put", scoped_db_3, [("11", "12")]) db_data = [("1", "2"), ("prefix1_3", "4"), ("prefix2_5", "6"), ("prefix2_a_13", "14"), ("prefix2_a_7", "8"), ("prefix2_b_9", "10"), ("prefix3_11", "12")] self.assertEquals(list(db), db_data) self.assertEquals(list(scoped_db_1), [("3", "4")]) scoped_db_2_data = [("5", "6"), ("a_13", "14"), ("a_7", "8"), ("b_9", "10")] self.assertEquals(list(scoped_db_2), scoped_db_2_data) self.assertEquals(list(scoped_db_2a), [("13", "14"), ("7", "8")]) self.assertEquals(list(scoped_db_2b), [("9", "10")]) self.assertEquals(list(scoped_db_3), [("11", "12")]) for key, val in db_data: self.assertEquals(db.Get(leveldb.ReadOptions(), key), val) for key, val in scoped_db_2_data: self.assertEquals(scoped_db_2.Get(leveldb.ReadOptions(), key), val) self.assertEquals(scoped_db_1.Get(leveldb.ReadOptions(), "3"), "4") self.assertEquals(scoped_db_2a.Get(leveldb.ReadOptions(), "7"), "8") self.assertEquals(scoped_db_2b.Get(leveldb.ReadOptions(), "9"), "10") self.assertEquals(scoped_db_3.Get(leveldb.ReadOptions(), "11"), "12") self.assertEqual(scoped_db_2a.Get(leveldb.ReadOptions(), "13"), "14") mod("delete", db, [["1"], ["prefix2_a_7"]]) mod("delete", scoped_db_1, [["3"]]) mod("delete", scoped_db_2, [["5"]]) mod("delete", scoped_db_2a, [["13"]]) mod("delete", scoped_db_2b, [["9"]]) mod("delete", scoped_db_3, [["11"]]) self.assertEquals(list(db), []) self.assertEquals(list(scoped_db_1), []) self.assertEquals(list(scoped_db_2), []) self.assertEquals(list(scoped_db_2a), []) self.assertEquals(list(scoped_db_2b), []) self.assertEquals(list(scoped_db_3), []) for key, val in db_data: self.assertEquals(db.Get(leveldb.ReadOptions(), key), None) for key, val in scoped_db_2_data: self.assertEquals(scoped_db_2.Get(leveldb.ReadOptions(), key), None) self.assertEquals(scoped_db_1.Get(leveldb.ReadOptions(), "3"), None) self.assertEquals(scoped_db_2a.Get(leveldb.ReadOptions(), "7"), None) self.assertEquals(scoped_db_2b.Get(leveldb.ReadOptions(), "9"), None) self.assertEquals(scoped_db_3.Get(leveldb.ReadOptions(), "11"), None) self.assertEqual(scoped_db_2a.Get(leveldb.ReadOptions(), "13"), None) db.close()