开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
cxx_table.cpp
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：19k
源码类别：

MySQL数据库

开发平台：

Visual C++

cxx_table.cpp：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1997, 1998, 1999, 2000
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  8. #include "db_config.h"
  10. #ifndef lint
  11. static const char revid[] = "$Id: cxx_table.cpp,v 11.35 2001/01/11 18:19:49 bostic Exp $";
  12. #endif /* not lint */
  14. #include <errno.h>
  15. #include <string.h>
  17. #include "db_cxx.h"
  18. #include "cxx_int.h"
  20. #include "db_int.h"
  21. #include "db_page.h"
  22. #include "db_ext.h"
  23. #include "common_ext.h"
  25. ////////////////////////////////////////////////////////////////////////
  26. //                                                                    //
  27. //                            Db                                      //
  28. //                                                                    //
  29. ////////////////////////////////////////////////////////////////////////
  31. // A truism for the DbEnv object is that there is a valid
  32. // DB_ENV handle from the constructor until close().
  33. // After the close, the DB handle is invalid and
  34. // no operations are permitted on the Db (other than
  35. // destructor).  Leaving the Db handle open and not
  36. // doing a close is generally considered an error.
  37. //
  38. // We used to allow Db objects to be closed and reopened.
  39. // This implied always keeping a valid DB object, and
  40. // coordinating the open objects between Db/DbEnv turned
  41. // out to be overly complicated.  Now we do not allow this.
  43. Db::Db(DbEnv *env, u_int32_t flags)
  44. : imp_(0)
  45. , env_(env)
  46. , construct_error_(0)
  47. , flags_(0)
  48. , construct_flags_(flags)
  49. {
  50. if (env_ == 0)
  51. flags_ |= DB_CXX_PRIVATE_ENV;
  52. initialize();
  53. }
  55. // Note: if the user has not closed, we call _destroy_check
  56. // to warn against this non-safe programming practice.
  57. // We can't close, because the environment may already
  58. // be closed/destroyed.
  59. //
  60. Db::~Db()
  61. {
  62. DB *db;
  64. db = unwrap(this);
  65. if (db != NULL) {
  66. DbEnv::_destroy_check("Db", 0);
  67. cleanup();
  68. }
  69. }
  71. // private method to initialize during constructor.
  72. // initialize must create a backing DB object,
  73. // and if that creates a new DB_ENV, it must be tied to a new DbEnv.
  74. // If there is an error, construct_error_ is set; this is examined
  75. // during open.
  76. //
  77. int Db::initialize()
  78. {
  79. u_int32_t cxx_flags;
  80. DB *db;
  81. int err;
  82. DB_ENV *cenv = unwrap(env_);
  84. cxx_flags = construct_flags_ & DB_CXX_NO_EXCEPTIONS;
  86. // Create a new underlying DB object.
  87. // We rely on the fact that if a NULL DB_ENV* is given,
  88. // one is allocated by DB.
  89. //
  90. if ((err = db_create(&db, cenv,
  91.      construct_flags_ & ~cxx_flags)) != 0) {
  92. construct_error_ = err;
  93. return (err);
  94. }
  96. // Associate the DB with this object
  97. imp_ = wrap(db);
  98. db->cj_internal = this;
  100. // Create a new DbEnv from a DB_ENV* if it was created locally.
  101. // It is deleted in Db::close().
  102. //
  103. if ((flags_ & DB_CXX_PRIVATE_ENV) != 0)
  104. env_ = new DbEnv(db->dbenv, cxx_flags);
  106. return (0);
  107. }
  109. // private method to cleanup after destructor or during close.
  110. // If the environment was created by this Db object, we optionally
  111. // delete it, or return it so the caller can delete it after
  112. // last use.
  113. //
  114. void Db::cleanup()
  115. {
  116. DB *db = unwrap(this);
  118. if (db != NULL) {
  119. // extra safety
  120. db->cj_internal = 0;
  121. imp_ = 0;
  123. // we must dispose of the DbEnv object if
  124. // we created it.  This will be the case
  125. // if a NULL DbEnv was passed into the constructor.
  126. // The underlying DB_ENV object will be inaccessible
  127. // after the close, so we must clean it up now.
  128. //
  129. if ((flags_ & DB_CXX_PRIVATE_ENV) != 0) {
  130. env_->cleanup();
  131. delete env_;
  132. env_ = 0;
  133. }
  134. }
  135. construct_error_ = 0;
  136. }
  138. // Return a tristate value corresponding to whether we should
  139. // throw exceptions on errors:
  140. //   ON_ERROR_RETURN
  141. //   ON_ERROR_THROW
  142. //   ON_ERROR_UNKNOWN
  143. //
  144. int Db::error_policy()
  145. {
  146. if (env_ != NULL)
  147. return (env_->error_policy());
  148. else {
  149. // If the env_ is null, that means that the user
  150. // did not attach an environment, so the correct error
  151. // policy can be deduced from constructor flags
  152. // for this Db.
  153. //
  154. if ((construct_flags_ & DB_CXX_NO_EXCEPTIONS) != 0) {
  155. return (ON_ERROR_RETURN);
  156. }
  157. else {
  158. return (ON_ERROR_THROW);
  159. }
  160. }
  161. }
  163. int Db::close(u_int32_t flags)
  164. {
  165. DB *db = unwrap(this);
  166. int err;
  168. // after a DB->close (no matter if success or failure),
  169. // the underlying DB object must not be accessed,
  170. // so we clean up in advance.
  171. //
  172. cleanup();
  174. // It's safe to throw an error after the close,
  175. // since our error mechanism does not peer into
  176. // the DB* structures.
  177. //
  178. if ((err = db->close(db, flags)) != 0 && err != DB_INCOMPLETE)
  179. DB_ERROR("Db::close", err, error_policy());
  181. return (err);
  182. }
  184. int Db::cursor(DbTxn *txnid, Dbc **cursorp, u_int32_t flags)
  185. {
  186. DB *db = unwrap(this);
  187. DBC *dbc = 0;
  188. int err;
  190. if ((err = db->cursor(db, unwrap(txnid), &dbc, flags)) != 0) {
  191. DB_ERROR("Db::cursor", err, error_policy());
  192. return (err);
  193. }
  195. // The following cast implies that Dbc can be no larger than DBC
  196. *cursorp = (Dbc*)dbc;
  197. return (0);
  198. }
  200. int Db::del(DbTxn *txnid, Dbt *key, u_int32_t flags)
  201. {
  202. DB *db = unwrap(this);
  203. int err;
  205. if ((err = db->del(db, unwrap(txnid), key, flags)) != 0) {
  206. // DB_NOTFOUND is a "normal" return, so should not be
  207. // thrown as an error
  208. //
  209. if (err != DB_NOTFOUND) {
  210. DB_ERROR("Db::del", err, error_policy());
  211. return (err);
  212. }
  213. }
  214. return (err);
  215. }
  217. void Db::err(int error, const char *format, ...)
  218. {
  219. va_list args;
  220. DB *db = unwrap(this);
  222. va_start(args, format);
  223. __db_real_err(db->dbenv, error, 1, 1, format, args);
  224. va_end(args);
  225. }
  227. void Db::errx(const char *format, ...)
  228. {
  229. va_list args;
  230. DB *db = unwrap(this);
  232. va_start(args, format);
  233. __db_real_err(db->dbenv, 0, 0, 1, format, args);
  234. va_end(args);
  235. }
  237. int Db::fd(int *fdp)
  238. {
  239. DB *db = unwrap(this);
  240. int err;
  242. if ((err = db->fd(db, fdp)) != 0) {
  243. DB_ERROR("Db::fd", err, error_policy());
  244. return (err);
  245. }
  246. return (0);
  247. }
  249. // This is a 'glue' function declared as extern "C" so it will
  250. // be compatible with picky compilers that do not allow mixing
  251. // of function pointers to 'C' functions with function pointers
  252. // to C++ functions.
  253. //
  254. extern "C"
  255. void _db_feedback_intercept_c(DB *db, int opcode, int pct)
  256. {
  257. Db::_feedback_intercept(db, opcode, pct);
  258. }
  260. //static
  261. void Db::_feedback_intercept(DB *db, int opcode, int pct)
  262. {
  263. if (db == 0) {
  264. DB_ERROR("Db::feedback_callback", EINVAL, ON_ERROR_UNKNOWN);
  265. return;
  266. }
  267. Db *cxxdb = (Db *)db->cj_internal;
  268. if (cxxdb == 0) {
  269. DB_ERROR("Db::feedback_callback", EINVAL, ON_ERROR_UNKNOWN);
  270. return;
  271. }
  272. if (cxxdb->feedback_callback_ == 0) {
  273. DB_ERROR("Db::feedback_callback", EINVAL, cxxdb->error_policy());
  274. return;
  275. }
  276. (*cxxdb->feedback_callback_)(cxxdb, opcode, pct);
  277. }
  279. int Db::set_feedback(void (*arg)(Db *, int, int))
  280. {
  281. DB *db = unwrap(this);
  283. feedback_callback_ = arg;
  285. return ((*(db->set_feedback))(db, _db_feedback_intercept_c));
  286. }
  288. // This is a 'glue' function declared as extern "C" so it will
  289. // be compatible with picky compilers that do not allow mixing
  290. // of function pointers to 'C' functions with function pointers
  291. // to C++ functions.
  292. //
  293. extern "C"
  294. int _db_append_recno_intercept_c(DB *db, DBT *data, db_recno_t recno)
  295. {
  296. return (Db::_append_recno_intercept(db, data, recno));
  297. }
  299. //static
  300. int Db::_append_recno_intercept(DB *db, DBT *data, db_recno_t recno)
  301. {
  302. int err;
  304. if (db == 0) {
  305. DB_ERROR("Db::append_recno_callback", EINVAL, ON_ERROR_UNKNOWN);
  306. return (EINVAL);
  307. }
  308. Db *cxxdb = (Db *)db->cj_internal;
  309. if (cxxdb == 0) {
  310. DB_ERROR("Db::append_recno_callback", EINVAL, ON_ERROR_UNKNOWN);
  311. return (EINVAL);
  312. }
  313. if (cxxdb->append_recno_callback_ == 0) {
  314. DB_ERROR("Db::append_recno_callback", EINVAL, cxxdb->error_policy());
  315. return (EINVAL);
  316. }
  318. // making these copies is slow but portable.
  319. // Another alternative is to cast the DBT* manufactured
  320. // by the C layer to a Dbt*.  It 'should be' safe since
  321. // Dbt is a thin shell over DBT, adding no extra data,
  322. // but is nonportable, and could lead to errors if anything
  323. // were added to the Dbt class.
  324. //
  325. Dbt cxxdbt;
  326. memcpy((DBT *)&cxxdbt, data, sizeof(DBT));
  327. err = (*cxxdb->append_recno_callback_)(cxxdb, &cxxdbt, recno);
  328. memcpy(data, (DBT *)&cxxdbt, sizeof(DBT));
  329. return (err);
  330. }
  332. int Db::set_append_recno(int (*arg)(Db *, Dbt *, db_recno_t))
  333. {
  334. DB *db = unwrap(this);
  336. append_recno_callback_ = arg;
  338. return ((*(db->set_append_recno))(db, _db_append_recno_intercept_c));
  339. }
  341. int Db::get(DbTxn *txnid, Dbt *key, Dbt *value, u_int32_t flags)
  342. {
  343. DB *db = unwrap(this);
  344. int err;
  346. if ((err = db->get(db, unwrap(txnid), key, value, flags)) != 0) {
  347. // DB_NOTFOUND and DB_KEYEMPTY are "normal" returns,
  348. // so should not be thrown as an error
  349. //
  350. if (err != DB_NOTFOUND && err != DB_KEYEMPTY) {
  351. DB_ERROR("Db::get", err, error_policy());
  352. return (err);
  353. }
  354. }
  355. return (err);
  356. }
  358. int Db::get_byteswapped() const
  359. {
  360. DB *db = (DB *)unwrapConst(this);
  361. return (db->get_byteswapped(db));
  362. }
  364. DBTYPE Db::get_type() const
  365. {
  366. DB *db = (DB *)unwrapConst(this);
  367. return ((DBTYPE)db->get_type(db));
  368. }
  370. int Db::join(Dbc **curslist, Dbc **cursorp, u_int32_t flags)
  371. {
  372. // Dbc is a "compatible" subclass of DBC -
  373. // that is, no virtual functions or even extra data members,
  374. // so this cast, although technically non-portable,
  375. // "should" always be okay.
  376. //
  377. DBC **list = (DBC **)(curslist);
  378. DB *db = unwrap(this);
  379. DBC *dbc = 0;
  380. int err;
  382. if ((err = db->join(db, list, &dbc, flags)) != 0) {
  383. DB_ERROR("Db::join_cursor", err, error_policy());
  384. return (err);
  385. }
  386. *cursorp = (Dbc*)dbc;
  387. return (0);
  388. }
  390. int Db::key_range(DbTxn *txnid, Dbt *key,
  391.   DB_KEY_RANGE *results, u_int32_t flags)
  392. {
  393. DB *db = unwrap(this);
  394. int err;
  396. if ((err = db->key_range(db, unwrap(txnid), key,
  397.  results, flags)) != 0) {
  398. DB_ERROR("Db::key_range", err, error_policy());
  399. return (err);
  400. }
  401. return (0);
  402. }
  404. // If an error occurred during the constructor, report it now.
  405. // Otherwise, call the underlying DB->open method.
  406. //
  407. int Db::open(const char *file, const char *database,
  408.      DBTYPE type, u_int32_t flags, int mode)
  409. {
  410. int err;
  411. DB *db = unwrap(this);
  413. if ((err = construct_error_) != 0)
  414. DB_ERROR("Db::open", construct_error_, error_policy());
  415. else if ((err = db->open(db, file, database, type, flags, mode)) != 0)
  416. DB_ERROR("Db::open", err, error_policy());
  418. return (err);
  419. }
  421. int Db::put(DbTxn *txnid, Dbt *key, Dbt *value, u_int32_t flags)
  422. {
  423. int err;
  424. DB *db = unwrap(this);
  426. if ((err = db->put(db, unwrap(txnid), key, value, flags)) != 0) {
  428. // DB_KEYEXIST is a "normal" return, so should not be
  429. // thrown as an error
  430. //
  431. if (err != DB_KEYEXIST) {
  432. DB_ERROR("Db::put", err, error_policy());
  433. return (err);
  434. }
  435. }
  436. return (err);
  437. }
  439. int Db::rename(const char *file, const char *database,
  440.        const char *newname, u_int32_t flags)
  441. {
  442. int err = 0;
  443. DB *db = unwrap(this);
  445. if (!db) {
  446. DB_ERROR("Db::rename", EINVAL, error_policy());
  447. return (EINVAL);
  448. }
  450. // after a DB->rename (no matter if success or failure),
  451. // the underlying DB object must not be accessed,
  452. // so we clean up in advance.
  453. //
  454. cleanup();
  456. if ((err = db->rename(db, file, database, newname, flags)) != 0) {
  457. DB_ERROR("Db::rename", err, error_policy());
  458. return (err);
  459. }
  460. return (0);
  461. }
  463. int Db::remove(const char *file, const char *database, u_int32_t flags)
  464. {
  465. int err = 0;
  466. DB *db = unwrap(this);
  468. if (!db) {
  469. DB_ERROR("Db::remove", EINVAL, error_policy());
  470. return (EINVAL);
  471. }
  473. // after a DB->remove (no matter if success or failure),
  474. // the underlying DB object must not be accessed,
  475. // so we clean up in advance.
  476. //
  477. cleanup();
  479. if ((err = db->remove(db, file, database, flags)) != 0)
  480. DB_ERROR("Db::remove", err, error_policy());
  482. return (err);
  483. }
  485. int Db::stat(void *sp, db_malloc_fcn_type db_malloc_fcn, u_int32_t flags)
  486. {
  487. int err;
  488. DB *db = unwrap(this);
  490. if (!db) {
  491. DB_ERROR("Db::stat", EINVAL, error_policy());
  492. return (EINVAL);
  493. }
  494. if ((err = db->stat(db, sp, db_malloc_fcn, flags)) != 0) {
  495. DB_ERROR("Db::stat", err, error_policy());
  496. return (err);
  497. }
  498. return (0);
  499. }
  501. int Db::sync(u_int32_t flags)
  502. {
  503. int err;
  504. DB *db = unwrap(this);
  506. if (!db) {
  507. DB_ERROR("Db::sync", EINVAL, error_policy());
  508. return (EINVAL);
  509. }
  510. if ((err = db->sync(db, flags)) != 0 && err != DB_INCOMPLETE) {
  511. DB_ERROR("Db::sync", err, error_policy());
  512. return (err);
  513. }
  514. return (err);
  515. }
  517. int Db::upgrade(const char *name, u_int32_t flags)
  518. {
  519. int err;
  520. DB *db = unwrap(this);
  522. if (!db) {
  523. DB_ERROR("Db::upgrade", EINVAL, error_policy());
  524. return (EINVAL);
  525. }
  526. if ((err = db->upgrade(db, name, flags)) != 0) {
  527. DB_ERROR("Db::upgrade", err, error_policy());
  528. return (err);
  529. }
  530. return (0);
  531. }
  533. static int _verify_callback_cxx(void *handle, const void *str_arg)
  534. {
  535. char *str;
  536. ostream *out;
  538. str = (char *)str_arg;
  539. out = (ostream *)handle;
  541. (*out) << str;
  542. if (out->fail())
  543. return (EIO);
  545. return (0);
  546. }
  548. // This is a 'glue' function declared as extern "C" so it will
  549. // be compatible with picky compilers that do not allow mixing
  550. // of function pointers to 'C' functions with function pointers
  551. // to C++ functions.
  552. //
  553. extern "C"
  554. int _verify_callback_c(void *handle, const void *str_arg)
  555. {
  556. return (_verify_callback_cxx(handle, str_arg));
  557. }
  559. int Db::verify(const char *name, const char *subdb,
  560.        ostream *ostr, u_int32_t flags)
  561. {
  562. int err;
  563. DB *db = unwrap(this);
  565. if (!db) {
  566. DB_ERROR("Db::verify", EINVAL, error_policy());
  567. return (EINVAL);
  568. }
  569. if ((err = __db_verify_internal(db, name, subdb, ostr,
  570. _verify_callback_c, flags)) != 0) {
  571. DB_ERROR("Db::verify", err, error_policy());
  572. return (err);
  573. }
  574. return (0);
  575. }
  577. // This is a variant of the DB_WO_ACCESS macro to define a simple set_
  578. // method calling the underlying C method, but unlike a simple
  579. // set method, it may return an error or raise an exception.
  580. // Note this macro expects that input _argspec is an argument
  581. // list element (e.g. "char *arg") defined in terms of "arg".
  582. //
  583. #define DB_DB_ACCESS(_name, _argspec)                          
  585. int Db::set_##_name(_argspec)                                  
  586. {                                                              
  587. int ret;                                               
  588. DB *db = unwrap(this);                                 
  589.        
  590. if ((ret = (*(db->set_##_name))(db, arg)) != 0) {      
  591. DB_ERROR("Db::set_" # _name, ret, error_policy()); 
  592. }                                                      
  593. return (ret);                                          
  594. }
  596. #define DB_DB_ACCESS_NORET(_name, _argspec)                    
  597.        
  598. void Db::set_##_name(_argspec)                                 
  599. {                                                              
  600. DB *db = unwrap(this);                                 
  601.        
  602. (*(db->set_##_name))(db, arg);                         
  603. return;                                                
  604. }
  606. DB_DB_ACCESS(bt_compare, bt_compare_fcn_type arg)
  607. DB_DB_ACCESS(bt_maxkey, u_int32_t arg)
  608. DB_DB_ACCESS(bt_minkey, u_int32_t arg)
  609. DB_DB_ACCESS(bt_prefix, bt_prefix_fcn_type arg)
  610. DB_DB_ACCESS(dup_compare, dup_compare_fcn_type arg)
  611. DB_DB_ACCESS_NORET(errfile, FILE *arg)
  612. DB_DB_ACCESS_NORET(errpfx, const char *arg)
  613. DB_DB_ACCESS(flags, u_int32_t arg)
  614. DB_DB_ACCESS(h_ffactor, u_int32_t arg)
  615. DB_DB_ACCESS(h_hash, h_hash_fcn_type arg)
  616. DB_DB_ACCESS(h_nelem, u_int32_t arg)
  617. DB_DB_ACCESS(lorder, int arg)
  618. DB_DB_ACCESS(malloc, db_malloc_fcn_type arg)
  619. DB_DB_ACCESS(pagesize, u_int32_t arg)
  620. DB_DB_ACCESS(realloc, db_realloc_fcn_type arg)
  621. DB_DB_ACCESS(re_delim, int arg)
  622. DB_DB_ACCESS(re_len, u_int32_t arg)
  623. DB_DB_ACCESS(re_pad, int arg)
  624. DB_DB_ACCESS(re_source, char *arg)
  625. DB_DB_ACCESS(q_extentsize, u_int32_t arg)
  627. // Here are the set methods that don't fit the above mold.
  628. //
  630. void Db::set_errcall(void (*arg)(const char *, char *))
  631. {
  632. env_->set_errcall(arg);
  633. }
  635. int Db::set_cachesize(u_int32_t gbytes, u_int32_t bytes, int ncache)
  636. {
  637. int ret;
  638. DB *db = unwrap(this);
  640. if ((ret = (*(db->set_cachesize))(db, gbytes, bytes, ncache)) != 0) {
  641. DB_ERROR("Db::set_cachesize", ret, error_policy());
  642. }
  643. return (ret);
  644. }
  646. int Db::set_paniccall(void (*callback)(DbEnv *, int))
  647. {
  648. return (env_->set_paniccall(callback));
  649. }
  651. void Db::set_error_stream(ostream *error_stream)
  652. {
  653. env_->set_error_stream(error_stream);
  654. }
  656. ////////////////////////////////////////////////////////////////////////
  657. //                                                                    //
  658. //                            Dbc                                     //
  659. //                                                                    //
  660. ////////////////////////////////////////////////////////////////////////
  662. // It's private, and should never be called, but VC4.0 needs it resolved
  663. //
  664. Dbc::~Dbc()
  665. {
  666. }
  668. int Dbc::close()
  669. {
  670. DBC *cursor = this;
  671. int err;
  673. if ((err = cursor->c_close(cursor)) != 0) {
  674. DB_ERROR("Db::close", err, ON_ERROR_UNKNOWN);
  675. return (err);
  676. }
  677. return (0);
  678. }
  680. int Dbc::count(db_recno_t *countp, u_int32_t flags_arg)
  681. {
  682. DBC *cursor = this;
  683. int err;
  685. if ((err = cursor->c_count(cursor, countp, flags_arg)) != 0) {
  686. DB_ERROR("Db::count", err, ON_ERROR_UNKNOWN);
  687. return (err);
  688. }
  689. return (0);
  690. }
  692. int Dbc::del(u_int32_t flags_arg)
  693. {
  694. DBC *cursor = this;
  695. int err;
  697. if ((err = cursor->c_del(cursor, flags_arg)) != 0) {
  699. // DB_KEYEMPTY is a "normal" return, so should not be
  700. // thrown as an error
  701. //
  702. if (err != DB_KEYEMPTY) {
  703. DB_ERROR("Db::del", err, ON_ERROR_UNKNOWN);
  704. return (err);
  705. }
  706. }
  707. return (err);
  708. }
  710. int Dbc::dup(Dbc** cursorp, u_int32_t flags_arg)
  711. {
  712. DBC *cursor = this;
  713. DBC *new_cursor = 0;
  714. int err;
  716. if ((err = cursor->c_dup(cursor, &new_cursor, flags_arg)) != 0) {
  717. DB_ERROR("Db::dup", err, ON_ERROR_UNKNOWN);
  718. return (err);
  719. }
  721. // The following cast implies that Dbc can be no larger than DBC
  722. *cursorp = (Dbc*)new_cursor;
  723. return (0);
  724. }
  726. int Dbc::get(Dbt* key, Dbt *data, u_int32_t flags_arg)
  727. {
  728. DBC *cursor = this;
  729. int err;
  731. if ((err = cursor->c_get(cursor, key, data, flags_arg)) != 0) {
  733. // DB_NOTFOUND and DB_KEYEMPTY are "normal" returns,
  734. // so should not be thrown as an error
  735. //
  736. if (err != DB_NOTFOUND && err != DB_KEYEMPTY) {
  737. DB_ERROR("Db::get", err, ON_ERROR_UNKNOWN);
  738. return (err);
  739. }
  740. }
  741. return (err);
  742. }
  744. int Dbc::put(Dbt* key, Dbt *data, u_int32_t flags_arg)
  745. {
  746. DBC *cursor = this;
  747. int err;
  749. if ((err = cursor->c_put(cursor, key, data, flags_arg)) != 0) {
  751. // DB_KEYEXIST is a "normal" return, so should not be
  752. // thrown as an error
  753. //
  754. if (err != DB_KEYEXIST) {
  755. DB_ERROR("Db::put", err, ON_ERROR_UNKNOWN);
  756. return (err);
  757. }
  758. }
  759. return (err);
  760. }
  762. ////////////////////////////////////////////////////////////////////////
  763. //                                                                    //
  764. //                            Dbt                                 //
  765. //                                                                    //
  766. ////////////////////////////////////////////////////////////////////////
  768. Dbt::Dbt()
  769. {
  770. DBT *dbt = this;
  771. memset(dbt, 0, sizeof(DBT));
  772. }
  774. Dbt::Dbt(void *data_arg, size_t size_arg)
  775. {
  776. DBT *dbt = this;
  777. memset(dbt, 0, sizeof(DBT));
  778. set_data(data_arg);
  779. set_size(size_arg);
  780. }
  782. Dbt::~Dbt()
  783. {
  784. }
  786. Dbt::Dbt(const Dbt &that)
  787. {
  788. const DBT *from = &that;
  789. DBT *to = this;
  790. memcpy(to, from, sizeof(DBT));
  791. }
  793. Dbt &Dbt::operator = (const Dbt &that)
  794. {
  795. if (this != &that) {
  796. const DBT *from = &that;
  797. DBT *to = this;
  798. memcpy(to, from, sizeof(DBT));
  799. }
  800. return (*this);
  801. }
  803. DB_RW_ACCESS(Dbt, void *, data, data)
  804. DB_RW_ACCESS(Dbt, u_int32_t, size, size)
  805. DB_RW_ACCESS(Dbt, u_int32_t, ulen, ulen)
  806. DB_RW_ACCESS(Dbt, u_int32_t, dlen, dlen)
  807. DB_RW_ACCESS(Dbt, u_int32_t, doff, doff)
  808. DB_RW_ACCESS(Dbt, u_int32_t, flags, flags)