C++ leveldb::WriteBatch类代码示例

int IndexDbLevelDb::writeUsrDb(const map<string, SiMap>& usrFidMap, leveldb::DB* dbUsrDb, leveldb::WriteBatch& wb_usrdb, const string& dbName)
{
    // lookup map
    for(const auto& itr : usrFidMap) {
        const string& usr = itr.first;
        if(usr != "") {
            SiMap file_list_map = itr.second;
#ifdef USE_USR2FILE_TABLE2
            for(const auto& itr_str : file_list_map) {
                wb_usrdb.Put(dbName + "|" + usr + "|" + itr_str.first, "1");
            }
#else
            // check if already registered
            string value;
            int rv = dbRead(value, dbUsrDb, dbName + "|" + usr);
            if(rv == 0) {
                const string delim = ",";
                list<string> old_list;
                boost::split(old_list, value, boost::is_any_of(delim));
                for(const auto& itr_old : old_list) {
                    file_list_map[itr_old] = 0;
                }
            }
            string file_list_string = "";
            for(const auto& itr_str : file_list_map) {
                file_list_string.append(itr_str.first+",");
            }
            file_list_string = file_list_string.substr(0, file_list_string.size()-1);
            wb_usrdb.Put(dbName + "|" + usr, file_list_string);
#endif
        }
    }
    return 0;
}

bool leveldb_chain_keeper::remove_address(leveldb::WriteBatch& batch,
    const script& output_script, const output_point& outpoint)
{
    payment_address address;
    if (!extract(address, output_script))
        return false;
    data_chunk raw_address = create_address_key(address);
    BITCOIN_ASSERT(!raw_address.empty());
    data_chunk outpoint_value = create_spent_key(outpoint);
    bool is_found = false;
    leveldb_iterator it(address_iterator(db_.addr, raw_address));
    for (; valid_address_iterator(it, raw_address); it->Next())
    {
        if (slice_to_output_point(it->value()) != outpoint)
            continue;
        // We found the address entry we were looking for.
        BITCOIN_ASSERT(!is_found);
        is_found = true;
        // Put changes into batch finally.
        batch.Delete(it->key());
        break;
    }
    BITCOIN_ASSERT(it->status().ok());
    if (!is_found)
        return false;
    return true;
}

bool mark_spent_outputs(leveldb::WriteBatch& spend_batch,
    const output_point& previous_output, const input_point& spent_inpoint)
{
    data_chunk spent_key = create_spent_key(previous_output),
        spend_value = create_spent_key(spent_inpoint);
    spend_batch.Put(slice(spent_key), slice(spend_value));
    return true;
}

void c_seq::seq_update(leveldb::WriteBatch& bh)
{
	m_seq_head.s_uptime(time(0));
	m_seq_head.m_head.s_crc(c_crc::crc16(0, 
		(uint8*)&m_seq_head + sizeof(_zmsg_head), 
		sizeof(m_seq_head) - sizeof(_zmsg_head)));
	leveldb::Slice value( (const char*)&m_seq_head, sizeof(m_seq_head) );
	bh.Put(m_key, value);
}

bool remove_credit(leveldb::WriteBatch& batch,
    const transaction_output_type& output, const output_point& outpoint)
{
    payment_address address;
    // Not a Bitcoin address so skip this output.
    if (!extract(address, output.script))
        return true;
    data_chunk addr_key = create_address_key(address, outpoint);
    batch.Delete(slice(addr_key));
    return true;
}

TxId DatabaseHelper::txSave(leveldb::WriteBatch& batch, const Hash256& txHash, const DbTransaction& dbTx)
{
	auto buffer = bufferTLS.get();
	if (buffer == NULL)
	{
		bufferTLS.reset(buffer = new std::string());
	}

	auto index = txGetOrCreateId(txHash);

	Serialize(*buffer, dbTx);

	char searchKey2[1 + sizeof(TxId)];
	searchKey2[0] = (uint8_t)DatabaseKeyHeader::Tx;
	*(TxId*) &searchKey2[1] = swapByteOrder(index);
	batch.Put(leveldb::Slice((const char*)searchKey2, sizeof(searchKey2)), *buffer);

	return index;
}

			Status Put(const std::vector<std::pair<std::string, std::string>>& writes)
			{
				leveldb::WriteBatch batch;

				for (auto kv : writes)
				{
					batch.Put(kv.first, kv.second);
				}

				leveldb::Status s = db->Write(leveldb::WriteOptions(), &batch);

				if (s.ok())
				{
					return Status::OK();
				}

				return Status::NotFound();

			}

bool add_credit(leveldb::WriteBatch& batch,
    const payment_address& address, uint64_t output_value,
    const output_point& outpoint, uint32_t block_height)
{
    data_chunk addr_key = create_address_key(address, outpoint);
    // outpoint, value, block_height
    data_chunk row_info(36 + 8 + 4);
    auto serial = make_serializer(row_info.begin());
    // outpoint
    serial.write_hash(outpoint.hash);
    serial.write_4_bytes(outpoint.index);
    // value
    serial.write_8_bytes(output_value);
    // block_height
    serial.write_4_bytes(block_height);
    BITCOIN_ASSERT(
        std::distance(row_info.begin(), serial.iterator()) == 36 + 8 + 4);
    batch.Put(slice(addr_key), slice(row_info));
    return true;
}

void c_seq::seq_set(leveldb::WriteBatch& bh, leveldb::Slice& value)
{
	uint32 keyId = m_seq_head.g_index() + 1;

	m_seq_head.s_index(keyId);
	m_seq_head.s_count(m_seq_head.g_count() + 1);

	_zmsg_head head;
	head.type = T_SEQ_VALUE;
	head.s_effective(time(0));
	head.s_crc(c_crc::crc16(0, (uint8*)value.data(), value.size()));

	memcpy(TSEQ_BUF(), &head, sizeof(_zmsg_head));
	memcpy(TSEQ_BUF() + sizeof(_zmsg_head), (void*)value.data(), value.size());
	int len = sizeof(_zmsg_head) + value.size();
	if (len > 0)
	{
		leveldb::Slice data(TSEQ_BUF(), len);
		bh.Put(__tos(m_key << "@" << keyId), data);
	}
}

bool add_debit(leveldb::WriteBatch& batch,
    const transaction_input_type& input, const input_point& inpoint,
    uint32_t block_height)
{
    payment_address address;
    // Not a Bitcoin address so skip this output.
    if (!extract(address, input.script))
        return true;
    data_chunk addr_key = create_address_key(address, input.previous_output);
    // inpoint
    data_chunk row_info(36 + 4);
    auto serial = make_serializer(row_info.begin());
    // inpoint
    serial.write_hash(inpoint.hash);
    serial.write_4_bytes(inpoint.index);
    // block_height
    serial.write_4_bytes(block_height);
    BITCOIN_ASSERT(
        std::distance(row_info.begin(), serial.iterator()) == 36 + 4);
    batch.Put(slice(addr_key), slice(row_info));
    return true;
}

void c_seq::seq_del(uint32 keyId, leveldb::WriteBatch& bh)
{
	bh.Delete(__tos(m_key << "@" << keyId));
	m_seq_head.s_count(m_seq_head.g_count() - 1);
	//LOG4_ERROR("SEQ DEL KEY:" << __tos(m_key << "@" << keyId));
}

					void Clear()
					{
						batch.Clear();
						count = 0;
					}