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

设计模式 前端之家
前端之家收集整理的这篇文章主要介绍了持久化的多键映射，使用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

猜你在找的设计模式相关文章

适配器模式-让不兼容的接口得以适配
适配器模式将一个类的接口转换成客户期望的另一个接口，使得原本接口不兼容的类可以相互合...
策略模式-定义一个算法族
策略模式定义了一系列算法族，并封装在类中，它们之间可以互相替换，此模式让算法的变化独...
设计模式之高质量代码
设计模式讲的是如何编写可扩展、可维护、可读的高质量代码，它是针对软件开发中经常遇到的...
模板方法模式-封装一套算法流程
模板方法模式在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中，使得子类可以在...
迭代器模式-统一集合的遍历方式
迭代器模式提供了一种方法，用于遍历集合对象中的元素，而又不暴露其内部的细节。
单例模式的五种实现方式及优缺点
单例模式（Singleton Design Pattern）保证一个类只能有一个实例，并提供一个全局访问点。
组合模式-统一的处理个别对象与组合对象
组合模式可以将对象组合成树形结构来表示“整体-部分”的层次结构，使得客户可以用一致的方...
装饰者模式-动态的包装原有对象的行为
装饰者模式能够更灵活的，动态的给对象添加其它功能，而不需要修改任何现有的底层代码。
观察者模式-将消息通知给观察者
观察者模式（Observer Design Pattern）定义了对象之间的一对多依赖，当对象状态改变的时候...
代理模式-访问对象的代理而非其本身
代理模式为对象提供一个代理，来控制对该对象的访问。代理模式在不改变原始类代码的情况下...
算法设计模式多媒体技术正则表达式ElasticsearchFlinkHadoopIDE
受约束摘*day25Java常用类库置信lamda留存持续录入年后正则表达式303.17regularexpre匹多模适20130322基础理论pathmunge涵义reectok需要转义的特资源分享validationex简明魔法里弄形如源码实现完备actionscript