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

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

 

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

 

1. /* vim: set tabstop=4 : */
2. #ifndef __febird_bdb_kmapdset_h__
3. #define __febird_bdb_kmapdset_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 kmapdset_iterator_impl_base : public RefCounter
18. {
19. public:
20.     class kmapdset_base* m_owner;
21.     DBC* m_curp;
22.     int  m_ret;
23.     DBT  m_bulk;
25. public:
26.     kmapdset_iterator_impl_base(class kmapdset_base* owner);
27.     void init(DB* dbp, DB_TXN* txn, const char* func);
29.     virtual ~kmapdset_iterator_impl_base();
31.     virtual void clear_vec() = 0;
32.     virtual void push_back(void* data, size_t size) = 0;
33.     virtual void load_key1(void* data, size_t size) = 0;
34.     virtual void save_key1(PortableDataOutput<AutoGrownMemIO>& oKey) = 0;
36.     bool next_key(size_t* cnt, const char* func);
37.     void bulk_load(DBT* tk1);
38.     void increment(const char* func);
39.     void decrement(const char* func);
41.     bool find_pos(const void* k1, const void* k2, bool bulk, const char* func);
43.     bool insert(const void* d, const char* func);
44.     bool update(const void* d, const char* func);
45.     bool replace(const void* d, const char* func);
47.     bool remove(const void* k2, const char* func);
48.     bool remove(const char* func);
49. };
51. class FEBIRD_DLL_EXPORT kmapdset_base
52. {
53.     DECLARE_NONE_COPYABLE_CLASS(kmapdset_base)
55. public:
56.     DB*    m_db;
57.     size_t m_bulkSize;
58.     bt_compare_fcn_type m_bt_comp, m_dup_comp;
60.     kmapdset_base(DB_ENV* env, const char* dbname
61.         , DB_TXN* txn
62.         , bt_compare_fcn_type bt_comp
63.         , bt_compare_fcn_type dup_comp
64.         , const char* func
65.         );
67.     virtual ~kmapdset_base();
68.     virtual void save_key1(PortableDataOutput<AutoGrownMemIO>& dio, const void* key1) const = 0;
69.     virtual void save_key2(PortableDataOutput<AutoGrownMemIO>& dio, const void* key2) const = 0;
70.     virtual void save_data(PortableDataOutput<AutoGrownMemIO>& dio, const void* data) const = 0;
72.     virtual kmapdset_iterator_impl_base* make_iter() = 0;
74.     kmapdset_iterator_impl_base* begin_impl(DB_TXN* txn, const char* func);
75.     kmapdset_iterator_impl_base* end_impl(DB_TXN* txn, const char* func);
77.     kmapdset_iterator_impl_base* find_impl(const void* k1, DB_TXN* txn, u_int32_t flags, const char* func);
78.     kmapdset_iterator_impl_base* find_impl(const void* k1, const void* k2, DB_TXN* txn, bool bulk, const char* func);
79.     kmapdset_iterator_impl_base* upper_bound_impl(const void* k1, DB_TXN* txn, const char* func);
80.     size_t count_impl(const void* k1, DB_TXN* txn, const char* func);
82.     bool insert_impl(const void* k1, const void* d, DB_TXN* txn, const char* func);
83.     bool replace_impl(const void* k1, const void* d, DB_TXN* txn, const char* func);
84.     bool remove_impl(const void* k1, const void* k2, DB_TXN* txn, const char* func);
85.     bool remove_impl(const void* k1, DB_TXN* txn, const char* func);
86.     void clear_impl(DB_TXN* txn, const char* func);
87.     void flush_impl(const char* func);
88. };
90. template<class Data>
91. struct kmapdset_select_key2
92. {
93.     typedef typename Data::key_type type;
94. };
95. template<class Key2, class NonKeyData>
96. struct kmapdset_select_key2<std::pair<Key2, NonKeyData> >
97. {
98.     typedef Key2 type;
99. };
101. template<class Key1, class Key2, class Data, class Value, class Impl>
102. class kmapdset_iterator :
103.     public std::iterator<std::bidirectional_iterator_tag, Value, ptrdiff_t, const Value*, const Value&>
104. {
105.     boost::intrusive_ptr<Impl> m_impl;
107.     void copy_on_write()
108.     {
109.         if (m_impl->getRefCount() > 1)
110.         {
111.             Impl* p = new Impl(m_impl->m_owner);
112.             m_impl->m_ret = m_impl->m_curp->dup(m_impl->m_curp, &p->m_curp, DB_POSITION);
113.             FEBIRD_RT_assert(0 == m_impl->m_ret, std::runtime_error);
114.             m_impl.reset(p);
115.         }
116.     }
117. private:
118. #ifdef _MSC_VER
119. //# pragma warning(disable: 4661) // declaration but not definition
120. //! MSVC will warning C4661 "declaration but not definition"
121. void operator++(int) { assert(0); }
122. void operator--(int) { assert(0); }
123. #else
124. //! disable, because clone iterator will cause very much time and resource
125. void operator++(int);// { assert(0); }
126. void operator--(int);// { assert(0); }
127. #endif
129. public:
130.     kmapdset_iterator() {}
131.     explicit kmapdset_iterator(kmapdset_iterator_impl_base* impl)
132.         : m_impl(static_cast<Impl*>(impl))
133.     {
134.         assert(impl);
135.         assert(dynamic_cast<Impl*>(impl));
136.     }
138. //  bool exist() const { return DB_NOTFOUND != m_impl->m_ret && DB_KEYEMPTY != m_impl->m_ret; }
139.     bool exist() const { return 0 == m_impl->m_ret; }
141.     // increment and get key/data-cnt
142.     bool next_key(size_t& cnt) { return m_impl->next_key(&cnt,BOOST_CURRENT_FUNCTION); }
144.     bool insert(const Data& d) { return m_impl->insert(&d,BOOST_CURRENT_FUNCTION); }
145.     bool update(const Data& d) { return m_impl->update(&d,BOOST_CURRENT_FUNCTION); }
146.     bool replace(const Data& d) { return m_impl->replace(&d,BOOST_CURRENT_FUNCTION); }
148.     bool remove() const { return m_impl->remove(BOOST_CURRENT_FUNCTION); }
149.     bool remove(const Key2& k2) const { return m_impl->remove(&k2,BOOST_CURRENT_FUNCTION); }
151.     kmapdset_iterator& operator++()
152.     {
153.         assert(0 == m_impl->m_ret);
154.         copy_on_write();
155.         m_impl->increment(BOOST_CURRENT_FUNCTION);
156.         return *this;
157.     }
158.     kmapdset_iterator& operator--()
159.     {
160.         assert(0 == m_impl->m_ret);
161.         copy_on_write();
162.         m_impl->decrement(BOOST_CURRENT_FUNCTION);
163.         return *this;
164.     }
165.     const Value& operator*() const
166.     {
167.         assert(0 == m_impl->m_ret);
168.         return m_impl->m_kdv;
169.     }
170.     const Value* operator->() const
171.     {
172.         assert(0 == m_impl->m_ret);
173.         return &m_impl->m_kdv;
174.     }
175.     Value& get_mutable() const
176.     {
177.         assert(0 == m_impl->m_ret);
178.         return m_impl->m_kdv;
179.     }
180. };
182. //! @param Data Key2 is embeded in Data
183. template<class Key1, class Data>
184. class kmapdset : protected kmapdset_base
185. {
186.     DECLARE_NONE_COPYABLE_CLASS(kmapdset)
188. public:
189.     typedef Key1
190.             key1_t, key_type;
191.     typedef typename kmapdset_select_key2<Data>::type
192.             key2_t;
193.     typedef Data
194.             data_type, data_t;
195.     typedef std::pair<Key1, std::vector<Data> >
196.             value_type;
197.     typedef std::vector<Data>
198.             data_vec_t;
199.     typedef typename std::vector<Data>::const_iterator
200.             data_iter_t;
202. protected:
203.     class kmapdset_iterator_impl : public kmapdset_iterator_impl_base
204.     {
205.     public:
206.         value_type m_kdv;
208.         kmapdset_iterator_impl(kmapdset_base* owner)
209.             : kmapdset_iterator_impl_base(owner)
210.         {}
212.         virtual void clear_vec()
213.         {
214.             m_kdv.second.resize(0);
215.         }
217.         virtual void push_back(void* data, size_t size)
218.         {
219.             Data x;
220.             PortableDataInput<MinMemIO> iData;
221.             iData.set(data);
222.             iData >> x;
223.             FEBIRD_RT_assert(iData.diff(data) == size, std::logic_error);
224.             m_kdv.second.push_back(x);
225.         }
226.         virtual void load_key1(void* data, size_t size)
227.         {
228.             PortableDataInput<MemIO> iKey1;
229.             iKey1.set(data, size);
230.             iKey1 >> m_kdv.first;
231.             FEBIRD_RT_assert(iKey1.diff(data) == size, std::logic_error);
232.         }
233.         virtual void save_key1(PortableDataOutput<AutoGrownMemIO>& oKey1)
234.         {
235.             oKey1 << m_kdv.first;
236.         }
237.     };
239.     //! overrides
240.     void save_key1(PortableDataOutput<AutoGrownMemIO>& dio, const void* key1) const { dio << *(const key1_t*)key1; }
241.     void save_key2(PortableDataOutput<AutoGrownMemIO>& dio, const void* key2) const { dio << *(const key2_t*)key2; }
242.     void save_data(PortableDataOutput<AutoGrownMemIO>& dio, const void* data) const { dio << *(const data_t*)data; }
244.     kmapdset_iterator_impl_base* make_iter() { return new kmapdset_iterator_impl(this); }
246. public:
248.     typedef kmapdset_iterator<Key1, key2_t, Data, value_type, kmapdset_iterator_impl>
249.             iterator, const_iterator;
251.     kmapdset(DB_ENV* env, const char* dbname
252.         , DB_TXN* txn = NULL
253.         , bt_compare_fcn_type bt_comp = bdb_auto_bt_compare((key1_t*)(0))
254.         , bt_compare_fcn_type dup_comp = bdb_auto_bt_compare((key2_t*)(0))
255.         )
256.         : kmapdset_base(env, dbname, txn, bt_comp, dup_comp, BOOST_CURRENT_FUNCTION)
257.     {
258.     }
259.     kmapdset(DbEnv* env, const char* dbname
260.         , DbTxn* txn = NULL
261.         , bt_compare_fcn_type bt_comp = bdb_auto_bt_compare((key1_t*)(0))
262.         , bt_compare_fcn_type dup_comp = bdb_auto_bt_compare((key2_t*)(0))
263.         )
264.         : kmapdset_base(env->get_DB_ENV(), dbname, txn ? txn->get_DB_TXN() : NULL, bt_comp, dup_comp, BOOST_CURRENT_FUNCTION)
265.     {
266.     }
268.     iterator begin(DB_TXN* txn = NULL) { return iterator(begin_impl(txn, BOOST_CURRENT_FUNCTION)); }
269.     iterator end  (DB_TXN* txn = NULL) { return iterator(end_impl  (txn, BOOST_CURRENT_FUNCTION)); }
271.     iterator begin(DbTxn* txn) { return iterator(begin_impl(txn->get_DB_TXN(), BOOST_CURRENT_FUNCTION)); }
272.     iterator end  (DbTxn* txn) { return iterator(end_impl  (txn->get_DB_TXN(), BOOST_CURRENT_FUNCTION)); }
274.     iterator find(const Key1& k1, DB_TXN* txn = NULL)
275.     {
276.         return iterator(find_impl(&k1, txn, DB_SET|DB_MULTIPLE, BOOST_CURRENT_FUNCTION));
277.     }
278.     iterator find(const Key1& k1, DbTxn* txn)
279.     {
280.         return iterator(find_impl(&k1, txn->get_DB_TXN(), DB_SET|DB_MULTIPLE, BOOST_CURRENT_FUNCTION));
281.     }
283.     iterator find(const Key1& k1, const key2_t& k2, DB_TXN* txn = NULL)
284.     {
285.         return iterator(find_impl(&k1, &k2, txn, false, BOOST_CURRENT_FUNCTION));
286.     }
287.     iterator find(const Key1& k1, const key2_t& k2, DbTxn* txn)
288.     {
289.         return iterator(find_impl(&k1, &k2, txn->get_DB_TXN(), false, BOOST_CURRENT_FUNCTION));
290.     }
292.     iterator find_md(const Key1& k1, const key2_t& k2, DB_TXN* txn = NULL)
293.     {
294.         return iterator(find_impl(&k1, &k2, txn, true, BOOST_CURRENT_FUNCTION));
295.     }
296.     iterator find_md(const Key1& k1, const key2_t& k2, DbTxn* txn)
297.     {
298.         return iterator(find_impl(&k1, &k2, txn->get_DB_TXN(), true, BOOST_CURRENT_FUNCTION));
299.     }
301.     iterator lower_bound(const Key1& k1, DB_TXN* txn = NULL)
302.     {
303.         return iterator(find_impl(&k1, txn, DB_SET_RANGE|DB_MULTIPLE, BOOST_CURRENT_FUNCTION));
304.     }
305.     iterator lower_bound(const Key1& k1, DbTxn* txn)
306.     {
307.         return iterator(find_impl(&k1, txn->get_DB_TXN(), DB_SET_RANGE|DB_MULTIPLE, BOOST_CURRENT_FUNCTION));
308.     }
309.     iterator upper_bound(const Key1& k1, DB_TXN* txn = NULL)
310.     {
311.         return iterator(upper_bound_impl(&k1, txn, BOOST_CURRENT_FUNCTION));
312.     }
314.     bool insert(const Key1& k1, const Data& d, DB_TXN* txn = NULL)
315.     {
316.         return insert_impl(&k1, &d, txn, BOOST_CURRENT_FUNCTION);
317.     }
318.     bool insert(const Key1& k1, const Data& d, DbTxn* txn)
319.     {
320.         return insert_impl(&k1, &d, txn->get_DB_TXN(), BOOST_CURRENT_FUNCTION);
321.     }
323.     bool replace(const Key1& k1, const Data& d, DB_TXN* txn = NULL)
324.     {
325.         return replace_impl(&k1, &d, txn, BOOST_CURRENT_FUNCTION);
326.     }
327.     bool replace(const Key1& k1, const Data& d, DbTxn* txn)
328.     {
329.         return replace_impl(&k1, &d, txn->get_DB_TXN(), BOOST_CURRENT_FUNCTION);
330.     }
332.     bool remove(const Key1& k1, const key2_t& k2, DB_TXN* txn = NULL)
333.     {
334.         return remove_impl(&k1, &k2, txn, BOOST_CURRENT_FUNCTION);
335.     }
336.     bool remove(const Key1& k1, const key2_t& k2, DbTxn* txn)
337.     {
338.         return remove_impl(&k1, &k2, txn->get_DB_TXN(), BOOST_CURRENT_FUNCTION);
339.     }
341.     bool remove(const Key1& k1, DB_TXN* txn = NULL)
342.     {
343.         return remove_impl(&k1, txn, BOOST_CURRENT_FUNCTION);
344.     }
345.     bool remove(const Key1& k1, DbTxn* txn)
346.     {
347.         return remove_impl(&k1, txn->get_DB_TXN(), BOOST_CURRENT_FUNCTION);
348.     }
350.     bool erase(const iterator& iter)
351.     {
352.         return iter.remove();
353.     }
355.     void clear(DB_TXN* txn = NULL)
356.     {
357.         clear_impl(txn, BOOST_CURRENT_FUNCTION);
358.     }
359.     void clear(DbTxn* txn)
360.     {
361.         return clear_impl(txn->get_DB_TXN(), BOOST_CURRENT_FUNCTION);
362.     }
364.     void flush()
365.     {
366.         return flush_impl(BOOST_CURRENT_FUNCTION);
367.     }
369.     size_t count(const Key1& k1, DB_TXN* txn = NULL)
370.     {
371.         return count_impl(&k1, txn, BOOST_CURRENT_FUNCTION);
372.     }
373.     size_t count(const Key1& k1, DbTxn* txn)
374.     {
375.         return count_impl(&k1, txn ? txn->get_DB_TXN() : NULL, BOOST_CURRENT_FUNCTION);
376.     }
378.     DB* getDB() { return m_db; }
379.     const DB* getDB() const { return m_db; }
380. };
382. } // namespace febird
385. #endif // __febird_bdb_kmapdset_h__

 

1. /* vim: set tabstop=4 : */
2. #include "kmapdset.h"
3. //#include "../DataBuffer.h"
4. #include <sstream>
6. namespace febird {
8. kmapdset_iterator_impl_base::kmapdset_iterator_impl_base(class kmapdset_base* owner)
9.     : m_owner(owner)
10.     , m_curp(0), m_ret(-1)
11. {
12.     memset(&m_bulk, 0, sizeof(DBT));
13.     m_bulk.size = (owner->m_bulkSize);
14.     m_bulk.data = (::malloc(owner->m_bulkSize));
15.     m_bulk.flags = (DB_DBT_USERMEM);
16.     m_bulk.ulen = (owner->m_bulkSize);
17. }
19. void kmapdset_iterator_impl_base::init(DB* dbp, DB_TXN* txn, const char* func)
20. {
21.     int ret = dbp->cursor(dbp, txn, &m_curp, 0);
22.     if (0 != ret)
23.     {
24.         delete this;
25.         std::ostringstream oss;
26.         oss << db_strerror(ret) << "... at: " << func;
27.         throw std::runtime_error(oss.str());
28.     }
29.     m_ret = 0;
30. }
32. kmapdset_iterator_impl_base::~kmapdset_iterator_impl_base()
33. {
34.     if (m_bulk.data)
35.         ::free(m_bulk.data);
36.     if (m_curp)
37.         m_curp->close(m_curp);
38. }
40. bool kmapdset_iterator_impl_base::next_key(size_t* cnt, const char* func)
41. {
42.     FEBIRD_RT_assert(0 == m_ret, std::logic_error);
43.     DBT tk1; memset(&tk1, 0, sizeof(DBT));
44.     m_ret = m_curp->get(m_curp, &tk1, &m_bulk, DB_NEXT_NODUP);
45.     if (0 == m_ret)
46.     {
47.         load_key1(tk1.data, tk1.size);
48.         db_recno_t cnt0 = 0;
49.         int ret = m_curp->count(m_curp, &cnt0, 0);
50.         if (0 != ret)
51.         {
52.             std::ostringstream oss;
53.             oss << db_strerror(ret) << "... at: " << func;
54.             throw std::runtime_error(oss.str());
55.         }
56.         *cnt = cnt0;
57.         return true;
58.     }
59.     else if (DB_NOTFOUND == m_ret)
60.     {
61.         return false;
62.     }
63.     else
64.     {
65.         std::ostringstream oss;
66.         oss << db_strerror(m_ret) << "... at: " << func;
67.         throw std::runtime_error(oss.str());
68.     }
69. }
71. void kmapdset_iterator_impl_base::bulk_load(DBT* tk1)
72. {
73.     FEBIRD_RT_assert(0 == m_ret, std::logic_error);
74.     load_key1(tk1->data, tk1->size);
75.     clear_vec();
76.     int ret;
77.     do {
78.         void  *bptr, *data;
79.         size_t size;
80.         DB_MULTIPLE_INIT(bptr, &m_bulk);
81.         assert(NULL != bptr);
82.         for (;;)
83.         {
84.             DB_MULTIPLE_NEXT(bptr, &m_bulk, data, size);
85.             if (bptr)
86.                 this->push_back(data, size);
87.             else
88.                 break;
89.         }
90.         ret = m_curp->get(m_curp, tk1, &m_bulk, DB_MULTIPLE|DB_NEXT_DUP);
91.     } while (0 == ret);
92. }
94. void kmapdset_iterator_impl_base::increment(const char* func)
95. {
96.     FEBIRD_RT_assert(0 == m_ret, std::logic_error);
97.     DBT tk1; memset(&tk1, 0, sizeof(DBT));
98.     m_ret = m_curp->get(m_curp, &tk1, &m_bulk, DB_NEXT_NODUP|DB_MULTIPLE);
99.     if (0 == m_ret)
100.     {
101.         bulk_load(&tk1);
102.     }
103.     else if (DB_NOTFOUND != m_ret)
104.     {
105.         std::ostringstream oss;
106.         oss << db_strerror(m_ret) << "... at: " << func;
107.         throw std::runtime_error(oss.str());
108.     }
109. }
111. void kmapdset_iterator_impl_base::decrement(const char* func)
112. {
113.     FEBIRD_RT_assert(0 == m_ret, std::logic_error);
114.     DBT tk1; memset(&tk1, 0, sizeof(DBT));
115.     m_ret = m_curp->get(m_curp, &tk1, &m_bulk, DB_PREV_NODUP);
116.     if (0 == m_ret)
117.     {
118.         m_ret = m_curp->get(m_curp, &tk1, &m_bulk, DB_CURRENT|DB_MULTIPLE);
119.         if (0 == m_ret)
120.         {
121.             bulk_load(&tk1);
122.         }
123.         else if (DB_KEYEMPTY == m_ret)
124.         {
125.             std::ostringstream oss;
126.             oss << db_strerror(m_ret)
127.                 << "... at: " << func;
128.             throw std::runtime_error(oss.str());
129.         }
130.     }
131.     else if (DB_NOTFOUND != m_ret)
132.     {
133.         std::ostringstream oss;
134.         oss << db_strerror(m_ret) << "... at: " << func;
135.         throw std::runtime_error(oss.str());
136.     }
137. }
139. bool kmapdset_iterator_impl_base::find_pos(const void* k1, const void* k2, bool bulk, const char* func)
140. {
141.     PortableDataOutput<AutoGrownMemIO> oKey1, oKey2;
142.     m_owner->save_key1(oKey1, k1);
143.     m_owner->save_key2(oKey2, k2);
144.     DBT tk1; memset(&tk1, 0, sizeof(DBT)); tk1.data = oKey1.begin(); tk1.size = oKey1.tell();
145.     DBT tk2; memset(&tk2, 0, sizeof(DBT)); tk2.data = oKey2.begin(); tk2.size = oKey2.tell();
146.     m_ret = m_curp->get(m_curp, &tk1, &tk2, DB_GET_BOTH);
147.     if (0 == m_ret)
148.     {
149.         if (bulk) {
150.             m_ret = m_curp->get(m_curp, &tk1, &m_bulk, DB_CURRENT|DB_MULTIPLE);
151.             if (0 == m_ret) {
152.                 bulk_load(&tk1);
153.                 return true;
154.             }
155.         } else {
156.             clear_vec();
157.             load_key1(tk1.data, tk1.size);
158.             push_back(tk2.data, tk2.size);
159.             return true;
160.         }
161.     }
162.     else if (DB_NOTFOUND == m_ret)
163.     {
164.         return false;
165.     }
166.     std::ostringstream oss;
167.     oss << db_strerror(m_ret)
168.         << "... at: " << func
169.         << "\n"
170.         ;
171.     throw std::runtime_error(oss.str());
172. }
174. /**
175.  @brief 
176.  @return true successful inserted
177.         false fail, (key1, d) existed, and not inserted
178.  @throw other errors
179.  */
180. bool kmapdset_iterator_impl_base::insert(const void* d, const char* func)
181. {
182.     FEBIRD_RT_assert(0 == m_ret || DB_NOTFOUND == m_ret || DB_KEYEXIST == m_ret, std::logic_error);
183.     PortableDataOutput<AutoGrownMemIO> oKey1, oData;
184.     this->save_key1(oKey1);
185.     m_owner->save_data(oData, d);
186.     DBT tk1; memset(&tk1, 0, sizeof(DBT)); tk1.data = oKey1.begin(); tk1.size = oKey1.tell();
187.     DBT tdd; memset(&tdd, 0, sizeof(DBT)); tdd.data = oData.begin(); tdd.size = oData.tell();
188.     int ret = m_curp->put(m_curp, &tk1, &tdd, DB_NODUPDATA);
189.     if (DB_KEYEXIST == ret)
190.         return false;
191.     if (0 == ret)
192.         return true;
193.     std::ostringstream oss;
194.     oss << db_strerror(m_ret)
195.         << "... at: " << func;
196.     throw std::runtime_error(oss.str());
197. }
199. /**
200.  @brief 
201.  @return true successful updated
202.         false (key1, d.key2) did not exist, not updated
203.  @throw other errors
204.  */
205. bool kmapdset_iterator_impl_base::update(const void* d, const char* func)
206. {
207.     FEBIRD_RT_assert(0 == m_ret, std::logic_error);
208.     PortableDataOutput<AutoGrownMemIO> oKey1, oData;
209.     this->save_key1(oKey1);
210.     m_owner->save_data(oData, d);
211.     DBT tk1; memset(&tk1, 0, sizeof(DBT)); tk1.data = oKey1.begin(); tk1.size = oKey1.tell();
212.     DBT tdd; memset(&tdd, 0, sizeof(DBT)); tdd.data = oData.begin(); tdd.size = oData.tell();
213.     int ret = m_curp->get(m_curp, &tk1, &tdd, DB_GET_BOTH);
214.     if (0 == ret)
215.     {
216.         tk1.data = oKey1.begin(); tk1.size = oKey1.tell();
217.         tdd.data = oData.begin(); tdd.size = oData.tell();
218.         ret = m_curp->put(m_curp, &tk1, &tdd, DB_CURRENT);
219.         if (0 == ret)
220.             return true;
221.     }
222.     else if (DB_NOTFOUND == ret)
223.     {
224.         return false;
225.     }
226.     std::ostringstream oss;
227.     oss << db_strerror(ret)
228.         << "... at: " << func;
229.     throw std::runtime_error(oss.str());
230. }
232. /**
233.  @brief 
234.  @return true  item was replaced by (key1,d)
235.          false item was inserted
236.  @throw  other errors
237.  */
238. bool kmapdset_iterator_impl_base::replace(const void* d, const char* func)
239. {
240.     PortableDataOutput<AutoGrownMemIO> oKey1, oData;
241.     this->save_key1(oKey1);
242.     m_owner->save_data(oData, d);
243.     DBT tk1; memset(&tk1, 0, sizeof(DBT)); tk1.data = oKey1.begin(); tk1.size = oKey1.tell();
244.     DBT tdd; memset(&tdd, 0, sizeof(DBT)); tdd.data = oData.begin(); tdd.size = oData.tell();
245.     int ret = m_curp->get(m_curp, &tk1, &tdd, DB_GET_BOTH);
246.     if (0 == ret)
247.