#include <fcntl.h>
#include <assert.h>
-#include <err.h>
#include <errno.h>
-#include <fcntl.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
unsigned int mn_flags:4;
unsigned int mn_ksize:12; /* key size */
#define F_BIGDATA 0x01 /* data put on overflow page */
+#define F_SUBDATA 0x02 /* data is a sub-database */
char mn_data[1];
} MDB_node;
-
typedef struct MDB_dbx {
MDB_val md_name;
MDB_cmp_func *md_cmp; /* user compare function */
static void mdb_del_node(MDB_page *mp, indx_t indx);
static int mdb_del0(MDB_txn *txn, MDB_dbi dbi, unsigned int ki,
MDB_pageparent *mpp, MDB_node *leaf);
+static int mdb_put0(MDB_txn *txn, MDB_dbi dbi,
+ MDB_val *key, MDB_val *data, unsigned int flags);
static int mdb_read_data(MDB_txn *txn, MDB_node *leaf, MDB_val *data);
static int mdb_rebalance(MDB_txn *txn, MDB_dbi dbi, MDB_pageparent *mp);
MDB_val *key, MDB_val *data);
static void mdb_xcursor_init0(MDB_txn *txn, MDB_dbi dbi, MDB_xcursor *mx);
-static void mdb_xcursor_init1(MDB_txn *txn, MDB_dbi dbi, MDB_xcursor *mx, MDB_db *db);
+static void mdb_xcursor_init1(MDB_txn *txn, MDB_dbi dbi, MDB_xcursor *mx, MDB_node *node);
static void mdb_xcursor_fini(MDB_txn *txn, MDB_dbi dbi, MDB_xcursor *mx);
static size_t mdb_leaf_size(MDB_env *env, MDB_val *key,
static int
_mdb_cmp(MDB_txn *txn, MDB_dbi dbi, const MDB_val *key1, const MDB_val *key2)
{
- if (F_ISSET(txn->mt_dbs[dbi].md_flags, MDB_REVERSEKEY))
+ if (txn->mt_dbs[dbi].md_flags & (MDB_REVERSEKEY
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+ |MDB_INTEGERKEY
+#endif
+ ))
return memnrcmp(key1->mv_data, key1->mv_size, key2->mv_data, key2->mv_size);
else
return memncmp((char *)key1->mv_data, key1->mv_size, key2->mv_data, key2->mv_size);
key.mv_data = (char *)&mop->mo_txnid;
data.mv_size = MDB_IDL_SIZEOF(mop->mo_pages);
data.mv_data = mop->mo_pages;
- mdb_put(txn, FREE_DBI, &key, &data, 0);
+ mdb_put0(txn, FREE_DBI, &key, &data, 0);
free(env->me_pghead);
env->me_pghead = NULL;
}
key.mv_data = (char *)&txn->mt_txnid;
data.mv_size = MDB_IDL_SIZEOF(txn->mt_free_pgs);
data.mv_data = txn->mt_free_pgs;
- mdb_put(txn, FREE_DBI, &key, &data, 0);
+ mdb_put0(txn, FREE_DBI, &key, &data, 0);
}
/* Update DB root pointers. Their pages have already been
for (i = 2; i < txn->mt_numdbs; i++) {
if (txn->mt_dbxs[i].md_dirty) {
data.mv_data = &txn->mt_dbs[i];
- mdb_put(txn, i, &txn->mt_dbxs[i].md_name, &data, 0);
+ mdb_put0(txn, MAIN_DBI, &txn->mt_dbxs[i].md_name, &data, 0);
}
}
}
meta->mm_psize = psize;
meta->mm_last_pg = 1;
meta->mm_flags = env->me_flags & 0xffff;
-#if __BYTE_ORDER == __LITTLE_ENDIAN
- /* freeDB keys are pgno_t's, must compare in int order */
- meta->mm_flags |= MDB_REVERSEKEY;
-#endif
+ meta->mm_flags |= MDB_INTEGERKEY;
meta->mm_dbs[0].md_root = P_INVALID;
meta->mm_dbs[1].md_root = P_INVALID;
assert(txn != NULL);
assert(txn->mt_env != NULL);
- DPRINTF("writing meta page for root page %lu", txn->mt_dbs[MAIN_DBI].md_root);
+ DPRINTF("writing meta page %d for root page %lu",
+ !F_ISSET(txn->mt_flags, MDB_TXN_METOGGLE), txn->mt_dbs[MAIN_DBI].md_root);
env = txn->mt_env;
return MDB_SUCCESS;
}
-int
+static int
mdbenv_open2(MDB_env *env, unsigned int flags)
{
int i, newenv = 0;
assert(data);
DPRINTF("===> get key [%.*s]", (int)key->mv_size, (char *)key->mv_data);
+ if (txn == NULL || !dbi || dbi >= txn->mt_numdbs)
+ return EINVAL;
+
if (key->mv_size == 0 || key->mv_size > MAXKEYSIZE) {
return EINVAL;
}
MDB_xcursor mx;
mdb_xcursor_init0(txn, dbi, &mx);
- mdb_xcursor_init1(txn, dbi, &mx, NODEDATA(leaf));
+ mdb_xcursor_init1(txn, dbi, &mx, leaf);
rc = mdb_search_page(&mx.mx_txn, mx.mx_cursor.mc_dbi, NULL, NULL, 0, &mpp);
if (rc != MDB_SUCCESS)
return rc;
return rc;
if (cursor->mc_txn->mt_dbs[cursor->mc_dbi].md_flags & MDB_DUPSORT) {
- mdb_xcursor_init1(cursor->mc_txn, cursor->mc_dbi, cursor->mc_xcursor, NODEDATA(leaf));
+ mdb_xcursor_init1(cursor->mc_txn, cursor->mc_dbi, cursor->mc_xcursor, leaf);
rc = mdb_cursor_first(&cursor->mc_xcursor->mx_cursor, data, NULL);
if (rc != MDB_SUCCESS)
return rc;
if (cursor->mc_txn->mt_dbs[cursor->mc_dbi].md_flags & MDB_DUPSORT) {
if (op == MDB_PREV || op == MDB_PREV_DUP) {
- rc = mdb_cursor_next(&cursor->mc_xcursor->mx_cursor, data, NULL, MDB_PREV);
+ rc = mdb_cursor_prev(&cursor->mc_xcursor->mx_cursor, data, NULL, MDB_PREV);
if (op != MDB_PREV || rc == MDB_SUCCESS)
return rc;
}
return rc;
if (cursor->mc_txn->mt_dbs[cursor->mc_dbi].md_flags & MDB_DUPSORT) {
- mdb_xcursor_init1(cursor->mc_txn, cursor->mc_dbi, cursor->mc_xcursor, NODEDATA(leaf));
+ mdb_xcursor_init1(cursor->mc_txn, cursor->mc_dbi, cursor->mc_xcursor, leaf);
rc = mdb_cursor_last(&cursor->mc_xcursor->mx_cursor, data, NULL);
if (rc != MDB_SUCCESS)
return rc;
return rc;
if (cursor->mc_txn->mt_dbs[cursor->mc_dbi].md_flags & MDB_DUPSORT) {
- mdb_xcursor_init1(cursor->mc_txn, cursor->mc_dbi, cursor->mc_xcursor, NODEDATA(leaf));
+ mdb_xcursor_init1(cursor->mc_txn, cursor->mc_dbi, cursor->mc_xcursor, leaf);
if (op == MDB_SET || op == MDB_SET_RANGE) {
rc = mdb_cursor_first(&cursor->mc_xcursor->mx_cursor, data, NULL);
} else {
return rc;
if (cursor->mc_txn->mt_dbs[cursor->mc_dbi].md_flags & MDB_DUPSORT) {
- mdb_xcursor_init1(cursor->mc_txn, cursor->mc_dbi, cursor->mc_xcursor, NODEDATA(leaf));
+ mdb_xcursor_init1(cursor->mc_txn, cursor->mc_dbi, cursor->mc_xcursor, leaf);
rc = mdb_cursor_first(&cursor->mc_xcursor->mx_cursor, data, NULL);
if (rc)
return rc;
return rc;
if (cursor->mc_txn->mt_dbs[cursor->mc_dbi].md_flags & MDB_DUPSORT) {
- mdb_xcursor_init1(cursor->mc_txn, cursor->mc_dbi, cursor->mc_xcursor, NODEDATA(leaf));
+ mdb_xcursor_init1(cursor->mc_txn, cursor->mc_dbi, cursor->mc_xcursor, leaf);
rc = mdb_cursor_last(&cursor->mc_xcursor->mx_cursor, data, NULL);
if (rc)
return rc;
}
static void
-mdb_xcursor_init1(MDB_txn *txn, MDB_dbi dbi, MDB_xcursor *mx, MDB_db *db)
+mdb_xcursor_init1(MDB_txn *txn, MDB_dbi dbi, MDB_xcursor *mx, MDB_node *node)
{
+ MDB_db *db = NODEDATA(node);
+ MDB_dbi dbn;
mx->mx_dbs[0] = txn->mt_dbs[0];
mx->mx_dbs[1] = txn->mt_dbs[1];
if (dbi > 1) {
mx->mx_dbs[2] = txn->mt_dbs[dbi];
- mx->mx_dbs[3] = *db;
+ dbn = 3;
} else {
- mx->mx_dbs[2] = *db;
+ dbn = 2;
}
+ mx->mx_dbs[dbn] = *db;
+ mx->mx_dbxs[dbn].md_name.mv_data = NODEKEY(node);
+ mx->mx_dbxs[dbn].md_name.mv_size = node->mn_ksize;
+ mx->mx_txn.mt_next_pgno = txn->mt_next_pgno;
+ mx->mx_txn.mt_oldest = txn->mt_oldest;
+ mx->mx_txn.mt_u = txn->mt_u;
}
static void
mdb_xcursor_fini(MDB_txn *txn, MDB_dbi dbi, MDB_xcursor *mx)
{
+ txn->mt_next_pgno = mx->mx_txn.mt_next_pgno;
+ txn->mt_oldest = mx->mx_txn.mt_oldest;
+ txn->mt_u = mx->mx_txn.mt_u;
txn->mt_dbs[0] = mx->mx_dbs[0];
txn->mt_dbs[1] = mx->mx_dbs[1];
txn->mt_dbxs[0].md_dirty = mx->mx_dbxs[0].md_dirty;
return MDB_SUCCESS;
}
+/* Return the count of duplicate data items for the current key */
+int
+mdb_cursor_count(MDB_cursor *mc, unsigned long *countp)
+{
+ if (mc == NULL || countp == NULL)
+ return EINVAL;
+
+ if (!(mc->mc_txn->mt_dbs[mc->mc_dbi].md_flags & MDB_DUPSORT))
+ return EINVAL;
+
+ if (!mc->mc_xcursor->mx_cursor.mc_initialized)
+ return EINVAL;
+
+ *countp = mc->mc_xcursor->mx_txn.mt_dbs[mc->mc_xcursor->mx_cursor.mc_dbi].md_entries;
+ return MDB_SUCCESS;
+}
+
void
mdb_cursor_close(MDB_cursor *cursor)
{
assert(key != NULL);
- if (txn == NULL || dbi >= txn->mt_numdbs)
+ if (txn == NULL || !dbi || dbi >= txn->mt_numdbs)
return EINVAL;
if (F_ISSET(txn->mt_flags, MDB_TXN_RDONLY)) {
MDB_pageparent mp2;
mdb_xcursor_init0(txn, dbi, &mx);
- mdb_xcursor_init1(txn, dbi, &mx, NODEDATA(leaf));
+ mdb_xcursor_init1(txn, dbi, &mx, leaf);
if (flags == MDB_DEL_DUP) {
rc = mdb_del(&mx.mx_txn, mx.mx_cursor.mc_dbi, data, NULL, 0);
mdb_xcursor_fini(txn, dbi, &mx);
return rc;
}
-int
-mdb_put(MDB_txn *txn, MDB_dbi dbi,
+static int
+mdb_put0(MDB_txn *txn, MDB_dbi dbi,
MDB_val *key, MDB_val *data, unsigned int flags)
{
int rc = MDB_SUCCESS, exact;
MDB_val xdata, *rdata;
MDB_db dummy;
- assert(key != NULL);
- assert(data != NULL);
-
- if (txn == NULL)
- return EINVAL;
-
- if (F_ISSET(txn->mt_flags, MDB_TXN_RDONLY)) {
- return EINVAL;
- }
-
- if (key->mv_size == 0 || key->mv_size > MAXKEYSIZE) {
- return EINVAL;
- }
-
DPRINTF("==> put key %.*s, size %zu, data size %zu",
(int)key->mv_size, (char *)key->mv_data, key->mv_size, data->mv_size);
rdata = data;
}
- if (SIZELEFT(mpp.mp_page) < mdb_leaf_size(txn->mt_env, key, data)) {
- rc = mdb_split(txn, dbi, &mpp.mp_page, &ki, key, data, P_INVALID);
+ if (SIZELEFT(mpp.mp_page) < mdb_leaf_size(txn->mt_env, key, rdata)) {
+ rc = mdb_split(txn, dbi, &mpp.mp_page, &ki, key, rdata, P_INVALID);
} else {
/* There is room already in this leaf page. */
- rc = mdb_add_node(txn, dbi, mpp.mp_page, ki, key, data, 0, 0);
+ rc = mdb_add_node(txn, dbi, mpp.mp_page, ki, key, rdata, 0, 0);
}
if (rc != MDB_SUCCESS)
txn->mt_flags |= MDB_TXN_ERROR;
else {
txn->mt_dbs[dbi].md_entries++;
+
+ /* Remember if we just added a subdatabase */
+ if (flags & F_SUBDATA) {
+ leaf = NODEPTR(mpp.mp_page, ki);
+ leaf->mn_flags |= F_SUBDATA;
+ }
+
/* Now store the actual data in the child DB. Note that we're
* storing the user data in the keys field, so there are strict
* size limits on dupdata. The actual data fields of the child
leaf = NODEPTR(mpp.mp_page, ki);
put_sub:
mdb_xcursor_init0(txn, dbi, &mx);
- mdb_xcursor_init1(txn, dbi, &mx, NODEDATA(leaf));
+ mdb_xcursor_init1(txn, dbi, &mx, leaf);
xdata.mv_size = 0;
xdata.mv_data = "";
if (flags == MDB_NODUPDATA)
flags = MDB_NOOVERWRITE;
- rc = mdb_put(&mx.mx_txn, mx.mx_cursor.mc_dbi, data, &xdata, flags);
+ rc = mdb_put0(&mx.mx_txn, mx.mx_cursor.mc_dbi, data, &xdata, flags);
mdb_xcursor_fini(txn, dbi, &mx);
memcpy(NODEDATA(leaf), &mx.mx_txn.mt_dbs[mx.mx_cursor.mc_dbi],
sizeof(MDB_db));
return rc;
}
+int
+mdb_put(MDB_txn *txn, MDB_dbi dbi,
+ MDB_val *key, MDB_val *data, unsigned int flags)
+{
+ assert(key != NULL);
+ assert(data != NULL);
+
+ if (txn == NULL || !dbi || dbi >= txn->mt_numdbs)
+ return EINVAL;
+
+ if (F_ISSET(txn->mt_flags, MDB_TXN_RDONLY)) {
+ return EINVAL;
+ }
+
+ if (key->mv_size == 0 || key->mv_size > MAXKEYSIZE) {
+ return EINVAL;
+ }
+
+ if ((flags & (MDB_NOOVERWRITE|MDB_NODUPDATA)) != flags)
+ return EINVAL;
+
+ return mdb_put0(txn, dbi, key, data, flags);
+}
+
int
mdbenv_get_flags(MDB_env *env, unsigned int *arg)
{
return MDB_SUCCESS;
}
+static int
+mdb_stat0(MDB_env *env, MDB_db *db, MDB_stat *arg)
+{
+ arg->ms_psize = env->me_psize;
+ arg->ms_depth = db->md_depth;
+ arg->ms_branch_pages = db->md_branch_pages;
+ arg->ms_leaf_pages = db->md_leaf_pages;
+ arg->ms_overflow_pages = db->md_overflow_pages;
+ arg->ms_entries = db->md_entries;
+
+ return MDB_SUCCESS;
+}
int
mdbenv_stat(MDB_env *env, MDB_stat *arg)
{
if (env == NULL || arg == NULL)
return EINVAL;
- arg->ms_psize = env->me_psize;
- arg->ms_depth = env->me_meta->mm_dbs[MAIN_DBI].md_depth;
- arg->ms_branch_pages = env->me_meta->mm_dbs[MAIN_DBI].md_branch_pages;
- arg->ms_leaf_pages = env->me_meta->mm_dbs[MAIN_DBI].md_leaf_pages;
- arg->ms_overflow_pages = env->me_meta->mm_dbs[MAIN_DBI].md_overflow_pages;
- arg->ms_entries = env->me_meta->mm_dbs[MAIN_DBI].md_entries;
-
- return MDB_SUCCESS;
+ return mdb_stat0(env, &env->me_meta->mm_dbs[MAIN_DBI], arg);
}
int mdb_open(MDB_txn *txn, const char *name, unsigned int flags, MDB_dbi *dbi)
/* main DB? */
if (!name) {
*dbi = MAIN_DBI;
+ if (flags & (MDB_DUPSORT|MDB_REVERSEKEY|MDB_INTEGERKEY))
+ txn->mt_dbs[MAIN_DBI].md_flags |= (flags & (MDB_DUPSORT|MDB_REVERSEKEY|MDB_INTEGERKEY));
return MDB_SUCCESS;
}
memset(&dummy, 0, sizeof(dummy));
dummy.md_root = P_INVALID;
dummy.md_flags = flags & 0xffff;
- rc = mdb_put(txn, MAIN_DBI, &key, &data, 0);
+ rc = mdb_put0(txn, MAIN_DBI, &key, &data, F_SUBDATA);
dirty = 1;
}
int mdb_stat(MDB_txn *txn, MDB_dbi dbi, MDB_stat *arg)
{
- if (txn == NULL || arg == NULL)
+ if (txn == NULL || arg == NULL || dbi >= txn->mt_numdbs)
return EINVAL;
- arg->ms_psize = txn->mt_env->me_psize;
- arg->ms_depth = txn->mt_dbs[dbi].md_depth;
- arg->ms_branch_pages = txn->mt_dbs[dbi].md_branch_pages;
- arg->ms_leaf_pages = txn->mt_dbs[dbi].md_leaf_pages;
- arg->ms_overflow_pages = txn->mt_dbs[dbi].md_overflow_pages;
- arg->ms_entries = txn->mt_dbs[dbi].md_entries;
-
- return MDB_SUCCESS;
+ return mdb_stat0(txn->mt_env, &txn->mt_dbs[dbi], arg);
}
void mdb_close(MDB_txn *txn, MDB_dbi dbi)
txn->mt_dbxs[dbi].md_name.mv_size = 0;
free(ptr);
}
+
+int mdb_set_compare(MDB_txn *txn, MDB_dbi dbi, MDB_cmp_func *cmp)
+{
+ if (txn == NULL || !dbi || dbi >= txn->mt_numdbs)
+ return EINVAL;
+
+ txn->mt_dbxs[dbi].md_cmp = cmp;
+ return MDB_SUCCESS;
+}
+
+int mdb_set_dupsort(MDB_txn *txn, MDB_dbi dbi, MDB_cmp_func *cmp)
+{
+ if (txn == NULL || !dbi || dbi >= txn->mt_numdbs)
+ return EINVAL;
+
+ txn->mt_dbxs[dbi].md_dcmp = cmp;
+ return MDB_SUCCESS;
+}
+
+int mdb_set_relfunc(MDB_txn *txn, MDB_dbi dbi, MDB_rel_func *rel)
+{
+ if (txn == NULL || !dbi || dbi >= txn->mt_numdbs)
+ return EINVAL;
+
+ txn->mt_dbxs[dbi].md_rel = rel;
+ return MDB_SUCCESS;
+}
projects / openldap / blobdiff