#include "db_config.h"
#include "db_int.h"
#include "dbinc/db_page.h"
#include "dbinc/btree.h"
#include "dbinc/hash.h"
#include "dbinc/lock.h"
#include "dbinc/mp.h"
#include "dbinc/qam.h"
#include "dbinc/txn.h"
static int __db_buildpartial __P((DB *, DBT *, DBT *, DBT *));
static int __db_s_count __P((DB *));
static int __db_wrlock_err __P((ENV *));
static int __dbc_cleanup __P((DBC *, DBC *, int));
static int __dbc_del_foreign __P((DBC *));
static int __dbc_del_oldskey __P((DB *, DBC *, DBT *, DBT *, DBT *));
static int __dbc_del_secondary __P((DBC *));
static int __dbc_pget_recno __P((DBC *, DBT *, DBT *, u_int32_t));
#define CDB_LOCKING_INIT(env, dbc) \
\
if (CDB_LOCKING(env)) { \
if (!F_ISSET(dbc, DBC_WRITECURSOR | DBC_WRITER)) \
return (__db_wrlock_err(env)); \
\
if (F_ISSET(dbc, DBC_WRITECURSOR) && \
(ret = __lock_get(env, \
(dbc)->locker, DB_LOCK_UPGRADE, &(dbc)->lock_dbt, \
DB_LOCK_WRITE, &(dbc)->mylock)) != 0) \
return (ret); \
}
#define CDB_LOCKING_DONE(env, dbc) \
\
if (F_ISSET(dbc, DBC_WRITECURSOR)) \
(void)__lock_downgrade( \
env, &(dbc)->mylock, DB_LOCK_IWRITE, 0);
int
__dbc_close(dbc)
DBC *dbc;
{
DB *dbp;
DBC *opd;
DBC_INTERNAL *cp;
DB_TXN *txn;
ENV *env;
int ret, t_ret;
dbp = dbc->dbp;
env = dbp->env;
cp = dbc->internal;
opd = cp->opd;
ret = 0;
MUTEX_LOCK(env, dbp->mutex);
if (opd != NULL) {
DB_ASSERT(env, F_ISSET(opd, DBC_ACTIVE));
F_CLR(opd, DBC_ACTIVE);
TAILQ_REMOVE(&dbp->active_queue, opd, links);
}
DB_ASSERT(env, F_ISSET(dbc, DBC_ACTIVE));
F_CLR(dbc, DBC_ACTIVE);
TAILQ_REMOVE(&dbp->active_queue, dbc, links);
MUTEX_UNLOCK(env, dbp->mutex);
if ((t_ret =
dbc->am_close(dbc, PGNO_INVALID, NULL)) != 0 && ret == 0)
ret = t_ret;
if (CDB_LOCKING(env)) {
if ((t_ret = __LPUT(dbc, dbc->mylock)) != 0 && ret == 0)
ret = t_ret;
memset(&dbc->mylock, 0, sizeof(dbc->mylock));
if (opd != NULL)
memset(&opd->mylock, 0, sizeof(opd->mylock));
}
if ((txn = dbc->txn) != NULL)
txn->cursors--;
MUTEX_LOCK(env, dbp->mutex);
if (opd != NULL) {
if (txn != NULL)
txn->cursors--;
TAILQ_INSERT_TAIL(&dbp->free_queue, opd, links);
opd = NULL;
}
TAILQ_INSERT_TAIL(&dbp->free_queue, dbc, links);
MUTEX_UNLOCK(env, dbp->mutex);
if (txn != NULL && F_ISSET(txn, TXN_PRIVATE) && txn->cursors == 0 &&
(t_ret = __txn_commit(txn, 0)) != 0 && ret == 0)
ret = t_ret;
return (ret);
}
int
__dbc_destroy(dbc)
DBC *dbc;
{
DB *dbp;
ENV *env;
int ret, t_ret;
dbp = dbc->dbp;
env = dbp->env;
MUTEX_LOCK(env, dbp->mutex);
TAILQ_REMOVE(&dbp->free_queue, dbc, links);
MUTEX_UNLOCK(env, dbp->mutex);
if (dbc->my_rskey.data != NULL)
__os_free(env, dbc->my_rskey.data);
if (dbc->my_rkey.data != NULL)
__os_free(env, dbc->my_rkey.data);
if (dbc->my_rdata.data != NULL)
__os_free(env, dbc->my_rdata.data);
ret = dbc->am_destroy == NULL ? 0 : dbc->am_destroy(dbc);
if (LOCKING_ON(env) &&
F_ISSET(dbc, DBC_OWN_LID) &&
(t_ret = __lock_id_free(env, dbc->lref)) != 0 && ret == 0)
ret = t_ret;
__os_free(env, dbc);
return (ret);
}
int
__dbc_count(dbc, recnop)
DBC *dbc;
db_recno_t *recnop;
{
ENV *env;
int ret;
env = dbc->env;
switch (dbc->dbtype) {
case DB_QUEUE:
case DB_RECNO:
*recnop = 1;
break;
case DB_HASH:
if (dbc->internal->opd == NULL) {
if ((ret = __hamc_count(dbc, recnop)) != 0)
return (ret);
break;
}
case DB_BTREE:
if ((ret = __bamc_count(dbc, recnop)) != 0)
return (ret);
break;
case DB_UNKNOWN:
default:
return (__db_unknown_type(env, "__dbc_count", dbc->dbtype));
}
return (0);
}
int
__dbc_del(dbc, flags)
DBC *dbc;
u_int32_t flags;
{
DB *dbp;
DBC *opd;
ENV *env;
int ret, t_ret;
dbp = dbc->dbp;
env = dbp->env;
CDB_LOCKING_INIT(env, dbc);
if (flags != DB_UPDATE_SECONDARY && F_ISSET(dbp, DB_AM_SECONDARY)) {
ret = __dbc_del_secondary(dbc);
goto done;
}
if (LIST_FIRST(&dbp->f_primaries) != NULL &&
(ret = __dbc_del_foreign(dbc)) != 0)
goto done;
if (LIST_FIRST(&dbp->s_secondaries) != NULL &&
(ret = __dbc_del_primary(dbc)) != 0)
goto done;
opd = dbc->internal->opd;
if (opd == NULL)
ret = dbc->am_del(dbc);
else
if ((ret = dbc->am_writelock(dbc)) == 0)
ret = opd->am_del(opd);
if (F_ISSET(dbc->dbp, DB_AM_READ_UNCOMMITTED) &&
dbc->internal->lock_mode == DB_LOCK_WRITE) {
if ((t_ret =
__TLPUT(dbc, dbc->internal->lock)) != 0 && ret == 0)
ret = t_ret;
if (t_ret == 0)
dbc->internal->lock_mode = DB_LOCK_WWRITE;
}
done: CDB_LOCKING_DONE(env, dbc);
return (ret);
}
int
__dbc_dup(dbc_orig, dbcp, flags)
DBC *dbc_orig;
DBC **dbcp;
u_int32_t flags;
{
DBC *dbc_n, *dbc_nopd;
int ret;
dbc_n = dbc_nopd = NULL;
if ((ret = __dbc_idup(dbc_orig, &dbc_n, flags)) != 0)
goto err;
*dbcp = dbc_n;
if (dbc_orig->internal->opd != NULL) {
if ((ret =
__dbc_idup(dbc_orig->internal->opd, &dbc_nopd, flags)) != 0)
goto err;
dbc_n->internal->opd = dbc_nopd;
}
return (0);
err: if (dbc_n != NULL)
(void)__dbc_close(dbc_n);
if (dbc_nopd != NULL)
(void)__dbc_close(dbc_nopd);
return (ret);
}
int
__dbc_idup(dbc_orig, dbcp, flags)
DBC *dbc_orig, **dbcp;
u_int32_t flags;
{
DB *dbp;
DBC *dbc_n;
DBC_INTERNAL *int_n, *int_orig;
ENV *env;
int ret;
dbp = dbc_orig->dbp;
dbc_n = *dbcp;
env = dbp->env;
if ((ret = __db_cursor_int(dbp, dbc_orig->thread_info,
dbc_orig->txn, dbc_orig->dbtype, dbc_orig->internal->root,
F_ISSET(dbc_orig, DBC_OPD) | DBC_DUPLICATE,
dbc_orig->locker, &dbc_n)) != 0)
return (ret);
if (flags == DB_POSITION) {
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 = __qamc_dup(dbc_orig, dbc_n)) != 0)
goto err;
break;
case DB_BTREE:
case DB_RECNO:
if ((ret = __bamc_dup(dbc_orig, dbc_n)) != 0)
goto err;
break;
case DB_HASH:
if ((ret = __hamc_dup(dbc_orig, dbc_n)) != 0)
goto err;
break;
case DB_UNKNOWN:
default:
ret = __db_unknown_type(env,
"__dbc_idup", dbc_orig->dbtype);
goto err;
}
}
F_SET(dbc_n, F_ISSET(dbc_orig,
DBC_READ_COMMITTED | DBC_READ_UNCOMMITTED | DBC_WRITECURSOR));
if (CDB_LOCKING(env) && !F_ISSET(dbc_n, DBC_OPD) &&
(ret = __lock_get(env, dbc_n->locker, 0,
&dbc_n->lock_dbt, F_ISSET(dbc_orig, DBC_WRITECURSOR) ?
DB_LOCK_IWRITE : DB_LOCK_READ, &dbc_n->mylock)) != 0)
goto err;
dbc_n->priority = dbc_orig->priority;
*dbcp = dbc_n;
return (0);
err: (void)__dbc_close(dbc_n);
return (ret);
}
int
__dbc_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;
*dbcp = oldopd;
if ((ret = __db_cursor_int(dbp, dbc_parent->thread_info,
dbc_parent->txn,
dbtype, root, DBC_OPD, dbc_parent->locker, &opd)) != 0)
return (ret);
opd->priority = dbc_parent->priority;
*dbcp = opd;
if (oldopd != NULL && (ret = __dbc_close(oldopd)) != 0)
return (ret);
return (0);
}
int
__dbc_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;
ENV *env;
db_pgno_t pgno;
db_indx_t indx_off;
u_int32_t multi, orig_ulen, tmp_flags, tmp_read_uncommitted, tmp_rmw;
u_int8_t type;
int key_small, ret, t_ret;
COMPQUIET(orig_ulen, 0);
key_small = 0;
dbp = dbc_arg->dbp;
env = dbp->env;
mpf = dbp->mpf;
dbc_n = NULL;
opd = NULL;
tmp_rmw = LF_ISSET(DB_RMW);
LF_CLR(DB_RMW);
tmp_read_uncommitted =
LF_ISSET(DB_READ_UNCOMMITTED) &&
!F_ISSET(dbc_arg, DBC_READ_UNCOMMITTED);
LF_CLR(DB_READ_UNCOMMITTED);
multi = LF_ISSET(DB_MULTIPLE|DB_MULTIPLE_KEY);
LF_CLR(DB_MULTIPLE|DB_MULTIPLE_KEY);
if (flags == DB_GET_RECNO) {
if (tmp_rmw)
F_SET(dbc_arg, DBC_RMW);
if (tmp_read_uncommitted)
F_SET(dbc_arg, DBC_READ_UNCOMMITTED);
ret = __bamc_rget(dbc_arg, data);
if (tmp_rmw)
F_CLR(dbc_arg, DBC_RMW);
if (tmp_read_uncommitted)
F_CLR(dbc_arg, DBC_READ_UNCOMMITTED);
return (ret);
}
if (flags == DB_CONSUME || flags == DB_CONSUME_WAIT)
CDB_LOCKING_INIT(env, dbc_arg);
if (!DB_RETURNS_A_KEY(dbp, flags))
F_SET(key, DB_DBT_ISSET);
if (flags == DB_GET_BOTH &&
(dbp->dup_compare == NULL || dbp->dup_compare == __bam_defcmp))
F_SET(data, DB_DBT_ISSET);
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 || flags == DB_PREV_DUP)) {
if (tmp_rmw && (ret = dbc_arg->am_writelock(dbc_arg)) != 0)
goto err;
if (F_ISSET(dbc_arg, DBC_TRANSIENT))
opd = cp->opd;
else if ((ret = __dbc_idup(cp->opd, &opd, DB_POSITION)) != 0)
goto err;
switch (ret = opd->am_get(opd, key, data, flags, NULL)) {
case 0:
goto done;
case DB_NOTFOUND:
if (flags == DB_NEXT || flags == DB_PREV) {
if ((ret = __dbc_close(opd)) != 0)
goto err;
opd = NULL;
if (F_ISSET(dbc_arg, DBC_TRANSIENT))
cp->opd = NULL;
break;
}
goto err;
default:
goto err;
}
} else if (cp->opd != NULL && F_ISSET(dbc_arg, DBC_TRANSIENT)) {
if ((ret = __dbc_close(cp->opd)) != 0)
goto err;
cp->opd = NULL;
}
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_DUP:
case DB_PREV_NODUP:
tmp_flags = DB_POSITION;
break;
default:
tmp_flags = 0;
break;
}
if (tmp_read_uncommitted)
F_SET(dbc_arg, DBC_READ_UNCOMMITTED);
if (F_ISSET(dbc_arg, DBC_TRANSIENT))
dbc_n = dbc_arg;
else {
ret = __dbc_idup(dbc_arg, &dbc_n, tmp_flags);
if (tmp_read_uncommitted)
F_CLR(dbc_arg, DBC_READ_UNCOMMITTED);
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:
default:
break;
}
retry: pgno = PGNO_INVALID;
ret = dbc_n->am_get(dbc_n, key, data, flags, &pgno);
if (tmp_rmw)
F_CLR(dbc_n, DBC_RMW);
if (tmp_read_uncommitted)
F_CLR(dbc_arg, DBC_READ_UNCOMMITTED);
F_CLR(dbc_n, DBC_MULTIPLE|DBC_MULTIPLE_KEY);
if (ret != 0)
goto err;
cp_n = dbc_n->internal;
if (pgno != PGNO_INVALID) {
if ((ret = __dbc_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(env, "__dbc_get", flags);
goto err;
}
ret = cp_n->opd->am_get(cp_n->opd, key, data, tmp_flags, NULL);
switch (ret) {
case 0:
break;
case DB_NOTFOUND:
if (flags == DB_NEXT || flags == DB_PREV) {
if ((ret = __dbc_close(cp_n->opd)) != 0)
goto err;
cp_n->opd = NULL;
goto retry;
}
goto err;
default:
goto err;
}
}
done:
cp_n = dbc_n == NULL ? dbc_arg->internal : dbc_n->internal;
if (!F_ISSET(key, DB_DBT_ISSET)) {
if (cp_n->page == NULL && (ret = __memp_fget(mpf, &cp_n->pgno,
dbc_arg->thread_info, dbc_arg->txn, 0, &cp_n->page)) != 0)
goto err;
if ((ret = __db_ret(dbp, dbc_arg->thread_info,
dbc_arg->txn, cp_n->page, cp_n->indx, key,
&dbc_arg->rkey->data, &dbc_arg->rkey->ulen)) != 0) {
if (ret == DB_BUFFER_SMALL &&
F_ISSET(data, DB_DBT_USERMEM)) {
key_small = 1;
orig_ulen = data->ulen;
data->ulen = 0;
} else
goto err;
}
}
if (multi != 0) {
if (dbc_n == NULL) {
if ((!(multi & DB_MULTIPLE_KEY) &&
dbc_arg->internal->opd == NULL) ||
F_ISSET(dbc_arg, DBC_TRANSIENT))
dbc_n = dbc_arg;
else {
if ((ret = __dbc_idup(dbc_arg,
&dbc_n, DB_POSITION)) != 0)
goto err;
if ((ret = dbc_n->am_get(dbc_n,
key, data, DB_CURRENT, &pgno)) != 0)
goto err;
}
cp_n = dbc_n->internal;
}
if (opd != NULL) {
DB_ASSERT(env, cp_n->opd == NULL);
cp_n->opd = opd;
opd = NULL;
}
data->size = data->ulen;
ret = dbc_n->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;
cp = dbc->internal;
if (cp->page == NULL &&
(ret = __memp_fget(mpf, &cp->pgno,
dbc_arg->thread_info, dbc->txn, 0, &cp->page)) != 0)
goto err;
type = TYPE(cp->page);
indx_off = ((type == P_LBTREE ||
type == P_HASH || type == P_HASH_UNSORTED) ? O_INDX : 0);
ret = __db_ret(dbp,
dbc->thread_info, dbc->txn, cp->page, cp->indx + indx_off,
data, &dbc_arg->rdata->data, &dbc_arg->rdata->ulen);
}
err:
F_CLR(key, DB_DBT_ISSET);
F_CLR(data, DB_DBT_ISSET);
if (opd != NULL) {
if (F_ISSET(dbc_arg->dbp, DB_AM_READ_UNCOMMITTED) &&
F_ISSET((BTREE_CURSOR *)
dbc_arg->internal->opd->internal, C_DELETED))
if ((t_ret =
dbc_arg->am_writelock(dbc_arg)) != 0 && ret == 0)
ret = t_ret;
if ((t_ret = __dbc_cleanup(
dbc_arg->internal->opd, opd, ret)) != 0 && ret == 0)
ret = t_ret;
}
if (key_small) {
data->ulen = orig_ulen;
if (ret == 0)
ret = DB_BUFFER_SMALL;
}
if ((t_ret = __dbc_cleanup(dbc_arg, dbc_n, ret)) != 0 &&
(ret == 0 || ret == DB_BUFFER_SMALL))
ret = t_ret;
if (flags == DB_CONSUME || flags == DB_CONSUME_WAIT)
CDB_LOCKING_DONE(env, dbc_arg);
return (ret);
}
int
__dbc_put(dbc_arg, key, data, flags)
DBC *dbc_arg;
DBT *key, *data;
u_int32_t flags;
{
DB *dbp, *sdbp;
DBC *dbc_n, *fdbc, *oldopd, *opd, *sdbc, *pdbc;
DBT *all_skeys, *skeyp, *tskeyp;
DBT fdata, olddata, oldpkey, newdata, pkey, temppkey, tempskey;
ENV *env;
db_pgno_t pgno;
int cmp, have_oldrec, ispartial, nodel, re_pad, ret, s_count, t_ret;
u_int32_t re_len, nskey, rmw, size, tmp_flags;
dbp = dbc_arg->dbp;
env = dbp->env;
sdbp = NULL;
fdbc = pdbc = dbc_n = NULL;
all_skeys = NULL;
memset(&newdata, 0, sizeof(DBT));
ret = s_count = 0;
memset(&olddata, 0, sizeof(DBT));
F_SET(&olddata, DB_DBT_MALLOC);
if (flags == DB_UPDATE_SECONDARY)
flags = DB_KEYLAST;
CDB_LOCKING_INIT(env, dbc_arg);
if (LIST_FIRST(&dbp->s_secondaries) == NULL)
goto skip_s_update;
memset(&pkey, 0, sizeof(DBT));
s_count = __db_s_count(dbp);
if ((ret = __os_calloc(
env, (u_int)s_count, sizeof(DBT), &all_skeys)) != 0)
goto err;
have_oldrec = nodel = 0;
DB_ASSERT(env, flags == DB_CURRENT || flags == DB_KEYFIRST ||
flags == DB_KEYLAST || flags == DB_NOOVERWRITE);
rmw = STD_LOCKING(dbc_arg) ? DB_RMW : 0;
if (flags == DB_CURRENT) {
ret = __dbc_get(dbc_arg, &pkey, &olddata, rmw | DB_CURRENT);
if (ret == DB_KEYEMPTY)
ret = DB_NOTFOUND;
if (ret != 0)
goto err;
have_oldrec = 1;
} else {
pkey.data = key->data;
pkey.size = key->size;
}
if (F_ISSET(data, DB_DBT_PARTIAL)) {
if (!have_oldrec && !nodel) {
if ((ret = __dbc_idup(dbc_arg, &pdbc, 0)) != 0)
goto err;
DB_ASSERT(env, flags != DB_CURRENT);
ret = __dbc_get(pdbc, &pkey, &olddata, rmw | DB_SET);
if (ret == DB_KEYEMPTY || ret == DB_NOTFOUND) {
nodel = 1;
ret = 0;
}
if ((t_ret = __dbc_close(pdbc)) != 0)
ret = t_ret;
if (ret != 0)
goto err;
have_oldrec = 1;
}
if ((ret =
__db_buildpartial(dbp, &olddata, data, &newdata)) != 0)
goto err;
ispartial = 1;
} else
ispartial = 0;
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) {
ret = __db_rec_toobig(env, size, re_len);
goto err;
} else if (size < re_len) {
if ((ret =
__os_realloc(env, 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;
}
}
for (ret = __db_s_first(dbp, &sdbp), skeyp = all_skeys;
sdbp != NULL && ret == 0;
ret = __db_s_next(&sdbp, dbc_arg->txn), ++skeyp) {
DB_ASSERT(env, skeyp - all_skeys < s_count);
if (have_oldrec && !nodel &&
FLD_ISSET(sdbp->s_assoc_flags, DB_ASSOC_IMMUTABLE_KEY))
continue;
if ((ret = sdbp->s_callback(sdbp,
&pkey, ispartial ? &newdata : data, skeyp)) != 0) {
if (ret == DB_DONOTINDEX) {
F_SET(skeyp, DB_DBT_MULTIPLE);
skeyp->size = 0;
ret = 0;
} else
goto err;
}
if (sdbp->s_foreign != NULL &&
(ret = __db_cursor_int(sdbp->s_foreign,
dbc_arg->thread_info, dbc_arg->txn, sdbp->s_foreign->type,
PGNO_INVALID, 0, dbc_arg->locker, &fdbc)) != 0)
goto err;
if (F_ISSET(skeyp, DB_DBT_MULTIPLE)) {
#ifdef DIAGNOSTIC
__db_check_skeyset(sdbp, skeyp);
#endif
for (tskeyp = (DBT *)skeyp->data, nskey = skeyp->size;
nskey > 0; nskey--, tskeyp++) {
if (fdbc != NULL) {
memset(&fdata, 0, sizeof(DBT));
F_SET(&fdata,
DB_DBT_PARTIAL | DB_DBT_USERMEM);
if ((ret = __dbc_get(
fdbc, tskeyp, &fdata,
DB_SET | rmw)) == DB_NOTFOUND ||
ret == DB_KEYEMPTY) {
ret = DB_FOREIGN_CONFLICT;
break;
}
}
F_SET(tskeyp, DB_DBT_ISSET);
}
tskeyp = (DBT *)skeyp->data;
nskey = skeyp->size;
} else {
if (fdbc != NULL) {
memset(&fdata, 0, sizeof(DBT));
F_SET(&fdata, DB_DBT_PARTIAL | DB_DBT_USERMEM);
if ((ret = __dbc_get(fdbc, skeyp, &fdata,
DB_SET | rmw)) == DB_NOTFOUND ||
ret == DB_KEYEMPTY)
ret = DB_FOREIGN_CONFLICT;
}
F_SET(skeyp, DB_DBT_ISSET);
tskeyp = skeyp;
nskey = 1;
}
if (fdbc != NULL && (t_ret = __dbc_close(fdbc)) != 0 &&
ret == 0)
ret = t_ret;
fdbc = NULL;
if (ret != 0)
goto err;
if (have_oldrec) {
if ((ret = __dbc_del_oldskey(sdbp, dbc_arg,
skeyp, &pkey, &olddata)) == DB_KEYEXIST)
continue;
else if (ret != 0)
goto err;
}
if (nskey == 0)
continue;
if ((ret = __db_cursor_int(sdbp, dbc_arg->thread_info,
dbc_arg->txn, sdbp->type,
PGNO_INVALID, 0, dbc_arg->locker, &sdbc)) != 0)
goto err;
if (CDB_LOCKING(env)) {
DB_ASSERT(env, sdbc->mylock.off == LOCK_INVALID);
F_SET(sdbc, DBC_WRITER);
}
SWAP_IF_NEEDED(sdbp, &pkey);
for (; nskey > 0 && ret == 0; nskey--, tskeyp++) {
if (!F_ISSET(tskeyp, DB_DBT_ISSET))
continue;
if (!F_ISSET(sdbp, DB_AM_DUP)) {
memset(&oldpkey, 0, sizeof(DBT));
F_SET(&oldpkey, DB_DBT_MALLOC);
ret = __dbc_get(sdbc,
tskeyp, &oldpkey, rmw | DB_SET);
if (ret == 0) {
cmp = __bam_defcmp(sdbp,
&oldpkey, &pkey);
__os_ufree(env, oldpkey.data);
if (cmp != 0) {
__db_errx(env, "%s%s",
"Put results in a non-unique secondary key in an ",
"index not configured to support duplicates");
ret = EINVAL;
}
}
if (ret != DB_NOTFOUND && ret != DB_KEYEMPTY)
break;
} else if (!F_ISSET(sdbp, DB_AM_DUPSORT)) {
DB_INIT_DBT(tempskey,
tskeyp->data, tskeyp->size);
DB_INIT_DBT(temppkey,
pkey.data, pkey.size);
ret = __dbc_get(sdbc, &tempskey, &temppkey,
rmw | DB_GET_BOTH);
if (ret != DB_NOTFOUND && ret != DB_KEYEMPTY)
break;
}
ret = __dbc_put(sdbc, tskeyp, &pkey,
DB_UPDATE_SECONDARY);
if (ret == DB_KEYEXIST)
ret = 0;
}
SWAP_IF_NEEDED(sdbp, &pkey);
if ((t_ret = __dbc_close(sdbc)) != 0 && ret == 0)
ret = t_ret;
if (ret != 0)
goto err;
F_SET(skeyp, DB_DBT_ISSET);
}
if (ret != 0)
goto err;
if (have_oldrec)
goto skip_s_update;
if ((ret = __dbc_idup(dbc_arg, &pdbc, 0)) != 0)
goto err;
DB_ASSERT(env, flags != DB_CURRENT);
pkey.data = key->data;
pkey.size = key->size;
ret = __dbc_get(pdbc, &pkey, &olddata, rmw | DB_SET);
if (ret == DB_KEYEMPTY || ret == DB_NOTFOUND) {
nodel = 1;
ret = 0;
}
if ((t_ret = __dbc_close(pdbc)) != 0 && ret == 0)
ret = t_ret;
if (ret != 0)
goto err;
if (nodel)
goto skip_s_update;
for (ret = __db_s_first(dbp, &sdbp), skeyp = all_skeys;
sdbp != NULL && ret == 0;
ret = __db_s_next(&sdbp, dbc_arg->txn), skeyp++) {
DB_ASSERT(env, skeyp - all_skeys < s_count);
if (FLD_ISSET(sdbp->s_assoc_flags, DB_ASSOC_IMMUTABLE_KEY))
continue;
if ((ret = __dbc_del_oldskey(sdbp, dbc_arg,
skeyp, &pkey, &olddata)) != 0 && ret != DB_KEYEXIST)
goto err;
}
if (ret != 0)
goto err;
skip_s_update:
if (dbc_arg->internal->opd != NULL &&
(flags == DB_AFTER || flags == DB_BEFORE || flags == DB_CURRENT)) {
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->am_writelock(dbc_arg)) != 0 ||
(ret = __dbc_dup(dbc_arg, &dbc_n, DB_POSITION)) != 0)
goto err;
opd = dbc_n->internal->opd;
if ((ret = opd->am_put(
opd, key, data, flags, NULL)) != 0)
goto err;
goto done;
}
tmp_flags = flags == DB_AFTER ||
flags == DB_BEFORE || flags == DB_CURRENT ? DB_POSITION : 0;
if (F_ISSET(dbc_arg, DBC_TRANSIENT))
dbc_n = dbc_arg;
else if ((ret = __dbc_idup(dbc_arg, &dbc_n, tmp_flags)) != 0)
goto err;
pgno = PGNO_INVALID;
if ((ret = dbc_n->am_put(dbc_n, key, data, flags, &pgno)) != 0)
goto err;
if (pgno != PGNO_INVALID) {
oldopd = dbc_n->internal->opd;
if ((ret = __dbc_newopd(dbc_arg, pgno, oldopd, &opd)) != 0) {
dbc_n->internal->opd = opd;
goto err;
}
dbc_n->internal->opd = opd;
if (flags == DB_NOOVERWRITE)
flags = DB_KEYLAST;
if ((ret = opd->am_put(
opd, key, data, flags, NULL)) != 0)
goto err;
}
done:
err:
if ((t_ret = __dbc_cleanup(dbc_arg, dbc_n, ret)) != 0 && ret == 0)
ret = t_ret;
if (newdata.data != NULL)
__os_free(env, newdata.data);
if (olddata.data != NULL)
__os_ufree(env, olddata.data);
CDB_LOCKING_DONE(env, dbc_arg);
if (sdbp != NULL &&
(t_ret = __db_s_done(sdbp, dbc_arg->txn)) != 0 && ret == 0)
ret = t_ret;
for (skeyp = all_skeys; skeyp - all_skeys < s_count; skeyp++) {
if (F_ISSET(skeyp, DB_DBT_MULTIPLE)) {
for (nskey = skeyp->size, tskeyp = (DBT *)skeyp->data;
nskey > 0;
nskey--, tskeyp++)
FREE_IF_NEEDED(env, tskeyp);
}
FREE_IF_NEEDED(env, skeyp);
}
if (all_skeys != NULL)
__os_free(env, all_skeys);
return (ret);
}
static int
__dbc_del_oldskey(sdbp, dbc_arg, skey, pkey, olddata)
DB *sdbp;
DBC *dbc_arg;
DBT *skey, *pkey, *olddata;
{
DB *dbp;
DBC *sdbc;
DBT *toldskeyp, *tskeyp;
DBT oldskey, temppkey, tempskey;
ENV *env;
int ret, t_ret;
u_int32_t i, noldskey, nsame, nskey, rmw;
sdbc = NULL;
dbp = sdbp->s_primary;
env = dbp->env;
nsame = 0;
rmw = STD_LOCKING(dbc_arg) ? DB_RMW : 0;
memset(&oldskey, 0, sizeof(DBT));
if ((ret = sdbp->s_callback(sdbp, pkey, olddata, &oldskey)) != 0) {
if (ret == DB_DONOTINDEX ||
(F_ISSET(&oldskey, DB_DBT_MULTIPLE) && oldskey.size == 0))
ret = 0;
return (ret);
}
if (F_ISSET(&oldskey, DB_DBT_MULTIPLE)) {
#ifdef DIAGNOSTIC
__db_check_skeyset(sdbp, &oldskey);
#endif
toldskeyp = (DBT *)oldskey.data;
noldskey = oldskey.size;
} else {
toldskeyp = &oldskey;
noldskey = 1;
}
if (F_ISSET(skey, DB_DBT_MULTIPLE)) {
nskey = skey->size;
skey = (DBT *)skey->data;
} else
nskey = F_ISSET(skey, DB_DBT_ISSET) ? 1 : 0;
for (; noldskey > 0 && ret == 0; noldskey--, toldskeyp++) {
for (i = 0, tskeyp = skey; i < nskey; i++, tskeyp++)
if (((BTREE *)sdbp->bt_internal)->bt_compare(sdbp,
toldskeyp, tskeyp) == 0) {
nsame++;
F_CLR(tskeyp, DB_DBT_ISSET);
break;
}
if (i < nskey) {
FREE_IF_NEEDED(env, toldskeyp);
continue;
}
if (sdbc == NULL) {
if ((ret = __db_cursor_int(sdbp,
dbc_arg->thread_info, dbc_arg->txn, sdbp->type,
PGNO_INVALID, 0, dbc_arg->locker, &sdbc)) != 0)
goto err;
if (CDB_LOCKING(env)) {
DB_ASSERT(env,
sdbc->mylock.off == LOCK_INVALID);
F_SET(sdbc, DBC_WRITER);
}
}
SWAP_IF_NEEDED(sdbp, pkey);
DB_INIT_DBT(temppkey, pkey->data, pkey->size);
DB_INIT_DBT(tempskey, toldskeyp->data, toldskeyp->size);
if ((ret = __dbc_get(sdbc,
&tempskey, &temppkey, rmw | DB_GET_BOTH)) == 0)
ret = __dbc_del(sdbc, DB_UPDATE_SECONDARY);
else if (ret == DB_NOTFOUND)
ret = __db_secondary_corrupt(dbp);
SWAP_IF_NEEDED(sdbp, pkey);
FREE_IF_NEEDED(env, toldskeyp);
}
err: for (; noldskey > 0; noldskey--, toldskeyp++)
FREE_IF_NEEDED(env, toldskeyp);
FREE_IF_NEEDED(env, &oldskey);
if (sdbc != NULL && (t_ret = __dbc_close(sdbc)) != 0 && ret == 0)
ret = t_ret;
if (ret == 0 && nsame == nskey)
return (DB_KEYEXIST);
return (ret);
}
int
__db_duperr(dbp, flags)
DB *dbp;
u_int32_t flags;
{
if (flags != DB_NODUPDATA && !F_ISSET(dbp, DB_AM_SECONDARY))
__db_errx(dbp->env,
"Duplicate data items are not supported with sorted data");
return (DB_KEYEXIST);
}
static int
__dbc_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;
if (internal->page != NULL) {
if ((t_ret = __memp_fput(mpf, dbc->thread_info,
internal->page, dbc->priority)) != 0 && ret == 0)
ret = t_ret;
internal->page = NULL;
}
opd = internal->opd;
if (opd != NULL && opd->internal->page != NULL) {
if ((t_ret = __memp_fput(mpf, dbc->thread_info,
opd->internal->page, dbc->priority)) != 0 && ret == 0)
ret = t_ret;
opd->internal->page = NULL;
}
if (dbc_n == NULL || dbc == dbc_n)
return (ret);
if (dbc_n->internal->page != NULL) {
if ((t_ret = __memp_fput(mpf, dbc->thread_info,
dbc_n->internal->page, dbc->priority)) != 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 = __memp_fput(mpf, dbc->thread_info,
opd->internal->page, dbc->priority)) != 0 && ret == 0)
ret = t_ret;
opd->internal->page = NULL;
}
if (!failed && ret == 0) {
dbc->internal = dbc_n->internal;
dbc_n->internal = internal;
}
if ((t_ret = __dbc_close(dbc_n)) != 0 && ret == 0)
ret = t_ret;
if (F_ISSET(dbp, DB_AM_READ_UNCOMMITTED) &&
dbc->internal->lock_mode == DB_LOCK_WRITE) {
if ((t_ret =
__TLPUT(dbc, dbc->internal->lock)) != 0 && ret == 0)
ret = t_ret;
if (t_ret == 0)
dbc->internal->lock_mode = DB_LOCK_WWRITE;
}
return (ret);
}
int
__dbc_secondary_get_pp(dbc, skey, data, flags)
DBC *dbc;
DBT *skey, *data;
u_int32_t flags;
{
DB_ASSERT(dbc->env, F_ISSET(dbc->dbp, DB_AM_SECONDARY));
return (__dbc_pget_pp(dbc, skey, NULL, data, flags));
}
int
__dbc_pget(dbc, skey, pkey, data, flags)
DBC *dbc;
DBT *skey, *pkey, *data;
u_int32_t flags;
{
DB *pdbp, *sdbp;
DBC *dbc_n, *pdbc;
DBT nullpkey;
u_int32_t save_pkey_flags, tmp_flags, tmp_read_uncommitted, tmp_rmw;
int pkeymalloc, ret, t_ret;
sdbp = dbc->dbp;
pdbp = sdbp->s_primary;
dbc_n = NULL;
pkeymalloc = t_ret = 0;
if (pkey == NULL) {
memset(&nullpkey, 0, sizeof(DBT));
pkey = &nullpkey;
}
tmp_rmw = LF_ISSET(DB_RMW);
LF_CLR(DB_RMW);
tmp_read_uncommitted =
LF_ISSET(DB_READ_UNCOMMITTED) &&
!F_ISSET(dbc, DBC_READ_UNCOMMITTED);
LF_CLR(DB_READ_UNCOMMITTED);
if (flags == DB_GET_RECNO) {
if (tmp_rmw)
F_SET(dbc, DBC_RMW);
if (tmp_read_uncommitted)
F_SET(dbc, DBC_READ_UNCOMMITTED);
ret = __dbc_pget_recno(dbc, pkey, data, flags);
if (tmp_rmw)
F_CLR(dbc, DBC_RMW);
if (tmp_read_uncommitted)
F_CLR(dbc, DBC_READ_UNCOMMITTED);
return (ret);
}
save_pkey_flags = pkey->flags;
F_CLR(pkey, DB_DBT_PARTIAL);
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_DUP:
case DB_PREV_NODUP:
tmp_flags = DB_POSITION;
break;
default:
tmp_flags = 0;
break;
}
if ((ret = __dbc_dup(dbc, &dbc_n, tmp_flags)) != 0)
return (ret);
F_SET(dbc_n, DBC_TRANSIENT);
if (tmp_rmw)
F_SET(dbc_n, DBC_RMW);
if (tmp_read_uncommitted)
F_SET(dbc_n, DBC_READ_UNCOMMITTED);
if (flags == DB_GET_BOTH || flags == DB_GET_BOTHC ||
flags == DB_GET_BOTH_RANGE)
SWAP_IF_NEEDED(sdbp, pkey);
retry:
dbc_n->rdata = dbc->rkey;
dbc_n->rkey = dbc->rskey;
ret = __dbc_get(dbc_n, skey, pkey, flags);
pkey->flags = save_pkey_flags;
if (ret == 0 || flags == DB_GET_BOTH || flags == DB_GET_BOTHC ||
flags == DB_GET_BOTH_RANGE)
SWAP_IF_NEEDED(sdbp, pkey);
if (ret != 0)
goto err;
if ((ret = __db_cursor_int(pdbp, dbc->thread_info,
dbc->txn, pdbp->type, PGNO_INVALID, 0, dbc->locker, &pdbc)) != 0)
goto err;
if (tmp_read_uncommitted || F_ISSET(dbc, DBC_READ_UNCOMMITTED))
F_SET(pdbc, DBC_READ_UNCOMMITTED);
if (tmp_rmw || F_ISSET(dbc, DBC_RMW))
F_SET(pdbc, DBC_RMW);
if (F_ISSET(dbc, DBC_READ_COMMITTED))
F_SET(pdbc, DBC_READ_COMMITTED);
if (F_ISSET(pkey, DB_DBT_MALLOC)) {
F_CLR(pkey, DB_DBT_MALLOC);
F_SET(pkey, DB_DBT_REALLOC);
pkeymalloc = 1;
} else if (F_ISSET(pkey, DB_DBT_USERCOPY)) {
if (flags == DB_GET_BOTH_RANGE)
__dbt_userfree(sdbp->env, NULL, pkey, NULL);
if ((ret = __dbt_usercopy(sdbp->env, pkey)) != 0)
goto err;
}
F_SET(pdbc, DBC_TRANSIENT);
SET_RET_MEM(pdbc, dbc);
ret = __dbc_get(pdbc, pkey, data, DB_SET);
if ((t_ret = __dbc_close(pdbc)) != 0 && ret == 0)
ret = t_ret;
else if (ret == DB_NOTFOUND) {
if (!F_ISSET(pdbc, DBC_READ_UNCOMMITTED))
ret = __db_secondary_corrupt(pdbp);
else switch (flags) {
case DB_GET_BOTHC:
case DB_NEXT:
case DB_NEXT_DUP:
case DB_NEXT_NODUP:
case DB_PREV:
case DB_PREV_DUP:
case DB_PREV_NODUP:
goto retry;
default:
break;
}
}
err:
if ((t_ret = __dbc_cleanup(dbc, dbc_n, ret)) != 0 && ret == 0)
ret = t_ret;
if (pkeymalloc) {
F_CLR(pkey, DB_DBT_REALLOC);
F_SET(pkey, DB_DBT_MALLOC);
}
return (ret);
}
static int
__dbc_pget_recno(sdbc, pkey, data, flags)
DBC *sdbc;
DBT *pkey, *data;
u_int32_t flags;
{
DB *pdbp, *sdbp;
DBC *pdbc;
DBT discardme, primary_key;
ENV *env;
db_recno_t oob;
u_int32_t rmw;
int ret, t_ret;
sdbp = sdbc->dbp;
pdbp = sdbp->s_primary;
env = sdbp->env;
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 (F_ISSET(pdbp, DB_AM_RECNUM)) {
memset(&primary_key, 0, sizeof(DBT));
F_SET(&primary_key, DB_DBT_MALLOC);
if ((ret = __dbc_get(sdbc,
&discardme, &primary_key, rmw | DB_CURRENT)) != 0)
return (ret);
if ((ret = __db_cursor_int(pdbp, sdbc->thread_info, sdbc->txn,
pdbp->type, PGNO_INVALID, 0, sdbc->locker, &pdbc)) != 0)
goto perr;
SET_RET_MEM(pdbc, sdbc);
if ((ret = __dbc_get(pdbc,
&primary_key, &discardme, rmw | DB_SET)) != 0)
goto perr;
ret = __dbc_get(pdbc, &discardme, data, rmw | DB_GET_RECNO);
perr: __os_ufree(env, primary_key.data);
if (pdbc != NULL &&
(t_ret = __dbc_close(pdbc)) != 0 && ret == 0)
ret = t_ret;
if (ret != 0)
return (ret);
} else if ((ret = __db_retcopy(env, data, &oob,
sizeof(oob), &sdbc->rkey->data, &sdbc->rkey->ulen)) != 0)
return (ret);
if (F_ISSET(sdbp, DB_AM_RECNUM))
return (__dbc_get(sdbc, &discardme, pkey, flags));
else
return (__db_retcopy(env, pkey, &oob,
sizeof(oob), &sdbc->rdata->data, &sdbc->rdata->ulen));
}
static int
__db_wrlock_err(env)
ENV *env;
{
__db_errx(env, "Write attempted on read-only cursor");
return (EPERM);
}
static int
__dbc_del_secondary(dbc)
DBC *dbc;
{
DB *pdbp;
DBC *pdbc;
DBT skey, pkey;
ENV *env;
int ret, t_ret;
u_int32_t rmw;
pdbp = dbc->dbp->s_primary;
env = pdbp->env;
rmw = STD_LOCKING(dbc) ? DB_RMW : 0;
memset(&skey, 0, sizeof(DBT));
memset(&pkey, 0, sizeof(DBT));
F_SET(&skey, DB_DBT_PARTIAL | DB_DBT_USERMEM);
if ((ret = __dbc_get(dbc, &skey, &pkey, DB_CURRENT)) != 0)
return (ret);
SWAP_IF_NEEDED(dbc->dbp, &pkey);
if ((ret = __db_cursor_int(pdbp, dbc->thread_info, dbc->txn,
pdbp->type, PGNO_INVALID, 0, dbc->locker, &pdbc)) != 0)
return (ret);
if (CDB_LOCKING(env)) {
DB_ASSERT(env, pdbc->mylock.off == LOCK_INVALID);
F_SET(pdbc, DBC_WRITER);
}
if ((ret = __dbc_get(pdbc, &pkey, &skey, DB_SET | rmw)) == 0)
ret = __dbc_del(pdbc, 0);
else if (ret == DB_NOTFOUND)
ret = __db_secondary_corrupt(pdbp);
if ((t_ret = __dbc_close(pdbc)) != 0 && ret == 0)
ret = t_ret;
return (ret);
}
int
__dbc_del_primary(dbc)
DBC *dbc;
{
DB *dbp, *sdbp;
DBC *sdbc;
DBT *tskeyp;
DBT data, pkey, skey, temppkey, tempskey;
ENV *env;
u_int32_t nskey, rmw;
int ret, t_ret;
dbp = dbc->dbp;
env = dbp->env;
rmw = STD_LOCKING(dbc) ? DB_RMW : 0;
memset(&pkey, 0, sizeof(DBT));
memset(&data, 0, sizeof(DBT));
if ((ret = __dbc_get(dbc, &pkey, &data, DB_CURRENT)) != 0)
return (ret);
memset(&skey, 0, sizeof(DBT));
for (ret = __db_s_first(dbp, &sdbp);
sdbp != NULL && ret == 0;
ret = __db_s_next(&sdbp, dbc->txn)) {
if ((ret = sdbp->s_callback(sdbp, &pkey, &data, &skey)) != 0) {
if (ret == DB_DONOTINDEX) {
F_SET(&skey, DB_DBT_MULTIPLE);
skey.size = 0;
} else
goto err;
}
#ifdef DIAGNOSTIC
if (F_ISSET(&skey, DB_DBT_MULTIPLE))
__db_check_skeyset(sdbp, &skey);
#endif
if (F_ISSET(&skey, DB_DBT_MULTIPLE)) {
tskeyp = (DBT *)skey.data;
nskey = skey.size;
if (nskey == 0)
continue;
} else {
tskeyp = &skey;
nskey = 1;
}
if ((ret = __db_cursor_int(sdbp,
dbc->thread_info, dbc->txn, sdbp->type,
PGNO_INVALID, 0, dbc->locker, &sdbc)) != 0)
goto err;
if (CDB_LOCKING(env)) {
DB_ASSERT(env, sdbc->mylock.off == LOCK_INVALID);
F_SET(sdbc, DBC_WRITER);
}
for (; nskey > 0; nskey--, tskeyp++) {
DB_INIT_DBT(tempskey, tskeyp->data, tskeyp->size);
SWAP_IF_NEEDED(sdbp, &pkey);
DB_INIT_DBT(temppkey, pkey.data, pkey.size);
if ((ret = __dbc_get(sdbc, &tempskey, &temppkey,
DB_GET_BOTH | rmw)) == 0)
ret = __dbc_del(sdbc, DB_UPDATE_SECONDARY);
else if (ret == DB_NOTFOUND)
ret = __db_secondary_corrupt(dbp);
SWAP_IF_NEEDED(sdbp, &pkey);
FREE_IF_NEEDED(env, tskeyp);
}
if ((t_ret = __dbc_close(sdbc)) != 0 && ret == 0)
ret = t_ret;
if (ret != 0)
goto err;
FREE_IF_NEEDED(env, &skey);
}
err: if (sdbp != NULL &&
(t_ret = __db_s_done(sdbp, dbc->txn)) != 0 && ret == 0)
ret = t_ret;
FREE_IF_NEEDED(env, &skey);
return (ret);
}
static int
__dbc_del_foreign(dbc)
DBC *dbc;
{
DB_FOREIGN_INFO *f_info;
DB *dbp, *pdbp, *sdbp;
DBC *pdbc, *sdbc;
DBT data, fkey, pkey;
ENV *env;
u_int32_t flags, rmw;
int changed, ret, t_ret;
dbp = dbc->dbp;
env = dbp->env;
memset(&fkey, 0, sizeof(DBT));
memset(&data, 0, sizeof(DBT));
if ((ret = __dbc_get(dbc, &fkey, &data, DB_CURRENT)) != 0)
return (ret);
LIST_FOREACH(f_info, &(dbp->f_primaries), f_links) {
sdbp = f_info->dbp;
pdbp = sdbp->s_primary;
flags = f_info->flags;
rmw = (STD_LOCKING(dbc) &&
!LF_ISSET(DB_FOREIGN_ABORT)) ? DB_RMW : 0;
sdbc = pdbc = NULL;
if (!LF_ISSET(DB_FOREIGN_ABORT) && CDB_LOCKING(env) &&
!F_ISSET(env->dbenv, DB_ENV_CDB_ALLDB)) {
ret = __db_cursor(sdbp,
dbc->thread_info, dbc->txn, &sdbc, DB_WRITECURSOR);
if (LF_ISSET(DB_FOREIGN_NULLIFY) && ret == 0) {
ret = __db_cursor_int(pdbp,
dbc->thread_info, dbc->txn, pdbp->type,
PGNO_INVALID, 0, dbc->locker, &pdbc);
F_SET(pdbc, DBC_WRITER);
}
} else {
ret = __db_cursor_int(sdbp, dbc->thread_info, dbc->txn,
sdbp->type, PGNO_INVALID, 0, dbc->locker, &sdbc);
if (LF_ISSET(DB_FOREIGN_NULLIFY) && ret == 0)
ret = __db_cursor_int(pdbp, dbc->thread_info,
dbc->txn, pdbp->type, PGNO_INVALID, 0,
dbc->locker, &pdbc);
}
if (ret != 0) {
if (sdbc != NULL)
(void)__dbc_close(sdbc);
return (ret);
}
if (CDB_LOCKING(env) && F_ISSET(env->dbenv, DB_ENV_CDB_ALLDB)){
DB_ASSERT(env, sdbc->mylock.off == LOCK_INVALID);
F_SET(sdbc, DBC_WRITER);
if (LF_ISSET(DB_FOREIGN_NULLIFY) && pdbc != NULL) {
DB_ASSERT(env,
pdbc->mylock.off == LOCK_INVALID);
F_SET(pdbc, DBC_WRITER);
}
}
memset(&pkey, 0, sizeof(DBT));
memset(&data, 0, sizeof(DBT));
ret = __dbc_pget(sdbc, &fkey, &pkey, &data, DB_SET|rmw);
if (ret == DB_NOTFOUND) {
ret = __dbc_close(sdbc);
if (LF_ISSET(DB_FOREIGN_NULLIFY) &&
(t_ret = __dbc_close(pdbc)) != 0)
ret = t_ret;
if (ret != 0)
return (ret);
continue;
} else if (ret != 0) {
(void)__dbc_close(sdbc);
if (LF_ISSET(DB_FOREIGN_NULLIFY))
(void)__dbc_close(pdbc);
return (ret);
} else if (LF_ISSET(DB_FOREIGN_ABORT)) {
if ((ret = __dbc_close(sdbc)) != 0)
return (ret);
return (DB_FOREIGN_CONFLICT);
}
while (ret == 0) {
if (LF_ISSET(DB_FOREIGN_CASCADE)) {
if ((ret = __dbc_del(sdbc, 0)) != 0) {
__db_err(env, ret,
"Attempt to execute cascading delete in a foreign index failed");
break;
}
} else if (LF_ISSET(DB_FOREIGN_NULLIFY)) {
changed = 0;
if ((ret = f_info->callback(sdbp,
&pkey, &data, &fkey, &changed)) != 0) {
__db_err(env, ret,
"Foreign database application callback");
break;
}
if (changed && (ret = __dbc_put(pdbc,
&pkey, &data, DB_KEYFIRST)) != 0) {
__db_err(env, ret,
"Attempt to overwrite item in foreign database with nullified value failed");
break;
}
}
memset(&pkey, 0, sizeof(DBT));
memset(&data, 0, sizeof(DBT));
ret = __dbc_pget(sdbc,
&fkey, &pkey, &data, DB_NEXT_DUP|rmw);
}
if (ret == DB_NOTFOUND)
ret = 0;
if ((t_ret = __dbc_close(sdbc)) != 0 && ret == 0)
ret = t_ret;
if (LF_ISSET(DB_FOREIGN_NULLIFY) &&
(t_ret = __dbc_close(pdbc)) != 0 && ret == 0)
ret = t_ret;
if (ret != 0)
return (ret);
}
return (ret);
}
int
__db_s_first(pdbp, sdbpp)
DB *pdbp, **sdbpp;
{
DB *sdbp;
MUTEX_LOCK(pdbp->env, pdbp->mutex);
sdbp = LIST_FIRST(&pdbp->s_secondaries);
if (sdbp != NULL)
sdbp->s_refcnt++;
MUTEX_UNLOCK(pdbp->env, pdbp->mutex);
*sdbpp = sdbp;
return (0);
}
int
__db_s_next(sdbpp, txn)
DB **sdbpp;
DB_TXN *txn;
{
DB *sdbp, *pdbp, *closeme;
ENV *env;
int ret;
sdbp = *sdbpp;
pdbp = sdbp->s_primary;
env = pdbp->env;
closeme = NULL;
MUTEX_LOCK(env, pdbp->mutex);
DB_ASSERT(env, 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_UNLOCK(env, pdbp->mutex);
*sdbpp = sdbp;
if (closeme == NULL)
ret = 0;
else if (txn == NULL)
ret = __db_close(closeme, NULL, 0);
else
ret = __txn_closeevent(env, txn, closeme);
return (ret);
}
int
__db_s_done(sdbp, txn)
DB *sdbp;
DB_TXN *txn;
{
DB *pdbp;
ENV *env;
int doclose, ret;
pdbp = sdbp->s_primary;
env = pdbp->env;
doclose = 0;
MUTEX_LOCK(env, pdbp->mutex);
DB_ASSERT(env, sdbp->s_refcnt != 0);
if (--sdbp->s_refcnt == 0) {
LIST_REMOVE(sdbp, s_links);
doclose = 1;
}
MUTEX_UNLOCK(env, pdbp->mutex);
if (doclose == 0)
ret = 0;
else if (txn == NULL)
ret = __db_close(sdbp, NULL, 0);
else
ret = __txn_closeevent(env, txn, sdbp);
return (ret);
}
static int
__db_s_count(pdbp)
DB *pdbp;
{
DB *sdbp;
ENV *env;
int count;
env = pdbp->env;
count = 0;
MUTEX_LOCK(env, pdbp->mutex);
for (sdbp = LIST_FIRST(&pdbp->s_secondaries);
sdbp != NULL;
sdbp = LIST_NEXT(sdbp, s_links))
++count;
MUTEX_UNLOCK(env, pdbp->mutex);
return (count);
}
static int
__db_buildpartial(dbp, oldrec, partial, newrec)
DB *dbp;
DBT *oldrec, *partial, *newrec;
{
ENV *env;
u_int32_t len, nbytes;
u_int8_t *buf;
int ret;
env = dbp->env;
DB_ASSERT(env, F_ISSET(partial, DB_DBT_PARTIAL));
memset(newrec, 0, sizeof(DBT));
nbytes = __db_partsize(oldrec->size, partial);
newrec->size = nbytes;
if ((ret = __os_malloc(env, nbytes, &buf)) != 0)
return (ret);
newrec->data = buf;
memset(buf,
F_ISSET(dbp, DB_AM_FIXEDLEN) ? ((BTREE *)dbp->bt_internal)->re_pad :
0, nbytes);
memcpy(buf, oldrec->data,
partial->doff > oldrec->size ? oldrec->size : partial->doff);
memcpy(buf + partial->doff, partial->data, partial->size);
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);
}
u_int32_t
__db_partsize(nbytes, data)
u_int32_t nbytes;
DBT *data;
{
if (nbytes < data->doff + data->dlen)
return (data->doff + data->size);
return (nbytes + data->size - data->dlen);
}
#ifdef DIAGNOSTIC
void
__db_check_skeyset(sdbp, skeyp)
DB *sdbp;
DBT *skeyp;
{
DBT *firstkey, *lastkey, *key1, *key2;
ENV *env;
env = sdbp->env;
firstkey = (DBT *)skeyp->data;
lastkey = firstkey + skeyp->size;
for (key1 = firstkey; key1 < lastkey; key1++)
for (key2 = key1 + 1; key2 < lastkey; key2++)
DB_ASSERT(env,
((BTREE *)sdbp->bt_internal)->bt_compare(sdbp,
key1, key2) != 0);
}
#endif