diff options
Diffstat (limited to 'storage/bdb/db/db_cam.c')
| -rw-r--r-- | storage/bdb/db/db_cam.c | 2286 |
1 files changed, 2286 insertions, 0 deletions
diff --git a/storage/bdb/db/db_cam.c b/storage/bdb/db/db_cam.c new file mode 100644 index 00000000000..4de3467d4aa --- /dev/null +++ b/storage/bdb/db/db_cam.c @@ -0,0 +1,2286 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 2000-2002 + * Sleepycat Software. All rights reserved. + */ + +#include "db_config.h" + +#ifndef lint +static const char revid[] = "$Id: db_cam.c,v 11.114 2002/09/03 15:44:46 krinsky Exp $"; +#endif /* not lint */ + +#ifndef NO_SYSTEM_INCLUDES +#include <sys/types.h> + +#include <string.h> +#endif + +#include "db_int.h" +#include "dbinc/db_page.h" +#include "dbinc/db_shash.h" +#include "dbinc/btree.h" +#include "dbinc/hash.h" +#include "dbinc/lock.h" +#include "dbinc/log.h" +#include "dbinc/qam.h" + +static int __db_buildpartial __P((DB *, DBT *, DBT *, DBT *)); +static int __db_c_cleanup __P((DBC *, DBC *, int)); +static int __db_c_del_secondary __P((DBC *)); +static int __db_c_pget_recno __P((DBC *, DBT *, DBT *, u_int32_t)); +static int __db_wrlock_err __P((DB_ENV *)); + +#define CDB_LOCKING_INIT(dbp, dbc) \ + /* \ + * If we are running CDB, this had better be either a write \ + * cursor or an immediate writer. If it's a regular writer, \ + * that means we have an IWRITE lock and we need to upgrade \ + * it to a write lock. \ + */ \ + if (CDB_LOCKING((dbp)->dbenv)) { \ + if (!F_ISSET(dbc, DBC_WRITECURSOR | DBC_WRITER)) \ + return (__db_wrlock_err(dbp->dbenv)); \ + \ + if (F_ISSET(dbc, DBC_WRITECURSOR) && \ + (ret = (dbp)->dbenv->lock_get((dbp)->dbenv, \ + (dbc)->locker, DB_LOCK_UPGRADE, &(dbc)->lock_dbt, \ + DB_LOCK_WRITE, &(dbc)->mylock)) != 0) \ + return (ret); \ + } +#define CDB_LOCKING_DONE(dbp, dbc) \ + /* Release the upgraded lock. */ \ + if (F_ISSET(dbc, DBC_WRITECURSOR)) \ + (void)__lock_downgrade( \ + (dbp)->dbenv, &(dbc)->mylock, DB_LOCK_IWRITE, 0); +/* + * Copy the lock info from one cursor to another, so that locking + * in CDB can be done in the context of an internally-duplicated + * or off-page-duplicate cursor. + */ +#define CDB_LOCKING_COPY(dbp, dbc_o, dbc_n) \ + if (CDB_LOCKING((dbp)->dbenv) && \ + F_ISSET((dbc_o), DBC_WRITECURSOR | DBC_WRITEDUP)) { \ + memcpy(&(dbc_n)->mylock, &(dbc_o)->mylock, \ + sizeof((dbc_o)->mylock)); \ + /* This lock isn't ours to put--just discard it on close. */ \ + F_SET((dbc_n), DBC_WRITEDUP); \ + } + +/* + * __db_c_close -- + * Close the cursor. + * + * PUBLIC: int __db_c_close __P((DBC *)); + */ +int +__db_c_close(dbc) + DBC *dbc; +{ + DB *dbp; + DBC *opd; + DBC_INTERNAL *cp; + DB_ENV *dbenv; + int ret, t_ret; + + dbp = dbc->dbp; + dbenv = dbp->dbenv; + ret = 0; + + PANIC_CHECK(dbenv); + + /* + * If the cursor is already closed we have a serious problem, and we + * assume that the cursor isn't on the active queue. Don't do any of + * the remaining cursor close processing. + */ + if (!F_ISSET(dbc, DBC_ACTIVE)) { + if (dbp != NULL) + __db_err(dbenv, "Closing already-closed cursor"); + + DB_ASSERT(0); + return (EINVAL); + } + + cp = dbc->internal; + opd = cp->opd; + + /* + * Remove the cursor(s) from the active queue. We may be closing two + * cursors at once here, a top-level one and a lower-level, off-page + * duplicate one. The acess-method specific cursor close routine must + * close both of them in a single call. + * + * !!! + * Cursors must be removed from the active queue before calling the + * access specific cursor close routine, btree depends on having that + * order of operations. + */ + MUTEX_THREAD_LOCK(dbenv, dbp->mutexp); + + if (opd != NULL) { + F_CLR(opd, DBC_ACTIVE); + TAILQ_REMOVE(&dbp->active_queue, opd, links); + } + F_CLR(dbc, DBC_ACTIVE); + TAILQ_REMOVE(&dbp->active_queue, dbc, links); + + MUTEX_THREAD_UNLOCK(dbenv, dbp->mutexp); + + /* Call the access specific cursor close routine. */ + if ((t_ret = + dbc->c_am_close(dbc, PGNO_INVALID, NULL)) != 0 && ret == 0) + ret = t_ret; + + /* + * Release the lock after calling the access method specific close + * routine, a Btree cursor may have had pending deletes. + */ + if (CDB_LOCKING(dbenv)) { + /* + * If DBC_WRITEDUP is set, the cursor is an internally + * duplicated write cursor and the lock isn't ours to put. + * + * Also, be sure not to free anything if mylock.off is + * INVALID; in some cases, such as idup'ed read cursors + * and secondary update cursors, a cursor in a CDB + * environment may not have a lock at all. + */ + if (!F_ISSET(dbc, DBC_WRITEDUP) && LOCK_ISSET(dbc->mylock)) { + if ((t_ret = dbenv->lock_put( + dbenv, &dbc->mylock)) != 0 && ret == 0) + ret = t_ret; + } + + /* For safety's sake, since this is going on the free queue. */ + memset(&dbc->mylock, 0, sizeof(dbc->mylock)); + F_CLR(dbc, DBC_WRITEDUP); + } + + if (dbc->txn != NULL) + dbc->txn->cursors--; + + /* Move the cursor(s) to the free queue. */ + MUTEX_THREAD_LOCK(dbenv, dbp->mutexp); + if (opd != NULL) { + if (dbc->txn != NULL) + dbc->txn->cursors--; + TAILQ_INSERT_TAIL(&dbp->free_queue, opd, links); + opd = NULL; + } + TAILQ_INSERT_TAIL(&dbp->free_queue, dbc, links); + MUTEX_THREAD_UNLOCK(dbenv, dbp->mutexp); + + return (ret); +} + +/* + * __db_c_destroy -- + * Destroy the cursor, called after DBC->c_close. + * + * PUBLIC: int __db_c_destroy __P((DBC *)); + */ +int +__db_c_destroy(dbc) + DBC *dbc; +{ + DB *dbp; + DB_ENV *dbenv; + int ret, t_ret; + + dbp = dbc->dbp; + dbenv = dbp->dbenv; + + /* Remove the cursor from the free queue. */ + MUTEX_THREAD_LOCK(dbenv, dbp->mutexp); + TAILQ_REMOVE(&dbp->free_queue, dbc, links); + MUTEX_THREAD_UNLOCK(dbenv, dbp->mutexp); + + /* Free up allocated memory. */ + if (dbc->my_rskey.data != NULL) + __os_free(dbenv, dbc->my_rskey.data); + if (dbc->my_rkey.data != NULL) + __os_free(dbenv, dbc->my_rkey.data); + if (dbc->my_rdata.data != NULL) + __os_free(dbenv, dbc->my_rdata.data); + + /* Call the access specific cursor destroy routine. */ + ret = dbc->c_am_destroy == NULL ? 0 : dbc->c_am_destroy(dbc); + + /* + * Release the lock id for this cursor. + */ + if (LOCKING_ON(dbenv) && + F_ISSET(dbc, DBC_OWN_LID) && + (t_ret = dbenv->lock_id_free(dbenv, dbc->lid)) != 0 && ret == 0) + ret = t_ret; + + __os_free(dbenv, dbc); + + return (ret); +} + +/* + * __db_c_count -- + * Return a count of duplicate data items. + * + * PUBLIC: int __db_c_count __P((DBC *, db_recno_t *, u_int32_t)); + */ +int +__db_c_count(dbc, recnop, flags) + DBC *dbc; + db_recno_t *recnop; + u_int32_t flags; +{ + DB *dbp; + int ret; + + /* + * Cursor Cleanup Note: + * All of the cursors passed to the underlying access methods by this + * routine are not duplicated and will not be cleaned up on return. + * So, pages/locks that the cursor references must be resolved by the + * underlying functions. + */ + dbp = dbc->dbp; + + PANIC_CHECK(dbp->dbenv); + + /* Check for invalid flags. */ + if ((ret = __db_ccountchk(dbp, flags, IS_INITIALIZED(dbc))) != 0) + return (ret); + + switch (dbc->dbtype) { + case DB_QUEUE: + case DB_RECNO: + *recnop = 1; + break; + case DB_HASH: + if (dbc->internal->opd == NULL) { + if ((ret = __ham_c_count(dbc, recnop)) != 0) + return (ret); + break; + } + /* FALLTHROUGH */ + case DB_BTREE: + if ((ret = __bam_c_count(dbc, recnop)) != 0) + return (ret); + break; + default: + return (__db_unknown_type(dbp->dbenv, + "__db_c_count", dbp->type)); + } + return (0); +} + +/* + * __db_c_del -- + * Delete using a cursor. + * + * PUBLIC: int __db_c_del __P((DBC *, u_int32_t)); + */ +int +__db_c_del(dbc, flags) + DBC *dbc; + u_int32_t flags; +{ + DB *dbp; + DBC *opd; + int ret; + + /* + * Cursor Cleanup Note: + * All of the cursors passed to the underlying access methods by this + * routine are not duplicated and will not be cleaned up on return. + * So, pages/locks that the cursor references must be resolved by the + * underlying functions. + */ + dbp = dbc->dbp; + + PANIC_CHECK(dbp->dbenv); + + /* Check for invalid flags. */ + if ((ret = __db_cdelchk(dbp, flags, IS_INITIALIZED(dbc))) != 0) + return (ret); + + /* Check for consistent transaction usage. */ + if ((ret = __db_check_txn(dbp, dbc->txn, dbc->locker, 0)) != 0) + return (ret); + + DEBUG_LWRITE(dbc, dbc->txn, "db_c_del", NULL, NULL, flags); + + CDB_LOCKING_INIT(dbp, dbc); + + /* + * If we're a secondary index, and DB_UPDATE_SECONDARY isn't set + * (which it only is if we're being called from a primary update), + * then we need to call through to the primary and delete the item. + * + * Note that this will delete the current item; we don't need to + * delete it ourselves as well, so we can just goto done. + */ + if (flags != DB_UPDATE_SECONDARY && F_ISSET(dbp, DB_AM_SECONDARY)) { + ret = __db_c_del_secondary(dbc); + goto done; + } + + /* + * If we are a primary and have secondary indices, go through + * and delete any secondary keys that point at the current record. + */ + if (LIST_FIRST(&dbp->s_secondaries) != NULL && + (ret = __db_c_del_primary(dbc)) != 0) + goto done; + + /* + * Off-page duplicate trees are locked in the primary tree, that is, + * we acquire a write lock in the primary tree and no locks in the + * off-page dup tree. If the del operation is done in an off-page + * duplicate tree, call the primary cursor's upgrade routine first. + */ + opd = dbc->internal->opd; + if (opd == NULL) + ret = dbc->c_am_del(dbc); + else + if ((ret = dbc->c_am_writelock(dbc)) == 0) + ret = opd->c_am_del(opd); + +done: CDB_LOCKING_DONE(dbp, dbc); + + return (ret); +} + +/* + * __db_c_dup -- + * Duplicate a cursor + * + * PUBLIC: int __db_c_dup __P((DBC *, DBC **, u_int32_t)); + */ +int +__db_c_dup(dbc_orig, dbcp, flags) + DBC *dbc_orig; + DBC **dbcp; + u_int32_t flags; +{ + DB_ENV *dbenv; + DB *dbp; + DBC *dbc_n, *dbc_nopd; + int ret; + + dbp = dbc_orig->dbp; + dbenv = dbp->dbenv; + dbc_n = dbc_nopd = NULL; + + PANIC_CHECK(dbp->dbenv); + + /* + * We can never have two write cursors open in CDB, so do not + * allow duplication of a write cursor. + */ + if (flags != DB_POSITIONI && + F_ISSET(dbc_orig, DBC_WRITER | DBC_WRITECURSOR)) { + __db_err(dbenv, "Cannot duplicate writeable cursor"); + return (EINVAL); + } + + /* Allocate a new cursor and initialize it. */ + if ((ret = __db_c_idup(dbc_orig, &dbc_n, flags)) != 0) + goto err; + *dbcp = dbc_n; + + /* + * If we're in CDB, and this isn't an internal duplication (in which + * case we're explicitly overriding CDB locking), the duplicated + * cursor needs its own read lock. (We know it's not a write cursor + * because we wouldn't have made it this far; you can't dup them.) + */ + if (CDB_LOCKING(dbenv) && flags != DB_POSITIONI) { + DB_ASSERT(!F_ISSET(dbc_orig, DBC_WRITER | DBC_WRITECURSOR)); + + if ((ret = dbenv->lock_get(dbenv, dbc_n->locker, 0, + &dbc_n->lock_dbt, DB_LOCK_READ, &dbc_n->mylock)) != 0) { + (void)__db_c_close(dbc_n); + return (ret); + } + } + + /* + * If the cursor references an off-page duplicate tree, allocate a + * new cursor for that tree and initialize it. + */ + if (dbc_orig->internal->opd != NULL) { + if ((ret = + __db_c_idup(dbc_orig->internal->opd, &dbc_nopd, flags)) != 0) + goto err; + dbc_n->internal->opd = dbc_nopd; + } + + /* Copy the dirty read flag to the new cursor. */ + F_SET(dbc_n, F_ISSET(dbc_orig, DBC_DIRTY_READ)); + return (0); + +err: if (dbc_n != NULL) + (void)dbc_n->c_close(dbc_n); + if (dbc_nopd != NULL) + (void)dbc_nopd->c_close(dbc_nopd); + + return (ret); +} + +/* + * __db_c_idup -- + * Internal version of __db_c_dup. + * + * PUBLIC: int __db_c_idup __P((DBC *, DBC **, u_int32_t)); + */ +int +__db_c_idup(dbc_orig, dbcp, flags) + DBC *dbc_orig, **dbcp; + u_int32_t flags; +{ + DB *dbp; + DBC *dbc_n; + DBC_INTERNAL *int_n, *int_orig; + int ret; + + dbp = dbc_orig->dbp; + dbc_n = *dbcp; + + if ((ret = __db_icursor(dbp, dbc_orig->txn, dbc_orig->dbtype, + dbc_orig->internal->root, F_ISSET(dbc_orig, DBC_OPD), + dbc_orig->locker, &dbc_n)) != 0) + return (ret); + + /* If the user wants the cursor positioned, do it here. */ + if (flags == DB_POSITION || flags == DB_POSITIONI) { + int_n = dbc_n->internal; + int_orig = dbc_orig->internal; + + dbc_n->flags |= dbc_orig->flags & ~DBC_OWN_LID; + + int_n->indx = int_orig->indx; + int_n->pgno = int_orig->pgno; + int_n->root = int_orig->root; + int_n->lock_mode = int_orig->lock_mode; + + switch (dbc_orig->dbtype) { + case DB_QUEUE: + if ((ret = __qam_c_dup(dbc_orig, dbc_n)) != 0) + goto err; + break; + case DB_BTREE: + case DB_RECNO: + if ((ret = __bam_c_dup(dbc_orig, dbc_n)) != 0) + goto err; + break; + case DB_HASH: + if ((ret = __ham_c_dup(dbc_orig, dbc_n)) != 0) + goto err; + break; + default: + ret = __db_unknown_type(dbp->dbenv, + "__db_c_idup", dbc_orig->dbtype); + goto err; + } + } + + /* Now take care of duping the CDB information. */ + CDB_LOCKING_COPY(dbp, dbc_orig, dbc_n); + + /* Copy the dirty read flag to the new cursor. */ + F_SET(dbc_n, F_ISSET(dbc_orig, DBC_DIRTY_READ)); + + *dbcp = dbc_n; + return (0); + +err: (void)dbc_n->c_close(dbc_n); + return (ret); +} + +/* + * __db_c_newopd -- + * Create a new off-page duplicate cursor. + * + * PUBLIC: int __db_c_newopd __P((DBC *, db_pgno_t, DBC *, DBC **)); + */ +int +__db_c_newopd(dbc_parent, root, oldopd, dbcp) + DBC *dbc_parent; + db_pgno_t root; + DBC *oldopd; + DBC **dbcp; +{ + DB *dbp; + DBC *opd; + DBTYPE dbtype; + int ret; + + dbp = dbc_parent->dbp; + dbtype = (dbp->dup_compare == NULL) ? DB_RECNO : DB_BTREE; + + /* + * On failure, we want to default to returning the old off-page dup + * cursor, if any; our caller can't be left with a dangling pointer + * to a freed cursor. On error the only allowable behavior is to + * close the cursor (and the old OPD cursor it in turn points to), so + * this should be safe. + */ + *dbcp = oldopd; + + if ((ret = __db_icursor(dbp, + dbc_parent->txn, dbtype, root, 1, dbc_parent->locker, &opd)) != 0) + return (ret); + + /* !!! + * If the parent is a DBC_WRITER, this won't copy anything. That's + * not actually a problem--we only need lock information in an + * off-page dup cursor in order to upgrade at cursor close time + * if we've done a delete, but WRITERs don't need to upgrade. + */ + CDB_LOCKING_COPY(dbp, dbc_parent, opd); + + *dbcp = opd; + + /* + * Check to see if we already have an off-page dup cursor that we've + * passed in. If we do, close it. It'd be nice to use it again + * if it's a cursor belonging to the right tree, but if we're doing + * a cursor-relative operation this might not be safe, so for now + * we'll take the easy way out and always close and reopen. + * + * Note that under no circumstances do we want to close the old + * cursor without returning a valid new one; we don't want to + * leave the main cursor in our caller with a non-NULL pointer + * to a freed off-page dup cursor. + */ + if (oldopd != NULL && (ret = oldopd->c_close(oldopd)) != 0) + return (ret); + + return (0); +} + +/* + * __db_c_get -- + * Get using a cursor. + * + * PUBLIC: int __db_c_get __P((DBC *, DBT *, DBT *, u_int32_t)); + */ +int +__db_c_get(dbc_arg, key, data, flags) + DBC *dbc_arg; + DBT *key, *data; + u_int32_t flags; +{ + DB *dbp; + DBC *dbc, *dbc_n, *opd; + DBC_INTERNAL *cp, *cp_n; + DB_MPOOLFILE *mpf; + db_pgno_t pgno; + u_int32_t multi, tmp_dirty, tmp_flags, tmp_rmw; + u_int8_t type; + int ret, t_ret; + + /* + * Cursor Cleanup Note: + * All of the cursors passed to the underlying access methods by this + * routine are duplicated cursors. On return, any referenced pages + * will be discarded, and, if the cursor is not intended to be used + * again, the close function will be called. So, pages/locks that + * the cursor references do not need to be resolved by the underlying + * functions. + */ + dbp = dbc_arg->dbp; + mpf = dbp->mpf; + dbc_n = NULL; + opd = NULL; + + PANIC_CHECK(dbp->dbenv); + + /* Check for invalid flags. */ + if ((ret = + __db_cgetchk(dbp, key, data, flags, IS_INITIALIZED(dbc_arg))) != 0) + return (ret); + + /* Clear OR'd in additional bits so we can check for flag equality. */ + tmp_rmw = LF_ISSET(DB_RMW); + LF_CLR(DB_RMW); + + tmp_dirty = LF_ISSET(DB_DIRTY_READ); + LF_CLR(DB_DIRTY_READ); + + multi = LF_ISSET(DB_MULTIPLE|DB_MULTIPLE_KEY); + LF_CLR(DB_MULTIPLE|DB_MULTIPLE_KEY); + + DEBUG_LREAD(dbc_arg, dbc_arg->txn, "db_c_get", + flags == DB_SET || flags == DB_SET_RANGE ? key : NULL, NULL, flags); + + /* + * Return a cursor's record number. It has nothing to do with the + * cursor get code except that it was put into the interface. + */ + if (flags == DB_GET_RECNO) { + if (tmp_rmw) + F_SET(dbc_arg, DBC_RMW); + if (tmp_dirty) + F_SET(dbc_arg, DBC_DIRTY_READ); + ret = __bam_c_rget(dbc_arg, data); + if (tmp_rmw) + F_CLR(dbc_arg, DBC_RMW); + if (tmp_dirty) + F_CLR(dbc_arg, DBC_DIRTY_READ); + return (ret); + } + + if (flags == DB_CONSUME || flags == DB_CONSUME_WAIT) + CDB_LOCKING_INIT(dbp, dbc_arg); + + /* + * If we have an off-page duplicates cursor, and the operation applies + * to it, perform the operation. Duplicate the cursor and call the + * underlying function. + * + * Off-page duplicate trees are locked in the primary tree, that is, + * we acquire a write lock in the primary tree and no locks in the + * off-page dup tree. If the DB_RMW flag was specified and the get + * operation is done in an off-page duplicate tree, call the primary + * cursor's upgrade routine first. + */ + cp = dbc_arg->internal; + if (cp->opd != NULL && + (flags == DB_CURRENT || flags == DB_GET_BOTHC || + flags == DB_NEXT || flags == DB_NEXT_DUP || flags == DB_PREV)) { + if (tmp_rmw && (ret = dbc_arg->c_am_writelock(dbc_arg)) != 0) + return (ret); + if ((ret = __db_c_idup(cp->opd, &opd, DB_POSITIONI)) != 0) + return (ret); + + switch (ret = + opd->c_am_get(opd, key, data, flags, NULL)) { + case 0: + goto done; + case DB_NOTFOUND: + /* + * Translate DB_NOTFOUND failures for the DB_NEXT and + * DB_PREV operations into a subsequent operation on + * the parent cursor. + */ + if (flags == DB_NEXT || flags == DB_PREV) { + if ((ret = opd->c_close(opd)) != 0) + goto err; + opd = NULL; + break; + } + goto err; + default: + goto err; + } + } + + /* + * Perform an operation on the main cursor. Duplicate the cursor, + * upgrade the lock as required, and call the underlying function. + */ + switch (flags) { + case DB_CURRENT: + case DB_GET_BOTHC: + case DB_NEXT: + case DB_NEXT_DUP: + case DB_NEXT_NODUP: + case DB_PREV: + case DB_PREV_NODUP: + tmp_flags = DB_POSITIONI; + break; + default: + tmp_flags = 0; + break; + } + + if (tmp_dirty) + F_SET(dbc_arg, DBC_DIRTY_READ); + + /* + * If this cursor is going to be closed immediately, we don't + * need to take precautions to clean it up on error. + */ + if (F_ISSET(dbc_arg, DBC_TRANSIENT)) + dbc_n = dbc_arg; + else { + ret = __db_c_idup(dbc_arg, &dbc_n, tmp_flags); + if (tmp_dirty) + F_CLR(dbc_arg, DBC_DIRTY_READ); + + if (ret != 0) + goto err; + COPY_RET_MEM(dbc_arg, dbc_n); + } + + if (tmp_rmw) + F_SET(dbc_n, DBC_RMW); + + switch (multi) { + case DB_MULTIPLE: + F_SET(dbc_n, DBC_MULTIPLE); + break; + case DB_MULTIPLE_KEY: + F_SET(dbc_n, DBC_MULTIPLE_KEY); + break; + case DB_MULTIPLE | DB_MULTIPLE_KEY: + F_SET(dbc_n, DBC_MULTIPLE|DBC_MULTIPLE_KEY); + break; + case 0: + break; + } + + pgno = PGNO_INVALID; + ret = dbc_n->c_am_get(dbc_n, key, data, flags, &pgno); + if (tmp_rmw) + F_CLR(dbc_n, DBC_RMW); + if (tmp_dirty) + F_CLR(dbc_arg, DBC_DIRTY_READ); + F_CLR(dbc_n, DBC_MULTIPLE|DBC_MULTIPLE_KEY); + if (ret != 0) + goto err; + + cp_n = dbc_n->internal; + + /* + * We may be referencing a new off-page duplicates tree. Acquire + * a new cursor and call the underlying function. + */ + if (pgno != PGNO_INVALID) { + if ((ret = __db_c_newopd(dbc_arg, + pgno, cp_n->opd, &cp_n->opd)) != 0) + goto err; + + switch (flags) { + case DB_FIRST: + case DB_NEXT: + case DB_NEXT_NODUP: + case DB_SET: + case DB_SET_RECNO: + case DB_SET_RANGE: + tmp_flags = DB_FIRST; + break; + case DB_LAST: + case DB_PREV: + case DB_PREV_NODUP: + tmp_flags = DB_LAST; + break; + case DB_GET_BOTH: + case DB_GET_BOTHC: + case DB_GET_BOTH_RANGE: + tmp_flags = flags; + break; + default: + ret = + __db_unknown_flag(dbp->dbenv, "__db_c_get", flags); + goto err; + } + if ((ret = cp_n->opd->c_am_get( + cp_n->opd, key, data, tmp_flags, NULL)) != 0) + goto err; + } + +done: /* + * Return a key/data item. The only exception is that we don't return + * a key if the user already gave us one, that is, if the DB_SET flag + * was set. The DB_SET flag is necessary. In a Btree, the user's key + * doesn't have to be the same as the key stored the tree, depending on + * the magic performed by the comparison function. As we may not have + * done any key-oriented operation here, the page reference may not be + * valid. Fill it in as necessary. We don't have to worry about any + * locks, the cursor must already be holding appropriate locks. + * + * XXX + * If not a Btree and DB_SET_RANGE is set, we shouldn't return a key + * either, should we? + */ + cp_n = dbc_n == NULL ? dbc_arg->internal : dbc_n->internal; + if (!F_ISSET(key, DB_DBT_ISSET)) { + if (cp_n->page == NULL && (ret = + mpf->get(mpf, &cp_n->pgno, 0, &cp_n->page)) != 0) + goto err; + + if ((ret = __db_ret(dbp, cp_n->page, cp_n->indx, + key, &dbc_arg->rkey->data, &dbc_arg->rkey->ulen)) != 0) + goto err; + } + if (multi != 0) { + /* + * Even if fetching from the OPD cursor we need a duplicate + * primary cursor if we are going after multiple keys. + */ + if (dbc_n == NULL) { + /* + * Non-"_KEY" DB_MULTIPLE doesn't move the main cursor, + * so it's safe to just use dbc_arg, unless dbc_arg + * has an open OPD cursor whose state might need to + * be preserved. + */ + if ((!(multi & DB_MULTIPLE_KEY) && + dbc_arg->internal->opd == NULL) || + F_ISSET(dbc_arg, DBC_TRANSIENT)) + dbc_n = dbc_arg; + else { + if ((ret = __db_c_idup(dbc_arg, + &dbc_n, DB_POSITIONI)) != 0) + goto err; + if ((ret = dbc_n->c_am_get(dbc_n, + key, data, DB_CURRENT, &pgno)) != 0) + goto err; + } + cp_n = dbc_n->internal; + } + + /* + * If opd is set then we dupped the opd that we came in with. + * When we return we may have a new opd if we went to another + * key. + */ + if (opd != NULL) { + DB_ASSERT(cp_n->opd == NULL); + cp_n->opd = opd; + opd = NULL; + } + + /* + * Bulk get doesn't use __db_retcopy, so data.size won't + * get set up unless there is an error. Assume success + * here. This is the only call to c_am_bulk, and it avoids + * setting it exactly the same everywhere. If we have an + * ENOMEM error, it'll get overwritten with the needed value. + */ + data->size = data->ulen; + ret = dbc_n->c_am_bulk(dbc_n, data, flags | multi); + } else if (!F_ISSET(data, DB_DBT_ISSET)) { + dbc = opd != NULL ? opd : cp_n->opd != NULL ? cp_n->opd : dbc_n; + type = TYPE(dbc->internal->page); + ret = __db_ret(dbp, dbc->internal->page, dbc->internal->indx + + (type == P_LBTREE || type == P_HASH ? O_INDX : 0), + data, &dbc_arg->rdata->data, &dbc_arg->rdata->ulen); + } + +err: /* Don't pass DB_DBT_ISSET back to application level, error or no. */ + F_CLR(key, DB_DBT_ISSET); + F_CLR(data, DB_DBT_ISSET); + + /* Cleanup and cursor resolution. */ + if (opd != NULL) { + if ((t_ret = __db_c_cleanup( + dbc_arg->internal->opd, opd, ret)) != 0 && ret == 0) + ret = t_ret; + + } + + if ((t_ret = __db_c_cleanup(dbc_arg, dbc_n, ret)) != 0 && ret == 0) + ret = t_ret; + + if (flags == DB_CONSUME || flags == DB_CONSUME_WAIT) + CDB_LOCKING_DONE(dbp, dbc_arg); + return (ret); +} + +/* + * __db_c_put -- + * Put using a cursor. + * + * PUBLIC: int __db_c_put __P((DBC *, DBT *, DBT *, u_int32_t)); + */ +int +__db_c_put(dbc_arg, key, data, flags) + DBC *dbc_arg; + DBT *key, *data; + u_int32_t flags; +{ + DB *dbp, *sdbp; + DBC *dbc_n, *oldopd, *opd, *sdbc, *pdbc; + DBT olddata, oldpkey, oldskey, newdata, pkey, save_skey, skey, temp; + db_pgno_t pgno; + int cmp, have_oldrec, ispartial, nodel, re_pad, ret, rmw, t_ret; + u_int32_t re_len, size, tmp_flags; + + /* + * Cursor Cleanup Note: + * All of the cursors passed to the underlying access methods by this + * routine are duplicated cursors. On return, any referenced pages + * will be discarded, and, if the cursor is not intended to be used + * again, the close function will be called. So, pages/locks that + * the cursor references do not need to be resolved by the underlying + * functions. + */ + dbp = dbc_arg->dbp; + sdbp = NULL; + pdbc = dbc_n = NULL; + memset(&newdata, 0, sizeof(DBT)); + + PANIC_CHECK(dbp->dbenv); + + /* Check for invalid flags. */ + if ((ret = __db_cputchk(dbp, + key, data, flags, IS_INITIALIZED(dbc_arg))) != 0) + return (ret); + + /* Check for consistent transaction usage. */ + if ((ret = __db_check_txn(dbp, dbc_arg->txn, dbc_arg->locker, 0)) != 0) + return (ret); + + /* + * Putting to secondary indices is forbidden; when we need + * to internally update one, we'll call this with a private + * synonym for DB_KEYLAST, DB_UPDATE_SECONDARY, which does + * the right thing but won't return an error from cputchk(). + */ + if (flags == DB_UPDATE_SECONDARY) + flags = DB_KEYLAST; + + DEBUG_LWRITE(dbc_arg, dbc_arg->txn, "db_c_put", + flags == DB_KEYFIRST || flags == DB_KEYLAST || + flags == DB_NODUPDATA ? key : NULL, data, flags); + + CDB_LOCKING_INIT(dbp, dbc_arg); + + /* + * Check to see if we are a primary and have secondary indices. + * If we are not, we save ourselves a good bit of trouble and + * just skip to the "normal" put. + */ + if (LIST_FIRST(&dbp->s_secondaries) == NULL) + goto skip_s_update; + + /* + * We have at least one secondary which we may need to update. + * + * There is a rather vile locking issue here. Secondary gets + * will always involve acquiring a read lock in the secondary, + * then acquiring a read lock in the primary. Ideally, we + * would likewise perform puts by updating all the secondaries + * first, then doing the actual put in the primary, to avoid + * deadlock (since having multiple threads doing secondary + * gets and puts simultaneously is probably a common case). + * + * However, if this put is a put-overwrite--and we have no way to + * tell in advance whether it will be--we may need to delete + * an outdated secondary key. In order to find that old + * secondary key, we need to get the record we're overwriting, + * before we overwrite it. + * + * (XXX: It would be nice to avoid this extra get, and have the + * underlying put routines somehow pass us the old record + * since they need to traverse the tree anyway. I'm saving + * this optimization for later, as it's a lot of work, and it + * would be hard to fit into this locking paradigm anyway.) + * + * The simple thing to do would be to go get the old record before + * we do anything else. Unfortunately, though, doing so would + * violate our "secondary, then primary" lock acquisition + * ordering--even in the common case where no old primary record + * exists, we'll still acquire and keep a lock on the page where + * we're about to do the primary insert. + * + * To get around this, we do the following gyrations, which + * hopefully solve this problem in the common case: + * + * 1) If this is a c_put(DB_CURRENT), go ahead and get the + * old record. We already hold the lock on this page in + * the primary, so no harm done, and we'll need the primary + * key (which we weren't passed in this case) to do any + * secondary puts anyway. + * + * 2) If we're doing a partial put, we need to perform the + * get on the primary key right away, since we don't have + * the whole datum that the secondary key is based on. + * We may also need to pad out the record if the primary + * has a fixed record length. + * + * 3) Loop through the secondary indices, putting into each a + * new secondary key that corresponds to the new record. + * + * 4) If we haven't done so in (1) or (2), get the old primary + * key/data pair. If one does not exist--the common case--we're + * done with secondary indices, and can go straight on to the + * primary put. + * + * 5) If we do have an old primary key/data pair, however, we need + * to loop through all the secondaries a second time and delete + * the old secondary in each. + */ + memset(&pkey, 0, sizeof(DBT)); + memset(&olddata, 0, sizeof(DBT)); + have_oldrec = nodel = 0; + + /* + * Primary indices can't have duplicates, so only DB_CURRENT, + * DB_KEYFIRST, and DB_KEYLAST make any sense. Other flags + * should have been caught by the checking routine, but + * add a sprinkling of paranoia. + */ + DB_ASSERT(flags == DB_CURRENT || + flags == DB_KEYFIRST || flags == DB_KEYLAST); + + /* + * We'll want to use DB_RMW in a few places, but it's only legal + * when locking is on. + */ + rmw = STD_LOCKING(dbc_arg) ? DB_RMW : 0; + + if (flags == DB_CURRENT) { /* Step 1. */ + /* + * This is safe to do on the cursor we already have; + * error or no, it won't move. + * + * We use DB_RMW for all of these gets because we'll be + * writing soon enough in the "normal" put code. In + * transactional databases we'll hold those write locks + * even if we close the cursor we're reading with. + */ + ret = dbc_arg->c_get(dbc_arg, + &pkey, &olddata, rmw | DB_CURRENT); + if (ret == DB_KEYEMPTY) { + nodel = 1; /* + * We know we don't need a delete + * in the secondary. + */ + have_oldrec = 1; /* We've looked for the old record. */ + } else if (ret != 0) + goto err; + else + have_oldrec = 1; + + } else { + /* So we can just use &pkey everywhere instead of key. */ + pkey.data = key->data; + pkey.size = key->size; + } + + /* + * Check for partial puts (step 2). + */ + if (F_ISSET(data, DB_DBT_PARTIAL)) { + if (!have_oldrec && !nodel) { + /* + * We're going to have to search the tree for the + * specified key. Dup a cursor (so we have the same + * locking info) and do a c_get. + */ + if ((ret = __db_c_idup(dbc_arg, &pdbc, 0)) != 0) + goto err; + + /* We should have gotten DB_CURRENT in step 1. */ + DB_ASSERT(flags != DB_CURRENT); + + ret = pdbc->c_get(pdbc, + &pkey, &olddata, rmw | DB_SET); + if (ret == DB_KEYEMPTY || ret == DB_NOTFOUND) { + nodel = 1; + ret = 0; + } + if ((t_ret = pdbc->c_close(pdbc)) != 0) + ret = t_ret; + if (ret != 0) + goto err; + + have_oldrec = 1; + } + + /* + * Now build the new datum from olddata and the partial + * data we were given. + */ + if ((ret = + __db_buildpartial(dbp, &olddata, data, &newdata)) != 0) + goto err; + ispartial = 1; + } else + ispartial = 0; + + /* + * Handle fixed-length records. If the primary database has + * fixed-length records, we need to pad out the datum before + * we pass it into the callback function; we always index the + * "real" record. + */ + if ((dbp->type == DB_RECNO && F_ISSET(dbp, DB_AM_FIXEDLEN)) || + (dbp->type == DB_QUEUE)) { + if (dbp->type == DB_QUEUE) { + re_len = ((QUEUE *)dbp->q_internal)->re_len; + re_pad = ((QUEUE *)dbp->q_internal)->re_pad; + } else { + re_len = ((BTREE *)dbp->bt_internal)->re_len; + re_pad = ((BTREE *)dbp->bt_internal)->re_pad; + } + + size = ispartial ? newdata.size : data->size; + if (size > re_len) { + __db_err(dbp->dbenv, + "Length improper for fixed length record %lu", + (u_long)size); + ret = EINVAL; + goto err; + } else if (size < re_len) { + /* + * If we're not doing a partial put, copy + * data->data into newdata.data, then pad out + * newdata.data. + * + * If we're doing a partial put, the data + * we want are already in newdata.data; we + * just need to pad. + * + * Either way, realloc is safe. + */ + if ((ret = __os_realloc(dbp->dbenv, re_len, + &newdata.data)) != 0) + goto err; + if (!ispartial) + memcpy(newdata.data, data->data, size); + memset((u_int8_t *)newdata.data + size, re_pad, + re_len - size); + newdata.size = re_len; + ispartial = 1; + } + } + + /* + * Loop through the secondaries. (Step 3.) + * + * Note that __db_s_first and __db_s_next will take care of + * thread-locking and refcounting issues. + */ + for (sdbp = __db_s_first(dbp); + sdbp != NULL && ret == 0; ret = __db_s_next(&sdbp)) { + /* + * Call the callback for this secondary, to get the + * appropriate secondary key. + */ + memset(&skey, 0, sizeof(DBT)); + if ((ret = sdbp->s_callback(sdbp, + &pkey, ispartial ? &newdata : data, &skey)) != 0) { + if (ret == DB_DONOTINDEX) + /* + * The callback returned a null value--don't + * put this key in the secondary. Just + * move on to the next one--we'll handle + * any necessary deletes in step 5. + */ + continue; + else + goto err; + } + + /* + * Save the DBT we just got back from the callback function + * off; we want to pass its value into c_get functions + * that may stomp on a buffer the callback function + * allocated. + */ + memset(&save_skey, 0, sizeof(DBT)); /* Paranoia. */ + save_skey = skey; + + /* + * Open a cursor in this secondary. + * + * Use the same locker ID as our primary cursor, so that + * we're guaranteed that the locks don't conflict (e.g. in CDB + * or if we're subdatabases that share and want to lock a + * metadata page). + */ + if ((ret = __db_icursor(sdbp, dbc_arg->txn, sdbp->type, + PGNO_INVALID, 0, dbc_arg->locker, &sdbc)) != 0) + goto err; + + /* + * If we're in CDB, updates will fail since the new cursor + * isn't a writer. However, we hold the WRITE lock in the + * primary and will for as long as our new cursor lasts, + * and the primary and secondary share a lock file ID, + * so it's safe to consider this a WRITER. The close + * routine won't try to put anything because we don't + * really have a lock. + */ + if (CDB_LOCKING(sdbp->dbenv)) { + DB_ASSERT(sdbc->mylock.off == LOCK_INVALID); + F_SET(sdbc, DBC_WRITER); + } + + /* + * There are three cases here-- + * 1) The secondary supports sorted duplicates. + * If we attempt to put a secondary/primary pair + * that already exists, that's a duplicate duplicate, + * and c_put will return DB_KEYEXIST (see __db_duperr). + * This will leave us with exactly one copy of the + * secondary/primary pair, and this is just right--we'll + * avoid deleting it later, as the old and new secondaries + * will match (since the old secondary is the dup dup + * that's already there). + * 2) The secondary supports duplicates, but they're not + * sorted. We need to avoid putting a duplicate + * duplicate, because the matching old and new secondaries + * will prevent us from deleting anything and we'll + * wind up with two secondary records that point to the + * same primary key. Do a c_get(DB_GET_BOTH); if + * that returns 0, skip the put. + * 3) The secondary doesn't support duplicates at all. + * In this case, secondary keys must be unique; if + * another primary key already exists for this + * secondary key, we have to either overwrite it or + * not put this one, and in either case we've + * corrupted the secondary index. Do a c_get(DB_SET). + * If the secondary/primary pair already exists, do + * nothing; if the secondary exists with a different + * primary, return an error; and if the secondary + * does not exist, put it. + */ + if (!F_ISSET(sdbp, DB_AM_DUP)) { + /* Case 3. */ + memset(&oldpkey, 0, sizeof(DBT)); + F_SET(&oldpkey, DB_DBT_MALLOC); + ret = sdbc->c_real_get(sdbc, + &skey, &oldpkey, rmw | DB_SET); + if (ret == 0) { + cmp = __bam_defcmp(sdbp, &oldpkey, &pkey); + __os_ufree(sdbp->dbenv, oldpkey.data); + if (cmp != 0) { + __db_err(sdbp->dbenv, "%s%s", + "Put results in a non-unique secondary key in an ", + "index not configured to support duplicates"); + ret = EINVAL; + goto skipput; + } + } else if (ret != DB_NOTFOUND && ret != DB_KEYEMPTY) + goto skipput; + } else if (!F_ISSET(sdbp, DB_AM_DUPSORT)) + /* Case 2. */ + if ((ret = sdbc->c_real_get(sdbc, + &skey, &pkey, rmw | DB_GET_BOTH)) == 0) + goto skipput; + + ret = sdbc->c_put(sdbc, &skey, &pkey, DB_UPDATE_SECONDARY); + + /* + * We don't know yet whether this was a put-overwrite that + * in fact changed nothing. If it was, we may get DB_KEYEXIST. + * This is not an error. + */ + if (ret == DB_KEYEXIST) + ret = 0; + +skipput: FREE_IF_NEEDED(sdbp, &save_skey) + + if ((t_ret = sdbc->c_close(sdbc)) != 0) + ret = t_ret; + + if (ret != 0) + goto err; + } + if (ret != 0) + goto err; + + /* If still necessary, go get the old primary key/data. (Step 4.) */ + if (!have_oldrec) { + /* See the comments in step 2. This is real familiar. */ + if ((ret = __db_c_idup(dbc_arg, &pdbc, 0)) != 0) + goto err; + DB_ASSERT(flags != DB_CURRENT); + pkey.data = key->data; + pkey.size = key->size; + ret = pdbc->c_get(pdbc, &pkey, &olddata, rmw | DB_SET); + if (ret == DB_KEYEMPTY || ret == DB_NOTFOUND) { + nodel = 1; + ret = 0; + } + if ((t_ret = pdbc->c_close(pdbc)) != 0) + ret = t_ret; + if (ret != 0) + goto err; + have_oldrec = 1; + } + + /* + * If we don't follow this goto, we do in fact have an old record + * we may need to go delete. (Step 5). + */ + if (nodel) + goto skip_s_update; + + for (sdbp = __db_s_first(dbp); + sdbp != NULL && ret == 0; ret = __db_s_next(&sdbp)) { + /* + * Call the callback for this secondary to get the + * old secondary key. + */ + memset(&oldskey, 0, sizeof(DBT)); + if ((ret = sdbp->s_callback(sdbp, + &pkey, &olddata, &oldskey)) != 0) { + if (ret == DB_DONOTINDEX) + /* + * The callback returned a null value--there's + * nothing to delete. Go on to the next + * secondary. + */ + continue; + else + goto err; + } + if ((ret = sdbp->s_callback(sdbp, + &pkey, ispartial ? &newdata : data, &skey)) != 0 && + ret != DB_DONOTINDEX) + goto err; + + /* + * If there is no new secondary key, or if the old secondary + * key is different from the new secondary key, then + * we need to delete the old one. + * + * Note that bt_compare is (and must be) set no matter + * what access method we're in. + */ + sdbc = NULL; + if (ret == DB_DONOTINDEX || + ((BTREE *)sdbp->bt_internal)->bt_compare(sdbp, + &oldskey, &skey) != 0) { + if ((ret = __db_icursor(sdbp, dbc_arg->txn, sdbp->type, + PGNO_INVALID, 0, dbc_arg->locker, &sdbc)) != 0) + goto err; + if (CDB_LOCKING(sdbp->dbenv)) { + DB_ASSERT(sdbc->mylock.off == LOCK_INVALID); + F_SET(sdbc, DBC_WRITER); + } + + /* + * Don't let c_get(DB_GET_BOTH) stomp on + * any secondary key value that the callback + * function may have allocated. Use a temp + * DBT instead. + */ + memset(&temp, 0, sizeof(DBT)); + temp.data = oldskey.data; + temp.size = oldskey.size; + if ((ret = sdbc->c_real_get(sdbc, + &temp, &pkey, rmw | DB_GET_BOTH)) == 0) + ret = sdbc->c_del(sdbc, DB_UPDATE_SECONDARY); + } + + FREE_IF_NEEDED(sdbp, &skey); + FREE_IF_NEEDED(sdbp, &oldskey); + if (sdbc != NULL && (t_ret = sdbc->c_close(sdbc)) != 0) + ret = t_ret; + if (ret != 0) + goto err; + } + + /* Secondary index updates are now done. On to the "real" stuff. */ + +skip_s_update: + /* + * If we have an off-page duplicates cursor, and the operation applies + * to it, perform the operation. Duplicate the cursor and call the + * underlying function. + * + * Off-page duplicate trees are locked in the primary tree, that is, + * we acquire a write lock in the primary tree and no locks in the + * off-page dup tree. If the put operation is done in an off-page + * duplicate tree, call the primary cursor's upgrade routine first. + */ + if (dbc_arg->internal->opd != NULL && + (flags == DB_AFTER || flags == DB_BEFORE || flags == DB_CURRENT)) { + /* + * A special case for hash off-page duplicates. Hash doesn't + * support (and is documented not to support) put operations + * relative to a cursor which references an already deleted + * item. For consistency, apply the same criteria to off-page + * duplicates as well. + */ + if (dbc_arg->dbtype == DB_HASH && F_ISSET( + ((BTREE_CURSOR *)(dbc_arg->internal->opd->internal)), + C_DELETED)) { + ret = DB_NOTFOUND; + goto err; + } + + if ((ret = dbc_arg->c_am_writelock(dbc_arg)) != 0) + return (ret); + if ((ret = __db_c_dup(dbc_arg, &dbc_n, DB_POSITIONI)) != 0) + goto err; + opd = dbc_n->internal->opd; + if ((ret = opd->c_am_put( + opd, key, data, flags, NULL)) != 0) + goto err; + goto done; + } + + /* + * Perform an operation on the main cursor. Duplicate the cursor, + * and call the underlying function. + * + * XXX: MARGO + * + tmp_flags = flags == DB_AFTER || + flags == DB_BEFORE || flags == DB_CURRENT ? DB_POSITIONI : 0; + */ + tmp_flags = DB_POSITIONI; + + /* + * If this cursor is going to be closed immediately, we don't + * need to take precautions to clean it up on error. + */ + if (F_ISSET(dbc_arg, DBC_TRANSIENT)) + dbc_n = dbc_arg; + else if ((ret = __db_c_idup(dbc_arg, &dbc_n, tmp_flags)) != 0) + goto err; + + pgno = PGNO_INVALID; + if ((ret = dbc_n->c_am_put(dbc_n, key, data, flags, &pgno)) != 0) + goto err; + + /* + * We may be referencing a new off-page duplicates tree. Acquire + * a new cursor and call the underlying function. + */ + if (pgno != PGNO_INVALID) { + oldopd = dbc_n->internal->opd; + if ((ret = __db_c_newopd(dbc_arg, pgno, oldopd, &opd)) != 0) { + dbc_n->internal->opd = opd; + goto err; + } + + dbc_n->internal->opd = opd; + + if ((ret = opd->c_am_put( + opd, key, data, flags, NULL)) != 0) + goto err; + } + +done: +err: /* Cleanup and cursor resolution. */ + if ((t_ret = __db_c_cleanup(dbc_arg, dbc_n, ret)) != 0 && ret == 0) + ret = t_ret; + + /* If newdata was used, free its buffer. */ + if (newdata.data != NULL) + __os_free(dbp->dbenv, newdata.data); + + CDB_LOCKING_DONE(dbp, dbc_arg); + + if (sdbp != NULL && (t_ret = __db_s_done(sdbp)) != 0) + return (t_ret); + + return (ret); +} + +/* + * __db_duperr() + * Error message: we don't currently support sorted duplicate duplicates. + * PUBLIC: int __db_duperr __P((DB *, u_int32_t)); + */ +int +__db_duperr(dbp, flags) + DB *dbp; + u_int32_t flags; +{ + + /* + * If we run into this error while updating a secondary index, + * don't yell--there's no clean way to pass DB_NODUPDATA in along + * with DB_UPDATE_SECONDARY, but we may run into this problem + * in a normal, non-error course of events. + * + * !!! + * If and when we ever permit duplicate duplicates in sorted-dup + * databases, we need to either change the secondary index code + * to check for dup dups, or we need to maintain the implicit + * "DB_NODUPDATA" behavior for databases with DB_AM_SECONDARY set. + */ + if (flags != DB_NODUPDATA && !F_ISSET(dbp, DB_AM_SECONDARY)) + __db_err(dbp->dbenv, + "Duplicate data items are not supported with sorted data"); + return (DB_KEYEXIST); +} + +/* + * __db_c_cleanup -- + * Clean up duplicate cursors. + */ +static int +__db_c_cleanup(dbc, dbc_n, failed) + DBC *dbc, *dbc_n; + int failed; +{ + DB *dbp; + DBC *opd; + DBC_INTERNAL *internal; + DB_MPOOLFILE *mpf; + int ret, t_ret; + + dbp = dbc->dbp; + mpf = dbp->mpf; + internal = dbc->internal; + ret = 0; + + /* Discard any pages we're holding. */ + if (internal->page != NULL) { + if ((t_ret = mpf->put(mpf, internal->page, 0)) != 0 && ret == 0) + ret = t_ret; + internal->page = NULL; + } + opd = internal->opd; + if (opd != NULL && opd->internal->page != NULL) { + if ((t_ret = + mpf->put(mpf, opd->internal->page, 0)) != 0 && ret == 0) + ret = t_ret; + opd->internal->page = NULL; + } + + /* + * If dbc_n is NULL, there's no internal cursor swapping to be done + * and no dbc_n to close--we probably did the entire operation on an + * offpage duplicate cursor. Just return. + * + * If dbc and dbc_n are the same, we're either inside a DB->{put/get} + * operation, and as an optimization we performed the operation on + * the main cursor rather than on a duplicated one, or we're in a + * bulk get that can't have moved the cursor (DB_MULTIPLE with the + * initial c_get operation on an off-page dup cursor). Just + * return--either we know we didn't move the cursor, or we're going + * to close it before we return to application code, so we're sure + * not to visibly violate the "cursor stays put on error" rule. + */ + if (dbc_n == NULL || dbc == dbc_n) + return (ret); + + if (dbc_n->internal->page != NULL) { + if ((t_ret = + mpf->put(mpf, dbc_n->internal->page, 0)) != 0 && ret == 0) + ret = t_ret; + dbc_n->internal->page = NULL; + } + opd = dbc_n->internal->opd; + if (opd != NULL && opd->internal->page != NULL) { + if ((t_ret = + mpf->put(mpf, opd->internal->page, 0)) != 0 && ret == 0) + ret = t_ret; + opd->internal->page = NULL; + } + + /* + * If we didn't fail before entering this routine or just now when + * freeing pages, swap the interesting contents of the old and new + * cursors. + */ + if (!failed && ret == 0) { + dbc->internal = dbc_n->internal; + dbc_n->internal = internal; + } + + /* + * Close the cursor we don't care about anymore. The close can fail, + * but we only expect DB_LOCK_DEADLOCK failures. This violates our + * "the cursor is unchanged on error" semantics, but since all you can + * do with a DB_LOCK_DEADLOCK failure is close the cursor, I believe + * that's OK. + * + * XXX + * There's no way to recover from failure to close the old cursor. + * All we can do is move to the new position and return an error. + * + * XXX + * We might want to consider adding a flag to the cursor, so that any + * subsequent operations other than close just return an error? + */ + if ((t_ret = dbc_n->c_close(dbc_n)) != 0 && ret == 0) + ret = t_ret; + + return (ret); +} + +/* + * __db_c_secondary_get -- + * This wrapper function for DBC->c_pget() is the DBC->c_get() function + * for a secondary index cursor. + * + * PUBLIC: int __db_c_secondary_get __P((DBC *, DBT *, DBT *, u_int32_t)); + */ +int +__db_c_secondary_get(dbc, skey, data, flags) + DBC *dbc; + DBT *skey, *data; + u_int32_t flags; +{ + + DB_ASSERT(F_ISSET(dbc->dbp, DB_AM_SECONDARY)); + return (dbc->c_pget(dbc, skey, NULL, data, flags)); +} + +/* + * __db_c_pget -- + * Get a primary key/data pair through a secondary index. + * + * PUBLIC: int __db_c_pget __P((DBC *, DBT *, DBT *, DBT *, u_int32_t)); + */ +int +__db_c_pget(dbc, skey, pkey, data, flags) + DBC *dbc; + DBT *skey, *pkey, *data; + u_int32_t flags; +{ + DB *pdbp, *sdbp; + DBC *pdbc; + DBT *save_rdata, nullpkey; + int pkeymalloc, ret, save_pkey_flags, t_ret; + + sdbp = dbc->dbp; + pdbp = sdbp->s_primary; + pkeymalloc = t_ret = 0; + + PANIC_CHECK(sdbp->dbenv); + if ((ret = __db_cpgetchk(sdbp, + skey, pkey, data, flags, IS_INITIALIZED(dbc))) != 0) + return (ret); + + /* + * The challenging part of this function is getting the behavior + * right for all the various permutations of DBT flags. The + * next several blocks handle the various cases we need to + * deal with specially. + */ + + /* + * We may be called with a NULL pkey argument, if we've been + * wrapped by a 2-DBT get call. If so, we need to use our + * own DBT. + */ + if (pkey == NULL) { + memset(&nullpkey, 0, sizeof(DBT)); + pkey = &nullpkey; + } + + /* + * DB_GET_RECNO is a special case, because we're interested not in + * the primary key/data pair, but rather in the primary's record + * number. + */ + if ((flags & DB_OPFLAGS_MASK) == DB_GET_RECNO) + return (__db_c_pget_recno(dbc, pkey, data, flags)); + + /* + * If the DBTs we've been passed don't have any of the + * user-specified memory management flags set, we want to make sure + * we return values using the DBTs dbc->rskey, dbc->rkey, and + * dbc->rdata, respectively. + * + * There are two tricky aspects to this: first, we need to pass + * skey and pkey *in* to the initial c_get on the secondary key, + * since either or both may be looked at by it (depending on the + * get flag). Second, we must not use a normal DB->get call + * on the secondary, even though that's what we want to accomplish, + * because the DB handle may be free-threaded. Instead, + * we open a cursor, then take steps to ensure that we actually use + * the rkey/rdata from the *secondary* cursor. + * + * We accomplish all this by passing in the DBTs we started out + * with to the c_get, but having swapped the contents of rskey and + * rkey, respectively, into rkey and rdata; __db_ret will treat + * them like the normal key/data pair in a c_get call, and will + * realloc them as need be (this is "step 1"). Then, for "step 2", + * we swap back rskey/rkey/rdata to normal, and do a get on the primary + * with the secondary dbc appointed as the owner of the returned-data + * memory. + * + * Note that in step 2, we copy the flags field in case we need to + * pass down a DB_DBT_PARTIAL or other flag that is compatible with + * letting DB do the memory management. + */ + /* Step 1. */ + save_rdata = dbc->rdata; + dbc->rdata = dbc->rkey; + dbc->rkey = dbc->rskey; + + /* + * It is correct, though slightly sick, to attempt a partial get + * of a primary key. However, if we do so here, we'll never find the + * primary record; clear the DB_DBT_PARTIAL field of pkey just + * for the duration of the next call. + */ + save_pkey_flags = pkey->flags; + F_CLR(pkey, DB_DBT_PARTIAL); + + /* + * Now we can go ahead with the meat of this call. First, get the + * primary key from the secondary index. (What exactly we get depends + * on the flags, but the underlying cursor get will take care of the + * dirty work.) + */ + if ((ret = dbc->c_real_get(dbc, skey, pkey, flags)) != 0) { + /* Restore rskey/rkey/rdata and return. */ + pkey->flags = save_pkey_flags; + dbc->rskey = dbc->rkey; + dbc->rkey = dbc->rdata; + dbc->rdata = save_rdata; + goto err; + } + + /* Restore pkey's flags in case we stomped the PARTIAL flag. */ + pkey->flags = save_pkey_flags; + + /* + * Restore the cursor's rskey, rkey, and rdata DBTs. If DB + * is handling the memory management, we now have newly + * reallocated buffers and ulens in rkey and rdata which we want + * to put in rskey and rkey. save_rdata contains the old value + * of dbc->rdata. + */ + dbc->rskey = dbc->rkey; + dbc->rkey = dbc->rdata; + dbc->rdata = save_rdata; + + /* + * Now we're ready for "step 2". If either or both of pkey and + * data do not have memory management flags set--that is, if DB is + * managing their memory--we need to swap around the rkey/rdata + * structures so that we don't wind up trying to use memory managed + * by the primary database cursor, which we'll close before we return. + * + * !!! + * If you're carefully following the bouncing ball, you'll note + * that in the DB-managed case, the buffer hanging off of pkey is + * the same as dbc->rkey->data. This is just fine; we may well + * realloc and stomp on it when we return, if we're going a + * DB_GET_BOTH and need to return a different partial or key + * (depending on the comparison function), but this is safe. + * + * !!! + * We need to use __db_icursor here rather than simply calling + * pdbp->cursor, because otherwise, if we're in CDB, we'll + * allocate a new locker ID and leave ourselves open to deadlocks. + * (Even though we're only acquiring read locks, we'll still block + * if there are any waiters.) + */ + if ((ret = __db_icursor(pdbp, + dbc->txn, pdbp->type, PGNO_INVALID, 0, dbc->locker, &pdbc)) != 0) + goto err; + + /* + * We're about to use pkey a second time. If DB_DBT_MALLOC + * is set on it, we'll leak the memory we allocated the first time. + * Thus, set DB_DBT_REALLOC instead so that we reuse that memory + * instead of leaking it. + * + * !!! + * This assumes that the user must always specify a compatible + * realloc function if a malloc function is specified. I think + * this is a reasonable requirement. + */ + if (F_ISSET(pkey, DB_DBT_MALLOC)) { + F_CLR(pkey, DB_DBT_MALLOC); + F_SET(pkey, DB_DBT_REALLOC); + pkeymalloc = 1; + } + + /* + * Do the actual get. Set DBC_TRANSIENT since we don't care + * about preserving the position on error, and it's faster. + * SET_RET_MEM so that the secondary DBC owns any returned-data + * memory. + */ + F_SET(pdbc, DBC_TRANSIENT); + SET_RET_MEM(pdbc, dbc); + ret = pdbc->c_get(pdbc, pkey, data, DB_SET); + + /* + * If the item wasn't found in the primary, this is a bug; + * our secondary has somehow gotten corrupted, and contains + * elements that don't correspond to anything in the primary. + * Complain. + */ + if (ret == DB_NOTFOUND) + ret = __db_secondary_corrupt(pdbp); + + /* Now close the primary cursor. */ + t_ret = pdbc->c_close(pdbc); + +err: if (pkeymalloc) { + /* + * If pkey had a MALLOC flag, we need to restore it; + * otherwise, if the user frees the buffer but reuses + * the DBT without NULL'ing its data field or changing + * the flags, we may drop core. + */ + F_CLR(pkey, DB_DBT_REALLOC); + F_SET(pkey, DB_DBT_MALLOC); + } + return (t_ret == 0 ? ret : t_ret); +} + +/* + * __db_c_pget_recno -- + * Perform a DB_GET_RECNO c_pget on a secondary index. Returns + * the secondary's record number in the pkey field and the primary's + * in the data field. + */ +static int +__db_c_pget_recno(sdbc, pkey, data, flags) + DBC *sdbc; + DBT *pkey, *data; + u_int32_t flags; +{ + DB *pdbp, *sdbp; + DB_ENV *dbenv; + DBC *pdbc; + DBT discardme, primary_key; + db_recno_t oob; + u_int32_t rmw; + int ret, t_ret; + + sdbp = sdbc->dbp; + pdbp = sdbp->s_primary; + dbenv = sdbp->dbenv; + pdbc = NULL; + ret = t_ret = 0; + + rmw = LF_ISSET(DB_RMW); + + memset(&discardme, 0, sizeof(DBT)); + F_SET(&discardme, DB_DBT_USERMEM | DB_DBT_PARTIAL); + + oob = RECNO_OOB; + + /* + * If the primary is an rbtree, we want its record number, whether + * or not the secondary is one too. Fetch the recno into "data". + * + * If it's not an rbtree, return RECNO_OOB in "data". + */ + if (F_ISSET(pdbp, DB_AM_RECNUM)) { + /* + * Get the primary key, so we can find the record number + * in the primary. (We're uninterested in the secondary key.) + */ + memset(&primary_key, 0, sizeof(DBT)); + F_SET(&primary_key, DB_DBT_MALLOC); + if ((ret = sdbc->c_real_get(sdbc, + &discardme, &primary_key, rmw | DB_CURRENT)) != 0) + return (ret); + + /* + * Open a cursor on the primary, set it to the right record, + * and fetch its recno into "data". + * + * (See __db_c_pget for a comment on the use of __db_icursor.) + * + * SET_RET_MEM so that the secondary DBC owns any returned-data + * memory. + */ + if ((ret = __db_icursor(pdbp, sdbc->txn, + pdbp->type, PGNO_INVALID, 0, sdbc->locker, &pdbc)) != 0) + goto perr; + SET_RET_MEM(pdbc, sdbc); + if ((ret = pdbc->c_get(pdbc, + &primary_key, &discardme, rmw | DB_SET)) != 0) + goto perr; + + ret = pdbc->c_get(pdbc, &discardme, data, rmw | DB_GET_RECNO); + +perr: __os_ufree(sdbp->dbenv, primary_key.data); + if (pdbc != NULL && + (t_ret = pdbc->c_close(pdbc)) != 0 && ret == 0) + ret = t_ret; + if (ret != 0) + return (ret); + } else if ((ret = __db_retcopy(dbenv, data, &oob, + sizeof(oob), &sdbc->rkey->data, &sdbc->rkey->ulen)) != 0) + return (ret); + + /* + * If the secondary is an rbtree, we want its record number, whether + * or not the primary is one too. Fetch the recno into "pkey". + * + * If it's not an rbtree, return RECNO_OOB in "pkey". + */ + if (F_ISSET(sdbp, DB_AM_RECNUM)) + return (sdbc->c_real_get(sdbc, &discardme, pkey, flags)); + else + return (__db_retcopy(dbenv, pkey, &oob, + sizeof(oob), &sdbc->rdata->data, &sdbc->rdata->ulen)); +} + +/* + * __db_wrlock_err -- do not have a write lock. + */ +static int +__db_wrlock_err(dbenv) + DB_ENV *dbenv; +{ + __db_err(dbenv, "Write attempted on read-only cursor"); + return (EPERM); +} + +/* + * __db_c_del_secondary -- + * Perform a delete operation on a secondary index: call through + * to the primary and delete the primary record that this record + * points to. + * + * Note that deleting the primary record will call c_del on all + * the secondaries, including this one; thus, it is not necessary + * to execute both this function and an actual delete. + * + */ +static int +__db_c_del_secondary(dbc) + DBC *dbc; +{ + DB *pdbp; + DBC *pdbc; + DBT skey, pkey; + int ret, t_ret; + + memset(&skey, 0, sizeof(DBT)); + memset(&pkey, 0, sizeof(DBT)); + + /* + * Get the current item that we're pointing at. + * We don't actually care about the secondary key, just + * the primary. + */ + F_SET(&skey, DB_DBT_PARTIAL | DB_DBT_USERMEM); + if ((ret = dbc->c_real_get(dbc, + &skey, &pkey, DB_CURRENT)) != 0) + return (ret); + + /* + * Create a cursor on the primary with our locker ID, + * so that when it calls back, we don't conflict. + * + * We create a cursor explicitly because there's no + * way to specify the same locker ID if we're using + * locking but not transactions if we use the DB->del + * interface. This shouldn't be any less efficient + * anyway. + */ + pdbp = dbc->dbp->s_primary; + if ((ret = __db_icursor(pdbp, dbc->txn, + pdbp->type, PGNO_INVALID, 0, dbc->locker, &pdbc)) != 0) + return (ret); + + /* + * See comment in __db_c_put--if we're in CDB, + * we already hold the locks we need, and we need to flag + * the cursor as a WRITER so we don't run into errors + * when we try to delete. + */ + if (CDB_LOCKING(pdbp->dbenv)) { + DB_ASSERT(pdbc->mylock.off == LOCK_INVALID); + F_SET(pdbc, DBC_WRITER); + } + + /* + * Set the new cursor to the correct primary key. Then + * delete it. We don't really care about the datum; + * just reuse our skey DBT. + * + * If the primary get returns DB_NOTFOUND, something is amiss-- + * every record in the secondary should correspond to some record + * in the primary. + */ + if ((ret = pdbc->c_get(pdbc, &pkey, &skey, + (STD_LOCKING(dbc) ? DB_RMW : 0) | DB_SET)) == 0) + ret = pdbc->c_del(pdbc, 0); + else if (ret == DB_NOTFOUND) + ret = __db_secondary_corrupt(pdbp); + + if ((t_ret = pdbc->c_close(pdbc)) != 0 && ret != 0) + ret = t_ret; + + return (ret); +} + +/* + * __db_c_del_primary -- + * Perform a delete operation on a primary index. Loop through + * all the secondary indices which correspond to this primary + * database, and delete any secondary keys that point at the current + * record. + * + * PUBLIC: int __db_c_del_primary __P((DBC *)); + */ +int +__db_c_del_primary(dbc) + DBC *dbc; +{ + DB *dbp, *sdbp; + DBC *sdbc; + DBT data, pkey, skey, temp; + int ret, t_ret; + + dbp = dbc->dbp; + + /* + * If we're called at all, we have at least one secondary. + * (Unfortunately, we can't assert this without grabbing the mutex.) + * Get the current record so that we can construct appropriate + * secondary keys as needed. + */ + memset(&pkey, 0, sizeof(DBT)); + memset(&data, 0, sizeof(DBT)); + if ((ret = dbc->c_get(dbc, &pkey, &data, DB_CURRENT)) != 0) + return (ret); + + for (sdbp = __db_s_first(dbp); + sdbp != NULL && ret == 0; ret = __db_s_next(&sdbp)) { + /* + * Get the secondary key for this secondary and the current + * item. + */ + memset(&skey, 0, sizeof(DBT)); + if ((ret = sdbp->s_callback(sdbp, &pkey, &data, &skey)) != 0) { + /* + * If the current item isn't in this index, we + * have no work to do. Proceed. + */ + if (ret == DB_DONOTINDEX) + continue; + + /* We had a substantive error. Bail. */ + FREE_IF_NEEDED(sdbp, &skey); + goto done; + } + + /* Open a secondary cursor. */ + if ((ret = __db_icursor(sdbp, dbc->txn, sdbp->type, + PGNO_INVALID, 0, dbc->locker, &sdbc)) != 0) + goto done; + /* See comment above and in __db_c_put. */ + if (CDB_LOCKING(sdbp->dbenv)) { + DB_ASSERT(sdbc->mylock.off == LOCK_INVALID); + F_SET(sdbc, DBC_WRITER); + } + + /* + * Set the secondary cursor to the appropriate item. + * Delete it. + * + * We want to use DB_RMW if locking is on; it's only + * legal then, though. + * + * !!! + * Don't stomp on any callback-allocated buffer in skey + * when we do a c_get(DB_GET_BOTH); use a temp DBT instead. + */ + memset(&temp, 0, sizeof(DBT)); + temp.data = skey.data; + temp.size = skey.size; + if ((ret = sdbc->c_real_get(sdbc, &temp, &pkey, + (STD_LOCKING(dbc) ? DB_RMW : 0) | DB_GET_BOTH)) == 0) + ret = sdbc->c_del(sdbc, DB_UPDATE_SECONDARY); + + FREE_IF_NEEDED(sdbp, &skey); + + if ((t_ret = sdbc->c_close(sdbc)) != 0 || ret != 0) { + if (ret == 0) + ret = t_ret; + goto done; + } + } + +done: if (sdbp != NULL && (t_ret = __db_s_done(sdbp)) != 0 && ret == 0) + return (t_ret); + return (ret); +} + +/* + * __db_s_first -- + * Get the first secondary, if any are present, from the primary. + * + * PUBLIC: DB *__db_s_first __P((DB *)); + */ +DB * +__db_s_first(pdbp) + DB *pdbp; +{ + DB *sdbp; + + MUTEX_THREAD_LOCK(pdbp->dbenv, pdbp->mutexp); + sdbp = LIST_FIRST(&pdbp->s_secondaries); + + /* See __db_s_next. */ + if (sdbp != NULL) + sdbp->s_refcnt++; + MUTEX_THREAD_UNLOCK(pdbp->dbenv, pdbp->mutexp); + + return (sdbp); +} + +/* + * __db_s_next -- + * Get the next secondary in the list. + * + * PUBLIC: int __db_s_next __P((DB **)); + */ +int +__db_s_next(sdbpp) + DB **sdbpp; +{ + DB *sdbp, *pdbp, *closeme; + int ret; + + /* + * Secondary indices are kept in a linked list, s_secondaries, + * off each primary DB handle. If a primary is free-threaded, + * this list may only be traversed or modified while the primary's + * thread mutex is held. + * + * The tricky part is that we don't want to hold the thread mutex + * across the full set of secondary puts necessary for each primary + * put, or we'll wind up essentially single-threading all the puts + * to the handle; the secondary puts will each take about as + * long as the primary does, and may require I/O. So we instead + * hold the thread mutex only long enough to follow one link to the + * next secondary, and then we release it before performing the + * actual secondary put. + * + * The only danger here is that we might legitimately close a + * secondary index in one thread while another thread is performing + * a put and trying to update that same secondary index. To + * prevent this from happening, we refcount the secondary handles. + * If close is called on a secondary index handle while we're putting + * to it, it won't really be closed--the refcount will simply drop, + * and we'll be responsible for closing it here. + */ + sdbp = *sdbpp; + pdbp = sdbp->s_primary; + closeme = NULL; + + MUTEX_THREAD_LOCK(pdbp->dbenv, pdbp->mutexp); + DB_ASSERT(sdbp->s_refcnt != 0); + if (--sdbp->s_refcnt == 0) { + LIST_REMOVE(sdbp, s_links); + closeme = sdbp; + } + sdbp = LIST_NEXT(sdbp, s_links); + if (sdbp != NULL) + sdbp->s_refcnt++; + MUTEX_THREAD_UNLOCK(pdbp->dbenv, pdbp->mutexp); + + *sdbpp = sdbp; + + /* + * closeme->close() is a wrapper; call __db_close explicitly. + */ + ret = closeme != NULL ? __db_close(closeme, 0) : 0; + return (ret); +} + +/* + * __db_s_done -- + * Properly decrement the refcount on a secondary database handle we're + * using, without calling __db_s_next. + * + * PUBLIC: int __db_s_done __P((DB *)); + */ +int +__db_s_done(sdbp) + DB *sdbp; +{ + DB *pdbp; + int doclose; + + pdbp = sdbp->s_primary; + doclose = 0; + + MUTEX_THREAD_LOCK(pdbp->dbenv, pdbp->mutexp); + DB_ASSERT(sdbp->s_refcnt != 0); + if (--sdbp->s_refcnt == 0) { + LIST_REMOVE(sdbp, s_links); + doclose = 1; + } + MUTEX_THREAD_UNLOCK(pdbp->dbenv, pdbp->mutexp); + + return (doclose ? __db_close(sdbp, 0) : 0); +} + +/* + * __db_buildpartial -- + * Build the record that will result after a partial put is applied to + * an existing record. + * + * This should probably be merged with __bam_build, but that requires + * a little trickery if we plan to keep the overflow-record optimization + * in that function. + */ +static int +__db_buildpartial(dbp, oldrec, partial, newrec) + DB *dbp; + DBT *oldrec, *partial, *newrec; +{ + int ret; + u_int8_t *buf; + u_int32_t len, nbytes; + + DB_ASSERT(F_ISSET(partial, DB_DBT_PARTIAL)); + + memset(newrec, 0, sizeof(DBT)); + + nbytes = __db_partsize(oldrec->size, partial); + newrec->size = nbytes; + + if ((ret = __os_malloc(dbp->dbenv, nbytes, &buf)) != 0) + return (ret); + newrec->data = buf; + + /* Nul or pad out the buffer, for any part that isn't specified. */ + memset(buf, + F_ISSET(dbp, DB_AM_FIXEDLEN) ? ((BTREE *)dbp->bt_internal)->re_pad : + 0, nbytes); + + /* Copy in any leading data from the original record. */ + memcpy(buf, oldrec->data, + partial->doff > oldrec->size ? oldrec->size : partial->doff); + + /* Copy the data from partial. */ + memcpy(buf + partial->doff, partial->data, partial->size); + + /* Copy any trailing data from the original record. */ + len = partial->doff + partial->dlen; + if (oldrec->size > len) + memcpy(buf + partial->doff + partial->size, + (u_int8_t *)oldrec->data + len, oldrec->size - len); + + return (0); +} + +/* + * __db_partsize -- + * Given the number of bytes in an existing record and a DBT that + * is about to be partial-put, calculate the size of the record + * after the put. + * + * This code is called from __bam_partsize. + * + * PUBLIC: u_int32_t __db_partsize __P((u_int32_t, DBT *)); + */ +u_int32_t +__db_partsize(nbytes, data) + u_int32_t nbytes; + DBT *data; +{ + + /* + * There are really two cases here: + * + * Case 1: We are replacing some bytes that do not exist (i.e., they + * are past the end of the record). In this case the number of bytes + * we are replacing is irrelevant and all we care about is how many + * bytes we are going to add from offset. So, the new record length + * is going to be the size of the new bytes (size) plus wherever those + * new bytes begin (doff). + * + * Case 2: All the bytes we are replacing exist. Therefore, the new + * size is the oldsize (nbytes) minus the bytes we are replacing (dlen) + * plus the bytes we are adding (size). + */ + if (nbytes < data->doff + data->dlen) /* Case 1 */ + return (data->doff + data->size); + + return (nbytes + data->size - data->dlen); /* Case 2 */ +} |