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

MySQL数据库

开发平台:

Visual C++

  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 2000-2002
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  7. #include "db_config.h"
  8. #ifndef lint
  9. static const char revid[] = "$Id: db_cam.c,v 11.114 2002/09/03 15:44:46 krinsky Exp $";
  10. #endif /* not lint */
  11. #ifndef NO_SYSTEM_INCLUDES
  12. #include <sys/types.h>
  13. #include <string.h>
  14. #endif
  15. #include "db_int.h"
  16. #include "dbinc/db_page.h"
  17. #include "dbinc/db_shash.h"
  18. #include "dbinc/btree.h"
  19. #include "dbinc/hash.h"
  20. #include "dbinc/lock.h"
  21. #include "dbinc/log.h"
  22. #include "dbinc/qam.h"
  23. static int __db_buildpartial __P((DB *, DBT *, DBT *, DBT *));
  24. static int __db_c_cleanup __P((DBC *, DBC *, int));
  25. static int __db_c_del_secondary __P((DBC *));
  26. static int __db_c_pget_recno __P((DBC *, DBT *, DBT *, u_int32_t));
  27. static int __db_wrlock_err __P((DB_ENV *));
  28. #define CDB_LOCKING_INIT(dbp, dbc)
  29. /*
  30.  * If we are running CDB, this had better be either a write
  31.  * cursor or an immediate writer.  If it's a regular writer,
  32.  * that means we have an IWRITE lock and we need to upgrade
  33.  * it to a write lock.
  34.  */
  35. if (CDB_LOCKING((dbp)->dbenv)) {
  36. if (!F_ISSET(dbc, DBC_WRITECURSOR | DBC_WRITER))
  37. return (__db_wrlock_err(dbp->dbenv));
  38. if (F_ISSET(dbc, DBC_WRITECURSOR) &&
  39.     (ret = (dbp)->dbenv->lock_get((dbp)->dbenv,
  40.     (dbc)->locker, DB_LOCK_UPGRADE, &(dbc)->lock_dbt,
  41.     DB_LOCK_WRITE, &(dbc)->mylock)) != 0)
  42. return (ret);
  43. }
  44. #define CDB_LOCKING_DONE(dbp, dbc)
  45. /* Release the upgraded lock. */
  46. if (F_ISSET(dbc, DBC_WRITECURSOR))
  47. (void)__lock_downgrade(
  48.     (dbp)->dbenv, &(dbc)->mylock, DB_LOCK_IWRITE, 0);
  49. /*
  50.  * Copy the lock info from one cursor to another, so that locking
  51.  * in CDB can be done in the context of an internally-duplicated
  52.  * or off-page-duplicate cursor.
  53.  */
  54. #define CDB_LOCKING_COPY(dbp, dbc_o, dbc_n)
  55. if (CDB_LOCKING((dbp)->dbenv) &&
  56.     F_ISSET((dbc_o), DBC_WRITECURSOR | DBC_WRITEDUP)) { 
  57. memcpy(&(dbc_n)->mylock, &(dbc_o)->mylock,
  58.     sizeof((dbc_o)->mylock));
  59. /* This lock isn't ours to put--just discard it on close. */ 
  60. F_SET((dbc_n), DBC_WRITEDUP);
  61. }
  62. /*
  63.  * __db_c_close --
  64.  * Close the cursor.
  65.  *
  66.  * PUBLIC: int __db_c_close __P((DBC *));
  67.  */
  68. int
  69. __db_c_close(dbc)
  70. DBC *dbc;
  71. {
  72. DB *dbp;
  73. DBC *opd;
  74. DBC_INTERNAL *cp;
  75. DB_ENV *dbenv;
  76. int ret, t_ret;
  77. dbp = dbc->dbp;
  78. dbenv = dbp->dbenv;
  79. ret = 0;
  80. PANIC_CHECK(dbenv);
  81. /*
  82.  * If the cursor is already closed we have a serious problem, and we
  83.  * assume that the cursor isn't on the active queue.  Don't do any of
  84.  * the remaining cursor close processing.
  85.  */
  86. if (!F_ISSET(dbc, DBC_ACTIVE)) {
  87. if (dbp != NULL)
  88. __db_err(dbenv, "Closing already-closed cursor");
  89. DB_ASSERT(0);
  90. return (EINVAL);
  91. }
  92. cp = dbc->internal;
  93. opd = cp->opd;
  94. /*
  95.  * Remove the cursor(s) from the active queue.  We may be closing two
  96.  * cursors at once here, a top-level one and a lower-level, off-page
  97.  * duplicate one.  The acess-method specific cursor close routine must
  98.  * close both of them in a single call.
  99.  *
  100.  * !!!
  101.  * Cursors must be removed from the active queue before calling the
  102.  * access specific cursor close routine, btree depends on having that
  103.  * order of operations.
  104.  */
  105. MUTEX_THREAD_LOCK(dbenv, dbp->mutexp);
  106. if (opd != NULL) {
  107. F_CLR(opd, DBC_ACTIVE);
  108. TAILQ_REMOVE(&dbp->active_queue, opd, links);
  109. }
  110. F_CLR(dbc, DBC_ACTIVE);
  111. TAILQ_REMOVE(&dbp->active_queue, dbc, links);
  112. MUTEX_THREAD_UNLOCK(dbenv, dbp->mutexp);
  113. /* Call the access specific cursor close routine. */
  114. if ((t_ret =
  115.     dbc->c_am_close(dbc, PGNO_INVALID, NULL)) != 0 && ret == 0)
  116. ret = t_ret;
  117. /*
  118.  * Release the lock after calling the access method specific close
  119.  * routine, a Btree cursor may have had pending deletes.
  120.  */
  121. if (CDB_LOCKING(dbenv)) {
  122. /*
  123.  * If DBC_WRITEDUP is set, the cursor is an internally
  124.  * duplicated write cursor and the lock isn't ours to put.
  125.  *
  126.  * Also, be sure not to free anything if mylock.off is
  127.  * INVALID;  in some cases, such as idup'ed read cursors
  128.  * and secondary update cursors, a cursor in a CDB
  129.  * environment may not have a lock at all.
  130.  */
  131. if (!F_ISSET(dbc, DBC_WRITEDUP) && LOCK_ISSET(dbc->mylock)) {
  132. if ((t_ret = dbenv->lock_put(
  133.     dbenv, &dbc->mylock)) != 0 && ret == 0)
  134. ret = t_ret;
  135. }
  136. /* For safety's sake, since this is going on the free queue. */
  137. memset(&dbc->mylock, 0, sizeof(dbc->mylock));
  138. F_CLR(dbc, DBC_WRITEDUP);
  139. }
  140. if (dbc->txn != NULL)
  141. dbc->txn->cursors--;
  142. /* Move the cursor(s) to the free queue. */
  143. MUTEX_THREAD_LOCK(dbenv, dbp->mutexp);
  144. if (opd != NULL) {
  145. if (dbc->txn != NULL)
  146. dbc->txn->cursors--;
  147. TAILQ_INSERT_TAIL(&dbp->free_queue, opd, links);
  148. opd = NULL;
  149. }
  150. TAILQ_INSERT_TAIL(&dbp->free_queue, dbc, links);
  151. MUTEX_THREAD_UNLOCK(dbenv, dbp->mutexp);
  152. return (ret);
  153. }
  154. /*
  155.  * __db_c_destroy --
  156.  * Destroy the cursor, called after DBC->c_close.
  157.  *
  158.  * PUBLIC: int __db_c_destroy __P((DBC *));
  159.  */
  160. int
  161. __db_c_destroy(dbc)
  162. DBC *dbc;
  163. {
  164. DB *dbp;
  165. DB_ENV *dbenv;
  166. int ret, t_ret;
  167. dbp = dbc->dbp;
  168. dbenv = dbp->dbenv;
  169. /* Remove the cursor from the free queue. */
  170. MUTEX_THREAD_LOCK(dbenv, dbp->mutexp);
  171. TAILQ_REMOVE(&dbp->free_queue, dbc, links);
  172. MUTEX_THREAD_UNLOCK(dbenv, dbp->mutexp);
  173. /* Free up allocated memory. */
  174. if (dbc->my_rskey.data != NULL)
  175. __os_free(dbenv, dbc->my_rskey.data);
  176. if (dbc->my_rkey.data != NULL)
  177. __os_free(dbenv, dbc->my_rkey.data);
  178. if (dbc->my_rdata.data != NULL)
  179. __os_free(dbenv, dbc->my_rdata.data);
  180. /* Call the access specific cursor destroy routine. */
  181. ret = dbc->c_am_destroy == NULL ? 0 : dbc->c_am_destroy(dbc);
  182. /*
  183.  * Release the lock id for this cursor.
  184.  */
  185. if (LOCKING_ON(dbenv) &&
  186.     F_ISSET(dbc, DBC_OWN_LID) &&
  187.     (t_ret = dbenv->lock_id_free(dbenv, dbc->lid)) != 0 && ret == 0)
  188. ret = t_ret;
  189. __os_free(dbenv, dbc);
  190. return (ret);
  191. }
  192. /*
  193.  * __db_c_count --
  194.  * Return a count of duplicate data items.
  195.  *
  196.  * PUBLIC: int __db_c_count __P((DBC *, db_recno_t *, u_int32_t));
  197.  */
  198. int
  199. __db_c_count(dbc, recnop, flags)
  200. DBC *dbc;
  201. db_recno_t *recnop;
  202. u_int32_t flags;
  203. {
  204. DB *dbp;
  205. int ret;
  206. /*
  207.  * Cursor Cleanup Note:
  208.  * All of the cursors passed to the underlying access methods by this
  209.  * routine are not duplicated and will not be cleaned up on return.
  210.  * So, pages/locks that the cursor references must be resolved by the
  211.  * underlying functions.
  212.  */
  213. dbp = dbc->dbp;
  214. PANIC_CHECK(dbp->dbenv);
  215. /* Check for invalid flags. */
  216. if ((ret = __db_ccountchk(dbp, flags, IS_INITIALIZED(dbc))) != 0)
  217. return (ret);
  218. switch (dbc->dbtype) {
  219. case DB_QUEUE:
  220. case DB_RECNO:
  221. *recnop = 1;
  222. break;
  223. case DB_HASH:
  224. if (dbc->internal->opd == NULL) {
  225. if ((ret = __ham_c_count(dbc, recnop)) != 0)
  226. return (ret);
  227. break;
  228. }
  229. /* FALLTHROUGH */
  230. case DB_BTREE:
  231. if ((ret = __bam_c_count(dbc, recnop)) != 0)
  232. return (ret);
  233. break;
  234. default:
  235. return (__db_unknown_type(dbp->dbenv,
  236.     "__db_c_count", dbp->type));
  237. }
  238. return (0);
  239. }
  240. /*
  241.  * __db_c_del --
  242.  * Delete using a cursor.
  243.  *
  244.  * PUBLIC: int __db_c_del __P((DBC *, u_int32_t));
  245.  */
  246. int
  247. __db_c_del(dbc, flags)
  248. DBC *dbc;
  249. u_int32_t flags;
  250. {
  251. DB *dbp;
  252. DBC *opd;
  253. int ret;
  254. /*
  255.  * Cursor Cleanup Note:
  256.  * All of the cursors passed to the underlying access methods by this
  257.  * routine are not duplicated and will not be cleaned up on return.
  258.  * So, pages/locks that the cursor references must be resolved by the
  259.  * underlying functions.
  260.  */
  261. dbp = dbc->dbp;
  262. PANIC_CHECK(dbp->dbenv);
  263. /* Check for invalid flags. */
  264. if ((ret = __db_cdelchk(dbp, flags, IS_INITIALIZED(dbc))) != 0)
  265. return (ret);
  266. /* Check for consistent transaction usage. */
  267. if ((ret = __db_check_txn(dbp, dbc->txn, dbc->locker, 0)) != 0)
  268. return (ret);
  269. DEBUG_LWRITE(dbc, dbc->txn, "db_c_del", NULL, NULL, flags);
  270. CDB_LOCKING_INIT(dbp, dbc);
  271. /*
  272.  * If we're a secondary index, and DB_UPDATE_SECONDARY isn't set
  273.  * (which it only is if we're being called from a primary update),
  274.  * then we need to call through to the primary and delete the item.
  275.  *
  276.  * Note that this will delete the current item;  we don't need to
  277.  * delete it ourselves as well, so we can just goto done.
  278.  */
  279. if (flags != DB_UPDATE_SECONDARY && F_ISSET(dbp, DB_AM_SECONDARY)) {
  280. ret = __db_c_del_secondary(dbc);
  281. goto done;
  282. }
  283. /*
  284.  * If we are a primary and have secondary indices, go through
  285.  * and delete any secondary keys that point at the current record.
  286.  */
  287. if (LIST_FIRST(&dbp->s_secondaries) != NULL &&
  288.     (ret = __db_c_del_primary(dbc)) != 0)
  289. goto done;
  290. /*
  291.  * Off-page duplicate trees are locked in the primary tree, that is,
  292.  * we acquire a write lock in the primary tree and no locks in the
  293.  * off-page dup tree.  If the del operation is done in an off-page
  294.  * duplicate tree, call the primary cursor's upgrade routine first.
  295.  */
  296. opd = dbc->internal->opd;
  297. if (opd == NULL)
  298. ret = dbc->c_am_del(dbc);
  299. else
  300. if ((ret = dbc->c_am_writelock(dbc)) == 0)
  301. ret = opd->c_am_del(opd);
  302. done: CDB_LOCKING_DONE(dbp, dbc);
  303. return (ret);
  304. }
  305. /*
  306.  * __db_c_dup --
  307.  * Duplicate a cursor
  308.  *
  309.  * PUBLIC: int __db_c_dup __P((DBC *, DBC **, u_int32_t));
  310.  */
  311. int
  312. __db_c_dup(dbc_orig, dbcp, flags)
  313. DBC *dbc_orig;
  314. DBC **dbcp;
  315. u_int32_t flags;
  316. {
  317. DB_ENV *dbenv;
  318. DB *dbp;
  319. DBC *dbc_n, *dbc_nopd;
  320. int ret;
  321. dbp = dbc_orig->dbp;
  322. dbenv = dbp->dbenv;
  323. dbc_n = dbc_nopd = NULL;
  324. PANIC_CHECK(dbp->dbenv);
  325. /*
  326.  * We can never have two write cursors open in CDB, so do not
  327.  * allow duplication of a write cursor.
  328.  */
  329. if (flags != DB_POSITIONI &&
  330.     F_ISSET(dbc_orig, DBC_WRITER | DBC_WRITECURSOR)) {
  331. __db_err(dbenv, "Cannot duplicate writeable cursor");
  332. return (EINVAL);
  333. }
  334. /* Allocate a new cursor and initialize it. */
  335. if ((ret = __db_c_idup(dbc_orig, &dbc_n, flags)) != 0)
  336. goto err;
  337. *dbcp = dbc_n;
  338. /*
  339.  * If we're in CDB, and this isn't an internal duplication (in which
  340.  * case we're explicitly overriding CDB locking), the duplicated
  341.  * cursor needs its own read lock.  (We know it's not a write cursor
  342.  * because we wouldn't have made it this far;  you can't dup them.)
  343.  */
  344. if (CDB_LOCKING(dbenv) && flags != DB_POSITIONI) {
  345. DB_ASSERT(!F_ISSET(dbc_orig, DBC_WRITER | DBC_WRITECURSOR));
  346. if ((ret = dbenv->lock_get(dbenv, dbc_n->locker, 0,
  347.     &dbc_n->lock_dbt, DB_LOCK_READ, &dbc_n->mylock)) != 0) {
  348. (void)__db_c_close(dbc_n);
  349. return (ret);
  350. }
  351. }
  352. /*
  353.  * If the cursor references an off-page duplicate tree, allocate a
  354.  * new cursor for that tree and initialize it.
  355.  */
  356. if (dbc_orig->internal->opd != NULL) {
  357. if ((ret =
  358.    __db_c_idup(dbc_orig->internal->opd, &dbc_nopd, flags)) != 0)
  359. goto err;
  360. dbc_n->internal->opd = dbc_nopd;
  361. }
  362. /* Copy the dirty read flag to the new cursor. */
  363. F_SET(dbc_n, F_ISSET(dbc_orig, DBC_DIRTY_READ));
  364. return (0);
  365. err: if (dbc_n != NULL)
  366. (void)dbc_n->c_close(dbc_n);
  367. if (dbc_nopd != NULL)
  368. (void)dbc_nopd->c_close(dbc_nopd);
  369. return (ret);
  370. }
  371. /*
  372.  * __db_c_idup --
  373.  * Internal version of __db_c_dup.
  374.  *
  375.  * PUBLIC: int __db_c_idup __P((DBC *, DBC **, u_int32_t));
  376.  */
  377. int
  378. __db_c_idup(dbc_orig, dbcp, flags)
  379. DBC *dbc_orig, **dbcp;
  380. u_int32_t flags;
  381. {
  382. DB *dbp;
  383. DBC *dbc_n;
  384. DBC_INTERNAL *int_n, *int_orig;
  385. int ret;
  386. dbp = dbc_orig->dbp;
  387. dbc_n = *dbcp;
  388. if ((ret = __db_icursor(dbp, dbc_orig->txn, dbc_orig->dbtype,
  389.     dbc_orig->internal->root, F_ISSET(dbc_orig, DBC_OPD),
  390.     dbc_orig->locker, &dbc_n)) != 0)
  391. return (ret);
  392. /* If the user wants the cursor positioned, do it here.  */
  393. if (flags == DB_POSITION || flags == DB_POSITIONI) {
  394. int_n = dbc_n->internal;
  395. int_orig = dbc_orig->internal;
  396. dbc_n->flags |= dbc_orig->flags & ~DBC_OWN_LID;
  397. int_n->indx = int_orig->indx;
  398. int_n->pgno = int_orig->pgno;
  399. int_n->root = int_orig->root;
  400. int_n->lock_mode = int_orig->lock_mode;
  401. switch (dbc_orig->dbtype) {
  402. case DB_QUEUE:
  403. if ((ret = __qam_c_dup(dbc_orig, dbc_n)) != 0)
  404. goto err;
  405. break;
  406. case DB_BTREE:
  407. case DB_RECNO:
  408. if ((ret = __bam_c_dup(dbc_orig, dbc_n)) != 0)
  409. goto err;
  410. break;
  411. case DB_HASH:
  412. if ((ret = __ham_c_dup(dbc_orig, dbc_n)) != 0)
  413. goto err;
  414. break;
  415. default:
  416. ret = __db_unknown_type(dbp->dbenv,
  417.     "__db_c_idup", dbc_orig->dbtype);
  418. goto err;
  419. }
  420. }
  421. /* Now take care of duping the CDB information. */
  422. CDB_LOCKING_COPY(dbp, dbc_orig, dbc_n);
  423. /* Copy the dirty read flag to the new cursor. */
  424. F_SET(dbc_n, F_ISSET(dbc_orig, DBC_DIRTY_READ));
  425. *dbcp = dbc_n;
  426. return (0);
  427. err: (void)dbc_n->c_close(dbc_n);
  428. return (ret);
  429. }
  430. /*
  431.  * __db_c_newopd --
  432.  * Create a new off-page duplicate cursor.
  433.  *
  434.  * PUBLIC: int __db_c_newopd __P((DBC *, db_pgno_t, DBC *, DBC **));
  435.  */
  436. int
  437. __db_c_newopd(dbc_parent, root, oldopd, dbcp)
  438. DBC *dbc_parent;
  439. db_pgno_t root;
  440. DBC *oldopd;
  441. DBC **dbcp;
  442. {
  443. DB *dbp;
  444. DBC *opd;
  445. DBTYPE dbtype;
  446. int ret;
  447. dbp = dbc_parent->dbp;
  448. dbtype = (dbp->dup_compare == NULL) ? DB_RECNO : DB_BTREE;
  449. /*
  450.  * On failure, we want to default to returning the old off-page dup
  451.  * cursor, if any;  our caller can't be left with a dangling pointer
  452.  * to a freed cursor.  On error the only allowable behavior is to
  453.  * close the cursor (and the old OPD cursor it in turn points to), so
  454.  * this should be safe.
  455.  */
  456. *dbcp = oldopd;
  457. if ((ret = __db_icursor(dbp,
  458.     dbc_parent->txn, dbtype, root, 1, dbc_parent->locker, &opd)) != 0)
  459. return (ret);
  460. /* !!!
  461.  * If the parent is a DBC_WRITER, this won't copy anything.  That's
  462.  * not actually a problem--we only need lock information in an
  463.  * off-page dup cursor in order to upgrade at cursor close time
  464.  * if we've done a delete, but WRITERs don't need to upgrade.
  465.  */
  466. CDB_LOCKING_COPY(dbp, dbc_parent, opd);
  467. *dbcp = opd;
  468. /*
  469.  * Check to see if we already have an off-page dup cursor that we've
  470.  * passed in.  If we do, close it.  It'd be nice to use it again
  471.  * if it's a cursor belonging to the right tree, but if we're doing
  472.  * a cursor-relative operation this might not be safe, so for now
  473.  * we'll take the easy way out and always close and reopen.
  474.  *
  475.  * Note that under no circumstances do we want to close the old
  476.  * cursor without returning a valid new one;  we don't want to
  477.  * leave the main cursor in our caller with a non-NULL pointer
  478.  * to a freed off-page dup cursor.
  479.  */
  480. if (oldopd != NULL && (ret = oldopd->c_close(oldopd)) != 0)
  481. return (ret);
  482. return (0);
  483. }
  484. /*
  485.  * __db_c_get --
  486.  * Get using a cursor.
  487.  *
  488.  * PUBLIC: int __db_c_get __P((DBC *, DBT *, DBT *, u_int32_t));
  489.  */
  490. int
  491. __db_c_get(dbc_arg, key, data, flags)
  492. DBC *dbc_arg;
  493. DBT *key, *data;
  494. u_int32_t flags;
  495. {
  496. DB *dbp;
  497. DBC *dbc, *dbc_n, *opd;
  498. DBC_INTERNAL *cp, *cp_n;
  499. DB_MPOOLFILE *mpf;
  500. db_pgno_t pgno;
  501. u_int32_t multi, tmp_dirty, tmp_flags, tmp_rmw;
  502. u_int8_t type;
  503. int ret, t_ret;
  504. /*
  505.  * Cursor Cleanup Note:
  506.  * All of the cursors passed to the underlying access methods by this
  507.  * routine are duplicated cursors.  On return, any referenced pages
  508.  * will be discarded, and, if the cursor is not intended to be used
  509.  * again, the close function will be called.  So, pages/locks that
  510.  * the cursor references do not need to be resolved by the underlying
  511.  * functions.
  512.  */
  513. dbp = dbc_arg->dbp;
  514. mpf = dbp->mpf;
  515. dbc_n = NULL;
  516. opd = NULL;
  517. PANIC_CHECK(dbp->dbenv);
  518. /* Check for invalid flags. */
  519. if ((ret =
  520.     __db_cgetchk(dbp, key, data, flags, IS_INITIALIZED(dbc_arg))) != 0)
  521. return (ret);
  522. /* Clear OR'd in additional bits so we can check for flag equality. */
  523. tmp_rmw = LF_ISSET(DB_RMW);
  524. LF_CLR(DB_RMW);
  525. tmp_dirty = LF_ISSET(DB_DIRTY_READ);
  526. LF_CLR(DB_DIRTY_READ);
  527. multi = LF_ISSET(DB_MULTIPLE|DB_MULTIPLE_KEY);
  528. LF_CLR(DB_MULTIPLE|DB_MULTIPLE_KEY);
  529. DEBUG_LREAD(dbc_arg, dbc_arg->txn, "db_c_get",
  530.     flags == DB_SET || flags == DB_SET_RANGE ? key : NULL, NULL, flags);
  531. /*
  532.  * Return a cursor's record number.  It has nothing to do with the
  533.  * cursor get code except that it was put into the interface.
  534.  */
  535. if (flags == DB_GET_RECNO) {
  536. if (tmp_rmw)
  537. F_SET(dbc_arg, DBC_RMW);
  538. if (tmp_dirty)
  539. F_SET(dbc_arg, DBC_DIRTY_READ);
  540. ret = __bam_c_rget(dbc_arg, data);
  541. if (tmp_rmw)
  542. F_CLR(dbc_arg, DBC_RMW);
  543. if (tmp_dirty)
  544. F_CLR(dbc_arg, DBC_DIRTY_READ);
  545. return (ret);
  546. }
  547. if (flags == DB_CONSUME || flags == DB_CONSUME_WAIT)
  548. CDB_LOCKING_INIT(dbp, dbc_arg);
  549. /*
  550.  * If we have an off-page duplicates cursor, and the operation applies
  551.  * to it, perform the operation.  Duplicate the cursor and call the
  552.  * underlying function.
  553.  *
  554.  * Off-page duplicate trees are locked in the primary tree, that is,
  555.  * we acquire a write lock in the primary tree and no locks in the
  556.  * off-page dup tree.  If the DB_RMW flag was specified and the get
  557.  * operation is done in an off-page duplicate tree, call the primary
  558.  * cursor's upgrade routine first.
  559.  */
  560. cp = dbc_arg->internal;
  561. if (cp->opd != NULL &&
  562.     (flags == DB_CURRENT || flags == DB_GET_BOTHC ||
  563.     flags == DB_NEXT || flags == DB_NEXT_DUP || flags == DB_PREV)) {
  564. if (tmp_rmw && (ret = dbc_arg->c_am_writelock(dbc_arg)) != 0)
  565. return (ret);
  566. if ((ret = __db_c_idup(cp->opd, &opd, DB_POSITIONI)) != 0)
  567. return (ret);
  568. switch (ret =
  569.     opd->c_am_get(opd, key, data, flags, NULL)) {
  570. case 0:
  571. goto done;
  572. case DB_NOTFOUND:
  573. /*
  574.  * Translate DB_NOTFOUND failures for the DB_NEXT and
  575.  * DB_PREV operations into a subsequent operation on
  576.  * the parent cursor.
  577.  */
  578. if (flags == DB_NEXT || flags == DB_PREV) {
  579. if ((ret = opd->c_close(opd)) != 0)
  580. goto err;
  581. opd = NULL;
  582. break;
  583. }
  584. goto err;
  585. default:
  586. goto err;
  587. }
  588. }
  589. /*
  590.  * Perform an operation on the main cursor.  Duplicate the cursor,
  591.  * upgrade the lock as required, and call the underlying function.
  592.  */
  593. switch (flags) {
  594. case DB_CURRENT:
  595. case DB_GET_BOTHC:
  596. case DB_NEXT:
  597. case DB_NEXT_DUP:
  598. case DB_NEXT_NODUP:
  599. case DB_PREV:
  600. case DB_PREV_NODUP:
  601. tmp_flags = DB_POSITIONI;
  602. break;
  603. default:
  604. tmp_flags = 0;
  605. break;
  606. }
  607. if (tmp_dirty)
  608. F_SET(dbc_arg, DBC_DIRTY_READ);
  609. /*
  610.  * If this cursor is going to be closed immediately, we don't
  611.  * need to take precautions to clean it up on error.
  612.  */
  613. if (F_ISSET(dbc_arg, DBC_TRANSIENT))
  614. dbc_n = dbc_arg;
  615. else {
  616. ret = __db_c_idup(dbc_arg, &dbc_n, tmp_flags);
  617. if (tmp_dirty)
  618. F_CLR(dbc_arg, DBC_DIRTY_READ);
  619. if (ret != 0)
  620. goto err;
  621. COPY_RET_MEM(dbc_arg, dbc_n);
  622. }
  623. if (tmp_rmw)
  624. F_SET(dbc_n, DBC_RMW);
  625. switch (multi) {
  626. case DB_MULTIPLE:
  627. F_SET(dbc_n, DBC_MULTIPLE);
  628. break;
  629. case DB_MULTIPLE_KEY:
  630. F_SET(dbc_n, DBC_MULTIPLE_KEY);
  631. break;
  632. case DB_MULTIPLE | DB_MULTIPLE_KEY:
  633. F_SET(dbc_n, DBC_MULTIPLE|DBC_MULTIPLE_KEY);
  634. break;
  635. case 0:
  636. break;
  637. }
  638. pgno = PGNO_INVALID;
  639. ret = dbc_n->c_am_get(dbc_n, key, data, flags, &pgno);
  640. if (tmp_rmw)
  641. F_CLR(dbc_n, DBC_RMW);
  642. if (tmp_dirty)
  643. F_CLR(dbc_arg, DBC_DIRTY_READ);
  644. F_CLR(dbc_n, DBC_MULTIPLE|DBC_MULTIPLE_KEY);
  645. if (ret != 0)
  646. goto err;
  647. cp_n = dbc_n->internal;
  648. /*
  649.  * We may be referencing a new off-page duplicates tree.  Acquire
  650.  * a new cursor and call the underlying function.
  651.  */
  652. if (pgno != PGNO_INVALID) {
  653. if ((ret = __db_c_newopd(dbc_arg,
  654.     pgno, cp_n->opd, &cp_n->opd)) != 0)
  655. goto err;
  656. switch (flags) {
  657. case DB_FIRST:
  658. case DB_NEXT:
  659. case DB_NEXT_NODUP:
  660. case DB_SET:
  661. case DB_SET_RECNO:
  662. case DB_SET_RANGE:
  663. tmp_flags = DB_FIRST;
  664. break;
  665. case DB_LAST:
  666. case DB_PREV:
  667. case DB_PREV_NODUP:
  668. tmp_flags = DB_LAST;
  669. break;
  670. case DB_GET_BOTH:
  671. case DB_GET_BOTHC:
  672. case DB_GET_BOTH_RANGE:
  673. tmp_flags = flags;
  674. break;
  675. default:
  676. ret =
  677.     __db_unknown_flag(dbp->dbenv, "__db_c_get", flags);
  678. goto err;
  679. }
  680. if ((ret = cp_n->opd->c_am_get(
  681.     cp_n->opd, key, data, tmp_flags, NULL)) != 0)
  682. goto err;
  683. }
  684. done: /*
  685.  * Return a key/data item.  The only exception is that we don't return
  686.  * a key if the user already gave us one, that is, if the DB_SET flag
  687.  * was set.  The DB_SET flag is necessary.  In a Btree, the user's key
  688.  * doesn't have to be the same as the key stored the tree, depending on
  689.  * the magic performed by the comparison function.  As we may not have
  690.  * done any key-oriented operation here, the page reference may not be
  691.  * valid.  Fill it in as necessary.  We don't have to worry about any
  692.  * locks, the cursor must already be holding appropriate locks.
  693.  *
  694.  * XXX
  695.  * If not a Btree and DB_SET_RANGE is set, we shouldn't return a key
  696.  * either, should we?
  697.  */
  698. cp_n = dbc_n == NULL ? dbc_arg->internal : dbc_n->internal;
  699. if (!F_ISSET(key, DB_DBT_ISSET)) {
  700. if (cp_n->page == NULL && (ret =
  701.     mpf->get(mpf, &cp_n->pgno, 0, &cp_n->page)) != 0)
  702. goto err;
  703. if ((ret = __db_ret(dbp, cp_n->page, cp_n->indx,
  704.     key, &dbc_arg->rkey->data, &dbc_arg->rkey->ulen)) != 0)
  705. goto err;
  706. }
  707. if (multi != 0) {
  708. /*
  709.  * Even if fetching from the OPD cursor we need a duplicate
  710.  * primary cursor if we are going after multiple keys.
  711.  */
  712. if (dbc_n == NULL) {
  713. /*
  714.  * Non-"_KEY" DB_MULTIPLE doesn't move the main cursor,
  715.  * so it's safe to just use dbc_arg, unless dbc_arg
  716.  * has an open OPD cursor whose state might need to
  717.  * be preserved.
  718.  */
  719. if ((!(multi & DB_MULTIPLE_KEY) && 
  720.     dbc_arg->internal->opd == NULL) ||
  721.     F_ISSET(dbc_arg, DBC_TRANSIENT))
  722. dbc_n = dbc_arg;
  723. else {
  724. if ((ret = __db_c_idup(dbc_arg,
  725.     &dbc_n, DB_POSITIONI)) != 0)
  726. goto err;
  727. if ((ret = dbc_n->c_am_get(dbc_n,
  728.     key, data, DB_CURRENT, &pgno)) != 0)
  729. goto err;
  730. }
  731. cp_n = dbc_n->internal;
  732. }
  733. /*
  734.  * If opd is set then we dupped the opd that we came in with.
  735.  * When we return we may have a new opd if we went to another
  736.  * key.
  737.  */
  738. if (opd != NULL) {
  739. DB_ASSERT(cp_n->opd == NULL);
  740. cp_n->opd = opd;
  741. opd = NULL;
  742. }
  743. /*
  744.  * Bulk get doesn't use __db_retcopy, so data.size won't
  745.  * get set up unless there is an error.  Assume success
  746.  * here.  This is the only call to c_am_bulk, and it avoids
  747.  * setting it exactly the same everywhere.  If we have an
  748.  * ENOMEM error, it'll get overwritten with the needed value.
  749.  */
  750. data->size = data->ulen;
  751. ret = dbc_n->c_am_bulk(dbc_n, data, flags | multi);
  752. } else if (!F_ISSET(data, DB_DBT_ISSET)) {
  753. dbc = opd != NULL ? opd : cp_n->opd != NULL ? cp_n->opd : dbc_n;
  754. type = TYPE(dbc->internal->page);
  755. ret = __db_ret(dbp, dbc->internal->page, dbc->internal->indx +
  756.     (type == P_LBTREE || type == P_HASH ? O_INDX : 0),
  757.     data, &dbc_arg->rdata->data, &dbc_arg->rdata->ulen);
  758. }
  759. err: /* Don't pass DB_DBT_ISSET back to application level, error or no. */
  760. F_CLR(key, DB_DBT_ISSET);
  761. F_CLR(data, DB_DBT_ISSET);
  762. /* Cleanup and cursor resolution. */
  763. if (opd != NULL) {
  764. if ((t_ret = __db_c_cleanup(
  765.     dbc_arg->internal->opd, opd, ret)) != 0 && ret == 0)
  766. ret = t_ret;
  767. }
  768. if ((t_ret = __db_c_cleanup(dbc_arg, dbc_n, ret)) != 0 && ret == 0)
  769. ret = t_ret;
  770. if (flags == DB_CONSUME || flags == DB_CONSUME_WAIT)
  771. CDB_LOCKING_DONE(dbp, dbc_arg);
  772. return (ret);
  773. }
  774. /*
  775.  * __db_c_put --
  776.  * Put using a cursor.
  777.  *
  778.  * PUBLIC: int __db_c_put __P((DBC *, DBT *, DBT *, u_int32_t));
  779.  */
  780. int
  781. __db_c_put(dbc_arg, key, data, flags)
  782. DBC *dbc_arg;
  783. DBT *key, *data;
  784. u_int32_t flags;
  785. {
  786. DB *dbp, *sdbp;
  787. DBC *dbc_n, *oldopd, *opd, *sdbc, *pdbc;
  788. DBT olddata, oldpkey, oldskey, newdata, pkey, save_skey, skey, temp;
  789. db_pgno_t pgno;
  790. int cmp, have_oldrec, ispartial, nodel, re_pad, ret, rmw, t_ret;
  791. u_int32_t re_len, size, tmp_flags;
  792. /*
  793.  * Cursor Cleanup Note:
  794.  * All of the cursors passed to the underlying access methods by this
  795.  * routine are duplicated cursors.  On return, any referenced pages
  796.  * will be discarded, and, if the cursor is not intended to be used
  797.  * again, the close function will be called.  So, pages/locks that
  798.  * the cursor references do not need to be resolved by the underlying
  799.  * functions.
  800.  */
  801. dbp = dbc_arg->dbp;
  802. sdbp = NULL;
  803. pdbc = dbc_n = NULL;
  804. memset(&newdata, 0, sizeof(DBT));
  805. PANIC_CHECK(dbp->dbenv);
  806. /* Check for invalid flags. */
  807. if ((ret = __db_cputchk(dbp,
  808.     key, data, flags, IS_INITIALIZED(dbc_arg))) != 0)
  809. return (ret);
  810. /* Check for consistent transaction usage. */
  811. if ((ret = __db_check_txn(dbp, dbc_arg->txn, dbc_arg->locker, 0)) != 0)
  812. return (ret);
  813. /*
  814.  * Putting to secondary indices is forbidden;  when we need
  815.  * to internally update one, we'll call this with a private
  816.  * synonym for DB_KEYLAST, DB_UPDATE_SECONDARY, which does
  817.  * the right thing but won't return an error from cputchk().
  818.  */
  819. if (flags == DB_UPDATE_SECONDARY)
  820. flags = DB_KEYLAST;
  821. DEBUG_LWRITE(dbc_arg, dbc_arg->txn, "db_c_put",
  822.     flags == DB_KEYFIRST || flags == DB_KEYLAST ||
  823.     flags == DB_NODUPDATA ? key : NULL, data, flags);
  824. CDB_LOCKING_INIT(dbp, dbc_arg);
  825. /*
  826.  * Check to see if we are a primary and have secondary indices.
  827.  * If we are not, we save ourselves a good bit of trouble and
  828.  * just skip to the "normal" put.
  829.  */
  830. if (LIST_FIRST(&dbp->s_secondaries) == NULL)
  831. goto skip_s_update;
  832. /*
  833.  * We have at least one secondary which we may need to update.
  834.  *
  835.  * There is a rather vile locking issue here.  Secondary gets
  836.  * will always involve acquiring a read lock in the secondary,
  837.  * then acquiring a read lock in the primary.  Ideally, we
  838.  * would likewise perform puts by updating all the secondaries
  839.  * first, then doing the actual put in the primary, to avoid
  840.  * deadlock (since having multiple threads doing secondary
  841.  * gets and puts simultaneously is probably a common case).
  842.  *
  843.  * However, if this put is a put-overwrite--and we have no way to
  844.  * tell in advance whether it will be--we may need to delete
  845.  * an outdated secondary key.  In order to find that old
  846.  * secondary key, we need to get the record we're overwriting,
  847.  * before we overwrite it.
  848.  *
  849.  * (XXX: It would be nice to avoid this extra get, and have the
  850.  * underlying put routines somehow pass us the old record
  851.  * since they need to traverse the tree anyway.  I'm saving
  852.  * this optimization for later, as it's a lot of work, and it
  853.  * would be hard to fit into this locking paradigm anyway.)
  854.  *
  855.  * The simple thing to do would be to go get the old record before
  856.  * we do anything else.  Unfortunately, though, doing so would
  857.  * violate our "secondary, then primary" lock acquisition
  858.  * ordering--even in the common case where no old primary record
  859.  * exists, we'll still acquire and keep a lock on the page where
  860.  * we're about to do the primary insert.
  861.  *
  862.  * To get around this, we do the following gyrations, which
  863.  * hopefully solve this problem in the common case:
  864.  *
  865.  * 1) If this is a c_put(DB_CURRENT), go ahead and get the
  866.  *    old record.  We already hold the lock on this page in
  867.  *    the primary, so no harm done, and we'll need the primary
  868.  *    key (which we weren't passed in this case) to do any
  869.  *    secondary puts anyway.
  870.  *
  871.  * 2) If we're doing a partial put, we need to perform the
  872.  *    get on the primary key right away, since we don't have
  873.  *    the whole datum that the secondary key is based on.
  874.  *    We may also need to pad out the record if the primary
  875.  *    has a fixed record length.
  876.  *
  877.  * 3) Loop through the secondary indices, putting into each a
  878.  *    new secondary key that corresponds to the new record.
  879.  *
  880.  * 4) If we haven't done so in (1) or (2), get the old primary
  881.  *    key/data pair.  If one does not exist--the common case--we're
  882.  *    done with secondary indices, and can go straight on to the
  883.  *    primary put.
  884.  *
  885.  * 5) If we do have an old primary key/data pair, however, we need
  886.  *    to loop through all the secondaries a second time and delete
  887.  *    the old secondary in each.
  888.  */
  889. memset(&pkey, 0, sizeof(DBT));
  890. memset(&olddata, 0, sizeof(DBT));
  891. have_oldrec = nodel = 0;
  892. /*
  893.  * Primary indices can't have duplicates, so only DB_CURRENT,
  894.  * DB_KEYFIRST, and DB_KEYLAST make any sense.  Other flags
  895.  * should have been caught by the checking routine, but
  896.  * add a sprinkling of paranoia.
  897.  */
  898. DB_ASSERT(flags == DB_CURRENT ||
  899.     flags == DB_KEYFIRST || flags == DB_KEYLAST);
  900. /*
  901.  * We'll want to use DB_RMW in a few places, but it's only legal
  902.  * when locking is on.
  903.  */
  904. rmw = STD_LOCKING(dbc_arg) ? DB_RMW : 0;
  905. if (flags == DB_CURRENT) { /* Step 1. */
  906. /*
  907.  * This is safe to do on the cursor we already have;
  908.  * error or no, it won't move.
  909.  *
  910.  * We use DB_RMW for all of these gets because we'll be
  911.  * writing soon enough in the "normal" put code.  In
  912.  * transactional databases we'll hold those write locks
  913.  * even if we close the cursor we're reading with.
  914.  */
  915. ret = dbc_arg->c_get(dbc_arg,
  916.     &pkey, &olddata, rmw | DB_CURRENT);
  917. if (ret == DB_KEYEMPTY) {
  918. nodel = 1;  /*
  919.   * We know we don't need a delete
  920.   * in the secondary.
  921.   */
  922. have_oldrec = 1; /* We've looked for the old record. */
  923. } else if (ret != 0)
  924. goto err;
  925. else
  926. have_oldrec = 1;
  927. } else {
  928. /* So we can just use &pkey everywhere instead of key. */
  929. pkey.data = key->data;
  930. pkey.size = key->size;
  931. }
  932. /*
  933.  * Check for partial puts (step 2).
  934.  */
  935. if (F_ISSET(data, DB_DBT_PARTIAL)) {
  936. if (!have_oldrec && !nodel) {
  937. /*
  938.  * We're going to have to search the tree for the
  939.  * specified key.  Dup a cursor (so we have the same
  940.  * locking info) and do a c_get.
  941.  */
  942. if ((ret = __db_c_idup(dbc_arg, &pdbc, 0)) != 0)
  943. goto err;
  944. /* We should have gotten DB_CURRENT in step 1. */
  945. DB_ASSERT(flags != DB_CURRENT);
  946. ret = pdbc->c_get(pdbc,
  947.     &pkey, &olddata, rmw | DB_SET);
  948. if (ret == DB_KEYEMPTY || ret == DB_NOTFOUND) {
  949. nodel = 1;
  950. ret = 0;
  951. }
  952. if ((t_ret = pdbc->c_close(pdbc)) != 0)
  953. ret = t_ret;
  954. if (ret != 0)
  955. goto err;
  956. have_oldrec = 1;
  957. }
  958. /*
  959.  * Now build the new datum from olddata and the partial
  960.  * data we were given.
  961.  */
  962. if ((ret =
  963.     __db_buildpartial(dbp, &olddata, data, &newdata)) != 0)
  964. goto err;
  965. ispartial = 1;
  966. } else
  967. ispartial = 0;
  968. /*
  969.  * Handle fixed-length records.  If the primary database has
  970.  * fixed-length records, we need to pad out the datum before
  971.  * we pass it into the callback function;  we always index the
  972.  * "real" record.
  973.  */
  974. if ((dbp->type == DB_RECNO && F_ISSET(dbp, DB_AM_FIXEDLEN)) ||
  975.     (dbp->type == DB_QUEUE)) {
  976. if (dbp->type == DB_QUEUE) {
  977. re_len = ((QUEUE *)dbp->q_internal)->re_len;
  978. re_pad = ((QUEUE *)dbp->q_internal)->re_pad;
  979. } else {
  980. re_len = ((BTREE *)dbp->bt_internal)->re_len;
  981. re_pad = ((BTREE *)dbp->bt_internal)->re_pad;
  982. }
  983. size = ispartial ? newdata.size : data->size;
  984. if (size > re_len) {
  985. __db_err(dbp->dbenv,
  986.     "Length improper for fixed length record %lu",
  987.     (u_long)size);
  988. ret = EINVAL;
  989. goto err;
  990. } else if (size < re_len) {
  991. /*
  992.  * If we're not doing a partial put, copy
  993.  * data->data into newdata.data, then pad out
  994.  * newdata.data.
  995.  *
  996.  * If we're doing a partial put, the data
  997.  * we want are already in newdata.data;  we
  998.  * just need to pad.
  999.  *
  1000.  * Either way, realloc is safe.
  1001.  */
  1002. if ((ret = __os_realloc(dbp->dbenv, re_len,
  1003.     &newdata.data)) != 0)
  1004. goto err;
  1005. if (!ispartial)
  1006. memcpy(newdata.data, data->data, size);
  1007. memset((u_int8_t *)newdata.data + size, re_pad,
  1008.     re_len - size);
  1009. newdata.size = re_len;
  1010. ispartial = 1;
  1011. }
  1012. }
  1013. /*
  1014.  * Loop through the secondaries.  (Step 3.)
  1015.  *
  1016.  * Note that __db_s_first and __db_s_next will take care of
  1017.  * thread-locking and refcounting issues.
  1018.  */
  1019. for (sdbp = __db_s_first(dbp);
  1020.     sdbp != NULL && ret == 0; ret = __db_s_next(&sdbp)) {
  1021. /*
  1022.  * Call the callback for this secondary, to get the
  1023.  * appropriate secondary key.
  1024.  */
  1025. memset(&skey, 0, sizeof(DBT));
  1026. if ((ret = sdbp->s_callback(sdbp,
  1027.     &pkey, ispartial ? &newdata : data, &skey)) != 0) {
  1028. if (ret == DB_DONOTINDEX)
  1029. /*
  1030.  * The callback returned a null value--don't
  1031.  * put this key in the secondary.  Just
  1032.  * move on to the next one--we'll handle
  1033.  * any necessary deletes in step 5.
  1034.  */
  1035. continue;
  1036. else
  1037. goto err;
  1038. }
  1039. /*
  1040.  * Save the DBT we just got back from the callback function
  1041.  * off;  we want to pass its value into c_get functions
  1042.  * that may stomp on a buffer the callback function
  1043.  * allocated.
  1044.  */
  1045. memset(&save_skey, 0, sizeof(DBT)); /* Paranoia. */
  1046. save_skey = skey;
  1047. /*
  1048.  * Open a cursor in this secondary.
  1049.  *
  1050.  * Use the same locker ID as our primary cursor, so that
  1051.  * we're guaranteed that the locks don't conflict (e.g. in CDB
  1052.  * or if we're subdatabases that share and want to lock a
  1053.  * metadata page).
  1054.  */
  1055. if ((ret = __db_icursor(sdbp, dbc_arg->txn, sdbp->type,
  1056.     PGNO_INVALID, 0, dbc_arg->locker, &sdbc)) != 0)
  1057. goto err;
  1058. /*
  1059.  * If we're in CDB, updates will fail since the new cursor
  1060.  * isn't a writer.  However, we hold the WRITE lock in the
  1061.  * primary and will for as long as our new cursor lasts,
  1062.  * and the primary and secondary share a lock file ID,
  1063.  * so it's safe to consider this a WRITER.  The close
  1064.  * routine won't try to put anything because we don't
  1065.  * really have a lock.
  1066.  */
  1067. if (CDB_LOCKING(sdbp->dbenv)) {
  1068. DB_ASSERT(sdbc->mylock.off == LOCK_INVALID);
  1069. F_SET(sdbc, DBC_WRITER);
  1070. }
  1071. /*
  1072.  * There are three cases here--
  1073.  * 1) The secondary supports sorted duplicates.
  1074.  * If we attempt to put a secondary/primary pair
  1075.  * that already exists, that's a duplicate duplicate,
  1076.  * and c_put will return DB_KEYEXIST (see __db_duperr).
  1077.  * This will leave us with exactly one copy of the
  1078.  * secondary/primary pair, and this is just right--we'll
  1079.  * avoid deleting it later, as the old and new secondaries
  1080.  * will match (since the old secondary is the dup dup
  1081.  * that's already there).
  1082.  * 2) The secondary supports duplicates, but they're not
  1083.  * sorted.  We need to avoid putting a duplicate
  1084.  * duplicate, because the matching old and new secondaries
  1085.  * will prevent us from deleting anything and we'll
  1086.  * wind up with two secondary records that point to the
  1087.  * same primary key.  Do a c_get(DB_GET_BOTH);  if
  1088.  * that returns 0, skip the put.
  1089.  * 3) The secondary doesn't support duplicates at all.
  1090.  * In this case, secondary keys must be unique;  if
  1091.  * another primary key already exists for this
  1092.  * secondary key, we have to either overwrite it or
  1093.  * not put this one, and in either case we've
  1094.  * corrupted the secondary index.  Do a c_get(DB_SET).
  1095.  * If the secondary/primary pair already exists, do
  1096.  * nothing;  if the secondary exists with a different
  1097.  * primary, return an error;  and if the secondary
  1098.  * does not exist, put it.
  1099.  */
  1100. if (!F_ISSET(sdbp, DB_AM_DUP)) {
  1101. /* Case 3. */
  1102. memset(&oldpkey, 0, sizeof(DBT));
  1103. F_SET(&oldpkey, DB_DBT_MALLOC);
  1104. ret = sdbc->c_real_get(sdbc,
  1105.     &skey, &oldpkey, rmw | DB_SET);
  1106. if (ret == 0) {
  1107. cmp = __bam_defcmp(sdbp, &oldpkey, &pkey);
  1108. __os_ufree(sdbp->dbenv, oldpkey.data);
  1109. if (cmp != 0) {
  1110. __db_err(sdbp->dbenv, "%s%s",
  1111.     "Put results in a non-unique secondary key in an ",
  1112.     "index not configured to support duplicates");
  1113. ret = EINVAL;
  1114. goto skipput;
  1115. }
  1116. } else if (ret != DB_NOTFOUND && ret != DB_KEYEMPTY)
  1117. goto skipput;
  1118. } else if (!F_ISSET(sdbp, DB_AM_DUPSORT))
  1119. /* Case 2. */
  1120. if ((ret = sdbc->c_real_get(sdbc,
  1121.     &skey, &pkey, rmw | DB_GET_BOTH)) == 0)
  1122. goto skipput;
  1123. ret = sdbc->c_put(sdbc, &skey, &pkey, DB_UPDATE_SECONDARY);
  1124. /*
  1125.  * We don't know yet whether this was a put-overwrite that
  1126.  * in fact changed nothing.  If it was, we may get DB_KEYEXIST.
  1127.  * This is not an error.
  1128.  */
  1129. if (ret == DB_KEYEXIST)
  1130. ret = 0;
  1131. skipput: FREE_IF_NEEDED(sdbp, &save_skey)
  1132. if ((t_ret = sdbc->c_close(sdbc)) != 0)
  1133. ret = t_ret;
  1134. if (ret != 0)
  1135. goto err;
  1136. }
  1137. if (ret != 0)
  1138. goto err;
  1139. /* If still necessary, go get the old primary key/data.  (Step 4.) */
  1140. if (!have_oldrec) {
  1141. /* See the comments in step 2.  This is real familiar. */
  1142. if ((ret = __db_c_idup(dbc_arg, &pdbc, 0)) != 0)
  1143. goto err;
  1144. DB_ASSERT(flags != DB_CURRENT);
  1145. pkey.data = key->data;
  1146. pkey.size = key->size;
  1147. ret = pdbc->c_get(pdbc, &pkey, &olddata, rmw | DB_SET);
  1148. if (ret == DB_KEYEMPTY || ret == DB_NOTFOUND) {
  1149. nodel = 1;
  1150. ret = 0;
  1151. }
  1152. if ((t_ret = pdbc->c_close(pdbc)) != 0)
  1153. ret = t_ret;
  1154. if (ret != 0)
  1155. goto err;
  1156. have_oldrec = 1;
  1157. }
  1158. /*
  1159.  * If we don't follow this goto, we do in fact have an old record
  1160.  * we may need to go delete.  (Step 5).
  1161.  */
  1162. if (nodel)
  1163. goto skip_s_update;
  1164. for (sdbp = __db_s_first(dbp);
  1165.     sdbp != NULL && ret == 0; ret = __db_s_next(&sdbp)) {
  1166. /*
  1167.  * Call the callback for this secondary to get the
  1168.  * old secondary key.
  1169.  */
  1170. memset(&oldskey, 0, sizeof(DBT));
  1171. if ((ret = sdbp->s_callback(sdbp,
  1172.     &pkey, &olddata, &oldskey)) != 0) {
  1173. if (ret == DB_DONOTINDEX)
  1174. /*
  1175.  * The callback returned a null value--there's
  1176.  * nothing to delete.  Go on to the next
  1177.  * secondary.
  1178.  */
  1179. continue;
  1180. else
  1181. goto err;
  1182. }
  1183. if ((ret = sdbp->s_callback(sdbp,
  1184.     &pkey, ispartial ? &newdata : data, &skey)) != 0 &&
  1185.     ret != DB_DONOTINDEX)
  1186. goto err;
  1187. /*
  1188.  * If there is no new secondary key, or if the old secondary
  1189.  * key is different from the new secondary key, then
  1190.  * we need to delete the old one.
  1191.  *
  1192.  * Note that bt_compare is (and must be) set no matter
  1193.  * what access method we're in.
  1194.  */
  1195. sdbc = NULL;
  1196. if (ret == DB_DONOTINDEX ||
  1197.     ((BTREE *)sdbp->bt_internal)->bt_compare(sdbp,
  1198.     &oldskey, &skey) != 0) {
  1199. if ((ret = __db_icursor(sdbp, dbc_arg->txn, sdbp->type,
  1200.     PGNO_INVALID, 0, dbc_arg->locker, &sdbc)) != 0)
  1201. goto err;
  1202. if (CDB_LOCKING(sdbp->dbenv)) {
  1203. DB_ASSERT(sdbc->mylock.off == LOCK_INVALID);
  1204. F_SET(sdbc, DBC_WRITER);
  1205. }
  1206. /*
  1207.  * Don't let c_get(DB_GET_BOTH) stomp on
  1208.  * any secondary key value that the callback
  1209.  * function may have allocated.  Use a temp
  1210.  * DBT instead.
  1211.  */
  1212. memset(&temp, 0, sizeof(DBT));
  1213. temp.data = oldskey.data;
  1214. temp.size = oldskey.size;
  1215. if ((ret = sdbc->c_real_get(sdbc,
  1216.     &temp, &pkey, rmw | DB_GET_BOTH)) == 0)
  1217. ret = sdbc->c_del(sdbc, DB_UPDATE_SECONDARY);
  1218. }
  1219. FREE_IF_NEEDED(sdbp, &skey);
  1220. FREE_IF_NEEDED(sdbp, &oldskey);
  1221. if (sdbc != NULL && (t_ret = sdbc->c_close(sdbc)) != 0)
  1222. ret = t_ret;
  1223. if (ret != 0)
  1224. goto err;
  1225. }
  1226. /* Secondary index updates are now done.  On to the "real" stuff. */
  1227. skip_s_update:
  1228. /*
  1229.  * If we have an off-page duplicates cursor, and the operation applies
  1230.  * to it, perform the operation.  Duplicate the cursor and call the
  1231.  * underlying function.
  1232.  *
  1233.  * Off-page duplicate trees are locked in the primary tree, that is,
  1234.  * we acquire a write lock in the primary tree and no locks in the
  1235.  * off-page dup tree.  If the put operation is done in an off-page
  1236.  * duplicate tree, call the primary cursor's upgrade routine first.
  1237.  */
  1238. if (dbc_arg->internal->opd != NULL &&
  1239.     (flags == DB_AFTER || flags == DB_BEFORE || flags == DB_CURRENT)) {
  1240. /*
  1241.  * A special case for hash off-page duplicates.  Hash doesn't
  1242.  * support (and is documented not to support) put operations
  1243.  * relative to a cursor which references an already deleted
  1244.  * item.  For consistency, apply the same criteria to off-page
  1245.  * duplicates as well.
  1246.  */
  1247. if (dbc_arg->dbtype == DB_HASH && F_ISSET(
  1248.     ((BTREE_CURSOR *)(dbc_arg->internal->opd->internal)),
  1249.     C_DELETED)) {
  1250. ret = DB_NOTFOUND;
  1251. goto err;
  1252. }
  1253. if ((ret = dbc_arg->c_am_writelock(dbc_arg)) != 0)
  1254. return (ret);
  1255. if ((ret = __db_c_dup(dbc_arg, &dbc_n, DB_POSITIONI)) != 0)
  1256. goto err;
  1257. opd = dbc_n->internal->opd;
  1258. if ((ret = opd->c_am_put(
  1259.     opd, key, data, flags, NULL)) != 0)
  1260. goto err;
  1261. goto done;
  1262. }
  1263. /*
  1264.  * Perform an operation on the main cursor.  Duplicate the cursor,
  1265.  * and call the underlying function.
  1266.  *
  1267.  * XXX: MARGO
  1268.  *
  1269. tmp_flags = flags == DB_AFTER ||
  1270.     flags == DB_BEFORE || flags == DB_CURRENT ? DB_POSITIONI : 0;
  1271.  */
  1272. tmp_flags = DB_POSITIONI;
  1273. /*
  1274.  * If this cursor is going to be closed immediately, we don't
  1275.  * need to take precautions to clean it up on error.
  1276.  */
  1277. if (F_ISSET(dbc_arg, DBC_TRANSIENT))
  1278. dbc_n = dbc_arg;
  1279. else if ((ret = __db_c_idup(dbc_arg, &dbc_n, tmp_flags)) != 0)
  1280. goto err;
  1281. pgno = PGNO_INVALID;
  1282. if ((ret = dbc_n->c_am_put(dbc_n, key, data, flags, &pgno)) != 0)
  1283. goto err;
  1284. /*
  1285.  * We may be referencing a new off-page duplicates tree.  Acquire
  1286.  * a new cursor and call the underlying function.
  1287.  */
  1288. if (pgno != PGNO_INVALID) {
  1289. oldopd = dbc_n->internal->opd;
  1290. if ((ret = __db_c_newopd(dbc_arg, pgno, oldopd, &opd)) != 0) {
  1291. dbc_n->internal->opd = opd;
  1292. goto err;
  1293. }
  1294. dbc_n->internal->opd = opd;
  1295. if ((ret = opd->c_am_put(
  1296.     opd, key, data, flags, NULL)) != 0)
  1297. goto err;
  1298. }
  1299. done:
  1300. err: /* Cleanup and cursor resolution. */
  1301. if ((t_ret = __db_c_cleanup(dbc_arg, dbc_n, ret)) != 0 && ret == 0)
  1302. ret = t_ret;
  1303. /* If newdata was used, free its buffer. */
  1304. if (newdata.data != NULL)
  1305. __os_free(dbp->dbenv, newdata.data);
  1306. CDB_LOCKING_DONE(dbp, dbc_arg);
  1307. if (sdbp != NULL && (t_ret = __db_s_done(sdbp)) != 0)
  1308. return (t_ret);
  1309. return (ret);
  1310. }
  1311. /*
  1312.  * __db_duperr()
  1313.  * Error message: we don't currently support sorted duplicate duplicates.
  1314.  * PUBLIC: int __db_duperr __P((DB *, u_int32_t));
  1315.  */
  1316. int
  1317. __db_duperr(dbp, flags)
  1318. DB *dbp;
  1319. u_int32_t flags;
  1320. {
  1321. /*
  1322.  * If we run into this error while updating a secondary index,
  1323.  * don't yell--there's no clean way to pass DB_NODUPDATA in along
  1324.  * with DB_UPDATE_SECONDARY, but we may run into this problem
  1325.  * in a normal, non-error course of events.
  1326.  *
  1327.  * !!!
  1328.  * If and when we ever permit duplicate duplicates in sorted-dup
  1329.  * databases, we need to either change the secondary index code
  1330.  * to check for dup dups, or we need to maintain the implicit
  1331.  * "DB_NODUPDATA" behavior for databases with DB_AM_SECONDARY set.
  1332.  */
  1333. if (flags != DB_NODUPDATA && !F_ISSET(dbp, DB_AM_SECONDARY))
  1334. __db_err(dbp->dbenv,
  1335.     "Duplicate data items are not supported with sorted data");
  1336. return (DB_KEYEXIST);
  1337. }
  1338. /*
  1339.  * __db_c_cleanup --
  1340.  * Clean up duplicate cursors.
  1341.  */
  1342. static int
  1343. __db_c_cleanup(dbc, dbc_n, failed)
  1344. DBC *dbc, *dbc_n;
  1345. int failed;
  1346. {
  1347. DB *dbp;
  1348. DBC *opd;
  1349. DBC_INTERNAL *internal;
  1350. DB_MPOOLFILE *mpf;
  1351. int ret, t_ret;
  1352. dbp = dbc->dbp;
  1353. mpf = dbp->mpf;
  1354. internal = dbc->internal;
  1355. ret = 0;
  1356. /* Discard any pages we're holding. */
  1357. if (internal->page != NULL) {
  1358. if ((t_ret = mpf->put(mpf, internal->page, 0)) != 0 && ret == 0)
  1359. ret = t_ret;
  1360. internal->page = NULL;
  1361. }
  1362. opd = internal->opd;
  1363. if (opd != NULL && opd->internal->page != NULL) {
  1364. if ((t_ret =
  1365.     mpf->put(mpf, opd->internal->page, 0)) != 0 && ret == 0)
  1366. ret = t_ret;
  1367.  opd->internal->page = NULL;
  1368. }
  1369. /*
  1370.  * If dbc_n is NULL, there's no internal cursor swapping to be done
  1371.  * and no dbc_n to close--we probably did the entire operation on an
  1372.  * offpage duplicate cursor.  Just return.
  1373.  *
  1374.  * If dbc and dbc_n are the same, we're either inside a DB->{put/get}
  1375.  * operation, and as an optimization we performed the operation on
  1376.  * the main cursor rather than on a duplicated one, or we're in a
  1377.  * bulk get that can't have moved the cursor (DB_MULTIPLE with the
  1378.  * initial c_get operation on an off-page dup cursor).  Just
  1379.  * return--either we know we didn't move the cursor, or we're going
  1380.  * to close it before we return to application code, so we're sure
  1381.  * not to visibly violate the "cursor stays put on error" rule.
  1382.  */
  1383. if (dbc_n == NULL || dbc == dbc_n)
  1384. return (ret);
  1385. if (dbc_n->internal->page != NULL) {
  1386. if ((t_ret =
  1387.     mpf->put(mpf, dbc_n->internal->page, 0)) != 0 && ret == 0)
  1388. ret = t_ret;
  1389. dbc_n->internal->page = NULL;
  1390. }
  1391. opd = dbc_n->internal->opd;
  1392. if (opd != NULL && opd->internal->page != NULL) {
  1393. if ((t_ret =
  1394.     mpf->put(mpf, opd->internal->page, 0)) != 0 && ret == 0)
  1395. ret = t_ret;
  1396. opd->internal->page = NULL;
  1397. }
  1398. /*
  1399.  * If we didn't fail before entering this routine or just now when
  1400.  * freeing pages, swap the interesting contents of the old and new
  1401.  * cursors.
  1402.  */
  1403. if (!failed && ret == 0) {
  1404. dbc->internal = dbc_n->internal;
  1405. dbc_n->internal = internal;
  1406. }
  1407. /*
  1408.  * Close the cursor we don't care about anymore.  The close can fail,
  1409.  * but we only expect DB_LOCK_DEADLOCK failures.  This violates our
  1410.  * "the cursor is unchanged on error" semantics, but since all you can
  1411.  * do with a DB_LOCK_DEADLOCK failure is close the cursor, I believe
  1412.  * that's OK.
  1413.  *
  1414.  * XXX
  1415.  * There's no way to recover from failure to close the old cursor.
  1416.  * All we can do is move to the new position and return an error.
  1417.  *
  1418.  * XXX
  1419.  * We might want to consider adding a flag to the cursor, so that any
  1420.  * subsequent operations other than close just return an error?
  1421.  */
  1422. if ((t_ret = dbc_n->c_close(dbc_n)) != 0 && ret == 0)
  1423. ret = t_ret;
  1424. return (ret);
  1425. }
  1426. /*
  1427.  * __db_c_secondary_get --
  1428.  * This wrapper function for DBC->c_pget() is the DBC->c_get() function
  1429.  * for a secondary index cursor.
  1430.  *
  1431.  * PUBLIC: int __db_c_secondary_get __P((DBC *, DBT *, DBT *, u_int32_t));
  1432.  */
  1433. int
  1434. __db_c_secondary_get(dbc, skey, data, flags)
  1435. DBC *dbc;
  1436. DBT *skey, *data;
  1437. u_int32_t flags;
  1438. {
  1439. DB_ASSERT(F_ISSET(dbc->dbp, DB_AM_SECONDARY));
  1440. return (dbc->c_pget(dbc, skey, NULL, data, flags));
  1441. }
  1442. /*
  1443.  * __db_c_pget --
  1444.  * Get a primary key/data pair through a secondary index.
  1445.  *
  1446.  * PUBLIC: int __db_c_pget __P((DBC *, DBT *, DBT *, DBT *, u_int32_t));
  1447.  */
  1448. int
  1449. __db_c_pget(dbc, skey, pkey, data, flags)
  1450. DBC *dbc;
  1451. DBT *skey, *pkey, *data;
  1452. u_int32_t flags;
  1453. {
  1454. DB *pdbp, *sdbp;
  1455. DBC *pdbc;
  1456. DBT *save_rdata, nullpkey;
  1457. int pkeymalloc, ret, save_pkey_flags, t_ret;
  1458. sdbp = dbc->dbp;
  1459. pdbp = sdbp->s_primary;
  1460. pkeymalloc = t_ret = 0;
  1461. PANIC_CHECK(sdbp->dbenv);
  1462. if ((ret = __db_cpgetchk(sdbp,
  1463.     skey, pkey, data, flags, IS_INITIALIZED(dbc))) != 0)
  1464. return (ret);
  1465. /*
  1466.  * The challenging part of this function is getting the behavior
  1467.  * right for all the various permutations of DBT flags.  The
  1468.  * next several blocks handle the various cases we need to
  1469.  * deal with specially.
  1470.  */
  1471. /*
  1472.  * We may be called with a NULL pkey argument, if we've been
  1473.  * wrapped by a 2-DBT get call.  If so, we need to use our
  1474.  * own DBT.
  1475.  */
  1476. if (pkey == NULL) {
  1477. memset(&nullpkey, 0, sizeof(DBT));
  1478. pkey = &nullpkey;
  1479. }
  1480. /*
  1481.  * DB_GET_RECNO is a special case, because we're interested not in
  1482.  * the primary key/data pair, but rather in the primary's record
  1483.  * number.
  1484.  */
  1485. if ((flags & DB_OPFLAGS_MASK) == DB_GET_RECNO)
  1486. return (__db_c_pget_recno(dbc, pkey, data, flags));
  1487. /*
  1488.  * If the DBTs we've been passed don't have any of the
  1489.  * user-specified memory management flags set, we want to make sure
  1490.  * we return values using the DBTs dbc->rskey, dbc->rkey, and
  1491.  * dbc->rdata, respectively.
  1492.  *
  1493.  * There are two tricky aspects to this:  first, we need to pass
  1494.  * skey and pkey *in* to the initial c_get on the secondary key,
  1495.  * since either or both may be looked at by it (depending on the
  1496.  * get flag).  Second, we must not use a normal DB->get call
  1497.  * on the secondary, even though that's what we want to accomplish,
  1498.  * because the DB handle may be free-threaded.  Instead,
  1499.  * we open a cursor, then take steps to ensure that we actually use
  1500.  * the rkey/rdata from the *secondary* cursor.
  1501.  *
  1502.  * We accomplish all this by passing in the DBTs we started out
  1503.  * with to the c_get, but having swapped the contents of rskey and
  1504.  * rkey, respectively, into rkey and rdata;  __db_ret will treat
  1505.  * them like the normal key/data pair in a c_get call, and will
  1506.  * realloc them as need be (this is "step 1").  Then, for "step 2",
  1507.  * we swap back rskey/rkey/rdata to normal, and do a get on the primary
  1508.  * with the secondary dbc appointed as the owner of the returned-data
  1509.  * memory.
  1510.  *
  1511.  * Note that in step 2, we copy the flags field in case we need to
  1512.  * pass down a DB_DBT_PARTIAL or other flag that is compatible with
  1513.  * letting DB do the memory management.
  1514.  */
  1515. /* Step 1. */
  1516. save_rdata = dbc->rdata;
  1517. dbc->rdata = dbc->rkey;
  1518. dbc->rkey = dbc->rskey;
  1519. /*
  1520.  * It is correct, though slightly sick, to attempt a partial get
  1521.  * of a primary key.  However, if we do so here, we'll never find the
  1522.  * primary record;  clear the DB_DBT_PARTIAL field of pkey just
  1523.  * for the duration of the next call.
  1524.  */
  1525. save_pkey_flags = pkey->flags;
  1526. F_CLR(pkey, DB_DBT_PARTIAL);
  1527. /*
  1528.  * Now we can go ahead with the meat of this call.  First, get the
  1529.  * primary key from the secondary index.  (What exactly we get depends
  1530.  * on the flags, but the underlying cursor get will take care of the
  1531.  * dirty work.)
  1532.  */
  1533. if ((ret = dbc->c_real_get(dbc, skey, pkey, flags)) != 0) {
  1534. /* Restore rskey/rkey/rdata and return. */
  1535. pkey->flags = save_pkey_flags;
  1536. dbc->rskey = dbc->rkey;
  1537. dbc->rkey = dbc->rdata;
  1538. dbc->rdata = save_rdata;
  1539. goto err;
  1540. }
  1541. /* Restore pkey's flags in case we stomped the PARTIAL flag. */
  1542. pkey->flags = save_pkey_flags;
  1543. /*
  1544.  * Restore the cursor's rskey, rkey, and rdata DBTs.  If DB
  1545.  * is handling the memory management, we now have newly
  1546.  * reallocated buffers and ulens in rkey and rdata which we want
  1547.  * to put in rskey and rkey.  save_rdata contains the old value
  1548.  * of dbc->rdata.
  1549.  */
  1550. dbc->rskey = dbc->rkey;
  1551. dbc->rkey = dbc->rdata;
  1552. dbc->rdata = save_rdata;
  1553. /*
  1554.  * Now we're ready for "step 2".  If either or both of pkey and
  1555.  * data do not have memory management flags set--that is, if DB is
  1556.  * managing their memory--we need to swap around the rkey/rdata
  1557.  * structures so that we don't wind up trying to use memory managed
  1558.  * by the primary database cursor, which we'll close before we return.
  1559.  *
  1560.  * !!!
  1561.  * If you're carefully following the bouncing ball, you'll note
  1562.  * that in the DB-managed case, the buffer hanging off of pkey is
  1563.  * the same as dbc->rkey->data.  This is just fine;  we may well
  1564.  * realloc and stomp on it when we return, if we're going a
  1565.  * DB_GET_BOTH and need to return a different partial or key
  1566.  * (depending on the comparison function), but this is safe.
  1567.  *
  1568.  * !!!
  1569.  * We need to use __db_icursor here rather than simply calling
  1570.  * pdbp->cursor, because otherwise, if we're in CDB, we'll
  1571.  * allocate a new locker ID and leave ourselves open to deadlocks.
  1572.  * (Even though we're only acquiring read locks, we'll still block
  1573.  * if there are any waiters.)
  1574.  */
  1575. if ((ret = __db_icursor(pdbp,
  1576.     dbc->txn, pdbp->type, PGNO_INVALID, 0, dbc->locker, &pdbc)) != 0)
  1577. goto err;
  1578. /*
  1579.  * We're about to use pkey a second time.  If DB_DBT_MALLOC
  1580.  * is set on it, we'll leak the memory we allocated the first time.
  1581.  * Thus, set DB_DBT_REALLOC instead so that we reuse that memory
  1582.  * instead of leaking it.
  1583.  *
  1584.  * !!!
  1585.  * This assumes that the user must always specify a compatible
  1586.  * realloc function if a malloc function is specified.  I think
  1587.  * this is a reasonable requirement.
  1588.  */
  1589. if (F_ISSET(pkey, DB_DBT_MALLOC)) {
  1590. F_CLR(pkey, DB_DBT_MALLOC);
  1591. F_SET(pkey, DB_DBT_REALLOC);
  1592. pkeymalloc = 1;
  1593. }
  1594. /*
  1595.  * Do the actual get.  Set DBC_TRANSIENT since we don't care
  1596.  * about preserving the position on error, and it's faster.
  1597.  * SET_RET_MEM so that the secondary DBC owns any returned-data
  1598.  * memory.
  1599.  */
  1600. F_SET(pdbc, DBC_TRANSIENT);
  1601. SET_RET_MEM(pdbc, dbc);
  1602. ret = pdbc->c_get(pdbc, pkey, data, DB_SET);
  1603. /*
  1604.  * If the item wasn't found in the primary, this is a bug;
  1605.  * our secondary has somehow gotten corrupted, and contains
  1606.  * elements that don't correspond to anything in the primary.
  1607.  * Complain.
  1608.  */
  1609. if (ret == DB_NOTFOUND)
  1610. ret = __db_secondary_corrupt(pdbp);
  1611. /* Now close the primary cursor. */
  1612. t_ret = pdbc->c_close(pdbc);
  1613. err: if (pkeymalloc) {
  1614. /*
  1615.  * If pkey had a MALLOC flag, we need to restore it;
  1616.  * otherwise, if the user frees the buffer but reuses
  1617.  * the DBT without NULL'ing its data field or changing
  1618.  * the flags, we may drop core.
  1619.  */
  1620. F_CLR(pkey, DB_DBT_REALLOC);
  1621. F_SET(pkey, DB_DBT_MALLOC);
  1622. }
  1623. return (t_ret == 0 ? ret : t_ret);
  1624. }
  1625. /*
  1626.  * __db_c_pget_recno --
  1627.  * Perform a DB_GET_RECNO c_pget on a secondary index.  Returns
  1628.  * the secondary's record number in the pkey field and the primary's
  1629.  * in the data field.
  1630.  */
  1631. static int
  1632. __db_c_pget_recno(sdbc, pkey, data, flags)
  1633. DBC *sdbc;
  1634. DBT *pkey, *data;
  1635. u_int32_t flags;
  1636. {
  1637. DB *pdbp, *sdbp;
  1638. DB_ENV *dbenv;
  1639. DBC *pdbc;
  1640. DBT discardme, primary_key;
  1641. db_recno_t oob;
  1642. u_int32_t rmw;
  1643. int ret, t_ret;
  1644. sdbp = sdbc->dbp;
  1645. pdbp = sdbp->s_primary;
  1646. dbenv = sdbp->dbenv;
  1647. pdbc = NULL;
  1648. ret = t_ret = 0;
  1649. rmw = LF_ISSET(DB_RMW);
  1650. memset(&discardme, 0, sizeof(DBT));
  1651. F_SET(&discardme, DB_DBT_USERMEM | DB_DBT_PARTIAL);
  1652. oob = RECNO_OOB;
  1653. /*
  1654.  * If the primary is an rbtree, we want its record number, whether
  1655.  * or not the secondary is one too.  Fetch the recno into "data".
  1656.  *
  1657.  * If it's not an rbtree, return RECNO_OOB in "data".
  1658.  */
  1659. if (F_ISSET(pdbp, DB_AM_RECNUM)) {
  1660. /*
  1661.  * Get the primary key, so we can find the record number
  1662.  * in the primary. (We're uninterested in the secondary key.)
  1663.  */
  1664. memset(&primary_key, 0, sizeof(DBT));
  1665. F_SET(&primary_key, DB_DBT_MALLOC);
  1666. if ((ret = sdbc->c_real_get(sdbc,
  1667.     &discardme, &primary_key, rmw | DB_CURRENT)) != 0)
  1668. return (ret);
  1669. /*
  1670.  * Open a cursor on the primary, set it to the right record,
  1671.  * and fetch its recno into "data".
  1672.  *
  1673.  * (See __db_c_pget for a comment on the use of __db_icursor.)
  1674.  *
  1675.  * SET_RET_MEM so that the secondary DBC owns any returned-data
  1676.  * memory.
  1677.  */
  1678. if ((ret = __db_icursor(pdbp, sdbc->txn,
  1679.     pdbp->type, PGNO_INVALID, 0, sdbc->locker, &pdbc)) != 0)
  1680. goto perr;
  1681. SET_RET_MEM(pdbc, sdbc);
  1682. if ((ret = pdbc->c_get(pdbc,
  1683.     &primary_key, &discardme, rmw | DB_SET)) != 0)
  1684. goto perr;
  1685. ret = pdbc->c_get(pdbc, &discardme, data, rmw | DB_GET_RECNO);
  1686. perr: __os_ufree(sdbp->dbenv, primary_key.data);
  1687. if (pdbc != NULL &&
  1688.     (t_ret = pdbc->c_close(pdbc)) != 0 && ret == 0)
  1689. ret = t_ret;
  1690. if (ret != 0)
  1691. return (ret);
  1692. } else if ((ret = __db_retcopy(dbenv, data, &oob,
  1693.     sizeof(oob), &sdbc->rkey->data, &sdbc->rkey->ulen)) != 0)
  1694. return (ret);
  1695. /*
  1696.  * If the secondary is an rbtree, we want its record number, whether
  1697.  * or not the primary is one too.  Fetch the recno into "pkey".
  1698.  *
  1699.  * If it's not an rbtree, return RECNO_OOB in "pkey".
  1700.  */
  1701. if (F_ISSET(sdbp, DB_AM_RECNUM))
  1702. return (sdbc->c_real_get(sdbc, &discardme, pkey, flags));
  1703. else
  1704. return (__db_retcopy(dbenv, pkey, &oob,
  1705.     sizeof(oob), &sdbc->rdata->data, &sdbc->rdata->ulen));
  1706. }
  1707. /*
  1708.  * __db_wrlock_err -- do not have a write lock.
  1709.  */
  1710. static int
  1711. __db_wrlock_err(dbenv)
  1712. DB_ENV *dbenv;
  1713. {
  1714. __db_err(dbenv, "Write attempted on read-only cursor");
  1715. return (EPERM);
  1716. }
  1717. /*
  1718.  * __db_c_del_secondary --
  1719.  * Perform a delete operation on a secondary index:  call through
  1720.  * to the primary and delete the primary record that this record
  1721.  * points to.
  1722.  *
  1723.  * Note that deleting the primary record will call c_del on all
  1724.  * the secondaries, including this one;  thus, it is not necessary
  1725.  * to execute both this function and an actual delete.
  1726.  *
  1727.  */
  1728. static int
  1729. __db_c_del_secondary(dbc)
  1730. DBC *dbc;
  1731. {
  1732. DB *pdbp;
  1733. DBC *pdbc;
  1734. DBT skey, pkey;
  1735. int ret, t_ret;
  1736. memset(&skey, 0, sizeof(DBT));
  1737. memset(&pkey, 0, sizeof(DBT));
  1738. /*
  1739.  * Get the current item that we're pointing at.
  1740.  * We don't actually care about the secondary key, just
  1741.  * the primary.
  1742.  */
  1743. F_SET(&skey, DB_DBT_PARTIAL | DB_DBT_USERMEM);
  1744. if ((ret = dbc->c_real_get(dbc,
  1745.     &skey, &pkey, DB_CURRENT)) != 0)
  1746. return (ret);
  1747. /*
  1748.  * Create a cursor on the primary with our locker ID,
  1749.  * so that when it calls back, we don't conflict.
  1750.  *
  1751.  * We create a cursor explicitly because there's no
  1752.  * way to specify the same locker ID if we're using
  1753.  * locking but not transactions if we use the DB->del
  1754.  * interface.  This shouldn't be any less efficient
  1755.  * anyway.
  1756.  */
  1757. pdbp = dbc->dbp->s_primary;
  1758. if ((ret = __db_icursor(pdbp, dbc->txn,
  1759.     pdbp->type, PGNO_INVALID, 0, dbc->locker, &pdbc)) != 0)
  1760. return (ret);
  1761. /*
  1762.  * See comment in __db_c_put--if we're in CDB,
  1763.  * we already hold the locks we need, and we need to flag
  1764.  * the cursor as a WRITER so we don't run into errors
  1765.  * when we try to delete.
  1766.  */
  1767. if (CDB_LOCKING(pdbp->dbenv)) {
  1768. DB_ASSERT(pdbc->mylock.off == LOCK_INVALID);
  1769. F_SET(pdbc, DBC_WRITER);
  1770. }
  1771. /*
  1772.  * Set the new cursor to the correct primary key.  Then
  1773.  * delete it.  We don't really care about the datum;
  1774.  * just reuse our skey DBT.
  1775.  *
  1776.  * If the primary get returns DB_NOTFOUND, something is amiss--
  1777.  * every record in the secondary should correspond to some record
  1778.  * in the primary.
  1779.  */
  1780. if ((ret = pdbc->c_get(pdbc, &pkey, &skey,
  1781.     (STD_LOCKING(dbc) ? DB_RMW : 0) | DB_SET)) == 0)
  1782. ret = pdbc->c_del(pdbc, 0);
  1783. else if (ret == DB_NOTFOUND)
  1784. ret = __db_secondary_corrupt(pdbp);
  1785. if ((t_ret = pdbc->c_close(pdbc)) != 0 && ret != 0)
  1786. ret = t_ret;
  1787. return (ret);
  1788. }
  1789. /*
  1790.  * __db_c_del_primary --
  1791.  * Perform a delete operation on a primary index.  Loop through
  1792.  * all the secondary indices which correspond to this primary
  1793.  * database, and delete any secondary keys that point at the current
  1794.  * record.
  1795.  *
  1796.  * PUBLIC: int __db_c_del_primary __P((DBC *));
  1797.  */
  1798. int
  1799. __db_c_del_primary(dbc)
  1800. DBC *dbc;
  1801. {
  1802. DB *dbp, *sdbp;
  1803. DBC *sdbc;
  1804. DBT data, pkey, skey, temp;
  1805. int ret, t_ret;
  1806. dbp = dbc->dbp;
  1807. /*
  1808.  * If we're called at all, we have at least one secondary.
  1809.  * (Unfortunately, we can't assert this without grabbing the mutex.)
  1810.  * Get the current record so that we can construct appropriate
  1811.  * secondary keys as needed.
  1812.  */
  1813. memset(&pkey, 0, sizeof(DBT));
  1814. memset(&data, 0, sizeof(DBT));
  1815. if ((ret = dbc->c_get(dbc, &pkey, &data, DB_CURRENT)) != 0)
  1816. return (ret);
  1817. for (sdbp = __db_s_first(dbp);
  1818.     sdbp != NULL && ret == 0; ret = __db_s_next(&sdbp)) {
  1819. /*
  1820.  * Get the secondary key for this secondary and the current
  1821.  * item.
  1822.  */
  1823. memset(&skey, 0, sizeof(DBT));
  1824. if ((ret = sdbp->s_callback(sdbp, &pkey, &data, &skey)) != 0) {
  1825. /*
  1826.  * If the current item isn't in this index, we
  1827.  * have no work to do.  Proceed.
  1828.  */
  1829. if (ret == DB_DONOTINDEX)
  1830. continue;
  1831. /* We had a substantive error.  Bail. */
  1832. FREE_IF_NEEDED(sdbp, &skey);
  1833. goto done;
  1834. }
  1835. /* Open a secondary cursor. */
  1836. if ((ret = __db_icursor(sdbp, dbc->txn, sdbp->type,
  1837.     PGNO_INVALID, 0, dbc->locker, &sdbc)) != 0)
  1838. goto done;
  1839. /* See comment above and in __db_c_put. */
  1840. if (CDB_LOCKING(sdbp->dbenv)) {
  1841. DB_ASSERT(sdbc->mylock.off == LOCK_INVALID);
  1842. F_SET(sdbc, DBC_WRITER);
  1843. }
  1844. /*
  1845.  * Set the secondary cursor to the appropriate item.
  1846.  * Delete it.
  1847.  *
  1848.  * We want to use DB_RMW if locking is on;  it's only
  1849.  * legal then, though.
  1850.  *
  1851.  * !!!
  1852.  * Don't stomp on any callback-allocated buffer in skey
  1853.  * when we do a c_get(DB_GET_BOTH);  use a temp DBT instead.
  1854.  */
  1855. memset(&temp, 0, sizeof(DBT));
  1856. temp.data = skey.data;
  1857. temp.size = skey.size;
  1858. if ((ret = sdbc->c_real_get(sdbc, &temp, &pkey,
  1859.     (STD_LOCKING(dbc) ? DB_RMW : 0) | DB_GET_BOTH)) == 0)
  1860. ret = sdbc->c_del(sdbc, DB_UPDATE_SECONDARY);
  1861. FREE_IF_NEEDED(sdbp, &skey);
  1862. if ((t_ret = sdbc->c_close(sdbc)) != 0 || ret != 0) {
  1863. if (ret == 0)
  1864. ret = t_ret;
  1865. goto done;
  1866. }
  1867. }
  1868. done: if (sdbp != NULL && (t_ret = __db_s_done(sdbp)) != 0 && ret == 0)
  1869. return (t_ret);
  1870. return (ret);
  1871. }
  1872. /*
  1873.  * __db_s_first --
  1874.  * Get the first secondary, if any are present, from the primary.
  1875.  *
  1876.  * PUBLIC: DB *__db_s_first __P((DB *));
  1877.  */
  1878. DB *
  1879. __db_s_first(pdbp)
  1880. DB *pdbp;
  1881. {
  1882. DB *sdbp;
  1883. MUTEX_THREAD_LOCK(pdbp->dbenv, pdbp->mutexp);
  1884. sdbp = LIST_FIRST(&pdbp->s_secondaries);
  1885. /* See __db_s_next. */
  1886. if (sdbp != NULL)
  1887. sdbp->s_refcnt++;
  1888. MUTEX_THREAD_UNLOCK(pdbp->dbenv, pdbp->mutexp);
  1889. return (sdbp);
  1890. }
  1891. /*
  1892.  * __db_s_next --
  1893.  * Get the next secondary in the list.
  1894.  *
  1895.  * PUBLIC: int __db_s_next __P((DB **));
  1896.  */
  1897. int
  1898. __db_s_next(sdbpp)
  1899. DB **sdbpp;
  1900. {
  1901. DB *sdbp, *pdbp, *closeme;
  1902. int ret;
  1903. /*
  1904.  * Secondary indices are kept in a linked list, s_secondaries,
  1905.  * off each primary DB handle.  If a primary is free-threaded,
  1906.  * this list may only be traversed or modified while the primary's
  1907.  * thread mutex is held.
  1908.  *
  1909.  * The tricky part is that we don't want to hold the thread mutex
  1910.  * across the full set of secondary puts necessary for each primary
  1911.  * put, or we'll wind up essentially single-threading all the puts
  1912.  * to the handle;  the secondary puts will each take about as
  1913.  * long as the primary does, and may require I/O.  So we instead
  1914.  * hold the thread mutex only long enough to follow one link to the
  1915.  * next secondary, and then we release it before performing the
  1916.  * actual secondary put.
  1917.  *
  1918.  * The only danger here is that we might legitimately close a
  1919.  * secondary index in one thread while another thread is performing
  1920.  * a put and trying to update that same secondary index.  To
  1921.  * prevent this from happening, we refcount the secondary handles.
  1922.  * If close is called on a secondary index handle while we're putting
  1923.  * to it, it won't really be closed--the refcount will simply drop,
  1924.  * and we'll be responsible for closing it here.
  1925.  */
  1926. sdbp = *sdbpp;
  1927. pdbp = sdbp->s_primary;
  1928. closeme = NULL;
  1929. MUTEX_THREAD_LOCK(pdbp->dbenv, pdbp->mutexp);
  1930. DB_ASSERT(sdbp->s_refcnt != 0);
  1931. if (--sdbp->s_refcnt == 0) {
  1932. LIST_REMOVE(sdbp, s_links);
  1933. closeme = sdbp;
  1934. }
  1935. sdbp = LIST_NEXT(sdbp, s_links);
  1936. if (sdbp != NULL)
  1937. sdbp->s_refcnt++;
  1938. MUTEX_THREAD_UNLOCK(pdbp->dbenv, pdbp->mutexp);
  1939. *sdbpp = sdbp;
  1940. /*
  1941.  * closeme->close() is a wrapper;  call __db_close explicitly.
  1942.  */
  1943. ret = closeme != NULL ? __db_close(closeme, 0) : 0;
  1944. return (ret);
  1945. }
  1946. /*
  1947.  * __db_s_done --
  1948.  * Properly decrement the refcount on a secondary database handle we're
  1949.  * using, without calling __db_s_next.
  1950.  *
  1951.  * PUBLIC: int __db_s_done __P((DB *));
  1952.  */
  1953. int
  1954. __db_s_done(sdbp)
  1955. DB *sdbp;
  1956. {
  1957. DB *pdbp;
  1958. int doclose;
  1959. pdbp = sdbp->s_primary;
  1960. doclose = 0;
  1961. MUTEX_THREAD_LOCK(pdbp->dbenv, pdbp->mutexp);
  1962. DB_ASSERT(sdbp->s_refcnt != 0);
  1963. if (--sdbp->s_refcnt == 0) {
  1964. LIST_REMOVE(sdbp, s_links);
  1965. doclose = 1;
  1966. }
  1967. MUTEX_THREAD_UNLOCK(pdbp->dbenv, pdbp->mutexp);
  1968. return (doclose ? __db_close(sdbp, 0) : 0);
  1969. }
  1970. /*
  1971.  * __db_buildpartial --
  1972.  * Build the record that will result after a partial put is applied to
  1973.  * an existing record.
  1974.  *
  1975.  * This should probably be merged with __bam_build, but that requires
  1976.  * a little trickery if we plan to keep the overflow-record optimization
  1977.  * in that function.
  1978.  */
  1979. static int
  1980. __db_buildpartial(dbp, oldrec, partial, newrec)
  1981. DB *dbp;
  1982. DBT *oldrec, *partial, *newrec;
  1983. {
  1984. int ret;
  1985. u_int8_t *buf;
  1986. u_int32_t len, nbytes;
  1987. DB_ASSERT(F_ISSET(partial, DB_DBT_PARTIAL));
  1988. memset(newrec, 0, sizeof(DBT));
  1989. nbytes = __db_partsize(oldrec->size, partial);
  1990. newrec->size = nbytes;
  1991. if ((ret = __os_malloc(dbp->dbenv, nbytes, &buf)) != 0)
  1992. return (ret);
  1993. newrec->data = buf;
  1994. /* Nul or pad out the buffer, for any part that isn't specified. */
  1995. memset(buf,
  1996.     F_ISSET(dbp, DB_AM_FIXEDLEN) ? ((BTREE *)dbp->bt_internal)->re_pad :
  1997.     0, nbytes);
  1998. /* Copy in any leading data from the original record. */
  1999. memcpy(buf, oldrec->data,
  2000.     partial->doff > oldrec->size ? oldrec->size : partial->doff);
  2001. /* Copy the data from partial. */
  2002. memcpy(buf + partial->doff, partial->data, partial->size);
  2003. /* Copy any trailing data from the original record. */
  2004. len = partial->doff + partial->dlen;
  2005. if (oldrec->size > len)
  2006. memcpy(buf + partial->doff + partial->size,
  2007.     (u_int8_t *)oldrec->data + len, oldrec->size - len);
  2008. return (0);
  2009. }
  2010. /*
  2011.  * __db_partsize --
  2012.  * Given the number of bytes in an existing record and a DBT that
  2013.  * is about to be partial-put, calculate the size of the record
  2014.  * after the put.
  2015.  *
  2016.  * This code is called from __bam_partsize.
  2017.  *
  2018.  * PUBLIC: u_int32_t __db_partsize __P((u_int32_t, DBT *));
  2019.  */
  2020. u_int32_t
  2021. __db_partsize(nbytes, data)
  2022. u_int32_t nbytes;
  2023. DBT *data;
  2024. {
  2025. /*
  2026.  * There are really two cases here:
  2027.  *
  2028.  * Case 1: We are replacing some bytes that do not exist (i.e., they
  2029.  * are past the end of the record).  In this case the number of bytes
  2030.  * we are replacing is irrelevant and all we care about is how many
  2031.  * bytes we are going to add from offset.  So, the new record length
  2032.  * is going to be the size of the new bytes (size) plus wherever those
  2033.  * new bytes begin (doff).
  2034.  *
  2035.  * Case 2: All the bytes we are replacing exist.  Therefore, the new
  2036.  * size is the oldsize (nbytes) minus the bytes we are replacing (dlen)
  2037.  * plus the bytes we are adding (size).
  2038.  */
  2039. if (nbytes < data->doff + data->dlen) /* Case 1 */
  2040. return (data->doff + data->size);
  2041. return (nbytes + data->size - data->dlen); /* Case 2 */
  2042. }