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

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

1. /*vim:settabstop=4:*/
2. #ifndef__febird_bdb_kmapdset_h__
3. #define__febird_bdb_kmapdset_h__
5. #ifdefined(_MSC_VER)&&(_MSC_VER>=1020)
6. #pragmaonce
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. namespacefebird{
17. classFEBIRD_DLL_EXPORTkmapdset_iterator_impl_base:publicRefCounter
18. {
19. public:
20. classkmapdset_base*m_owner;
21. DBC*m_curp;
22. intm_ret;
23. DBTm_bulk;
25. public:
26. kmapdset_iterator_impl_base(classkmapdset_base*owner);
27. voidinit(DB*dbp,DB_TXN*txn,constchar*func);
29. virtual~kmapdset_iterator_impl_base();
31. virtualvoidclear_vec()=0;
32. virtualvoidpush_back(void*data,size_tsize)=0;
33. virtualvoidload_key1(void*data,size_tsize)=0;
34. virtualvoidsave_key1(PortableDataOutput<autogrownMemIO>&oKey)=0;
36. boolnext_key(size_t*cnt,constchar*func);
37. voidbulk_load(DBT*tk1);
38. voidincrement(constchar*func);
39. voiddecrement(constchar*func);
41. boolfind_pos(constvoid*k1,constvoid*k2,boolbulk,constchar*func);
43. boolinsert(constvoid*d,constchar*func);
44. boolupdate(constvoid*d,constchar*func);
45. boolreplace(constvoid*d,constchar*func);
47. boolremove(constvoid*k2,constchar*func);
48. boolremove(constchar*func);
49. };
51. classFEBIRD_DLL_EXPORTkmapdset_base
52. {
53. DECLARE_NONE_copYABLE_CLASS(kmapdset_base)
55. public:
56. DB*m_db;
57. size_tm_bulkSize;
58. bt_compare_fcn_typem_bt_comp,m_dup_comp;
60. kmapdset_base(DB_ENV*env,constchar*dbname
61. ,DB_TXN*txn
62. ,bt_compare_fcn_typebt_comp
63. ,bt_compare_fcn_typedup_comp
64. ,constchar*func
65. );
67. virtual~kmapdset_base();
68. virtualvoidsave_key1(PortableDataOutput<autogrownMemIO>&dio,constvoid*key1)const=0;
69. virtualvoidsave_key2(PortableDataOutput<autogrownMemIO>&dio,constvoid*key2)const=0;
70. virtualvoidsave_data(PortableDataOutput<autogrownMemIO>&dio,constvoid*data)const=0;
72. virtualkmapdset_iterator_impl_base*make_iter()=0;
74. kmapdset_iterator_impl_base*begin_impl(DB_TXN*txn,constchar*func);
75. kmapdset_iterator_impl_base*end_impl(DB_TXN*txn,constchar*func);
77. kmapdset_iterator_impl_base*find_impl(constvoid*k1,u_int32_tflags,constchar*func);
78. kmapdset_iterator_impl_base*find_impl(constvoid*k1,constchar*func);
79. kmapdset_iterator_impl_base*upper_bound_impl(constvoid*k1,constchar*func);
80. size_tcount_impl(constvoid*k1,constchar*func);
82. boolinsert_impl(constvoid*k1,constvoid*d,constchar*func);
83. boolreplace_impl(constvoid*k1,constchar*func);
84. boolremove_impl(constvoid*k1,constchar*func);
85. boolremove_impl(constvoid*k1,constchar*func);
86. voidclear_impl(DB_TXN*txn,constchar*func);
87. voidflush_impl(constchar*func);
88. };
90. template<classData>
91. structkmapdset_select_key2
92. {
93. typedeftypenameData::key_typetype;
94. };
95. template<classKey2,classNonKeyData>
96. structkmapdset_select_key2<std::pair<Key2,NonKeyData>>
97. {
98. typedefKey2type;
99. };
101. template<classKey1,classKey2,classData,classValue,classImpl>
102. classkmapdset_iterator:
103. publicstd::iterator<std::bidirectional_iterator_tag,Value,ptrdiff_t,constValue*,constValue&>
104. {
105. boost::intrusive_ptr<Impl>m_impl;
107. voidcopy_on_write()
108. {
109. if(m_impl->getRefCount()>1)
110. {
111. Impl*p=newImpl(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. //#pragmawarning(disable:4661)//declarationbutnotdeFinition
120. //!MSVCwillwarningC4661"declarationbutnotdeFinition"
121. voidoperator++(int){assert(0);}
122. voidoperator--(int){assert(0);}
123. #else
124. //!disable,becausecloneiteratorwillcauseverymuchtimeandresource
125. voidoperator++(int);//{assert(0);}
126. voidoperator--(int);//{assert(0);}
127. #endif
129. public:
130. kmapdset_iterator(){}
131. explicitkmapdset_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. //boolexist()const{returnDB_NOTFOUND!=m_impl->m_ret&&DB_KEYEMPTY!=m_impl->m_ret;}
139. boolexist()const{return0==m_impl->m_ret;}
141. //incrementandgetkey/data-cnt
142. boolnext_key(size_t&cnt){returnm_impl->next_key(&cnt,BOOST_CURRENT_FUNCTION);}
144. boolinsert(constData&d){returnm_impl->insert(&d,BOOST_CURRENT_FUNCTION);}
145. boolupdate(constData&d){returnm_impl->update(&d,BOOST_CURRENT_FUNCTION);}
146. boolreplace(constData&d){returnm_impl->replace(&d,BOOST_CURRENT_FUNCTION);}
148. boolremove()const{returnm_impl->remove(BOOST_CURRENT_FUNCTION);}
149. boolremove(constKey2&k2)const{returnm_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. constValue&operator*()const
166. {
167. assert(0==m_impl->m_ret);
168. returnm_impl->m_kdv;
169. }
170. constValue*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. returnm_impl->m_kdv;
179. }
180. };
182. //!@paramDataKey2isembededindata
183. template<classKey1,classData>
184. classkmapdset:protectedkmapdset_base
185. {
186. DECLARE_NONE_copYABLE_CLASS(kmapdset)
188. public:
189. typedefKey1
190. key1_t,key_type;
191. typedeftypenamekmapdset_select_key2<Data>::type
192. key2_t;
193. typedefData
194. data_type,data_t;
195. typedefstd::pair<Key1,std::vector<Data>>
196. value_type;
197. typedefstd::vector<Data>
198. data_vec_t;
199. typedeftypenamestd::vector<Data>::const_iterator
200. data_iter_t;
202. protected:
203. classkmapdset_iterator_impl:publickmapdset_iterator_impl_base
204. {
205. public:
206. value_typem_kdv;
208. kmapdset_iterator_impl(kmapdset_base*owner)
209. :kmapdset_iterator_impl_base(owner)
210. {}
212. virtualvoidclear_vec()
213. {
214. m_kdv.second.resize(0);
215. }
217. virtualvoidpush_back(void*data,size_tsize)
218. {
219. datax;
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. virtualvoidload_key1(void*data,size_tsize)
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. virtualvoidsave_key1(PortableDataOutput<autogrownMemIO>&oKey1)
234. {
235. oKey1<<m_kdv.first;
236. }
237. };
239. //!overrides
240. voidsave_key1(PortableDataOutput<autogrownMemIO>&dio,constvoid*key1)const{dio<<*(constkey1_t*)key1;}
241. voidsave_key2(PortableDataOutput<autogrownMemIO>&dio,constvoid*key2)const{dio<<*(constkey2_t*)key2;}
242. voidsave_data(PortableDataOutput<autogrownMemIO>&dio,constvoid*data)const{dio<<*(constdata_t*)data;}
244. kmapdset_iterator_impl_base*make_iter(){returnnewkmapdset_iterator_impl(this);}
246. public:
248. typedefkmapdset_iterator<Key1,key2_t,Data,value_type,kmapdset_iterator_impl>
249. iterator,const_iterator;
251. kmapdset(DB_ENV*env,constchar*dbname
252. ,DB_TXN*txn=NULL
253. ,bt_compare_fcn_typebt_comp=bdb_auto_bt_compare((key1_t*)(0))
254. ,bt_compare_fcn_typedup_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,DbTxn*txn=NULL
260. ,bt_compare_fcn_typedup_comp=bdb_auto_bt_compare((key2_t*)(0))
261. )
262. :kmapdset_base(env->get_DB_ENV(),txn?txn->get_DB_TXN():NULL,BOOST_CURRENT_FUNCTION)
263. {
264. }
266. iteratorbegin(DB_TXN*txn=NULL){returniterator(begin_impl(txn,BOOST_CURRENT_FUNCTION));}
267. iteratorend(DB_TXN*txn=NULL){returniterator(end_impl(txn,BOOST_CURRENT_FUNCTION));}
269. iteratorbegin(DbTxn*txn){returniterator(begin_impl(txn->get_DB_TXN(),BOOST_CURRENT_FUNCTION));}
270. iteratorend(DbTxn*txn){returniterator(end_impl(txn->get_DB_TXN(),BOOST_CURRENT_FUNCTION));}
272. iteratorfind(constKey1&k1,DB_TXN*txn=NULL)
273. {
274. returniterator(find_impl(&k1,DB_SET|DB_MULTIPLE,BOOST_CURRENT_FUNCTION));
275. }
276. iteratorfind(constKey1&k1,DbTxn*txn)
277. {
278. returniterator(find_impl(&k1,txn->get_DB_TXN(),BOOST_CURRENT_FUNCTION));
279. }
281. iteratorfind(constKey1&k1,constkey2_t&k2,DB_TXN*txn=NULL)
282. {
283. returniterator(find_impl(&k1,&k2,false,BOOST_CURRENT_FUNCTION));
284. }
285. iteratorfind(constKey1&k1,DbTxn*txn)
286. {
287. returniterator(find_impl(&k1,BOOST_CURRENT_FUNCTION));
288. }
290. iteratorfind_md(constKey1&k1,true,BOOST_CURRENT_FUNCTION));
291. }
292. iteratorfind_md(constKey1&k1,BOOST_CURRENT_FUNCTION));
293. }
295. iteratorlower_bound(constKey1&k1,DB_SET_RANGE|DB_MULTIPLE,BOOST_CURRENT_FUNCTION));
296. }
297. iteratorlower_bound(constKey1&k1,BOOST_CURRENT_FUNCTION));
298. }
299. iteratorupper_bound(constKey1&k1,DB_TXN*txn=NULL)
300. {
301. returniterator(upper_bound_impl(&k1,BOOST_CURRENT_FUNCTION));
302. }
304. boolinsert(constKey1&k1,constData&d,DB_TXN*txn=NULL)
305. {
306. returninsert_impl(&k1,&d,BOOST_CURRENT_FUNCTION);
307. }
308. boolinsert(constKey1&k1,DbTxn*txn)
309. {
310. returninsert_impl(&k1,BOOST_CURRENT_FUNCTION);
311. }
313. boolreplace(constKey1&k1,DB_TXN*txn=NULL)
314. {
315. returnreplace_impl(&k1,BOOST_CURRENT_FUNCTION);
316. }
317. boolreplace(constKey1&k1,DbTxn*txn)
318. {
319. returnreplace_impl(&k1,BOOST_CURRENT_FUNCTION);
320. }
322. boolremove(constKey1&k1,DB_TXN*txn=NULL)
323. {
324. returnremove_impl(&k1,BOOST_CURRENT_FUNCTION);
325. }
326. boolremove(constKey1&k1,DbTxn*txn)
327. {
328. returnremove_impl(&k1,BOOST_CURRENT_FUNCTION);
329. }
331. boolremove(constKey1&k1,DB_TXN*txn=NULL)
332. {
333. returnremove_impl(&k1,BOOST_CURRENT_FUNCTION);
334. }
335. boolremove(constKey1&k1,DbTxn*txn)
336. {
337. returnremove_impl(&k1,BOOST_CURRENT_FUNCTION);
338. }
340. boolerase(constiterator&iter)
341. {
342. returniter.remove();
343. }
345. voidclear(DB_TXN*txn=NULL)
346. {
347. clear_impl(txn,BOOST_CURRENT_FUNCTION);
348. }
349. voidclear(DbTxn*txn)
350. {
351. returnclear_impl(txn->get_DB_TXN(),BOOST_CURRENT_FUNCTION);
352. }
354. voidflush()
355. {
356. returnflush_impl(BOOST_CURRENT_FUNCTION);
357. }
359. size_tcount(constKey1&k1,DB_TXN*txn=NULL)
360. {
361. returncount_impl(&k1,BOOST_CURRENT_FUNCTION);
362. }
363. size_tcount(constKey1&k1,DbTxn*txn)
364. {
365. returncount_impl(&k1,BOOST_CURRENT_FUNCTION);
366. }
368. DB*getDB(){returnm_db;}
369. constDB*getDB()const{returnm_db;}
370. };
372. }//namespacefebird
375. #endif//__febird_bdb_kmapdset_h__

1. /*vim:settabstop=4:*/
2. #include"kmapdset.h"
3. //#include"../DataBuffer.h"
4. #include<sstream>
6. namespacefebird{
8. kmapdset_iterator_impl_base::kmapdset_iterator_impl_base(classkmapdset_base*owner)
9. :m_owner(owner)
10. ,m_curp(0),m_ret(-1)
11. {
12. memset(&m_bulk,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. voidkmapdset_iterator_impl_base::init(DB*dbp,constchar*func)
20. {
21. intret=dbp->cursor(dbp,&m_curp,0);
22. if(0!=ret)
23. {
24. deletethis;
25. std::ostringstreamoss;
26. oss<<db_strerror(ret)<<"...at:"<<func;
27. throwstd::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. boolkmapdset_iterator_impl_base::next_key(size_t*cnt,constchar*func)
41. {
42. FEBIRD_RT_assert(0==m_ret,std::logic_error);
43. DBTtk1;memset(&tk1,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_tcnt0=0;
49. intret=m_curp->count(m_curp,&cnt0,0);
50. if(0!=ret)
51. {
52. std::ostringstreamoss;
53. oss<<db_strerror(ret)<<"...at:"<<func;
54. throwstd::runtime_error(oss.str());
55. }
56. *cnt=cnt0;
57. returntrue;
58. }
59. elseif(DB_NOTFOUND==m_ret)
60. {
61. returnfalse;
62. }
63. else
64. {
65. std::ostringstreamoss;
66. oss<<db_strerror(m_ret)<<"...at:"<<func;
67. throwstd::runtime_error(oss.str());
68. }
69. }
71. voidkmapdset_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. intret;
77. do{
78. void*bptr,*data;
79. size_tsize;
80. DB_MULTIPLE_INIT(bptr,&m_bulk);
81. assert(NULL!=bptr);
82. for(;;)
83. {
84. DB_MULTIPLE_NEXT(bptr,data,size);
85. if(bptr)
86. this->push_back(data,size);
87. else
88. break;
89. }
90. ret=m_curp->get(m_curp,tk1,DB_MULTIPLE|DB_NEXT_DUP);
91. }while(0==ret);
92. }
94. voidkmapdset_iterator_impl_base::increment(constchar*func)
95. {
96. FEBIRD_RT_assert(0==m_ret,DB_NEXT_NODUP|DB_MULTIPLE);
97. if(0==m_ret)
98. {
99. bulk_load(&tk1);
100. }
101. elseif(DB_NOTFOUND!=m_ret)
102. {
103. std::ostringstreamoss;
104. oss<<db_strerror(m_ret)<<"...at:"<<func;
105. throwstd::runtime_error(oss.str());
106. }
107. }
109. voidkmapdset_iterator_impl_base::decrement(constchar*func)
110. {
111. FEBIRD_RT_assert(0==m_ret,std::logic_error);
112. DBTtk1;memset(&tk1,sizeof(DBT));
113. m_ret=m_curp->get(m_curp,DB_PREV_NODUP);
114. if(0==m_ret)
115. {
116. m_ret=m_curp->get(m_curp,DB_CURRENT|DB_MULTIPLE);
117. if(0==m_ret)
118. {
119. bulk_load(&tk1);
120. }
121. elseif(DB_KEYEMPTY==m_ret)
122. {
123. std::ostringstreamoss;
124. oss<<db_strerror(m_ret)
125. <<"...at:"<<func;
126. throwstd::runtime_error(oss.str());
127. }
128. }
129. elseif(DB_NOTFOUND!=m_ret)
130. {
131. std::ostringstreamoss;
132. oss<<db_strerror(m_ret)<<"...at:"<<func;
133. throwstd::runtime_error(oss.str());
134. }
135. }
137. boolkmapdset_iterator_impl_base::find_pos(constvoid*k1,constchar*func)
138. {
139. PortableDataOutput<autogrownMemIO>oKey1,oKey2;
140. m_owner->save_key1(oKey1,k1);
141. m_owner->save_key2(oKey2,k2);
142. DBTtk1;memset(&tk1,sizeof(DBT));tk1.data=oKey1.begin();tk1.size=oKey1.tell();
143. DBTtk2;memset(&tk2,sizeof(DBT));tk2.data=oKey2.begin();tk2.size=oKey2.tell();
144. m_ret=m_curp->get(m_curp,&tk2,DB_GET_BOTH);
145. if(0==m_ret)
146. {
147. if(bulk){
148. m_ret=m_curp->get(m_curp,DB_CURRENT|DB_MULTIPLE);
149. if(0==m_ret){
150. bulk_load(&tk1);
151. returntrue;
152. }
153. }else{
154. clear_vec();
155. load_key1(tk1.data,tk1.size);
156. push_back(tk2.data,tk2.size);
157. returntrue;
158. }
159. }
160. elseif(DB_NOTFOUND==m_ret)
161. {
162. returnfalse;
163. }
164. std::ostringstreamoss;
165. oss<<db_strerror(m_ret)
166. <<"...at:"<<func
167. <<"/n"
168. ;
169. throwstd::runtime_error(oss.str());
170. }
172. /**
173. @brief
174. @returntruesuccessfulinserted
175. falsefail,(key1,d)existed,andnotinserted
176. @throwothererrors
177. */
178. boolkmapdset_iterator_impl_base::insert(constvoid*d,constchar*func)
179. {
180. FEBIRD_RT_assert(0==m_ret||DB_NOTFOUND==m_ret||DB_KEYEXIST==m_ret,std::logic_error);
181. PortableDataOutput<autogrownMemIO>oKey1,oData;
182. this->save_key1(oKey1);
183. m_owner->save_data(oData,d);
184. DBTtk1;memset(&tk1,sizeof(DBT));tk1.data=oKey1.begin();tk1.size=oKey1.tell();
185. DBTtdd;memset(&tdd,sizeof(DBT));tdd.data=oData.begin();tdd.size=oData.tell();
186. intret=m_curp->put(m_curp,&tdd,DB_NODUPDATA);
187. if(DB_KEYEXIST==ret)
188. returnfalse;
189. if(0==ret)
190. returntrue;
191. std::ostringstreamoss;
192. oss<<db_strerror(m_ret)
193. <<"...at:"<<func;
194. throwstd::runtime_error(oss.str());
195. }
197. /**
198. @brief
199. @returntruesuccessfulupdated
200. false(key1,d.key2)didnotexist,notupdated
201. @throwothererrors
202. */
203. boolkmapdset_iterator_impl_base::update(constvoid*d,constchar*func)
204. {
205. FEBIRD_RT_assert(0==m_ret,std::logic_error);
206. PortableDataOutput<autogrownMemIO>oKey1,oData;
207. this->save_key1(oKey1);
208. m_owner->save_data(oData,d);
209. DBTtk1;memset(&tk1,sizeof(DBT));tk1.data=oKey1.begin();tk1.size=oKey1.tell();
210. DBTtdd;memset(&tdd,sizeof(DBT));tdd.data=oData.begin();tdd.size=oData.tell();
211. intret=m_curp->get(m_curp,DB_GET_BOTH);
212. if(0==ret)
213. {
214. tk1.data=oKey1.begin();tk1.size=oKey1.tell();
215. tdd.data=oData.begin();tdd.size=oData.tell();
216. ret=m_curp->put(m_curp,DB_CURRENT);
217. if(0==ret)
218. returntrue;
219. }
220. elseif(DB_NOTFOUND==ret)
221. {
222. returnfalse;
223. }
224. std::ostringstreamoss;
225. oss<<db_strerror(ret)
226. <<"...at:"<<func;
227. throwstd::runtime_error(oss.str());
228. }
230. /**
231. @brief
232. @returntrueitemwasreplacedby(key1,d)
233. falseitemwasinserted
234. @throwothererrors
235. */
236. boolkmapdset_iterator_impl_base::replace(constvoid*d,constchar*func)
237. {
238. PortableDataOutput<autogrownMemIO>oKey1,DB_CURRENT);
239. if(0==ret)
240. returntrue;
241. }
242. elseif(DB_NOTFOUND==ret)
243. {
244. ret=m_curp->put(m_curp,DB_NODUPDATA);
245. if(0==ret)
246. returnfalse;
247. }
248. std::ostringstreamoss;
249. oss<<db_strerror(ret)
250. <<"...at:"<<func;
251. throwstd::runtime_error(oss.str());
252. }
254. boolkmapdset_iterator_impl_base::remove(constvoid*k2,oKey2;
255. this->save_key1(oKey1);
256. m_owner->save_key2(oKey2,sizeof(DBT));tdd.data=oKey2.begin();tdd.size=oKey2.tell();
258. intret=m_curp->get(m_curp,DB_GET_BOTH);
259. if(0==ret)
260. ret=m_curp->del(m_curp,0);
261. if(DB_KEYEMPTY==ret)
262. returnfalse;
263. if(0==ret)
264. returntrue;
265. std::ostringstreamoss;
266. oss<<db_strerror(ret)
267. <<"...at:"<<func;
268. throwstd::runtime_error(oss.str());
269. }
271. boolkmapdset_iterator_impl_base::remove(constchar*func)
272. {
273. FEBIRD_RT_assert(0==m_ret,std::logic_error);
274. PortableDataOutput<autogrownMemIO>oKey1;
275. this->save_key1(oKey1);
276. DBTtk1;memset(&tk1,sizeof(DBT));tk1.data=oKey1.begin();tk1.size=oKey1.tell();
277. intret=m_owner->m_db->del(m_owner->m_db,m_curp->txn,0);
278. if(DB_NOTFOUND==ret)
279. returnfalse;
280. if(0==ret)
281. returntrue;
282. std::ostringstreamoss;
283. oss<<db_strerror(ret)
284. <<"...at:"<<func;
285. throwstd::runtime_error(oss.str());
286. }
288. //////////////////////////////////////////////////////////////////////////
290. kmapdset_base::kmapdset_base(DB_ENV*env,DB_TXN*txn
291. ,bt_compare_fcn_typebt_comp
292. ,bt_compare_fcn_typedup_comp
293. ,constchar*func
294. )
295. :m_bt_comp(0)
296. {
297. m_bulkSize=512*1024;
298. m_db=0;
299. intret=db_create(&m_db,env,0);
300. if(0==ret)
301. {
302. if(bt_comp){
303. m_bt_comp=bt_comp;
304. m_db->set_bt_compare(m_db,bt_comp);
305. }
306. if(dup_comp){
307. m_dup_comp=dup_comp;
308. m_db->set_dup_compare(m_db,dup_comp);
309. }
310. m_db->app_private=(this);
311. intflags=env->open_flags&(DB_THREAD|DB_MULTIVERSION|DB_AUTO_COMMIT);
312. ret=m_db->open(m_db,DB_BTREE,DB_CREATE|flags,0);
313. }
315. if(0!=ret)
316. {
317. std::ostringstreamoss;
318. oss<<db_strerror(ret)
319. <<"...at:"<<func;
320. throwstd::runtime_error(oss.str());
321. }
322. }
324. kmapdset_base::~kmapdset_base()
325. {
326. if(m_db)
327. m_db->close(m_db,0);
328. }
330. kmapdset_iterator_impl_base*kmapdset_base::begin_impl(DB_TXN*txn,constchar*func)
331. {
332. kmapdset_iterator_impl_base*iter=make_iter();
333. iter->init(m_db,func);
334. DBTtk1;memset(&tk1,sizeof(DBT));
335. iter->m_ret=iter->m_curp->get(iter->m_curp,&iter->m_bulk,DB_FirsT|DB_MULTIPLE);
336. if(0==iter->m_ret)
337. {
338. iter->bulk_load(&tk1);
339. }
340. elseif(DB_NOTFOUND!=iter->m_ret)
341. {
342. std::ostringstreamoss;
343. oss<<db_strerror(iter->m_ret)
344. <<"...at:"<<func;
345. deleteiter;iter=0;
346. throwstd::runtime_error(oss.str());
347. }
348. returniter;
349. }
351. kmapdset_iterator_impl_base*kmapdset_base::end_impl(DB_TXN*txn,constchar*func)
352. {
353. kmapdset_iterator_impl_base*iter=make_iter();
354. iter->init(m_db,func);
355. returniter;
356. }
358. kmapdset_iterator_impl_base*kmapdset_base::find_impl(constvoid*k1,constchar*func)
359. {
360. PortableDataOutput<autogrownMemIO>oKey1;
361. save_key1(oKey1,k1);
362. DBTtk1;memset(&tk1,sizeof(DBT));tk1.data=oKey1.begin();tk1.size=oKey1.tell();
363. kmapdset_iterator_impl_base*iter=make_iter();
364. iter->init(m_db,func);
365. iter->m_ret=iter->m_curp->get(iter->m_curp,flags);
366. if(0==iter->m_ret)
367. {
368. iter->bulk_load(&tk1);
369. }
370. elseif(DB_NOTFOUND!=iter->m_ret&&DB_KEYEMPTY!=iter->m_ret)
371. {
372. std::ostringstreamoss;
373. oss<<db_strerror(iter->m_ret)
374. <<"...at:"<<func
375. <<"/n"
376. <<"flags="<<flags
377. ;
378. throwstd::runtime_error(oss.str());
379. }
380. returniter;
381. }
383. kmapdset_iterator_impl_base*
384. kmapdset_base::find_impl(constvoid*k1,func);
385. try{
386. boolbRet=iter->find_pos(k1,k2,bulk,func);
387. returniter;
388. }catch(std::exception&exp){
389. deleteiter;iter=0;
390. throwexp;
391. }
392. }
394. kmapdset_iterator_impl_base*kmapdset_base::upper_bound_impl(constvoid*k1,constchar*func)
395. {
396. PortableDataOutput<autogrownMemIO>oKey1;
397. save_key1(oKey1,k1);
398. DBTtk1;memset(&tk1,sizeof(DBT));tk1.data=oKey1.begin();tk1.size=oKey1.tell();
399. kmapdset_iterator_impl_base*iter=make_iter();
400. iter->init(m_db,func);
401. iter->m_ret=iter->m_curp->get(iter->m_curp,DB_SET_RANGE|DB_MULTIPLE);
402. if(0==iter->m_ret)
403. {
404. DBTkbak;memset(&kbak,sizeof(DBT));kbak.data=oKey1.begin();kbak.size=oKey1.tell();
405. intcmp=m_bt_comp(m_db,&kbak,&tk1);
406. assert(cmp<=0);
407. if(0==cmp){
408. iter->m_ret=iter->m_curp->get(iter->m_curp,DB_NEXT_NODUP|DB_MULTIPLE);
409. if(0==iter->m_ret)
410. iter->bulk_load(&tk1);
411. }else
412. iter->bulk_load(&tk1);
413. }
414. if(0!=iter->m_ret&&DB_NOTFOUND!=iter->m_ret)
415. {
416. std::ostringstreamoss;
417. oss<<db_strerror(iter->m_ret)
418. <<"...at:"<<func
419. <<"/n"
420. ;
421. throwstd::runtime_error(oss.str());
422. }
423. returniter;
424. }
426. size_tkmapdset_base::count_impl(constvoid*k1,constchar*func)
427. {
428. PortableDataOutput<autogrownMemIO>oKey1;
429. try{
430. save_key1(oKey1,k1);
431. }
432. catch(constIOException&exp)
433. {
434. std::ostringstreamoss;
435. oss<<exp.what()<<"...at:"<<func;
436. throwstd::runtime_error(oss.str());
437. }
438. DBTtk1;memset(&tk1,sizeof(DBT));
439. DBC*curp=NULL;
440. intret=m_db->cursor(m_db,&curp,0);
441. if(0==ret)
442. {
443. ret=curp->get(curp,DB_SET);
444. db_recno_tcount=0;
445. if(0==ret)
446. ret=curp->count(curp,&count,0);
447. elseif(DB_NOTFOUND==ret)
448. count=0,ret=0;//clearerror
450. curp->close(curp);
451. if(0!=ret)
452. gotoErrorL;
453. returncount;
454. }
455. ErrorL:
456. std::ostringstreamoss;
457. oss<<db_strerror(ret)
458. <<"...at:"<<func
459. <<"/n"
460. ;
461. throwstd::runtime_error(oss.str());
462. }
464. /**
465. @briefinsertarecord
466. @returntruesuccess,nosamek1-k2indb,therecordwasinserted
467. falseFailed,hassamek1-k2indb,therecordwasnotinserted,notreplacedexistingyet
468. @throwsexception,Failed
469. */
470. boolkmapdset_base::insert_impl(constvoid*k1,oData;
471. try{
472. save_key1(oKey1,k1);
473. save_data(oData,d);
474. }
475. catch(constIOException&exp)
476. {
477. std::ostringstreamoss;
478. oss<<exp.what()<<"...at:"<<func;
479. throwstd::runtime_error(oss.str());
480. }
481. DBTtk1;memset(&tk1,sizeof(DBT));tdd.data=oData.begin();tdd.size=oData.tell();
482. intret=m_db->put(m_db,DB_NODUPDATA);
483. if(DB_KEYEXIST==ret)
484. returnfalse;
485. if(0==ret)
486. returntrue;
487. std::ostringstreamoss;
488. oss<<db_strerror(ret)
489. <<"...at:"<<func
490. <<"/n"
491. ;
492. throwstd::runtime_error(oss.str());
493. }
495. /**
496. @briefreplaceORinsertarecord
497. @note
498. ifnotthrownanexception,alwayssuccess
499. @returntruereplacetherecord
500. falseinserttherecord
501. @throwsexception,Failed
502. */
503. boolkmapdset_base::replace_impl(constvoid*k1,sizeof(DBT));tdd.data=oData.begin();tdd.size=oData.tell();
504. DBC*curp=NULL;
505. intret=m_db->cursor(m_db,DB_GET_BOTH);
506. if(0==ret)
507. {
508. tk1.data=oKey1.begin();tk1.size=oKey1.tell();
509. tdd.data=oData.begin();tdd.size=oData.tell();
510. ret=curp->put(curp,DB_CURRENT);
511. curp->close(curp);
512. if(0==ret)
513. returntrue;
514. }
515. elseif(DB_NOTFOUND==ret)
516. {
517. ret=curp->put(curp,DB_NODUPDATA);
518. curp->close(curp);
519. if(0==ret)
520. returnfalse;
521. }
522. }
523. std::ostringstreamoss;
524. oss<<db_strerror(ret)
525. <<"...at:"<<func
526. <<"/n"
527. ;
528. throwstd::runtime_error(oss.str());
529. }
531. /**
532. @brief
533. @returntrue(k1,k2)existed,removesuccess
534. false(k1,k2)notexisted,nothingdone
535. */
536. boolkmapdset_base::remove_impl(constvoid*k1,oData;
537. oData.resize(4*1024);
538. save_key1(oKey1,k1);
539. save_key2(oData,sizeof(DBT));tdd.data=oData.begin();tdd.size=oData.tell();
540. DBC*curp=NULL;
541. intret=m_db->cursor(m_db,0);
542. if(0==ret)
543. {
544. ret=curp->get(curp,DB_GET_BOTH);
545. if(0==ret){
546. ret=curp->del(curp,0);
547. }
548. curp->close(curp);
549. return0==ret;
550. }
551. else
552. {
553. std::ostringstreamoss;
554. oss<<db_strerror(ret)
555. <<"...at:"<<func
556. <<"/n"
557. ;
558. throwstd::runtime_error(oss.str());
559. }
560. }
562. /**
563. @brief
564. @returntrue(k1)existed,removesuccess
565. false(k1)notexisted,nothingdone
566. */
567. boolkmapdset_base::remove_impl(constvoid*k1,sizeof(DBT));tk1.data=oKey1.begin();tk1.size=oKey1.tell();
568. intret=m_db->del(m_db,0);
569. if(DB_NOTFOUND==ret)
570. returnfalse;
571. if(0==ret)
572. returntrue;
573. std::ostringstreamoss;
574. oss<<db_strerror(ret)
575. <<"...at:"<<func
576. <<"/n"
577. ;
578. throwstd::runtime_error(oss.str());
579. }
581. voidkmapdset_base::clear_impl(DB_TXN*txn,constchar*func)
582. {
583. u_int32_tcount;
584. intret=m_db->truncate(m_db,0);
585. if(0!=ret)
586. {
587. std::ostringstreamoss;
588. oss<<db_strerror(ret)
589. <<"...at:"<<func
590. <<"/n"
591. ;
592. throwstd::runtime_error(oss.str());
593. }
594. }
596. voidkmapdset_base::flush_impl(constchar*func)
597. {
598. intret=m_db->sync(m_db,0);
599. if(0!=ret)
600. {
601. std::ostringstreamoss;
602. oss<<db_strerror(ret)
603. <<"...at:"<<func
604. <<"/n"
605. ;
606. throwstd::runtime_error(oss.str());
607. }
608. }
610. }//namespacefebird