Python leveldb.WriteBatch方法代码示例

# 需要导入模块: import leveldb [as 别名]
# 或者: from leveldb import WriteBatch [as 别名]
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(self.db_path, create_if_missing=True)
        db.write(batch)
        iterator = db.iterator(prefix="c")
        iterator.seekFirst()
        self.assertEqual(iterator.next(), ('', 'a'))
        self.assertEqual(iterator.next(), ('d', 'a'))
        self.assertEqual(iterator.next(), ('e', 'a'))
        self.assertRaises(StopIteration, iterator.next)
        db.close() 

# 需要导入模块: import leveldb [as 别名]
# 或者: from leveldb import WriteBatch [as 别名]
def testApproximateSizes(self):
        db = self.db_class(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(batch, sync=True)
        db.close()
        db = self.db_class(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("3%d" % i, os.urandom(10))
        db.close()
        db = self.db_class(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() 

# 需要导入模块: import leveldb [as 别名]
# 或者: from leveldb import WriteBatch [as 别名]
def testApproximateSizes(self):
        db = self.db_class(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(batch, sync=True)
        db.close()
        db = self.db_class(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("3%d" % i, os.urandom(10))
        db.close()
        db = self.db_class(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() 

# 需要导入模块: import leveldb [as 别名]
# 或者: from leveldb import WriteBatch [as 别名]
def _saveChunk_pre1_0(self, chunk, batch=None, writeOptions=None):
        """
        :param chunk: PocketLeveldbChunk
        :param batch: WriteBatch
        :param writeOptions: WriteOptions
        :return: None
        """
        cx, cz = chunk.chunkPosition
        data = chunk.savedData()
        key = struct.pack('<i', cx) + struct.pack('<i', cz)+dimension

        if batch is None:
            with self.world_db() as db:
                wop = self.writeOptions if writeOptions is None else writeOptions
                db.Put(wop, key + "0", data[0])
                if data[1] is not None:
                    db.Put(wop, key + "1", data[1])
                if data[2] is not None:
                    db.Put(wop, key + "2", data[2])
        else:
            batch.Put(key + "0", data[0])
            if data[1] is not None:
                batch.Put(key + "1", data[1])
            if data[2] is not None:
                batch.Put(key + "2", data[2]) 

# 需要导入模块: import leveldb [as 别名]
# 或者: from leveldb import WriteBatch [as 别名]
def saveChunk(self, chunk, batch=None, writeOptions=None):
        """
        Wrapper for the methods corresponding to the world version.
        :param chunk: PocketLeveldbChunk
        :param batch: WriteBatch
        :param writeOptions: WriteOptions
        :return: None
        """
        # Check the chunk version, since PE 1.0+ can contain pre 1.0+ chunks
        ver = chunk.chunk_version
        if ver == "\x02":
            self._saveChunk_pre1_0(chunk, batch, writeOptions)
        elif ord(ver) >= 3:
            self._saveChunk_1plus(chunk, batch, writeOptions)
        else:
            raise AttributeError("Unknown version %s for chunk %s"%(ver, chunk.chunkPosition())) 

# 需要导入模块: import leveldb [as 别名]
# 或者: from leveldb import WriteBatch [as 别名]
def deleteChunk(self, cx, cz, batch=None):
        """
        Deletes a chunk at given cx, cz. Deletes using the batch if batch is given, uses world_db() otherwise.
        :param cx, cz Coordinates of the chunk
        :param batch WriteBatch
        :return: None
        """
        self.worldFile.deleteChunk(cx, cz, batch=batch)
        try:
            del self._loadedChunks[(cx, cz)]
        except:
            pass
        try:
            self.allChunks.remove((cx, cz))
        except:
            pass 

# 需要导入模块: import leveldb [as 别名]
# 或者: from leveldb import WriteBatch [as 别名]
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() 

# 需要导入模块: import leveldb [as 别名]
# 或者: from leveldb import WriteBatch [as 别名]
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() 

# 需要导入模块: import leveldb [as 别名]
# 或者: from leveldb import WriteBatch [as 别名]
def setBatch(self, batch: Iterable[Tuple]):
        b = leveldb.WriteBatch()
        for key, value in batch:
            key = self.to_byte_repr(key)
            value = self.to_byte_repr(value)
            b.Put(key, value)
        self._db.Write(b, sync=False) 

# 需要导入模块: import leveldb [as 别名]
# 或者: from leveldb import WriteBatch [as 别名]
def do_ops_in_batch(self, batch: Iterable[Tuple]):
        b = leveldb.WriteBatch()
        for op, key, value in batch:
            key = self.to_byte_repr(key)
            value = self.to_byte_repr(value)
            if op == self.WRITE_OP:
                b.Put(key, value)
            elif op == self.REMOVE_OP:
                b.Delete(key)
            else:
                raise ValueError('Unknown operation')
        self._db.Write(b, sync=False) 

# 需要导入模块: import leveldb [as 别名]
# 或者: from leveldb import WriteBatch [as 别名]
def commit(self):
        log.debug('committing', db=self)
        batch = leveldb.WriteBatch()
        for k, v in self.uncommitted.items():
            if v is None:
                batch.Delete(k)
            else:
                batch.Put(k, compress(v))
        self.db.Write(batch, sync=False)
        self.uncommitted.clear() 

# 需要导入模块: import leveldb [as 别名]
# 或者: from leveldb import WriteBatch [as 别名]
def _new_batch(self):
        return leveldb.WriteBatch() 

# 需要导入模块: import leveldb [as 别名]
# 或者: from leveldb import WriteBatch [as 别名]
def WriteBatch(self, sync=False) -> KeyValueStoreWriteBatch:
        return _KeyValueStoreWriteBatchLevelDb(self._db, sync) 

# 需要导入模块: import leveldb [as 别名]
# 或者: from leveldb import WriteBatch [as 别名]
def __init__(self, path):
        self._path = path
        self._db = leveldb.LevelDB(path)
        self._batch = leveldb.WriteBatch()
        self._init_db()
        self.x = 0
        self.lflush = clock() 

# 需要导入模块: import leveldb [as 别名]
# 或者: from leveldb import WriteBatch [as 别名]
def flush(self, sync_mode=False):
        self._db.Write(self._batch, sync=sync_mode)
        self.x = 0
        self._batch = leveldb.WriteBatch()
        self.lflush = clock()