持久化的 map ，使用 BerkeleyDB

项目地址：http://code.google.com/p/febird

 

使用前面介绍的序列化框架，可以非常简单地将Bekeley DB作为存储层，实现一个易于使用的，强类型的，持久化的map。

 

这个设计的的基本原则就是：模板作为一个薄的、类型安全的包装层，实现层的代码可以多个模板实例来公用，这样不但加快了编译时间，也减小了生成的代码尺寸。

这个实现相当于std::map<Key,Data>，但接口上也不完全相同，主要是基于易实现和性能考虑。

下一篇介绍std::map<Key1,std::map<Key2,Data> >的BerkeleyDB实现。

 

 多的不说，贴上代码。

 

file: dbmap.h

 

 

 

1. /* vim: set tabstop=4 : */
2. #ifndef __febird_bdb_dbmap_h__
3. #define __febird_bdb_dbmap_h__
5. #if defined(_MSC_VER) && (_MSC_VER >= 1020)
6. # pragma once
7. #endif
9. #include <db_cxx.h>
10. #include "native_compare.h"
11. #include "../io/DataIO.h"
12. #include "../io/MemStream.h"
13. #include "../refcount.h"
15. namespace febird {
17. class FEBIRD_DLL_EXPORT dbmap_iterator_impl_base : public RefCounter
18. {
19. public:
20.     class dbmap_base* m_owner;
21.     DBC*  m_curp;
22.     int   m_ret;
24. public:
25.     dbmap_iterator_impl_base(class dbmap_base* owner);
26.     void init(DB* dbp, DB_TXN* txn, const char* func);
28.     virtual ~dbmap_iterator_impl_base();
30.     virtual void load_key(void* data, size_t size) = 0;
31.     virtual void load_val(void* data, size_t size) = 0;
32.     virtual void save_key(PortableDataOutput<AutoGrownMemIO>& oKey) = 0;
34.     void advance(u_int32_t direction_flag, const char* func);
36.     void update(const void* d, const char* func);
37.     void remove(const char* func);
38. };
40. class FEBIRD_DLL_EXPORT dbmap_base
41. {
42.     DECLARE_NONE_COPYABLE_CLASS(dbmap_base)
44. public:
45.     DB*    m_db;
46.     size_t m_bulkSize;
47.     bt_compare_fcn_type m_bt_comp;
49.     dbmap_base(DB_ENV* env, const char* dbname
50.         , DB_TXN* txn
51.         , bt_compare_fcn_type bt_comp
52.         , const char* func
53.         );
55.     virtual ~dbmap_base();
56.     virtual void save_key(PortableDataOutput<AutoGrownMemIO>& dio, const void* key) const = 0;
57.     virtual void save_val(PortableDataOutput<AutoGrownMemIO>& dio, const void* data) const = 0;
59.     virtual dbmap_iterator_impl_base* make_iter() = 0;
61.     dbmap_iterator_impl_base* begin_impl(DB_TXN* txn, const char* func);
62.     dbmap_iterator_impl_base* end_impl(DB_TXN* txn, const char* func);
64.     dbmap_iterator_impl_base* find_impl(const void* k, DB_TXN* txn, u_int32_t flags, const char* func);
66.     bool insert_impl(const void* k, const void* d, u_int32_t flags, DB_TXN* txn, const char* func);
67.     bool remove_impl(const void* k, DB_TXN* txn, const char* func);
68.     void clear_impl(DB_TXN* txn, const char* func);
69. };
71. template<class Key, class Val, class Value, class Impl>
72. class dbmap_iterator :
73.     public std::iterator<std::bidirectional_iterator_tag, Value, ptrdiff_t, const Value*, const Value&>
74. {
75.     boost::intrusive_ptr<Impl> m_impl;
77.     void copy_on_write()
78.     {
79.         if (m_impl->getRefCount() > 1)
80.         {
81.             Impl* p = new Impl(m_impl->m_owner);
82.             m_impl->m_ret = m_impl->m_curp->dup(m_impl->m_curp, &p->m_curp, DB_POSITION);
83.             FEBIRD_RT_assert(0 == m_impl->m_ret, std::runtime_error);
84.             m_impl.reset(p);
85.         }
86.     }
87. private:
88. #ifdef _MSC_VER
89. //# pragma warning(disable: 4661) // declaration but not definition
90. //! MSVC will warning C4661 "declaration but not definition"
91. void operator++(int) { assert(0); }
92. void operator--(int) { assert(0); }
93. #else
94. //! disable, because clone iterator will cause very much time and resource
95. void operator++(int);// { assert(0); }
96. void operator--(int);// { assert(0); }
97. #endif
99. public:
100.     dbmap_iterator() {}
101.     explicit dbmap_iterator(dbmap_iterator_impl_base* impl)
102.         : m_impl(static_cast<Impl*>(impl))
103.     {
104.         assert(impl);
105.         assert(dynamic_cast<Impl*>(impl));
106.     }
108. //  bool exist() const { return DB_NOTFOUND != m_impl->m_ret && DB_KEYEMPTY != m_impl->m_ret; }
109.     bool exist() const { return 0 == m_impl->m_ret; }
111.     void update(const Val& val) { m_impl->update(&val, BOOST_CURRENT_FUNCTION); }
113.     void remove() { m_impl->remove(BOOST_CURRENT_FUNCTION); }
115.     dbmap_iterator& operator++()
116.     {
117.         assert(0 == m_impl->m_ret);
118.         copy_on_write();
119.         m_impl->advance(DB_NEXT, BOOST_CURRENT_FUNCTION);
120.         return *this;
121.     }
122.     dbmap_iterator& operator--()
123.     {
124.         assert(0 == m_impl->m_ret);
125.         copy_on_write();
126.         m_impl->advance(DB_PREV, BOOST_CURRENT_FUNCTION);
127.         return *this;
128.     }
129.     const Value& operator*() const
130.     {
131.         assert(0 == m_impl->m_ret);
132.         return m_impl->m_val;
133.     }
134.     const Value* operator->() const
135.     {
136.         assert(0 == m_impl->m_ret);
137.         return &m_impl->m_val;
138.     }
139.     Value& get_mutable() const
140.     {
141.         assert(0 == m_impl->m_ret);
142.         return m_impl->m_val;
143.     }
144. };
146. template<class Key, class Val>
147. class dbmap : protected dbmap_base
148. {
149.     DECLARE_NONE_COPYABLE_CLASS(dbmap)
151. public:
152.     typedef Key     key_type;
153.     typedef std::pair<Key, Val> value_type;
155. protected:
156.     class dbmap_iterator_impl : public dbmap_iterator_impl_base
157.     {
158.     public:
159.         value_type m_val;
161.         dbmap_iterator_impl(dbmap_base* owner)
162.             : dbmap_iterator_impl_base(owner)
163.         {}
165.         virtual void load_key(void* data, size_t size)
166.         {
167.             PortableDataInput<MemIO> iKey;
168.             iKey.set(data, size);
169.             iKey >> m_val.first;
170.             FEBIRD_RT_assert(iKey.eof(), std::logic_error);
171.         }
172.         virtual void load_val(void* data, size_t size)
173.         {
174.             PortableDataInput<MinMemIO> iVal;
175.             iVal.set(data);
176.             iVal >> m_val.second;
177.             FEBIRD_RT_assert(iVal.diff(data) == size, std::logic_error);
178.         }
179.         virtual void save_key(PortableDataOutput<AutoGrownMemIO>& oKey1)
180.         {
181.             oKey1 << m_val.first;
182.         }
183.     };
185.     //! overrides
186.     void save_key(PortableDataOutput<AutoGrownMemIO>& dio, const void* key) const { dio << *(const Key*)key; }
187.     void save_val(PortableDataOutput<AutoGrownMemIO>& dio, const void* val) const { dio << *(const Val*)val; }
189.     dbmap_iterator_impl_base* make_iter() { return new dbmap_iterator_impl(this); }
191. public:
193.     typedef dbmap_iterator<Key, Val, value_type, dbmap_iterator_impl>
194.             iterator, const_iterator;
196.     dbmap(DB_ENV* env, const char* dbname
197.         , DB_TXN* txn = NULL
198.         , bt_compare_fcn_type bt_comp = bdb_auto_bt_compare((Key*)(0))
199.         )
200.         : dbmap_base(env, dbname, txn, bt_comp, BOOST_CURRENT_FUNCTION)
201.     {
202.     }
203.     dbmap(DbEnv* env, const char* dbname
204.         , DbTxn* txn = NULL
205.         , bt_compare_fcn_type bt_comp = bdb_auto_bt_compare((Key*)(0))
206.         )
207.         : dbmap_base(env->get_DB_ENV(), dbname, txn ? txn->get_DB_TXN() : NULL, bt_comp, BOOST_CURRENT_FUNCTION)
208.     {
209.     }
211.     iterator begin(DB_TXN* txn = NULL) { return iterator(begin_impl(txn, BOOST_CURRENT_FUNCTION)); }
212.     iterator end  (DB_TXN* txn = NULL) { return iterator(end_impl  (txn, BOOST_CURRENT_FUNCTION)); }
214.     iterator begin(DbTxn* txn) { return iterator(begin_impl(txn ? txn->get_DB_TXN() : NULL, BOOST_CURRENT_FUNCTION)); }
215.     iterator end  (DbTxn* txn) { return iterator(end_impl  (txn ? txn->get_DB_TXN() : NULL, BOOST_CURRENT_FUNCTION)); }
217.     value_type back()
218.     {
219.         iterator iter = this->end();
220.         --iter;
221.         if (iter.exist())
222.             return *iter;
223.         throw std::runtime_error(BOOST_CURRENT_FUNCTION);
224.     }
225.     value_type front()
226.     {
227.         iterator iter = this->begin();
228.         if (iter.exist())
229.             return *iter;
230.         throw std::runtime_error(BOOST_CURRENT_FUNCTION);
231.     }
233.     iterator find(const Key& k, DB_TXN* txn = NULL)
234.     {
235.         return iterator(find_impl(&k, txn, DB_SET, BOOST_CURRENT_FUNCTION));
236.     }
237.     iterator find(const Key& k, DbTxn* txn)
238.     {
239.         return iterator(find_impl(&k, txn ? txn->get_DB_TXN() : NULL, DB_SET, BOOST_CURRENT_FUNCTION));
240.     }
242.     iterator lower_bound(const Key& k, DB_TXN* txn = NULL)
243.     {
244.         return iterator(find_impl(&k, txn, DB_SET_RANGE, BOOST_CURRENT_FUNCTION));
245.     }
246.     iterator lower_bound(const Key& k, DbTxn* txn)
247.     {
248.         return iterator(find_impl(&k, txn ? txn->get_DB_TXN() : NULL, DB_SET_RANGE, BOOST_CURRENT_FUNCTION));
249.     }
251.     bool insert(const std::pair<Key,Val>& kv, DB_TXN* txn = NULL)
252.     {
253.         return insert_impl(&kv.first, &kv.second, DB_NOOVERWRITE, txn, BOOST_CURRENT_FUNCTION);
254.     }
255.     bool insert(const std::pair<Key,Val>& kv, DbTxn* txn)
256.     {
257.         return insert_impl(&kv.first, &kv.second, DB_NOOVERWRITE, txn ? txn->get_DB_TXN() : NULL, BOOST_CURRENT_FUNCTION);
258.     }
260.     bool insert(const Key& k, const Val& d, DB_TXN* txn = NULL)
261.     {
262.         return insert_impl(&k, &d, DB_NOOVERWRITE, txn, BOOST_CURRENT_FUNCTION);
263.     }
264.     bool insert(const Key& k, const Val& d, DbTxn* txn)
265.     {
266.         return insert_impl(&k, &d, DB_NOOVERWRITE, txn ? txn->get_DB_TXN() : NULL, BOOST_CURRENT_FUNCTION);
267.     }
269.     void replace(const std::pair<Key,Val>& kv, DB_TXN* txn = NULL)
270.     {
271.         insert_impl(&kv.first, &kv.second, 0, txn, BOOST_CURRENT_FUNCTION);
272.     }
273.     void replace(const std::pair<Key,Val>& kv, DbTxn* txn)
274.     {
275.         insert_impl(&kv.first, &kv.second, 0, txn ? txn->get_DB_TXN() : NULL, BOOST_CURRENT_FUNCTION);
276.     }
277.     void replace(const Key& k, const Val& d, DB_TXN* txn = NULL)
278.     {
279.         insert_impl(&k, &d, 0, txn, BOOST_CURRENT_FUNCTION);
280.     }
281.     void replace(const Key& k, const Val& d, DbTxn* txn)
282.     {
283.         insert_impl(&k, &d, 0, txn ? txn->get_DB_TXN() : NULL, BOOST_CURRENT_FUNCTION);
284.     }
286.     bool remove(const Key& k, DB_TXN* txn = NULL)
287.     {
288.         return remove_impl(&k, txn, BOOST_CURRENT_FUNCTION);
289.     }
290.     bool remove(const Key& k, DbTxn* txn)
291.     {
292.         return remove_impl(&k, txn ? txn->get_DB_TXN() : NULL, BOOST_CURRENT_FUNCTION);
293.     }
295.     bool erase(iterator& iter)
296.     {
297.         return iter.remove();
298.     }
300.     void clear(DB_TXN* txn = NULL)
301.     {
302.         clear_impl(txn, BOOST_CURRENT_FUNCTION);
303.     }
304.     void clear(DbTxn* txn)
305.     {
306.         return clear_impl(txn ? txn->get_DB_TXN() : NULL, BOOST_CURRENT_FUNCTION);
307.     }
309.     DB* getDB() { return m_db; }
310.     const DB* getDB() const { return m_db; }
311. };
313. } // namespace febird
316. #endif // __febird_bdb_dbmap_h__

file: dbmap.cpp

 

1. /* vim: set tabstop=4 : */
2. #include "dbmap.h"
3. #include <sstream>
5. /**
6.  @brief when iterate from end to begin
7.  @code
8.     for (dbmap<Key, Val>::iterator iter = dbm.end();;)
9.     {
10.         --iter;
11.         if (!iter.exist()) break;
13.         pair<Key,Val>& kv = *iter;
14.     //  do some thing
15.     }
16.  @endcode
17.  */
19. namespace febird {
21. dbmap_iterator_impl_base::dbmap_iterator_impl_base(class dbmap_base* owner)
22.     : m_owner(owner)
23.     , m_curp(0), m_ret(-1)
24. {
25. }
27. void dbmap_iterator_impl_base::init(DB* dbp, DB_TXN* txn, const char* func)
28. {
29.     int ret = dbp->cursor(dbp, txn, &m_curp, 0);
30.     if (0 != ret)
31.     {
32.         delete this;
33.         std::ostringstream oss;
34.         oss << db_strerror(ret) << "... at: " << func;
35.         throw std::runtime_error(oss.str());
36.     }
37.     m_ret = 0;
38. }
40. dbmap_iterator_impl_base::~dbmap_iterator_impl_base()
41. {
42.     if (m_curp)
43.         m_curp->close(m_curp);
44. }
46. void dbmap_iterator_impl_base::advance(u_int32_t direction_flag, const char* func)
47. {
48.     FEBIRD_RT_assert(0 == m_ret, std::logic_error);
49.     DBT tk; memset(&tk, 0, sizeof(DBT));
50.     DBT td; memset(&td, 0, sizeof(DBT));
51.     m_ret = m_curp->get(m_curp, &tk, &td, direction_flag);
52.     if (0 == m_ret)
53.     {
54.         load_key(tk.data, tk.size);
55.         load_val(td.data, td.size);
56.     }
57.     else if (DB_NOTFOUND != m_ret)
58.     {
59.         std::ostringstream oss;
60.         oss << db_strerror(m_ret) << "... at: " << func;
61.         throw std::runtime_error(oss.str());
62.     }
63. }
65. /**
66.  @brief 
67.  @return true successful updated
68.         false (key, d.key2) did not exist, not updated
69.  @throw other errors
70.  */
71. void dbmap_iterator_impl_base::update(const void* d, const char* func)
72. {
73.     FEBIRD_RT_assert(0 == m_ret, std::logic_error);
74.     PortableDataOutput<AutoGrownMemIO> oKey1, oData;
75.     this->save_key(oKey1);
76.     m_owner->save_val(oData, d);
77.     DBT tk; memset(&tk, 0, sizeof(DBT)); tk.data = oKey1.begin(); tk.size = oKey1.tell();
78.     DBT td; memset(&td, 0, sizeof(DBT)); td.data = oData.begin(); td.size = oData.tell();
79.     int ret = m_curp->put(m_curp, &tk, &td, DB_CURRENT);
80.     if (0 != ret)
81.     {
82.         std::ostringstream oss;
83.         oss << db_strerror(ret)
84.             << "... at: " << func;
85.         throw std::runtime_error(oss.str());
86.     }
87. }
89. void dbmap_iterator_impl_base::remove(const char* func)
90. {
91.     FEBIRD_RT_assert(0 == m_ret, std::logic_error);
92.     int ret = m_curp->del(m_curp, 0);
93.     if (0 != ret)
94.     {
95.         std::ostringstream oss;
96.         oss << db_strerror(ret)
97.             << "... at: " << func;
98.         throw std::runtime_error(oss.str());
99.     }
100. }
102. //////////////////////////////////////////////////////////////////////////
104. dbmap_base::dbmap_base(DB_ENV* env, const char* dbname
105.     , DB_TXN* txn
106.     , bt_compare_fcn_type bt_comp
107.     , const char* func
108.     )
109.     : m_bt_comp(0)
110. {
111.     m_bulkSize = 512*1024;
112.     m_db = 0;
113.     int ret = db_create(&m_db, env, 0);
114.     if (0 == ret)
115.     {
116.         if (bt_comp) {
117.             m_bt_comp = bt_comp;
118.             m_db->set_bt_compare(m_db, bt_comp);
119.         }
120.         m_db->app_private = (this);
121.         int flags = env->open_flags & (DB_THREAD|DB_MULTIVERSION|DB_AUTO_COMMIT);
122.         ret = m_db->open(m_db, txn, dbname, dbname, DB_BTREE, DB_CREATE|flags, 0);
123.     }
125.     if (0 != ret)
126.     {
127.         std::ostringstream oss;
128.         oss << db_strerror(ret)
129.             << "... at: " << func;
130.         throw std::runtime_error(oss.str());
131.     }
132. }
134. dbmap_base::~dbmap_base()
135. {
136.     if (m_db)
137.         m_db->close(m_db, 0);
138. }
140. dbmap_iterator_impl_base* dbmap_base::begin_impl(DB_TXN* txn, const char* func)
141. {
142.     dbmap_iterator_impl_base* iter = make_iter();
143.     iter->init(m_db, txn, func);
144.     DBT tk; memset(&tk, 0, sizeof(DBT));
145.     DBT td; memset(&td, 0, sizeof(DBT));
146.     iter->m_ret = iter->m_curp->get(iter->m_curp, &tk, &td, DB_FIRST);
147.     if (0 == iter->m_ret)
148.     {
149.         iter->load_key(tk.data, tk.size);
150.         iter->load_val(td.data, td.size);
151.     }
152.     else if (DB_NOTFOUND != iter->m_ret)
153.     {
154.         std::ostringstream oss;
155.         oss << db_strerror(iter->m_ret)
156.             << "... at: " << func;
157.         delete iter; iter = 0;
158.         throw std::runtime_error(oss.str());
159.     }
160.     return iter;
161. }
163. dbmap_iterator_impl_base* dbmap_base::end_impl(DB_TXN* txn, const char* func)
164. {
165.     dbmap_iterator_impl_base* iter = make_iter();
166.     iter->init(m_db, txn, func);
167. //  iter->m_ret = DB_NOTFOUND;
168.     return iter;
169. }
171. dbmap_iterator_impl_base* dbmap_base::find_impl(const void* k, DB_TXN* txn, u_int32_t flags, const char* func)
172. {
173.     PortableDataOutput<AutoGrownMemIO> oKey1;
174.     save_key(oKey1, k);
175.     DBT tk; memset(&tk, 0, sizeof(DBT)); tk.data = oKey1.begin(); tk.size = oKey1.tell();
176.     DBT td; memset(&td, 0, sizeof(DBT));
177.     dbmap_iterator_impl_base* iter = make_iter();
178.     iter->init(m_db, txn, func);
179.     iter->m_ret = iter->m_curp->get(iter->m_curp, &tk, &td, flags);
180.     if (0 == iter->m_ret)
181.     {
182.         iter->load_key(tk.data, tk.size);
183.         iter->load_val(td.data, td.size);
184.     }
185.     else if (DB_NOTFOUND != iter->m_ret && DB_KEYEMPTY != iter->m_ret)
186.     {
187.         std::ostringstream oss;
188.         oss << db_strerror(iter->m_ret)
189.             << "... at: " << func
190.             << "\n"
191.             << "flags=" << flags
192.             ;
193.         throw std::runtime_error(oss.str());
194.     }
195.     return iter;
196. }
198. /**
199.  @brief insert a record
200.  @return true success,  no same k-k2 in db, the record was inserted
201.          false failed, has same k-k2 in db, the record was not inserted, not replaced existing yet
202.  @throws exception, failed
203.  */
204. bool dbmap_base::insert_impl(const void* k, const void* d, u_int32_t flags, DB_TXN* txn, const char* func)
205. {
206.     PortableDataOutput<AutoGrownMemIO> oKey1, oData;
207.     try {
208.         save_key(oKey1, k);
209.         save_val(oData, d);
210.     }
211.     catch (const IOException& exp)
212.     {
213.         std::ostringstream oss;
214.         oss << exp.what() << "... at: " << func;
215.         throw std::runtime_error(oss.str());
216.     }
217.     DBT tk; memset(&tk, 0, sizeof(DBT)); tk.data = oKey1.begin(); tk.size = oKey1.tell();
218.     DBT td; memset(&td, 0, sizeof(DBT)); td.data = oData.begin(); td.size = oData.tell();
219.     int ret = m_db->put(m_db, txn, &tk, &td, flags);
220.     if (DB_KEYEXIST == ret)
221.         return false;
222.     if (0 == ret)
223.         return true;
224.     std::ostringstream oss;
225.     oss << db_strerror(ret)
226.         << "... at: " << func
227.         << "\n"
228.         ;
229.     throw std::runtime_error(oss.str());
230. }
232. /**
233.  @brief 
234.  @return true (k) existed, remove success
235.         false (k) not existed, nothing done
236.  */
237. bool dbmap_base::remove_impl(const void* k, DB_TXN* txn, const char* func)
238. {
239.     PortableDataOutput<AutoGrownMemIO> oKey1;
240.     save_key(oKey1, k);
241.     DBT tk; memset(&tk, 0, sizeof(DBT)); tk.data = oKey1.begin(); tk.size = oKey1.tell();
242.     int ret = m_db->del(m_db, txn, &tk, 0);
243.     if (DB_NOTFOUND == ret)
244.         return false;
245.     if (0 == ret)
246.         return true;
247.     std::ostringstream oss;
248.     oss << db_strerror(ret)
249.         << "... at: " << func
250.         << "\n"
251.         ;
252.     throw std::runtime_error(oss.str());
253. }
255. void dbmap_base::clear_impl(DB_TXN* txn, const char* func)
256. {
257.     u_int32_t count;
258.     int ret = m_db->truncate(m_db, txn, &count, 0);
259.     if (0 != ret)
260.     {
261.         std::ostringstream oss;
262.         oss << db_strerror(ret)
263.             << "... at: " << func
264.             << "\n"
265.             ;
266.         throw std::runtime_error(oss.str());
267.     }
268. }
270. } // namespace febird

272. 项目地址：http://code.google.com/p/febird