持久化的多键映射，使用BerkeleyDB

最新推荐文章于 2020-09-21 22:28:59 发布

Terark-CTO-雷鹏

最新推荐文章于 2020-09-21 22:28:59 发布

阅读量1.8k

点赞数

文章标签： iterator function tdd bt null insert

本文链接：https://blog.csdn.net/whinah/article/details/3248852

版权

如前介绍，相当于 std::map<Key1,std::map<Key2,Data> >，但接口也不完全相同，这里只贴代码：

 
 /* vim: set tabstop=4 : */
#ifndef __febird_bdb_kmapdset_h__ 
#define __febird_bdb_kmapdset_h__ 
#if defined(_MSC_VER) && (_MSC_VER >= 1020) 
# pragma once 
#endif 
#include <db_cxx.h> 
#include "native_compare.h" 
#include "../io/DataIO.h" 
#include "../io/MemStream.h" 
#include "../refcount.h" 
namespace febird {
class FEBIRD_DLL_EXPORT kmapdset_iterator_impl_base : public RefCounter
{
public:
    class kmapdset_base* m_owner;
    DBC* m_curp;
    int  m_ret;
    DBT  m_bulk;
public:
    kmapdset_iterator_impl_base(class kmapdset_base* owner);
    void init(DB* dbp, DB_TXN* txn, const char* func);
    virtual ~kmapdset_iterator_impl_base();
    virtual void clear_vec() = 0;
    virtual void push_back(void* data, size_t size) = 0;
    virtual void load_key1(void* data, size_t size) = 0;
    virtual void save_key1(PortableDataOutput<AutoGrownMemIO>& oKey) = 0;
    bool next_key(size_t* cnt, const char* func);
    void bulk_load(DBT* tk1);
    void increment(const char* func);
    void decrement(const char* func);
    bool find_pos(const void* k1, const void* k2, bool bulk, const char* func);
    bool insert(const void* d, const char* func);
    bool update(const void* d, const char* func);
    bool replace(const void* d, const char* func);
    bool remove(const void* k2, const char* func);
    bool remove(const char* func);
};
class FEBIRD_DLL_EXPORT kmapdset_base
{
    DECLARE_NONE_COPYABLE_CLASS(kmapdset_base)
public:
    DB*    m_db;
    size_t m_bulkSize;
    bt_compare_fcn_type m_bt_comp, m_dup_comp;
    kmapdset_base(DB_ENV* env, const char* dbname
        , DB_TXN* txn
        , bt_compare_fcn_type bt_comp
        , bt_compare_fcn_type dup_comp
        , const char* func
        );
    virtual ~kmapdset_base();
    virtual void save_key1(PortableDataOutput<AutoGrownMemIO>& dio, const void* key1) const = 0;
    virtual void save_key2(PortableDataOutput<AutoGrownMemIO>& dio, const void* key2) const = 0;
    virtual void save_data(PortableDataOutput<AutoGrownMemIO>& dio, const void* data) const = 0;
    virtual kmapdset_iterator_impl_base* make_iter() = 0;
    kmapdset_iterator_impl_base* begin_impl(DB_TXN* txn, const char* func);
    kmapdset_iterator_impl_base* end_impl(DB_TXN* txn, const char* func);
    kmapdset_iterator_impl_base* find_impl(const void* k1, DB_TXN* txn, u_int32_t flags, const char* func);
    kmapdset_iterator_impl_base* find_impl(const void* k1, const void* k2, DB_TXN* txn, bool bulk, const char* func);
    kmapdset_iterator_impl_base* upper_bound_impl(const void* k1, DB_TXN* txn, const char* func);
    size_t count_impl(const void* k1, DB_TXN* txn, const char* func);
    bool insert_impl(const void* k1, const void* d, DB_TXN* txn, const char* func);
    bool replace_impl(const void* k1, const void* d, DB_TXN* txn, const char* func);
    bool remove_impl(const void* k1, const void* k2, DB_TXN* txn, const char* func);
    bool remove_impl(const void* k1, DB_TXN* txn, const char* func);
    void clear_impl(DB_TXN* txn, const char* func);
    void flush_impl(const char* func);
};
template<class Data>
struct kmapdset_select_key2
{
    typedef typename Data::key_type type;
};
template<class Key2, class NonKeyData>
struct kmapdset_select_key2<std::pair<Key2, NonKeyData> >
{
    typedef Key2 type;
};
template<class Key1, class Key2, class Data, class Value, class Impl>
class kmapdset_iterator :
    public std::iterator<std::bidirectional_iterator_tag, Value, ptrdiff_t, const Value*, const Value&>
{
    boost::intrusive_ptr<Impl> m_impl;
    void copy_on_write()
    {
        if (m_impl->getRefCount() > 1)
        {
            Impl* p = new Impl(m_impl->m_owner);
            m_impl->m_ret = m_impl->m_curp->dup(m_impl->m_curp, &p->m_curp, DB_POSITION);
            FEBIRD_RT_assert(0 == m_impl->m_ret, std::runtime_error);
            m_impl.reset(p);
        }
    }
private:
#ifdef _MSC_VER 
//# pragma warning(disable: 4661) // declaration but not definition 
//! MSVC will warning C4661 "declaration but not definition" 
void operator++(int) { assert(0); }
void operator--(int) { assert(0); }
#else 
//! disable, because clone iterator will cause very much time and resource 
void operator++(int);// { assert(0); } 
void operator--(int);// { assert(0); } 
#endif 
public:
    kmapdset_iterator() {}
    explicit kmapdset_iterator(kmapdset_iterator_impl_base* impl)
        : m_impl(static_cast<Impl*>(impl))
    {
        assert(impl);
        assert(dynamic_cast<Impl*>(impl));
    }
//  bool exist() const { return DB_NOTFOUND != m_impl->m_ret && DB_KEYEMPTY != m_impl->m_ret; } 
    bool exist() const { return 0 == m_impl->m_ret; }
    // increment and get key/data-cnt 
    bool next_key(size_t& cnt) { return m_impl->next_key(&cnt,BOOST_CURRENT_FUNCTION); }
    bool insert(const Data& d) { return m_impl->insert(&d,BOOST_CURRENT_FUNCTION); }
    bool update(const Data& d) { return m_impl->update(&d,BOOST_CURRENT_FUNCTION); }
    bool replace(const Data& d) { return m_impl->replace(&d,BOOST_CURRENT_FUNCTION); }
    bool remove() const { return m_impl->remove(BOOST_CURRENT_FUNCTION); }
    bool remove(const Key2& k2) const { return m_impl->remove(&k2,BOOST_CURRENT_FUNCTION); }
    kmapdset_iterator& operator++()
    {
        assert(0 == m_impl->m_ret);
        copy_on_write();
        m_impl->increment(BOOST_CURRENT_FUNCTION);
        return *this;
    }
    kmapdset_iterator& operator--()
    {
        assert(0 == m_impl->m_ret);
        copy_on_write();
        m_impl->decrement(BOOST_CURRENT_FUNCTION);
        return *this;
    }
    const Value& operator*() const
    {
        assert(0 == m_impl->m_ret);
        return m_impl->m_kdv;
    }
    const Value* operator->() const
    {
        assert(0 == m_impl->m_ret);
        return &m_impl->m_kdv;
    }
    Value& get_mutable() const
    {
        assert(0 == m_impl->m_ret);
        return m_impl->m_kdv;
    }
};
//! @param Data Key2 is embeded in Data 
template<class Key1, class Data>
class kmapdset : protected kmapdset_base
{
    DECLARE_NONE_COPYABLE_CLASS(kmapdset)
public:
    typedef Key1
            key1_t, key_type;
    typedef typename kmapdset_select_key2<Data>::type
            key2_t;
    typedef Data
            data_type, data_t;
    typedef std::pair<Key1, std::vector<Data> >
            value_type;
    typedef std::vector<Data>
            data_vec_t;
    typedef typename std::vector<Data>::const_iterator
            data_iter_t;
protected:
    class kmapdset_iterator_impl : public kmapdset_iterator_impl_base
    {
    public:
        value_type m_kdv;
        kmapdset_iterator_impl(kmapdset_base* owner)
            : kmapdset_iterator_impl_base(owner)
        {}
        virtual void clear_vec()
        {
            m_kdv.second.resize(0);
        }
        virtual void push_back(void* data, size_t size)
        {
            Data x;
            PortableDataInput<MinMemIO> iData;
            iData.set(data);
            iData >> x;
            FEBIRD_RT_assert(iData.diff(data) == size, std::logic_error);
            m_kdv.second.push_back(x);
        }
        virtual void load_key1(void* data, size_t size)
        {
            PortableDataInput<MemIO> iKey1;
            iKey1.set(data, size);
            iKey1 >> m_kdv.first;
            FEBIRD_RT_assert(iKey1.diff(data) == size, std::logic_error);
        }
        virtual void save_key1(PortableDataOutput<AutoGrownMemIO>& oKey1)
        {
            oKey1 << m_kdv.first;
        }
    };
    //! overrides 
    void save_key1(PortableDataOutput<AutoGrownMemIO>& dio, const void* key1) const { dio << *(const key1_t*)key1; }
    void save_key2(PortableDataOutput<AutoGrownMemIO>& dio, const void* key2) const { dio << *(const key2_t*)key2; }
    void save_data(PortableDataOutput<AutoGrownMemIO>& dio, const void* data) const { dio << *(const data_t*)data; }
    kmapdset_iterator_impl_base* make_iter() { return new kmapdset_iterator_impl(this); }
public:
    typedef kmapdset_iterator<Key1, key2_t, Data, value_type, kmapdset_iterator_impl>
            iterator, const_iterator;
    kmapdset(DB_ENV* env, const char* dbname
        , DB_TXN* txn = NULL
        , bt_compare_fcn_type bt_comp = bdb_auto_bt_compare((key1_t*)(0))
        , bt_compare_fcn_type dup_comp = bdb_auto_bt_compare((key2_t*)(0))
        )
        : kmapdset_base(env, dbname, txn, bt_comp, dup_comp, BOOST_CURRENT_FUNCTION)
    {
    }
    kmapdset(DbEnv* env, const char* dbname
        , DbTxn* txn = NULL
        , bt_compare_fcn_type bt_comp = bdb_auto_bt_compare((key1_t*)(0))
        , bt_compare_fcn_type dup_comp = bdb_auto_bt_compare((key2_t*)(0))
        )
        : kmapdset_base(env->get_DB_ENV(), dbname, txn ? txn->get_DB_TXN() : NULL, bt_comp, dup_comp, BOOST_CURRENT_FUNCTION)
    {
    }
    iterator begin(DB_TXN* txn = NULL) { return iterator(begin_impl(txn, BOOST_CURRENT_FUNCTION)); }
    iterator end  (DB_TXN* txn = NULL) { return iterator(end_impl  (txn, BOOST_CURRENT_FUNCTION)); }
    iterator begin(DbTxn* txn) { return iterator(begin_impl(txn->get_DB_TXN(), BOOST_CURRENT_FUNCTION)); }
    iterator end  (DbTxn* txn) { return iterator(end_impl  (txn->get_DB_TXN(), BOOST_CURRENT_FUNCTION)); }
    iterator find(const Key1& k1, DB_TXN* txn = NULL)
    {
        return iterator(find_impl(&k1, txn, DB_SET|DB_MULTIPLE, BOOST_CURRENT_FUNCTION));
    }
    iterator find(const Key1& k1, DbTxn* txn)
    {
        return iterator(find_impl(&k1, txn->get_DB_TXN(), DB_SET|DB_MULTIPLE, BOOST_CURRENT_FUNCTION));
    }
    iterator find(const Key1& k1, const key2_t& k2, DB_TXN* txn = NULL)
    {
        return iterator(find_impl(&k1, &k2, txn, false, BOOST_CURRENT_FUNCTION));
    }
    iterator find(const Key1& k1, const key2_t& k2, DbTxn* txn)
    {
        return iterator(find_impl(&k1, &k2, txn->get_DB_TXN(), false, BOOST_CURRENT_FUNCTION));
    }
    iterator find_md(const Key1& k1, const key2_t& k2, DB_TXN* txn = NULL)
    {
        return iterator(find_impl(&k1, &k2, txn, true, BOOST_CURRENT_FUNCTION));
    }
    iterator find_md(const Key1& k1, const key2_t& k2, DbTxn* txn)
    {
        return iterator(find_impl(&k1, &k2, txn->get_DB_TXN(), true, BOOST_CURRENT_FUNCTION));
    }
    iterator lower_bound(const Key1& k1, DB_TXN* txn = NULL)
    {
        return iterator(find_impl(&k1, txn, DB_SET_RANGE|DB_MULTIPLE, BOOST_CURRENT_FUNCTION));
    }
    iterator lower_bound(const Key1& k1, DbTxn* txn)
    {
        return iterator(find_impl(&k1, txn->get_DB_TXN(), DB_SET_RANGE|DB_MULTIPLE, BOOST_CURRENT_FUNCTION));
    }
    iterator upper_bound(const Key1& k1, DB_TXN* txn = NULL)
    {
        return iterator(upper_bound_impl(&k1, txn, BOOST_CURRENT_FUNCTION));
    }
    bool insert(const Key1& k1, const Data& d, DB_TXN* txn = NULL)
    {
        return insert_impl(&k1, &d, txn, BOOST_CURRENT_FUNCTION);
    }
    bool insert(const Key1& k1, const Data& d, DbTxn* txn)
    {
        return insert_impl(&k1, &d, txn->get_DB_TXN(), BOOST_CURRENT_FUNCTION);
    }
    bool replace(const Key1& k1, const Data& d, DB_TXN* txn = NULL)
    {
        return replace_impl(&k1, &d, txn, BOOST_CURRENT_FUNCTION);
    }
    bool replace(const Key1& k1, const Data& d, DbTxn* txn)
    {
        return replace_impl(&k1, &d, txn->get_DB_TXN(), BOOST_CURRENT_FUNCTION);
    }
    bool remove(const Key1& k1, const key2_t& k2, DB_TXN* txn = NULL)
    {
        return remove_impl(&k1, &k2, txn, BOOST_CURRENT_FUNCTION);
    }
    bool remove(const Key1& k1, const key2_t& k2, DbTxn* txn)
    {
        return remove_impl(&k1, &k2, txn->get_DB_TXN(), BOOST_CURRENT_FUNCTION);
    }
    bool remove(const Key1& k1, DB_TXN* txn = NULL)
    {
        return remove_impl(&k1, txn, BOOST_CURRENT_FUNCTION);
    }
    bool remove(const Key1& k1, DbTxn* txn)
    {
        return remove_impl(&k1, txn->get_DB_TXN(), BOOST_CURRENT_FUNCTION);
    }
    bool erase(const iterator& iter)
    {
        return iter.remove();
    }
    void clear(DB_TXN* txn = NULL)
    {
        clear_impl(txn, BOOST_CURRENT_FUNCTION);
    }
    void clear(DbTxn* txn)
    {
        return clear_impl(txn->get_DB_TXN(), BOOST_CURRENT_FUNCTION);
    }
    void flush()
    {
        return flush_impl(BOOST_CURRENT_FUNCTION);
    }
    size_t count(const Key1& k1, DB_TXN* txn = NULL)
    {
        return count_impl(&k1, txn, BOOST_CURRENT_FUNCTION);
    }
    size_t count(const Key1& k1, DbTxn* txn)
    {
        return count_impl(&k1, txn ? txn->get_DB_TXN() : NULL, BOOST_CURRENT_FUNCTION);
    }
    DB* getDB() { return m_db; }
    const DB* getDB() const { return m_db; }
};
} // namespace febird 
#endif // __febird_bdb_kmapdset_h__ 
 

 
 /* vim: set tabstop=4 : */
#include "kmapdset.h" 
//#include "../DataBuffer.h" 
#include <sstream> 
namespace febird {
kmapdset_iterator_impl_base::kmapdset_iterator_impl_base(class kmapdset_base* owner)
    : m_owner(owner)
    , m_curp(0), m_ret(-1)
{
    memset(&m_bulk, 0, sizeof(DBT));
    m_bulk.size = (owner->m_bulkSize);
    m_bulk.data = (::malloc(owner->m_bulkSize));
    m_bulk.flags = (DB_DBT_USERMEM);
    m_bulk.ulen = (owner->m_bulkSize);
}
void kmapdset_iterator_impl_base::init(DB* dbp, DB_TXN* txn, const char* func)
{
    int ret = dbp->cursor(dbp, txn, &m_curp, 0);
    if (0 != ret)
    {
        delete this;
        std::ostringstream oss;
        oss << db_strerror(ret) << "... at: " << func;
        throw std::runtime_error(oss.str());
    }
    m_ret = 0;
}
kmapdset_iterator_impl_base::~kmapdset_iterator_impl_base()
{
    if (m_bulk.data)
        ::free(m_bulk.data);
    if (m_curp)
        m_curp->close(m_curp);
}
bool kmapdset_iterator_impl_base::next_key(size_t* cnt, const char* func)
{
    FEBIRD_RT_assert(0 == m_ret, std::logic_error);
    DBT tk1; memset(&tk1, 0, sizeof(DBT));
    m_ret = m_curp->get(m_curp, &tk1, &m_bulk, DB_NEXT_NODUP);
    if (0 == m_ret)
    {
        load_key1(tk1.data, tk1.size);
        db_recno_t cnt0 = 0;
        int ret = m_curp->count(m_curp, &cnt0, 0);
        if (0 != ret)
        {
            std::ostringstream oss;
            oss << db_strerror(ret) << "... at: " << func;
            throw std::runtime_error(oss.str());
        }
        *cnt = cnt0;
        return true;
    }
    else if (DB_NOTFOUND == m_ret)
    {
        return false;
    }
    else
    {
        std::ostringstream oss;
        oss << db_strerror(m_ret) << "... at: " << func;
        throw std::runtime_error(oss.str());
    }
}
void kmapdset_iterator_impl_base::bulk_load(DBT* tk1)
{
    FEBIRD_RT_assert(0 == m_ret, std::logic_error);
    load_key1(tk1->data, tk1->size);
    clear_vec();
    int ret;
    do {
        void  *bptr, *data;
        size_t size;
        DB_MULTIPLE_INIT(bptr, &m_bulk);
        assert(NULL != bptr);
        for (;;)
        {
            DB_MULTIPLE_NEXT(bptr, &m_bulk, data, size);
            if (bptr)
                this->push_back(data, size);
            else
                break;
        }
        ret = m_curp->get(m_curp, tk1, &m_bulk, DB_MULTIPLE|DB_NEXT_DUP);
    } while (0 == ret);
}
void kmapdset_iterator_impl_base::increment(const char* func)
{
    FEBIRD_RT_assert(0 == m_ret, std::logic_error);
    DBT tk1; memset(&tk1, 0, sizeof(DBT));
    m_ret = m_curp->get(m_curp, &tk1, &m_bulk, DB_NEXT_NODUP|DB_MULTIPLE);
    if (0 == m_ret)
    {
        bulk_load(&tk1);
    }
    else if (DB_NOTFOUND != m_ret)
    {
        std::ostringstream oss;
        oss << db_strerror(m_ret) << "... at: " << func;
        throw std::runtime_error(oss.str());
    }
}
void kmapdset_iterator_impl_base::decrement(const char* func)
{
    FEBIRD_RT_assert(0 == m_ret, std::logic_error);
    DBT tk1; memset(&tk1, 0, sizeof(DBT));
    m_ret = m_curp->get(m_curp, &tk1, &m_bulk, DB_PREV_NODUP);
    if (0 == m_ret)
    {
        m_ret = m_curp->get(m_curp, &tk1, &m_bulk, DB_CURRENT|DB_MULTIPLE);
        if (0 == m_ret)
        {
            bulk_load(&tk1);
        }
        else if (DB_KEYEMPTY == m_ret)
        {
            std::ostringstream oss;
            oss << db_strerror(m_ret)
                << "... at: " << func;
            throw std::runtime_error(oss.str());
        }
    }
    else if (DB_NOTFOUND != m_ret)
    {
        std::ostringstream oss;
        oss << db_strerror(m_ret) << "... at: " << func;
        throw std::runtime_error(oss.str());
    }
}
bool kmapdset_iterator_impl_base::find_pos(const void* k1, const void* k2, bool bulk, const char* func)
{
    PortableDataOutput<AutoGrownMemIO> oKey1, oKey2;
    m_owner->save_key1(oKey1, k1);
    m_owner->save_key2(oKey2, k2);
    DBT tk1; memset(&tk1, 0, sizeof(DBT)); tk1.data = oKey1.begin(); tk1.size = oKey1.tell();
    DBT tk2; memset(&tk2, 0, sizeof(DBT)); tk2.data = oKey2.begin(); tk2.size = oKey2.tell();
    m_ret = m_curp->get(m_curp, &tk1, &tk2, DB_GET_BOTH);
    if (0 == m_ret)
    {
        if (bulk) {
            m_ret = m_curp->get(m_curp, &tk1, &m_bulk, DB_CURRENT|DB_MULTIPLE);
            if (0 == m_ret) {
                bulk_load(&tk1);
                return true;
            }
        } else {
            clear_vec();
            load_key1(tk1.data, tk1.size);
            push_back(tk2.data, tk2.size);
            return true;
        }
    }
    else if (DB_NOTFOUND == m_ret)
    {
        return false;
    }
    std::ostringstream oss;
    oss << db_strerror(m_ret)
        << "... at: " << func
        << "/n"
        ;
    throw std::runtime_error(oss.str());
}
/**
 @brief 
 @return true successful inserted
        false fail, (key1, d) existed, and not inserted
 @throw other errors
 */
bool kmapdset_iterator_impl_base::insert(const void* d, const char* func)
{
    FEBIRD_RT_assert(0 == m_ret || DB_NOTFOUND == m_ret || DB_KEYEXIST == m_ret, std::logic_error);
    PortableDataOutput<AutoGrownMemIO> oKey1, oData;
    this->save_key1(oKey1);
    m_owner->save_data(oData, d);
    DBT tk1; memset(&tk1, 0, sizeof(DBT)); tk1.data = oKey1.begin(); tk1.size = oKey1.tell();
    DBT tdd; memset(&tdd, 0, sizeof(DBT)); tdd.data = oData.begin(); tdd.size = oData.tell();
    int ret = m_curp->put(m_curp, &tk1, &tdd, DB_NODUPDATA);
    if (DB_KEYEXIST == ret)
        return false;
    if (0 == ret)
        return true;
    std::ostringstream oss;
    oss << db_strerror(m_ret)
        << "... at: " << func;
    throw std::runtime_error(oss.str());
}
/**
 @brief 
 @return true successful updated
        false (key1, d.key2) did not exist, not updated
 @throw other errors
 */
bool kmapdset_iterator_impl_base::update(const void* d, const char* func)
{
    FEBIRD_RT_assert(0 == m_ret, std::logic_error);
    PortableDataOutput<AutoGrownMemIO> oKey1, oData;
    this->save_key1(oKey1);
    m_owner->save_data(oData, d);
    DBT tk1; memset(&tk1, 0, sizeof(DBT)); tk1.data = oKey1.begin(); tk1.size = oKey1.tell();
    DBT tdd; memset(&tdd, 0, sizeof(DBT)); tdd.data = oData.begin(); tdd.size = oData.tell();
    int ret = m_curp->get(m_curp, &tk1, &tdd, DB_GET_BOTH);
    if (0 == ret)
    {
        tk1.data = oKey1.begin(); tk1.size = oKey1.tell();
        tdd.data = oData.begin(); tdd.size = oData.tell();
        ret = m_curp->put(m_curp, &tk1, &tdd, DB_CURRENT);
        if (0 == ret)
            return true;
    }
    else if (DB_NOTFOUND == ret)
    {
        return false;
    }
    std::ostringstream oss;
    oss << db_strerror(ret)
        << "... at: " << func;
    throw std::runtime_error(oss.str());
}
/**
 @brief 
 @return true  item was replaced by (key1,d)
         false item was inserted
 @throw  other errors
 */
bool kmapdset_iterator_impl_base::replace(const void* d, const char* func)
{
    PortableDataOutput<AutoGrownMemIO> oKey1, oData;
    this->save_key1(oKey1);
    m_owner->save_data(oData, d);
    DBT tk1; memset(&tk1, 0, sizeof(DBT)); tk1.data = oKey1.begin(); tk1.size = oKey1.tell();
    DBT tdd; memset(&tdd, 0, sizeof(DBT)); tdd.data = oData.begin(); tdd.size = oData.tell();
    int ret = m_curp->get(m_curp, &tk1, &tdd, DB_GET_BOTH);
    if (0 == ret)
    {
        tk1.data = oKey1.begin(); tk1.size = oKey1.tell();
        tdd.data = oData.begin(); tdd.size = oData.tell();
        ret = m_curp->put(m_curp, &tk1, &tdd, DB_CURRENT);
        if (0 == ret)
            return true;
    }
    else if (DB_NOTFOUND == ret)
    {
        ret = m_curp->put(m_curp, &tk1, &tdd, DB_NODUPDATA);
        if (0 == ret)
            return false;
    }
    std::ostringstream oss;
    oss << db_strerror(ret)
        << "... at: " << func;
    throw std::runtime_error(oss.str());
}
bool kmapdset_iterator_impl_base::remove(const void* k2, const char* func)
{
    FEBIRD_RT_assert(0 == m_ret, std::logic_error);
    PortableDataOutput<AutoGrownMemIO> oKey1, oKey2;
    this->save_key1(oKey1);
    m_owner->save_key2(oKey2, k2);
    DBT tk1; memset(&tk1, 0, sizeof(DBT)); tk1.data = oKey1.begin(); tk1.size = oKey1.tell();
    DBT tdd; memset(&tdd, 0, sizeof(DBT)); tdd.data = oKey2.begin(); tdd.size = oKey2.tell();
    int ret = m_curp->get(m_curp, &tk1, &tdd, DB_GET_BOTH);
    if (0 == ret)
        ret = m_curp->del(m_curp, 0);
    if (DB_KEYEMPTY == ret)
        return false;
    if (0 == ret)
        return true;
    std::ostringstream oss;
    oss << db_strerror(ret)
        << "... at: " << func;
    throw std::runtime_error(oss.str());
}
bool kmapdset_iterator_impl_base::remove(const char* func)
{
    FEBIRD_RT_assert(0 == m_ret, std::logic_error);
    PortableDataOutput<AutoGrownMemIO> oKey1;
    this->save_key1(oKey1);
    DBT tk1; memset(&tk1, 0, sizeof(DBT)); tk1.data = oKey1.begin(); tk1.size = oKey1.tell();
    int ret = m_owner->m_db->del(m_owner->m_db, m_curp->txn, &tk1, 0);
    if (DB_NOTFOUND == ret)
        return false;
    if (0 == ret)
        return true;
    std::ostringstream oss;
    oss << db_strerror(ret)
        << "... at: " << func;
    throw std::runtime_error(oss.str());
}
// 
kmapdset_base::kmapdset_base(DB_ENV* env, const char* dbname
    , DB_TXN* txn
    , bt_compare_fcn_type bt_comp
    , bt_compare_fcn_type dup_comp
    , const char* func
    )
    : m_bt_comp(0)
{
    m_bulkSize = 512*1024;
    m_db = 0;
    int ret = db_create(&m_db, env, 0);
    if (0 == ret)
    {
        if (bt_comp) {
            m_bt_comp = bt_comp;
            m_db->set_bt_compare(m_db, bt_comp);
        }
        if (dup_comp) {
            m_dup_comp = dup_comp;
            m_db->set_dup_compare(m_db, dup_comp);
        }
        m_db->app_private = (this);
        int flags = env->open_flags & (DB_THREAD|DB_MULTIVERSION|DB_AUTO_COMMIT);
        ret = m_db->open(m_db, txn, dbname, dbname, DB_BTREE, DB_CREATE|flags, 0);
    }
    if (0 != ret)
    {
        std::ostringstream oss;
        oss << db_strerror(ret)
            << "... at: " << func;
        throw std::runtime_error(oss.str());
    }
}
kmapdset_base::~kmapdset_base()
{
    if (m_db)
        m_db->close(m_db, 0);
}
kmapdset_iterator_impl_base* kmapdset_base::begin_impl(DB_TXN* txn, const char* func)
{
    kmapdset_iterator_impl_base* iter = make_iter();
    iter->init(m_db, txn, func);
    DBT tk1; memset(&tk1, 0, sizeof(DBT));
    iter->m_ret = iter->m_curp->get(iter->m_curp, &tk1, &iter->m_bulk, DB_FIRST|DB_MULTIPLE);
    if (0 == iter->m_ret)
    {
        iter->bulk_load(&tk1);
    }
    else if (DB_NOTFOUND != iter->m_ret)
    {
        std::ostringstream oss;
        oss << db_strerror(iter->m_ret)
            << "... at: " << func;
        delete iter; iter = 0;
        throw std::runtime_error(oss.str());
    }
    return iter;
}
kmapdset_iterator_impl_base* kmapdset_base::end_impl(DB_TXN* txn, const char* func)
{
    kmapdset_iterator_impl_base* iter = make_iter();
    iter->init(m_db, txn, func);
    return iter;
}
kmapdset_iterator_impl_base* kmapdset_base::find_impl(const void* k1, DB_TXN* txn, u_int32_t flags, const char* func)
{
    PortableDataOutput<AutoGrownMemIO> oKey1;
    save_key1(oKey1, k1);
    DBT tk1; memset(&tk1, 0, sizeof(DBT)); tk1.data = oKey1.begin(); tk1.size = oKey1.tell();
    kmapdset_iterator_impl_base* iter = make_iter();
    iter->init(m_db, txn, func);
    iter->m_ret = iter->m_curp->get(iter->m_curp, &tk1, &iter->m_bulk, flags);
    if (0 == iter->m_ret)
    {
        iter->bulk_load(&tk1);
    }
    else if (DB_NOTFOUND != iter->m_ret && DB_KEYEMPTY != iter->m_ret)
    {
        std::ostringstream oss;
        oss << db_strerror(iter->m_ret)
            << "... at: " << func
            << "/n"
            << "flags=" << flags
            ;
        throw std::runtime_error(oss.str());
    }
    return iter;
}
kmapdset_iterator_impl_base* 
kmapdset_base::find_impl(const void* k1, const void* k2, DB_TXN* txn, bool bulk, const char* func)
{
    kmapdset_iterator_impl_base* iter = make_iter();
    iter->init(m_db, txn, func);
    try {
        bool bRet = iter->find_pos(k1, k2, bulk, func);
        return iter;
    } catch (std::exception& exp) {
        delete iter; iter = 0;
        throw exp;
    }
}
kmapdset_iterator_impl_base* kmapdset_base::upper_bound_impl(const void* k1, DB_TXN* txn, const char* func)
{
    PortableDataOutput<AutoGrownMemIO> oKey1;
    save_key1(oKey1, k1);
    DBT tk1; memset(&tk1, 0, sizeof(DBT)); tk1.data = oKey1.begin(); tk1.size = oKey1.tell();
    kmapdset_iterator_impl_base* iter = make_iter();
    iter->init(m_db, txn, func);
    iter->m_ret = iter->m_curp->get(iter->m_curp, &tk1, &iter->m_bulk, DB_SET_RANGE|DB_MULTIPLE);
    if (0 == iter->m_ret)
    {
        DBT kbak; memset(&kbak, 0, sizeof(DBT)); kbak.data = oKey1.begin(); kbak.size = oKey1.tell();
        int cmp = m_bt_comp(m_db, &kbak, &tk1);
        assert(cmp <= 0);
        if (0 == cmp) {
            iter->m_ret = iter->m_curp->get(iter->m_curp, &tk1, &iter->m_bulk, DB_NEXT_NODUP|DB_MULTIPLE);
            if (0 == iter->m_ret)
                iter->bulk_load(&tk1);
        } else
            iter->bulk_load(&tk1);
    }
    if (0 != iter->m_ret && DB_NOTFOUND != iter->m_ret)
    {
        std::ostringstream oss;
        oss << db_strerror(iter->m_ret)
            << "... at: " << func
            << "/n"
            ;
        throw std::runtime_error(oss.str());
    }
    return iter;
}
size_t kmapdset_base::count_impl(const void* k1, DB_TXN* txn, const char* func)
{
    PortableDataOutput<AutoGrownMemIO> oKey1;
    try {
        save_key1(oKey1, k1);
    }
    catch (const IOException& exp)
    {
        std::ostringstream oss;
        oss << exp.what() << "... at: " << func;
        throw std::runtime_error(oss.str());
    }
    DBT tk1; memset(&tk1, 0, sizeof(DBT)); tk1.data = oKey1.begin(); tk1.size = oKey1.tell();
    DBT tdd; memset(&tdd, 0, sizeof(DBT));
    DBC* curp = NULL;
    int ret = m_db->cursor(m_db, txn, &curp, 0);
    if (0 == ret)
    {
        ret = curp->get(curp, &tk1, &tdd, DB_SET);
        db_recno_t count = 0;
        if (0 == ret)
            ret = curp->count(curp, &count, 0);
        else if (DB_NOTFOUND == ret)
            count = 0, ret = 0; // clear error 
        curp->close(curp);
        if (0 != ret)
            goto ErrorL;
        return count;
    }
ErrorL:
    std::ostringstream oss;
    oss << db_strerror(ret)
        << "... at: " << func
        << "/n"
        ;
    throw std::runtime_error(oss.str());
}
/**
 @brief insert a record
 @return true success,  no same k1-k2 in db, the record was inserted
         false failed, has same k1-k2 in db, the record was not inserted, not replaced existing yet
 @throws exception, failed
 */
bool kmapdset_base::insert_impl(const void* k1, const void* d, DB_TXN* txn, const char* func)
{
    PortableDataOutput<AutoGrownMemIO> oKey1, oData;
    try {
        save_key1(oKey1, k1);
        save_data(oData, d);
    }
    catch (const IOException& exp)
    {
        std::ostringstream oss;
        oss << exp.what() << "... at: " << func;
        throw std::runtime_error(oss.str());
    }
    DBT tk1; memset(&tk1, 0, sizeof(DBT)); tk1.data = oKey1.begin(); tk1.size = oKey1.tell();
    DBT tdd; memset(&tdd, 0, sizeof(DBT)); tdd.data = oData.begin(); tdd.size = oData.tell();
    int ret = m_db->put(m_db, txn, &tk1, &tdd, DB_NODUPDATA);
    if (DB_KEYEXIST == ret)
        return false;
    if (0 == ret)
        return true;
    std::ostringstream oss;
    oss << db_strerror(ret)
        << "... at: " << func
        << "/n"
        ;
    throw std::runtime_error(oss.str());
}
/**
 @brief replace OR insert a record
 @note
  if not thrown an exception, always success
 @return true replace the record
         false insert the record
 @throws exception, failed
 */
bool kmapdset_base::replace_impl(const void* k1, const void* d, DB_TXN* txn, const char* func)
{
    PortableDataOutput<AutoGrownMemIO> oKey1, oData;
    try {
        save_key1(oKey1, k1);
        save_data(oData, d);
    }
    catch (const IOException& exp)
    {
        std::ostringstream oss;
        oss << exp.what() << "... at: " << func;
        throw std::runtime_error(oss.str());
    }
    DBT tk1; memset(&tk1, 0, sizeof(DBT)); tk1.data = oKey1.begin(); tk1.size = oKey1.tell();
    DBT tdd; memset(&tdd, 0, sizeof(DBT)); tdd.data = oData.begin(); tdd.size = oData.tell();
    DBC* curp = NULL;
    int ret = m_db->cursor(m_db, txn, &curp, 0);
    if (0 == ret)
    {
        ret = curp->get(curp, &tk1, &tdd, DB_GET_BOTH);
        if (0 == ret)
        {
            tk1.data = oKey1.begin(); tk1.size = oKey1.tell();
            tdd.data = oData.begin(); tdd.size = oData.tell();
            ret = curp->put(curp, &tk1, &tdd, DB_CURRENT);
            curp->close(curp);
            if (0 == ret)
                return true;
        }
        else if (DB_NOTFOUND == ret)
        {
            ret = curp->put(curp, &tk1, &tdd, DB_NODUPDATA);
            curp->close(curp);
            if (0 == ret)
                return false;
        }
    }
    std::ostringstream oss;
    oss << db_strerror(ret)
        << "... at: " << func
        << "/n"
        ;
    throw std::runtime_error(oss.str());
}
/**
 @brief 
 @return true (k1,k2) existed, remove success
        false (k1,k2) not existed, nothing done
 */
bool kmapdset_base::remove_impl(const void* k1, const void* k2, DB_TXN* txn, const char* func)
{
    PortableDataOutput<AutoGrownMemIO> oKey1, oData;
    oData.resize(4*1024);
    save_key1(oKey1, k1);
    save_key2(oData, k2);
    DBT tk1; memset(&tk1, 0, sizeof(DBT)); tk1.data = oKey1.begin(); tk1.size = oKey1.tell();
    DBT tdd; memset(&tdd, 0, sizeof(DBT)); tdd.data = oData.begin(); tdd.size = oData.tell();
    DBC* curp = NULL;
    int ret = m_db->cursor(m_db, txn, &curp, 0);
    if (0 == ret)
    {
        ret = curp->get(curp, &tk1, &tdd, DB_GET_BOTH);
        if (0 == ret) {
            ret = curp->del(curp, 0);
        }
        curp->close(curp);
        return 0 == ret;
    }
    else
    {
        std::ostringstream oss;
        oss << db_strerror(ret)
            << "... at: " << func
            << "/n"
            ;
        throw std::runtime_error(oss.str());
    }
}
/**
 @brief 
 @return true (k1) existed, remove success
        false (k1) not existed, nothing done
 */
bool kmapdset_base::remove_impl(const void* k1, DB_TXN* txn, const char* func)
{
    PortableDataOutput<AutoGrownMemIO> oKey1;
    save_key1(oKey1, k1);
    DBT tk1; memset(&tk1, 0, sizeof(DBT)); tk1.data = oKey1.begin(); tk1.size = oKey1.tell();
    int ret = m_db->del(m_db, txn, &tk1, 0);
    if (DB_NOTFOUND == ret)
        return false;
    if (0 == ret)
        return true;
    std::ostringstream oss;
    oss << db_strerror(ret)
        << "... at: " << func
        << "/n"
        ;
    throw std::runtime_error(oss.str());
}
void kmapdset_base::clear_impl(DB_TXN* txn, const char* func)
{
    u_int32_t count;
    int ret = m_db->truncate(m_db, txn, &count, 0);
    if (0 != ret)
    {
        std::ostringstream oss;
        oss << db_strerror(ret)
            << "... at: " << func
            << "/n"
            ;
        throw std::runtime_error(oss.str());
    }
}
void kmapdset_base::flush_impl(const char* func)
{
    int ret = m_db->sync(m_db, 0);
    if (0 != ret)
    {
        std::ostringstream oss;
        oss << db_strerror(ret)
            << "... at: " << func
            << "/n"
            ;
        throw std::runtime_error(oss.str());
    }
}
} // namespace febird 
 

Terark-CTO-雷鹏

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
持久化的多键映射，使用BerkeleyDB

如前介绍，相当于 std::map >，但接口也不完全相同，这里只贴代码： /* vim: set tabstop=4 : */#ifndef __febird_bdb_kmapdset_h__ #define __febird_bdb_kmapdset_h__ #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pra
复制链接

扫一扫