sophia-ruby 0.0.1

data/vendor/sophia/db/sp.h

@@ -0,0 +1,50 @@
+#ifndef SP_H_
+#define SP_H_
+
+/*
+ * sophia database
+ * sphia.org
+ *
+ * Copyright (c) Dmitry Simonenko
+ * BSD License
+*/
+
+#define _GNU_SOURCE 1
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <string.h>
+#include <assert.h>
+#include <pthread.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/uio.h>
+#include <errno.h>
+
+#include <sophia.h>
+
+#include <macro.h>
+#include <crc.h>
+#include <lock.h>
+#include <list.h>
+#include <e.h>
+#include <a.h>
+#include <meta.h>
+#include <file.h>
+#include <ref.h>
+#include <i.h>
+#include <rep.h>
+#include <cat.h>
+#include <task.h>
+#include <core.h>
+#include <util.h>
+#include <recover.h>
+#include <merge.h>
+#include <gc.h>
+#include <cursor.h>
+
+#endif

data/vendor/sophia/db/task.h

@@ -0,0 +1,70 @@
+#ifndef SP_TASK_H_
+#define SP_TASK_H_
+
+/*
+ * sophia database
+ * sphia.org
+ *
+ * Copyright (c) Dmitry Simonenko
+ * BSD License
+*/
+
+typedef struct sptask sptask;
+
+struct sptask {
+	volatile int run;
+	void *arg;
+	pthread_t id;
+	pthread_mutex_t l;
+	pthread_cond_t c;
+};
+
+static inline int
+sp_taskstart(sptask *t, void*(*f)(void*), void *arg) {
+	t->run = 1;
+	t->arg = arg;
+	pthread_mutex_init(&t->l, NULL);
+	pthread_cond_init(&t->c, NULL);
+	return pthread_create(&t->id, NULL, f, t);
+}
+
+static inline int
+sp_taskstop(sptask *t) {
+	pthread_mutex_lock(&t->l);
+	if (t->run == 0) {
+		pthread_mutex_unlock(&t->l);
+		return 0;
+	}
+	t->run = 0;
+	pthread_cond_signal(&t->c);
+	pthread_mutex_unlock(&t->l);
+	return pthread_join(t->id, NULL);
+}
+
+static inline void
+sp_taskwakeup(sptask *t) {
+	pthread_mutex_lock(&t->l);
+	pthread_cond_signal(&t->c);
+	pthread_mutex_unlock(&t->l);
+}
+
+static inline int
+sp_taskwait(sptask *t) {
+	pthread_mutex_lock(&t->l);
+	if (t->run == 0) {
+		pthread_mutex_unlock(&t->l);
+		return 0;
+	}
+	pthread_cond_wait(&t->c, &t->l);
+	pthread_mutex_unlock(&t->l);
+	return t->run;
+}
+
+static inline void
+sp_taskdone(sptask *t) {
+	pthread_mutex_lock(&t->l);
+	t->run = 0;
+	pthread_mutex_unlock(&t->l);
+}
+
+#endif

data/vendor/sophia/db/track.h

@@ -0,0 +1,99 @@
+#ifndef SP_TRACK_H_
+#define SP_TRACK_H_
+
+/*
+ * sophia database
+ * sphia.org
+ *
+ * Copyright (c) Dmitry Simonenko
+ * BSD License
+*/
+
+typedef struct sptrack sptrack;
+
+struct sptrack {
+	spa *a;
+	uint64_t max;
+	uint64_t *i;
+	int count;
+	int size;
+};
+
+static inline int
+sp_trackinit(sptrack *t, spa *a, int size) {
+	t->a = a;
+	t->max = 0;
+	t->count = 0;
+	t->size = size;
+	int sz = size * sizeof(uint64_t);
+	t->i = sp_malloc(a, sz);
+	if (spunlikely(t->i == NULL))
+		return -1;
+	memset(t->i, 0, sz);
+	return 0;
+}
+
+static inline void sp_trackfree(sptrack *t) {
+	if (spunlikely(t->i == NULL))
+		return;
+	sp_free(t->a, t->i);
+	t->i = NULL;
+}
+
+static inline void
+sp_trackinsert(sptrack *t, uint64_t id) {
+	uint32_t pos = id % t->size;
+	for (;;) {
+		if (spunlikely(t->i[pos] != 0)) {
+			pos = (pos + 1) % t->size;
+			continue;
+		}
+		if (id > t->max)
+			t->max = id;
+		t->i[pos] = id;
+		break;
+	}
+	t->count++;
+}
+
+static inline int
+sp_trackresize(sptrack *t) {
+	sptrack nt;
+	int rc = sp_trackinit(&nt, t->a, t->size * 2);
+	if (spunlikely(rc == -1))
+		return -1;
+	int i = 0;
+	while (i < t->size) {
+		if (t->i[i])
+			sp_trackinsert(&nt, t->i[i]);
+		i++;
+	}
+	sp_trackfree(t);
+	*t = nt;
+	return 0;
+}
+
+static inline int
+sp_trackset(sptrack *t, uint64_t id) {
+	if (spunlikely(t->count > (t->size / 2)))
+		if (spunlikely(sp_trackresize(t) == -1))
+			return -1;
+	sp_trackinsert(t, id);
+	return 0;
+}
+
+static inline int
+sp_trackhas(sptrack *t, uint64_t id) {
+	uint32_t pos = id % t->size;
+	for (;;) {
+		if (spunlikely(t->i[pos] == 0))
+			return 0;
+		if (t->i[pos] == id)
+			return 1;
+		pos = (pos + 1) % t->size;
+		continue;
+	}
+	return 0;
+}
+
+#endif

data/vendor/sophia/db/util.c

@@ -0,0 +1,105 @@
+
+/*
+ * sophia database
+ * sphia.org
+ *
+ * Copyright (c) Dmitry Simonenko
+ * BSD License
+*/
+
+#include <sp.h>
+
+char *sp_memdup(sp *s, void *src, size_t size)
+{
+	char *v = sp_malloc(&s->a, size);
+	if (spunlikely(v == NULL))
+		return NULL;
+	memcpy(v, src, size);
+	return v;
+}
+
+sppage *sp_pagenew(sp *s, spepoch *e) {
+	sppage *page = sp_malloc(&s->a, sizeof(sppage));
+	if (spunlikely(page == NULL))
+		return NULL;
+	memset(page, 0, sizeof(sppage));
+	page->epoch = e;
+	sp_listinit(&page->link);
+	return page;
+}
+
+void sp_pageattach(sppage *p) {
+	assert(p->epoch != NULL);
+	sp_listappend(&((spepoch*)p->epoch)->pages, &p->link);
+}
+
+void sp_pagedetach(sppage *p) {
+	assert(p->epoch != NULL);
+	sp_listunlink(&p->link);
+}
+
+void sp_pagefree(sp *s, sppage *p) {
+	sp_listunlink(&p->link);
+	sp_free(&s->a, p->min);
+	sp_free(&s->a, p->max);
+	sp_free(&s->a, p);
+}
+
+static inline spv*
+sp_vnewof(sp *s, void *k, uint16_t size, int reserve) {
+	spv *v = sp_malloc(&s->a, sizeof(spv) + size + reserve);
+	if (spunlikely(v == NULL))
+		return NULL;
+	v->epoch = 0;
+	v->size = size;
+	v->flags = 0;
+	memcpy(v->key, k, size);
+	return v;
+}
+
+spv *sp_vnew(sp *s, void *k, uint16_t size) {
+	return sp_vnewof(s, k, size, 0);
+}
+
+spv *sp_vnewv(sp *s, void *k, uint16_t size, void *v, uint32_t vsize)
+{
+	spv *vn = sp_vnewof(s, k, size, sizeof(uint32_t) + vsize);
+	if (spunlikely(vn == NULL))
+		return NULL;
+	memcpy(vn->key + vn->size, &vsize, sizeof(uint32_t));
+	memcpy(vn->key + vn->size + sizeof(uint32_t), v, vsize);
+	return vn;
+}
+
+spv *sp_vnewh(sp *s, spvh *v) {
+	spv *vn = sp_vnewof(s, v->key, v->size, 0);
+	if (spunlikely(vn == NULL))
+		return NULL;
+	vn->flags = v->flags;
+	return vn;
+}
+
+spv *sp_vdup(sp *s, spv *v)
+{
+	spv *vn = sp_malloc(&s->a, sizeof(spv) + v->size);
+	if (spunlikely(vn == NULL))
+		return NULL;
+	memcpy(vn, v, sizeof(spv) + v->size);
+	return vn;
+}
+
+spv *sp_vdupref(sp *s, spref *r, uint32_t epoch)
+{
+	spv *vn = NULL;
+	switch (r->type) {
+	case SPREFM: vn = sp_vdup(s, r->v.v);
+		break;
+	case SPREFD: vn = sp_vnewh(s, r->v.vh);
+		break;
+	}
+	if (spunlikely(vn == NULL))
+		return NULL;
+	vn->epoch = epoch;
+	vn->flags = 0;
+	return vn;
+}

data/vendor/sophia/db/util.h

@@ -0,0 +1,25 @@
+#ifndef SP_UTIL_H_
+#define SP_UTIL_H_
+
+/*
+ * sophia database
+ * sphia.org
+ *
+ * Copyright (c) Dmitry Simonenko
+ * BSD License
+*/
+
+char *sp_memdup(sp*, void*, size_t);
+
+spv *sp_vnew(sp*, void*, uint16_t);
+spv *sp_vnewv(sp*, void*, uint16_t, void*, uint32_t);
+spv *sp_vnewh(sp*, spvh*);
+spv *sp_vdup(sp*, spv*);
+spv *sp_vdupref(sp*, spref*, uint32_t);
+
+sppage *sp_pagenew(sp*, spepoch*);
+void sp_pagefree(sp*, sppage*);
+void sp_pageattach(sppage*);
+void sp_pagedetach(sppage*);
+
+#endif

data/vendor/sophia/makefile

@@ -0,0 +1,7 @@
+
+all:
+	@(cd db; $(MAKE))
+	@(cd test; $(MAKE))
+clean:
+	@(cd db; $(MAKE) clean)
+	@(cd test; $(MAKE) clean)

data/vendor/sophia/sophia.gyp

@@ -0,0 +1,30 @@
+{
+  'targets': [
+    {
+      'target_name': 'sophia',
+      'product_prefix': 'lib',
+      'type': 'static_library',
+      'include_dirs': ['db'],
+      'link_settings': {
+        'libraries': ['-lpthread'],
+      },
+      'direct_dependent_settings': {
+        'include_dirs': ['db'],
+      },
+      'sources': [
+        'db/cat.c',
+        'db/crc.c',
+        'db/cursor.c',
+        'db/e.c',
+        'db/file.c',
+        'db/gc.c',
+        'db/i.c',
+        'db/merge.c',
+        'db/recover.c',
+        'db/rep.c',
+        'db/sp.c',
+        'db/util.c',
+      ],
+    },
+  ],
+}

data/vendor/sophia/test/common.c

@@ -0,0 +1,870 @@
+
+/*
+ * sophia database
+ * sphia.org
+ *
+ * Copyright (c) Dmitry Simonenko
+ * BSD License
+*/
+
+#include <sophia.h>
+#include "test.h"
+
+static char *dbrep = "./rep";
+
+static inline int
+cmp(char *a, size_t asz, char *b, size_t bsz, void *arg) {
+	register uint32_t av = *(uint32_t*)a;
+	register uint32_t bv = *(uint32_t*)b;
+	if (av == bv)
+		return 0;
+	return (av > bv) ? 1 : -1;
+}
+
+static void
+env(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	t( sp_destroy(env) == 0 );
+}
+
+static void
+env_opts(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	t( sp_ctl(env, SPALLOC, NULL, NULL) == 0 );
+	t( sp_ctl(env, SPPAGE, 1024) == 0 );
+	t( sp_ctl(env, SPGC, 0.5) == 0 );
+	t( sp_ctl(env, SPGROW, 16 * 1024 * 1024, 2.0) == 0 );
+	t( sp_ctl(env, SPMERGE, 1) == 0 );
+	uint32_t major, minor;
+	t( sp_ctl(NULL, SPVERSION, &major, &minor) == 0 );
+	t( major == 1 );
+	t( minor == 1 );
+	t( sp_destroy(env) == 0 );
+}
+
+static void
+open_ro_creat(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDONLY, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db == NULL );
+	t( sp_error(env) != NULL );
+	t( sp_destroy(env) == 0 );
+}
+
+static void
+open_rdwr(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db == NULL );
+	t( sp_error(env) != NULL );
+	t( sp_destroy(env) == 0 );
+}
+
+static void
+open_rdwr_creat(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+static void
+open_reopen(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	t( sp_destroy(db) == 0 );
+	db = sp_open(env);
+	t( db != NULL );
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+static void
+open_reopen_ro(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	t( sp_destroy(db) == 0 );
+	t( sp_ctl(env, SPDIR, SPO_RDONLY, dbrep) == 0 );
+	db = sp_open(env);
+	t( db != NULL );
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+static void
+set(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	uint32_t k = 1, v = 1;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0);
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+static void
+set_get(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	uint32_t k = 1, v = 1;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	size_t vsize = 0;
+	void *vp = NULL;
+	t( sp_get(db, &k, sizeof(k), &vp, &vsize) == 1 );
+	t( vsize == sizeof(v) );
+	t( *(uint32_t*)vp == v );
+	free(vp);
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+static void
+set_get_zerovalue(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	uint32_t k = 1;
+	t( sp_set(db, &k, sizeof(k), NULL, 0) == 0 );
+	size_t vsize = 0;
+	void *vp = NULL;
+	t( sp_get(db, &k, sizeof(k), &vp, &vsize) == 1 );
+	t( vsize == 0 );
+	t( vp == NULL );
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+static void
+replace(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	uint32_t k = 1, v = 1;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0);
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0);
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+static void
+replace_get(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	uint32_t k = 1, v = 1;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0);
+	size_t vsize = 0;
+	void *vp = NULL;
+	t( sp_get(db, &k, sizeof(k), &vp, &vsize) == 1 );
+	t( vsize == sizeof(v) );
+	t( *(uint32_t*)vp == 1 );
+	free(vp);
+	v = 2;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0);
+	t( sp_get(db, &k, sizeof(k), &vp, &vsize) == 1 );
+	t( vsize == sizeof(v) );
+	t( *(uint32_t*)vp == 2 );
+	free(vp);
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+static void
+set_delete(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	uint32_t k = 1, v = 1;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	t( sp_delete(db, &k, sizeof(k)) == 0 );
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+static void
+set_delete_get(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	uint32_t k = 1, v = 1;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	t( sp_delete(db, &k, sizeof(k)) == 0 );
+	size_t vsize = 0;
+	void *vp = NULL;
+	t( sp_get(db, &k, sizeof(k), &vp, &vsize) == 0 );
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+static void
+set_delete_set_get(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	uint32_t k = 1, v = 1;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	t( sp_delete(db, &k, sizeof(k)) == 0 );
+	v = 2;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	size_t vsize = 0;
+	void *vp = NULL;
+	t( sp_get(db, &k, sizeof(k), &vp, &vsize) == 1 );
+	t( vsize == sizeof(v) );
+	t( *(uint32_t*)vp == 2 );
+	free(vp);
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+static void
+delete(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	uint32_t k = 1;
+	t( sp_delete(db, &k, sizeof(k)) == 0 );
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+static void
+delete_set_get(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	uint32_t k = 1, v = 1;
+	t( sp_delete(db, &k, sizeof(k)) == 0 );
+	v = 2;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	size_t vsize = 0;
+	void *vp = NULL;
+	t( sp_get(db, &k, sizeof(k), &vp, &vsize) == 1 );
+	t( vsize == sizeof(v) );
+	t( *(uint32_t*)vp == 2 );
+	free(vp);
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+static void
+cursor(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	void *cur = sp_cursor(db, SPGTE, NULL, 0);
+	t( cur != NULL );
+	t( sp_destroy(cur) == 0 );
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+static void
+fetch_gte_empty(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	void *cur = sp_cursor(db, SPGTE, NULL, 0);
+	t( cur != NULL );
+	t( sp_fetch(cur) == 0 );
+	t( sp_fetch(cur) == 0 );
+	t( sp_destroy(cur) == 0 );
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+static void
+fetch_gt_empty(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	void *cur = sp_cursor(db, SPGT, NULL, 0);
+	t( cur != NULL );
+	t( sp_fetch(cur) == 0 );
+	t( sp_fetch(cur) == 0 );
+	t( sp_destroy(cur) == 0 );
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+static void
+fetch_lte_empty(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	void *cur = sp_cursor(db, SPLTE, NULL, 0);
+	t( cur != NULL );
+	t( sp_fetch(cur) == 0 );
+	t( sp_fetch(cur) == 0 );
+	t( sp_destroy(cur) == 0 );
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+static void
+fetch_lt_empty(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	void *cur = sp_cursor(db, SPLT, NULL, 0);
+	t( cur != NULL );
+	t( sp_fetch(cur) == 0 );
+	t( sp_fetch(cur) == 0 );
+	t( sp_destroy(cur) == 0 );
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+static void
+fetch_kgte_empty(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	uint32_t k = 1;
+	void *cur = sp_cursor(db, SPGTE, &k, sizeof(k));
+	t( cur != NULL );
+	t( sp_fetch(cur) == 0 );
+	t( sp_fetch(cur) == 0 );
+	t( sp_destroy(cur) == 0 );
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+static void
+fetch_kgt_empty(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	uint32_t k = 1;
+	void *cur = sp_cursor(db, SPGT, &k, sizeof(k));
+	t( cur != NULL );
+	t( sp_fetch(cur) == 0 );
+	t( sp_fetch(cur) == 0 );
+	t( sp_destroy(cur) == 0 );
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+static void
+fetch_klte_empty(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	uint32_t k = 1;
+	void *cur = sp_cursor(db, SPLTE, &k, sizeof(k));
+	t( cur != NULL );
+	t( sp_fetch(cur) == 0 );
+	t( sp_fetch(cur) == 0 );
+	t( sp_destroy(cur) == 0 );
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+static void
+fetch_klt_empty(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	uint32_t k = 1;
+	void *cur = sp_cursor(db, SPLT, &k, sizeof(k));
+	t( cur != NULL );
+	t( sp_fetch(cur) == 0 );
+	t( sp_fetch(cur) == 0 );
+	t( sp_destroy(cur) == 0 );
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+static void
+fetch_gte(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	uint32_t k = 1, v = 2;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	k = 2;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	k = 3;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	void *cur = sp_cursor(db, SPGTE, NULL, 0);
+	t( cur != NULL );
+	t( sp_fetch(cur) == 1 );
+	t( *(uint32_t*)sp_key(cur) == 1 );
+	t( sp_keysize(cur) == sizeof(k) );
+	t( *(uint32_t*)sp_value(cur) == 2 );
+	t( sp_valuesize(cur) == sizeof(v) );
+	t( sp_fetch(cur) == 1 );
+	t( *(uint32_t*)sp_key(cur) == 2 );
+	t( sp_keysize(cur) == sizeof(k) );
+	t( *(uint32_t*)sp_value(cur) == 2 );
+	t( sp_valuesize(cur) == sizeof(v) );
+	t( sp_fetch(cur) == 1 );
+	t( *(uint32_t*)sp_key(cur) == 3 );
+	t( sp_keysize(cur) == sizeof(k) );
+	t( *(uint32_t*)sp_value(cur) == 2 );
+	t( sp_valuesize(cur) == sizeof(v) );
+	t( sp_fetch(cur) == 0 );
+	t( sp_fetch(cur) == 0 );
+	t( sp_destroy(cur) == 0 );
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+static void
+fetch_gt(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	uint32_t k = 1, v = 2;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	k = 2;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	k = 3;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	void *cur = sp_cursor(db, SPGT, NULL, 0);
+	t( cur != NULL );
+	t( sp_fetch(cur) == 1 );
+	t( *(uint32_t*)sp_key(cur) == 1 );
+	t( sp_keysize(cur) == sizeof(k) );
+	t( *(uint32_t*)sp_value(cur) == 2 );
+	t( sp_valuesize(cur) == sizeof(v) );
+	t( sp_fetch(cur) == 1 );
+	t( *(uint32_t*)sp_key(cur) == 2 );
+	t( sp_keysize(cur) == sizeof(k) );
+	t( *(uint32_t*)sp_value(cur) == 2 );
+	t( sp_valuesize(cur) == sizeof(v) );
+	t( sp_fetch(cur) == 1 );
+	t( *(uint32_t*)sp_key(cur) == 3 );
+	t( sp_keysize(cur) == sizeof(k) );
+	t( *(uint32_t*)sp_value(cur) == 2 );
+	t( sp_valuesize(cur) == sizeof(v) );
+	t( sp_fetch(cur) == 0 );
+	t( sp_fetch(cur) == 0 );
+	t( sp_destroy(cur) == 0 );
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+static void
+fetch_lte(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	uint32_t k = 1, v = 2;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	k = 2;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	k = 3;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	void *cur = sp_cursor(db, SPLTE, NULL, 0);
+	t( cur != NULL );
+	t( sp_fetch(cur) == 1 );
+	t( *(uint32_t*)sp_key(cur) == 3 );
+	t( sp_keysize(cur) == sizeof(k) );
+	t( *(uint32_t*)sp_value(cur) == 2 );
+	t( sp_valuesize(cur) == sizeof(v) );
+	t( sp_fetch(cur) == 1 );
+	t( *(uint32_t*)sp_key(cur) == 2 );
+	t( sp_keysize(cur) == sizeof(k) );
+	t( *(uint32_t*)sp_value(cur) == 2 );
+	t( sp_valuesize(cur) == sizeof(v) );
+	t( sp_fetch(cur) == 1 );
+	t( *(uint32_t*)sp_key(cur) == 1 );
+	t( sp_keysize(cur) == sizeof(k) );
+	t( *(uint32_t*)sp_value(cur) == 2 );
+	t( sp_valuesize(cur) == sizeof(v) );
+	t( sp_fetch(cur) == 0 );
+	t( sp_fetch(cur) == 0 );
+	t( sp_destroy(cur) == 0 );
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+static void
+fetch_lt(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	uint32_t k = 1, v = 2;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	k = 2;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	k = 3;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	void *cur = sp_cursor(db, SPLT, NULL, 0);
+	t( cur != NULL );
+	t( sp_fetch(cur) == 1 );
+	t( *(uint32_t*)sp_key(cur) == 3 );
+	t( sp_keysize(cur) == sizeof(k) );
+	t( *(uint32_t*)sp_value(cur) == 2 );
+	t( sp_valuesize(cur) == sizeof(v) );
+	t( sp_fetch(cur) == 1 );
+	t( *(uint32_t*)sp_key(cur) == 2 );
+	t( sp_keysize(cur) == sizeof(k) );
+	t( *(uint32_t*)sp_value(cur) == 2 );
+	t( sp_valuesize(cur) == sizeof(v) );
+	t( sp_fetch(cur) == 1 );
+	t( *(uint32_t*)sp_key(cur) == 1 );
+	t( sp_keysize(cur) == sizeof(k) );
+	t( *(uint32_t*)sp_value(cur) == 2 );
+	t( sp_valuesize(cur) == sizeof(v) );
+	t( sp_fetch(cur) == 0 );
+	t( sp_fetch(cur) == 0 );
+	t( sp_destroy(cur) == 0 );
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+static void
+fetch_kgte(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	uint32_t k = 1, v = 2;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	k = 2;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	k = 3;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+
+	k = 2;
+	void *cur = sp_cursor(db, SPGTE, &k, sizeof(k));
+	t( cur != NULL );
+	t( sp_fetch(cur) == 1 );
+	t( *(uint32_t*)sp_key(cur) == 2 );
+	t( sp_keysize(cur) == sizeof(k) );
+	t( *(uint32_t*)sp_value(cur) == 2 );
+	t( sp_valuesize(cur) == sizeof(v) );
+	t( sp_fetch(cur) == 1 );
+	t( *(uint32_t*)sp_key(cur) == 3 );
+	t( sp_keysize(cur) == sizeof(k) );
+	t( *(uint32_t*)sp_value(cur) == 2 );
+	t( sp_valuesize(cur) == sizeof(v) );
+	t( sp_fetch(cur) == 0 );
+	t( sp_fetch(cur) == 0 );
+	t( sp_destroy(cur) == 0 );
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+static void
+fetch_kgt(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	uint32_t k = 1, v = 2;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	k = 2;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	k = 3;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	k = 2;
+	void *cur = sp_cursor(db, SPGT, &k, sizeof(k));
+	t( cur != NULL );
+	t( sp_fetch(cur) == 1 );
+	t( *(uint32_t*)sp_key(cur) == 3 );
+	t( sp_keysize(cur) == sizeof(k) );
+	t( *(uint32_t*)sp_value(cur) == 2 );
+	t( sp_valuesize(cur) == sizeof(v) );
+	t( sp_fetch(cur) == 0 );
+	t( sp_fetch(cur) == 0 );
+	t( sp_destroy(cur) == 0 );
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+static void
+fetch_klte(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	uint32_t k = 1, v = 2;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	k = 2;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	k = 3;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	k = 2;
+	void *cur = sp_cursor(db, SPLTE, &k, sizeof(k) );
+	t( cur != NULL );
+	t( sp_fetch(cur) == 1 );
+	t( *(uint32_t*)sp_key(cur) == 2 );
+	t( sp_keysize(cur) == sizeof(k) );
+	t( *(uint32_t*)sp_value(cur) == 2 );
+	t( sp_valuesize(cur) == sizeof(v) );
+	t( sp_fetch(cur) == 1 );
+	t( *(uint32_t*)sp_key(cur) == 1 );
+	t( sp_keysize(cur) == sizeof(k) );
+	t( *(uint32_t*)sp_value(cur) == 2 );
+	t( sp_valuesize(cur) == sizeof(v) );
+	t( sp_fetch(cur) == 0 );
+	t( sp_fetch(cur) == 0 );
+	t( sp_destroy(cur) == 0 );
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+static void
+fetch_klt(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	uint32_t k = 1, v = 2;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	k = 2;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	k = 3;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	k = 2;
+	void *cur = sp_cursor(db, SPLT, &k, sizeof(k) );
+	t( cur != NULL );
+	t( sp_fetch(cur) == 1 );
+	t( *(uint32_t*)sp_key(cur) == 1 );
+	t( sp_keysize(cur) == sizeof(k) );
+	t( *(uint32_t*)sp_value(cur) == 2 );
+	t( sp_valuesize(cur) == sizeof(v) );
+	t( sp_fetch(cur) == 0 );
+	t( sp_fetch(cur) == 0 );
+	t( sp_destroy(cur) == 0 );
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+static void
+fetch_after_end(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	uint32_t k = 1, v = 2;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	k = 2;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	k = 3;
+	t( sp_set(db, &k, sizeof(k), &v, sizeof(v)) == 0 );
+	void *cur = sp_cursor(db, SPGTE, NULL, 0);
+	t( cur != NULL );
+	t( sp_fetch(cur) == 1 );
+	t( *(uint32_t*)sp_key(cur) == 1 );
+	t( sp_keysize(cur) == sizeof(k) );
+	t( *(uint32_t*)sp_value(cur) == 2 );
+	t( sp_valuesize(cur) == sizeof(v) );
+	t( sp_fetch(cur) == 1 );
+	t( *(uint32_t*)sp_key(cur) == 2 );
+	t( sp_keysize(cur) == sizeof(k) );
+	t( *(uint32_t*)sp_value(cur) == 2 );
+	t( sp_valuesize(cur) == sizeof(v) );
+	t( sp_fetch(cur) == 1 );
+	t( *(uint32_t*)sp_key(cur) == 3 );
+	t( sp_keysize(cur) == sizeof(k) );
+	t( *(uint32_t*)sp_value(cur) == 2 );
+	t( sp_valuesize(cur) == sizeof(v) );
+	t( sp_fetch(cur) == 0 );
+	t( sp_keysize(cur) == 0 );
+	t( sp_key(cur) == NULL );
+	t( sp_valuesize(cur) == 0 );
+	t( sp_value(cur) == NULL );
+	t( sp_destroy(cur) == 0 );
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+static void
+cursor_set(void) {
+	void *env = sp_env();
+	t( env != NULL );
+	t( sp_ctl(env, SPDIR, SPO_CREAT|SPO_RDWR, dbrep) == 0 );
+	t( sp_ctl(env, SPCMP, cmp, NULL) == 0 );
+	void *db = sp_open(env);
+	t( db != NULL );
+	void *cur = sp_cursor(db, SPGTE, NULL, 0);
+	t( cur != NULL );
+	uint32_t k = 1;
+	t( sp_set(db, &k, sizeof(k), &k, sizeof(k)) == -1 );
+	t( sp_destroy(cur) == 0 );
+	t( sp_destroy(db) == 0 );
+	t( sp_destroy(env) == 0 );
+	t( rmrf(dbrep) == 0 );
+}
+
+int
+main(int argc, char *argv[])
+{
+	rmrf(dbrep);
+
+	test(env);
+	test(env_opts);
+	test(open_ro_creat);
+	test(open_rdwr);
+	test(open_rdwr_creat);
+	test(open_reopen);
+	test(open_reopen_ro);
+	test(set);
+	test(set_get);
+	test(set_get_zerovalue);
+	test(replace);
+	test(replace_get);
+	test(set_delete);
+	test(set_delete_get);
+	test(set_delete_set_get);
+	test(delete);
+	test(delete_set_get);
+	test(cursor);
+	test(fetch_gte_empty);
+	test(fetch_gt_empty);
+	test(fetch_lte_empty);
+	test(fetch_lt_empty);
+	test(fetch_kgte_empty);
+	test(fetch_kgt_empty);
+	test(fetch_klte_empty);
+	test(fetch_klt_empty);
+	test(fetch_gte);
+	test(fetch_gt);
+	test(fetch_lte);
+	test(fetch_lt);
+	test(fetch_kgte);
+	test(fetch_kgt);
+	test(fetch_klte);
+	test(fetch_klt);
+	test(fetch_after_end);
+	test(cursor_set);
+	return 0;
+}