cxx_db.cpp
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:17k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1997-2002
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  7. #include "db_config.h"
  8. #ifndef lint
  9. static const char revid[] = "$Id: cxx_db.cpp,v 11.71 2002/08/26 22:13:36 mjc Exp $";
  10. #endif /* not lint */
  11. #include <errno.h>
  12. #include <string.h>
  13. #include "db_cxx.h"
  14. #include "dbinc/cxx_int.h"
  15. #include "db_int.h"
  16. #include "dbinc/db_page.h"
  17. #include "dbinc_auto/db_auto.h"
  18. #include "dbinc_auto/crdel_auto.h"
  19. #include "dbinc/db_dispatch.h"
  20. #include "dbinc_auto/db_ext.h"
  21. #include "dbinc_auto/common_ext.h"
  22. // Helper macros for simple methods that pass through to the
  23. // underlying C method. It may return an error or raise an exception.
  24. // Note this macro expects that input _argspec is an argument
  25. // list element (e.g., "char *arg") and that _arglist is the arguments
  26. // that should be passed through to the C method (e.g., "(db, arg)")
  27. //
  28. #define DB_METHOD(_name, _argspec, _arglist, _retok)
  29. int Db::_name _argspec
  30. {
  31. int ret;
  32. DB *db = unwrap(this);
  33. ret = db->_name _arglist;
  34. if (!_retok(ret))
  35. DB_ERROR("Db::" # _name, ret, error_policy());
  36. return (ret);
  37. }
  38. #define DB_METHOD_CHECKED(_name, _cleanup, _argspec, _arglist, _retok)
  39. int Db::_name _argspec
  40. {
  41. int ret;
  42. DB *db = unwrap(this);
  43. if (!db) {
  44. DB_ERROR("Db::" # _name, EINVAL, error_policy());
  45. return (EINVAL);
  46. }
  47. if (_cleanup)
  48. cleanup();
  49. ret = db->_name _arglist;
  50. if (!_retok(ret))
  51. DB_ERROR("Db::" # _name, ret, error_policy());
  52. return (ret);
  53. }
  54. #define DB_METHOD_QUIET(_name, _argspec, _arglist)
  55. int Db::_name _argspec
  56. {
  57. DB *db = unwrap(this);
  58. return (db->_name _arglist);
  59. }
  60. #define DB_METHOD_VOID(_name, _argspec, _arglist)
  61. void Db::_name _argspec
  62. {
  63. DB *db = unwrap(this);
  64. db->_name _arglist;
  65. }
  66. // A truism for the Db object is that there is a valid
  67. // DB handle from the constructor until close().
  68. // After the close, the DB handle is invalid and
  69. // no operations are permitted on the Db (other than
  70. // destructor).  Leaving the Db handle open and not
  71. // doing a close is generally considered an error.
  72. //
  73. // We used to allow Db objects to be closed and reopened.
  74. // This implied always keeping a valid DB object, and
  75. // coordinating the open objects between Db/DbEnv turned
  76. // out to be overly complicated.  Now we do not allow this.
  77. Db::Db(DbEnv *env, u_int32_t flags)
  78. : imp_(0)
  79. , env_(env)
  80. , construct_error_(0)
  81. , flags_(0)
  82. , construct_flags_(flags)
  83. , append_recno_callback_(0)
  84. , associate_callback_(0)
  85. , bt_compare_callback_(0)
  86. , bt_prefix_callback_(0)
  87. , dup_compare_callback_(0)
  88. , feedback_callback_(0)
  89. , h_hash_callback_(0)
  90. {
  91. if (env_ == 0)
  92. flags_ |= DB_CXX_PRIVATE_ENV;
  93. if ((construct_error_ = initialize()) != 0)
  94. DB_ERROR("Db::Db", construct_error_, error_policy());
  95. }
  96. // If the DB handle is still open, we close it.  This is to make stack
  97. // allocation of Db objects easier so that they are cleaned up in the error
  98. // path.  If the environment was closed prior to this, it may cause a trap, but
  99. // an error message is generated during the environment close.  Applications
  100. // should call close explicitly in normal (non-exceptional) cases to check the
  101. // return value.
  102. //
  103. Db::~Db()
  104. {
  105. DB *db;
  106. db = unwrap(this);
  107. if (db != NULL) {
  108. cleanup();
  109. (void)db->close(db, 0);
  110. }
  111. }
  112. // private method to initialize during constructor.
  113. // initialize must create a backing DB object,
  114. // and if that creates a new DB_ENV, it must be tied to a new DbEnv.
  115. //
  116. int Db::initialize()
  117. {
  118. DB *db;
  119. DB_ENV *cenv = unwrap(env_);
  120. int ret;
  121. u_int32_t cxx_flags;
  122. cxx_flags = construct_flags_ & DB_CXX_NO_EXCEPTIONS;
  123. // Create a new underlying DB object.
  124. // We rely on the fact that if a NULL DB_ENV* is given,
  125. // one is allocated by DB.
  126. //
  127. if ((ret = db_create(&db, cenv,
  128.      construct_flags_ & ~cxx_flags)) != 0)
  129. return (ret);
  130. // Associate the DB with this object
  131. imp_ = wrap(db);
  132. db->api_internal = this;
  133. // Create a new DbEnv from a DB_ENV* if it was created locally.
  134. // It is deleted in Db::close().
  135. //
  136. if ((flags_ & DB_CXX_PRIVATE_ENV) != 0)
  137. env_ = new DbEnv(db->dbenv, cxx_flags);
  138. return (0);
  139. }
  140. // private method to cleanup after destructor or during close.
  141. // If the environment was created by this Db object, we optionally
  142. // delete it, or return it so the caller can delete it after
  143. // last use.
  144. //
  145. void Db::cleanup()
  146. {
  147. DB *db = unwrap(this);
  148. if (db != NULL) {
  149. // extra safety
  150. db->api_internal = 0;
  151. imp_ = 0;
  152. // we must dispose of the DbEnv object if
  153. // we created it.  This will be the case
  154. // if a NULL DbEnv was passed into the constructor.
  155. // The underlying DB_ENV object will be inaccessible
  156. // after the close, so we must clean it up now.
  157. //
  158. if ((flags_ & DB_CXX_PRIVATE_ENV) != 0) {
  159. env_->cleanup();
  160. delete env_;
  161. env_ = 0;
  162. }
  163. }
  164. }
  165. // Return a tristate value corresponding to whether we should
  166. // throw exceptions on errors:
  167. //   ON_ERROR_RETURN
  168. //   ON_ERROR_THROW
  169. //   ON_ERROR_UNKNOWN
  170. //
  171. int Db::error_policy()
  172. {
  173. if (env_ != NULL)
  174. return (env_->error_policy());
  175. else {
  176. // If the env_ is null, that means that the user
  177. // did not attach an environment, so the correct error
  178. // policy can be deduced from constructor flags
  179. // for this Db.
  180. //
  181. if ((construct_flags_ & DB_CXX_NO_EXCEPTIONS) != 0) {
  182. return (ON_ERROR_RETURN);
  183. }
  184. else {
  185. return (ON_ERROR_THROW);
  186. }
  187. }
  188. }
  189. int Db::close(u_int32_t flags)
  190. {
  191. DB *db = unwrap(this);
  192. int ret;
  193. // after a DB->close (no matter if success or failure),
  194. // the underlying DB object must not be accessed,
  195. // so we clean up in advance.
  196. //
  197. cleanup();
  198. // It's safe to throw an error after the close,
  199. // since our error mechanism does not peer into
  200. // the DB* structures.
  201. //
  202. if ((ret = db->close(db, flags)) != 0)
  203. DB_ERROR("Db::close", ret, error_policy());
  204. return (ret);
  205. }
  206. // The following cast implies that Dbc can be no larger than DBC
  207. DB_METHOD(cursor, (DbTxn *txnid, Dbc **cursorp, u_int32_t flags),
  208.     (db, unwrap(txnid), (DBC **)cursorp, flags),
  209.     DB_RETOK_STD)
  210. DB_METHOD(del, (DbTxn *txnid, Dbt *key, u_int32_t flags),
  211.     (db, unwrap(txnid), key, flags),
  212.     DB_RETOK_DBDEL)
  213. void Db::err(int error, const char *format, ...)
  214. {
  215. DB *db = unwrap(this);
  216. DB_REAL_ERR(db->dbenv, error, 1, 1, format);
  217. }
  218. void Db::errx(const char *format, ...)
  219. {
  220. DB *db = unwrap(this);
  221. DB_REAL_ERR(db->dbenv, 0, 0, 1, format);
  222. }
  223. DB_METHOD(fd, (int *fdp),
  224.     (db, fdp),
  225.     DB_RETOK_STD)
  226. int Db::get(DbTxn *txnid, Dbt *key, Dbt *value, u_int32_t flags)
  227. {
  228. DB *db = unwrap(this);
  229. int ret;
  230. ret = db->get(db, unwrap(txnid), key, value, flags);
  231. if (!DB_RETOK_DBGET(ret)) {
  232. if (ret == ENOMEM && DB_OVERFLOWED_DBT(value))
  233. DB_ERROR_DBT("Db::get", value, error_policy());
  234. else
  235. DB_ERROR("Db::get", ret, error_policy());
  236. }
  237. return (ret);
  238. }
  239. int Db::get_byteswapped(int *isswapped)
  240. {
  241. DB *db = (DB *)unwrapConst(this);
  242. return (db->get_byteswapped(db, isswapped));
  243. }
  244. int Db::get_type(DBTYPE *dbtype)
  245. {
  246. DB *db = (DB *)unwrapConst(this);
  247. return (db->get_type(db, dbtype));
  248. }
  249. // Dbc is a "compatible" subclass of DBC - that is, no virtual functions
  250. // or even extra data members, so these casts, although technically
  251. // non-portable, "should" always be okay.
  252. DB_METHOD(join, (Dbc **curslist, Dbc **cursorp, u_int32_t flags),
  253.     (db, (DBC **)curslist, (DBC **)cursorp, flags),
  254.     DB_RETOK_STD)
  255. DB_METHOD(key_range,
  256.     (DbTxn *txnid, Dbt *key, DB_KEY_RANGE *results, u_int32_t flags),
  257.     (db, unwrap(txnid), key, results, flags),
  258.     DB_RETOK_STD)
  259. // If an error occurred during the constructor, report it now.
  260. // Otherwise, call the underlying DB->open method.
  261. //
  262. int Db::open(DbTxn *txnid, const char *file, const char *database,
  263.      DBTYPE type, u_int32_t flags, int mode)
  264. {
  265. int ret;
  266. DB *db = unwrap(this);
  267. if (construct_error_ != 0)
  268. ret = construct_error_;
  269. else
  270. ret = db->open(db, unwrap(txnid), file, database, type, flags,
  271.     mode);
  272. if (!DB_RETOK_STD(ret))
  273. DB_ERROR("Db::open", ret, error_policy());
  274. return (ret);
  275. }
  276. int Db::pget(DbTxn *txnid, Dbt *key, Dbt *pkey, Dbt *value, u_int32_t flags)
  277. {
  278. DB *db = unwrap(this);
  279. int ret;
  280. ret = db->pget(db, unwrap(txnid), key, pkey, value, flags);
  281. /* The logic here is identical to Db::get - reuse the macro. */
  282. if (!DB_RETOK_DBGET(ret)) {
  283. if (ret == ENOMEM && DB_OVERFLOWED_DBT(value))
  284. DB_ERROR_DBT("Db::pget", value, error_policy());
  285. else
  286. DB_ERROR("Db::pget", ret, error_policy());
  287. }
  288. return (ret);
  289. }
  290. DB_METHOD(put,
  291.     (DbTxn *txnid, Dbt *key, Dbt *value, u_int32_t flags),
  292.     (db, unwrap(txnid), key, value, flags),
  293.     DB_RETOK_DBPUT)
  294. DB_METHOD_CHECKED(rename, 1,
  295.     (const char *file, const char *database, const char *newname,
  296.     u_int32_t flags),
  297.     (db, file, database, newname, flags), DB_RETOK_STD)
  298. DB_METHOD_CHECKED(remove, 1,
  299.     (const char *file, const char *database, u_int32_t flags),
  300.     (db, file, database, flags), DB_RETOK_STD)
  301. DB_METHOD_CHECKED(truncate, 0,
  302.     (DbTxn *txnid, u_int32_t *countp, u_int32_t flags),
  303.     (db, unwrap(txnid), countp, flags), DB_RETOK_STD)
  304. DB_METHOD_CHECKED(stat, 0,
  305.     (void *sp, u_int32_t flags), (db, sp, flags), DB_RETOK_STD)
  306. DB_METHOD_CHECKED(sync, 0,
  307.     (u_int32_t flags), (db, flags), DB_RETOK_STD)
  308. DB_METHOD_CHECKED(upgrade, 0,
  309.     (const char *name, u_int32_t flags), (db, name, flags), DB_RETOK_STD)
  310. ////////////////////////////////////////////////////////////////////////
  311. //
  312. // callbacks
  313. //
  314. // *_intercept_c are 'glue' functions that must be declared
  315. // as extern "C" so to be typesafe.  Using a C++ method, even
  316. // a static class method with 'correct' arguments, will not pass
  317. // the test; some picky compilers do not allow mixing of function
  318. // pointers to 'C' functions with function pointers to C++ functions.
  319. //
  320. // One wart with this scheme is that the *_callback_ method pointer
  321. // must be declared public to be accessible by the C intercept.
  322. // It's possible to accomplish the goal without this, and with
  323. // another public transfer method, but it's just too much overhead.
  324. // These callbacks are supposed to be *fast*.
  325. //
  326. // The DBTs we receive in these callbacks from the C layer may be
  327. // manufactured there, but we want to treat them as a Dbts.
  328. // Technically speaking, these DBTs were not constructed as a Dbts,
  329. // but it should be safe to cast them as such given that Dbt is a
  330. // *very* thin extension of the DBT.  That is, Dbt has no additional
  331. // data elements, does not use virtual functions, virtual inheritance,
  332. // multiple inheritance, RTI, or any other language feature that
  333. // causes the structure to grow or be displaced.  Although this may
  334. // sound risky, a design goal of C++ is complete structure
  335. // compatibility with C, and has the philosophy 'if you don't use it,
  336. // you shouldn't incur the overhead'.  If the C/C++ compilers you're
  337. // using on a given machine do not have matching struct layouts, then
  338. // a lot more things will be broken than just this.
  339. //
  340. // The alternative, creating a Dbt here in the callback, and populating
  341. // it from the DBT, is just too slow and cumbersome to be very useful.
  342. // These macros avoid a lot of boilerplate code for callbacks
  343. #define DB_CALLBACK_C_INTERCEPT(_name, _rettype, _cargspec,
  344.     _return, _cxxargs)
  345. extern "C" _rettype _db_##_name##_intercept_c _cargspec
  346. {
  347. Db *cxxthis;
  348. DB_ASSERT(cthis != NULL);
  349. cxxthis = (Db *)cthis->api_internal;
  350. DB_ASSERT(cxxthis != NULL);
  351. DB_ASSERT(cxxthis->_name##_callback_ != 0);
  352. _return (*cxxthis->_name##_callback_) _cxxargs;
  353. }
  354. #define DB_SET_CALLBACK(_cxxname, _name, _cxxargspec, _cb)
  355. int Db::_cxxname _cxxargspec
  356. {
  357. DB *cthis = unwrap(this);
  358. _name##_callback_ = _cb;
  359. return ((*(cthis->_cxxname))(cthis,
  360.     (_cb) ? _db_##_name##_intercept_c : NULL));
  361. }
  362. /* associate callback - doesn't quite fit the pattern because of the flags */
  363. DB_CALLBACK_C_INTERCEPT(associate,
  364.     int, (DB *cthis, const DBT *key, const DBT *data, DBT *retval),
  365.     return, (cxxthis, Dbt::get_const_Dbt(key), Dbt::get_const_Dbt(data),
  366.     Dbt::get_Dbt(retval)))
  367. int Db::associate(DbTxn *txn, Db *secondary, int (*callback)(Db *, const Dbt *,
  368. const Dbt *, Dbt *), u_int32_t flags)
  369. {
  370. DB *cthis = unwrap(this);
  371. /* Since the secondary Db is used as the first argument
  372.  * to the callback, we store the C++ callback on it
  373.  * rather than on 'this'.
  374.  */
  375. secondary->associate_callback_ = callback;
  376. return ((*(cthis->associate))(cthis, unwrap(txn), unwrap(secondary),
  377.     (callback) ? _db_associate_intercept_c : NULL, flags));
  378. }
  379. DB_CALLBACK_C_INTERCEPT(feedback,
  380.     void, (DB *cthis, int opcode, int pct),
  381.     /* no return */ (void), (cxxthis, opcode, pct))
  382. DB_SET_CALLBACK(set_feedback, feedback,
  383.     (void (*arg)(Db *cxxthis, int opcode, int pct)), arg)
  384. DB_CALLBACK_C_INTERCEPT(append_recno,
  385.     int, (DB *cthis, DBT *data, db_recno_t recno),
  386.     return, (cxxthis, Dbt::get_Dbt(data), recno))
  387. DB_SET_CALLBACK(set_append_recno, append_recno,
  388.     (int (*arg)(Db *cxxthis, Dbt *data, db_recno_t recno)), arg)
  389. DB_CALLBACK_C_INTERCEPT(bt_compare,
  390.     int, (DB *cthis, const DBT *data1, const DBT *data2),
  391.     return,
  392.     (cxxthis, Dbt::get_const_Dbt(data1), Dbt::get_const_Dbt(data2)))
  393. DB_SET_CALLBACK(set_bt_compare, bt_compare,
  394.     (int (*arg)(Db *cxxthis, const Dbt *data1, const Dbt *data2)), arg)
  395. DB_CALLBACK_C_INTERCEPT(bt_prefix,
  396.     size_t, (DB *cthis, const DBT *data1, const DBT *data2),
  397.     return,
  398.     (cxxthis, Dbt::get_const_Dbt(data1), Dbt::get_const_Dbt(data2)))
  399. DB_SET_CALLBACK(set_bt_prefix, bt_prefix,
  400.     (size_t (*arg)(Db *cxxthis, const Dbt *data1, const Dbt *data2)), arg)
  401. DB_CALLBACK_C_INTERCEPT(dup_compare,
  402.     int, (DB *cthis, const DBT *data1, const DBT *data2),
  403.     return,
  404.     (cxxthis, Dbt::get_const_Dbt(data1), Dbt::get_const_Dbt(data2)))
  405. DB_SET_CALLBACK(set_dup_compare, dup_compare,
  406.     (int (*arg)(Db *cxxthis, const Dbt *data1, const Dbt *data2)), arg)
  407. DB_CALLBACK_C_INTERCEPT(h_hash,
  408.     u_int32_t, (DB *cthis, const void *data, u_int32_t len),
  409.     return, (cxxthis, data, len))
  410. DB_SET_CALLBACK(set_h_hash, h_hash,
  411.     (u_int32_t (*arg)(Db *cxxthis, const void *data, u_int32_t len)), arg)
  412. // This is a 'glue' function declared as extern "C" so it will
  413. // be compatible with picky compilers that do not allow mixing
  414. // of function pointers to 'C' functions with function pointers
  415. // to C++ functions.
  416. //
  417. extern "C"
  418. int _verify_callback_c(void *handle, const void *str_arg)
  419. {
  420. char *str;
  421. __DB_OSTREAMCLASS *out;
  422. str = (char *)str_arg;
  423. out = (__DB_OSTREAMCLASS *)handle;
  424. (*out) << str;
  425. if (out->fail())
  426. return (EIO);
  427. return (0);
  428. }
  429. int Db::verify(const char *name, const char *subdb,
  430.        __DB_OSTREAMCLASS *ostr, u_int32_t flags)
  431. {
  432. DB *db = unwrap(this);
  433. int ret;
  434. if (!db)
  435. ret = EINVAL;
  436. else
  437. ret = __db_verify_internal(db, name, subdb, ostr,
  438.     _verify_callback_c, flags);
  439. if (!DB_RETOK_STD(ret))
  440. DB_ERROR("Db::verify", ret, error_policy());
  441. return (ret);
  442. }
  443. DB_METHOD(set_bt_compare, (bt_compare_fcn_type func),
  444.     (db, func), DB_RETOK_STD)
  445. DB_METHOD(set_bt_maxkey, (u_int32_t bt_maxkey),
  446.     (db, bt_maxkey), DB_RETOK_STD)
  447. DB_METHOD(set_bt_minkey, (u_int32_t bt_minkey),
  448.     (db, bt_minkey), DB_RETOK_STD)
  449. DB_METHOD(set_bt_prefix, (bt_prefix_fcn_type func),
  450.     (db, func), DB_RETOK_STD)
  451. DB_METHOD(set_dup_compare, (dup_compare_fcn_type func),
  452.     (db, func), DB_RETOK_STD)
  453. DB_METHOD(set_encrypt, (const char *passwd, int flags),
  454.     (db, passwd, flags), DB_RETOK_STD)
  455. DB_METHOD_VOID(set_errfile, (FILE *errfile), (db, errfile))
  456. DB_METHOD_VOID(set_errpfx, (const char *errpfx), (db, errpfx))
  457. DB_METHOD(set_flags, (u_int32_t flags), (db, flags),
  458.     DB_RETOK_STD)
  459. DB_METHOD(set_h_ffactor, (u_int32_t h_ffactor),
  460.     (db, h_ffactor), DB_RETOK_STD)
  461. DB_METHOD(set_h_hash, (h_hash_fcn_type func),
  462.     (db, func), DB_RETOK_STD)
  463. DB_METHOD(set_h_nelem, (u_int32_t h_nelem),
  464.     (db, h_nelem), DB_RETOK_STD)
  465. DB_METHOD(set_lorder, (int db_lorder), (db, db_lorder),
  466.     DB_RETOK_STD)
  467. DB_METHOD(set_pagesize, (u_int32_t db_pagesize),
  468.     (db, db_pagesize), DB_RETOK_STD)
  469. DB_METHOD(set_re_delim, (int re_delim),
  470.     (db, re_delim), DB_RETOK_STD)
  471. DB_METHOD(set_re_len, (u_int32_t re_len),
  472.     (db, re_len), DB_RETOK_STD)
  473. DB_METHOD(set_re_pad, (int re_pad),
  474.     (db, re_pad), DB_RETOK_STD)
  475. DB_METHOD(set_re_source, (char *re_source),
  476.     (db, re_source), DB_RETOK_STD)
  477. DB_METHOD(set_q_extentsize, (u_int32_t extentsize),
  478.     (db, extentsize), DB_RETOK_STD)
  479. DB_METHOD_QUIET(set_alloc, (db_malloc_fcn_type malloc_fcn,
  480.     db_realloc_fcn_type realloc_fcn, db_free_fcn_type free_fcn),
  481.     (db, malloc_fcn, realloc_fcn, free_fcn))
  482. void Db::set_errcall(void (*arg)(const char *, char *))
  483. {
  484. env_->set_errcall(arg);
  485. }
  486. void *Db::get_app_private() const
  487. {
  488. return unwrapConst(this)->app_private;
  489. }
  490. void Db::set_app_private(void *value)
  491. {
  492. unwrap(this)->app_private = value;
  493. }
  494. DB_METHOD(set_cachesize, (u_int32_t gbytes, u_int32_t bytes, int ncache),
  495.     (db, gbytes, bytes, ncache), DB_RETOK_STD)
  496. DB_METHOD(set_cache_priority, (DB_CACHE_PRIORITY priority),
  497.     (db, priority), DB_RETOK_STD)
  498. int Db::set_paniccall(void (*callback)(DbEnv *, int))
  499. {
  500. return (env_->set_paniccall(callback));
  501. }
  502. void Db::set_error_stream(__DB_OSTREAMCLASS *error_stream)
  503. {
  504. env_->set_error_stream(error_stream);
  505. }