567 lines
17 KiB
C
567 lines
17 KiB
C
|
/* --------------------------------------------------------------------------
|
||
|
|
Copyright (c) 2018 Vincent Bernardoff. All rights reserved.
|
||
|
|
Distributed under the ISC license, see terms at the end of the file.
|
||
|
|
--------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
#include <string.h>
|
||
|
|
|
||
|
|
#include <caml/mlvalues.h>
|
||
|
|
#include <caml/alloc.h>
|
||
|
|
#include <caml/memory.h>
|
||
|
|
#include <caml/custom.h>
|
||
|
|
#include <caml/bigarray.h>
|
||
|
|
|
||
|
|
#include "lmdb.h"
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_version(value unit) {
|
||
|
|
CAMLparam1(unit);
|
||
|
|
CAMLlocal1(result);
|
||
|
|
|
||
|
|
int major, minor, patch;
|
||
|
|
mdb_version(&major, &minor, &patch);
|
||
|
|
result = caml_alloc_tuple(3);
|
||
|
|
Store_field(result, 0, Val_int(major));
|
||
|
|
Store_field(result, 1, Val_int(minor));
|
||
|
|
Store_field(result, 2, Val_int(patch));
|
||
|
|
|
||
|
|
CAMLreturn(result);
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_strerror(value errno) {
|
||
|
|
CAMLparam1(errno);
|
||
|
|
CAMLlocal1(result);
|
||
|
|
|
||
|
|
char *errstr;
|
||
|
|
errstr = mdb_strerror(Int_val(errno));
|
||
|
|
result = caml_copy_string(errstr);
|
||
|
|
|
||
|
|
CAMLreturn(result);
|
||
|
|
}
|
||
|
|
|
||
|
|
#define Env_val(v) (*((MDB_env **) Data_custom_val(v)))
|
||
|
|
#define Txn_val(v) (*((MDB_txn **) Data_custom_val(v)))
|
||
|
|
#define Cursor_val(v) (*((MDB_cursor **) Data_custom_val(v)))
|
||
|
|
|
||
|
|
#define Gen_custom_block(SNAME, CNAME, MNAME) \
|
||
|
|
static int compare_##SNAME(value a, value b) { \
|
||
|
|
CNAME *aa = MNAME(a), *bb = MNAME(b); \
|
||
|
|
return (aa == bb ? 0 : (aa < bb ? -1 : 1)); \
|
||
|
|
} \
|
||
|
|
\
|
||
|
|
static struct custom_operations lmdb_##SNAME##_ops = { \
|
||
|
|
.identifier = "lmdb_" #SNAME, \
|
||
|
|
.finalize = custom_finalize_default, \
|
||
|
|
.compare = compare_##SNAME, \
|
||
|
|
.compare_ext = custom_compare_ext_default, \
|
||
|
|
.hash = custom_hash_default, \
|
||
|
|
.serialize = custom_serialize_default, \
|
||
|
|
.deserialize = custom_deserialize_default \
|
||
|
|
}; \
|
||
|
|
\
|
||
|
|
static value alloc_##SNAME (CNAME *a) { \
|
||
|
|
value custom = alloc_custom(&lmdb_##SNAME##_ops, sizeof(CNAME *), 0, 1); \
|
||
|
|
MNAME(custom) = a; \
|
||
|
|
return custom; \
|
||
|
|
}
|
||
|
|
|
||
|
|
Gen_custom_block(env, MDB_env, Env_val)
|
||
|
|
Gen_custom_block(txn, MDB_txn, Txn_val)
|
||
|
|
Gen_custom_block(cursor, MDB_cursor, Cursor_val)
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_env_create(value unit) {
|
||
|
|
CAMLparam1(unit);
|
||
|
|
CAMLlocal2(result, ml_env);
|
||
|
|
|
||
|
|
int ret;
|
||
|
|
MDB_env *env;
|
||
|
|
|
||
|
|
ret = mdb_env_create(&env);
|
||
|
|
if (ret) {
|
||
|
|
result = caml_alloc(1, 1);
|
||
|
|
Store_field(result, 0, Val_int(ret));
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
result = caml_alloc(1, 0);
|
||
|
|
ml_env = alloc_env(env);
|
||
|
|
Store_field(result, 0, ml_env);
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLreturn(result);
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_env_open(value env, value path, value flags, value mode) {
|
||
|
|
return Val_int(mdb_env_open(Env_val(env), String_val(path), Int_val(flags), Int_val(mode)));
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_env_close(value env) {
|
||
|
|
mdb_env_close(Env_val(env));
|
||
|
|
return Val_unit;
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_env_copy2(value env, value path, value flags) {
|
||
|
|
return Val_int(mdb_env_copy2(Env_val(env), String_val(path), Int_val(flags)));
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_env_copyfd2(value env, value fd, value flags) {
|
||
|
|
return Val_int(mdb_env_copyfd2(Env_val(env), Int_val(fd), Int_val(flags)));
|
||
|
|
}
|
||
|
|
|
||
|
|
static void caml_mdb_stat(value result, const MDB_stat *stat) {
|
||
|
|
Store_field(result, 0, Val_int(stat->ms_psize));
|
||
|
|
Store_field(result, 1, Val_int(stat->ms_depth));
|
||
|
|
Store_field(result, 2, Val_long(stat->ms_branch_pages));
|
||
|
|
Store_field(result, 3, Val_long(stat->ms_leaf_pages));
|
||
|
|
Store_field(result, 4, Val_long(stat->ms_overflow_pages));
|
||
|
|
Store_field(result, 5, Val_long(stat->ms_entries));
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_env_stat(value env) {
|
||
|
|
CAMLparam1(env);
|
||
|
|
CAMLlocal1(result);
|
||
|
|
|
||
|
|
MDB_stat stat;
|
||
|
|
mdb_env_stat(Env_val(env), &stat);
|
||
|
|
result = caml_alloc_tuple(6);
|
||
|
|
caml_mdb_stat(result, &stat);
|
||
|
|
CAMLreturn(result);
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_env_info(value env) {
|
||
|
|
CAMLparam1(env);
|
||
|
|
CAMLlocal1(result);
|
||
|
|
|
||
|
|
MDB_envinfo info;
|
||
|
|
mdb_env_info(Env_val(env), &info);
|
||
|
|
result = caml_alloc_tuple(5);
|
||
|
|
|
||
|
|
Store_field(result, 0, Val_long(info.me_mapsize));
|
||
|
|
Store_field(result, 1, Val_long(info.me_last_pgno));
|
||
|
|
Store_field(result, 2, Val_long(info.me_last_txnid));
|
||
|
|
Store_field(result, 3, Val_int(info.me_maxreaders));
|
||
|
|
Store_field(result, 4, Val_int(info.me_numreaders));
|
||
|
|
|
||
|
|
CAMLreturn(result);
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_env_sync(value env, value force) {
|
||
|
|
return Val_int(mdb_env_sync(Env_val(env), Bool_val(force)));
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_env_set_flags(value env, value flags, value onoff) {
|
||
|
|
return Val_int(mdb_env_set_flags(Env_val(env), Int_val(flags), Bool_val(onoff)));
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_env_get_flags(value env) {
|
||
|
|
int flags;
|
||
|
|
mdb_env_get_flags(Env_val(env), &flags);
|
||
|
|
return Val_int(flags);
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_env_get_path(value env) {
|
||
|
|
CAMLparam1(env);
|
||
|
|
CAMLlocal1(result);
|
||
|
|
|
||
|
|
const char *path;
|
||
|
|
mdb_env_get_path(Env_val(env), &path);
|
||
|
|
result = caml_copy_string(path);
|
||
|
|
|
||
|
|
CAMLreturn(result);
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_env_get_fd(value env) {
|
||
|
|
mdb_filehandle_t fd;
|
||
|
|
mdb_env_get_fd(Env_val(env), &fd);
|
||
|
|
return Val_int(fd);
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_env_set_mapsize(value env, value size) {
|
||
|
|
return Val_int(mdb_env_set_mapsize(Env_val(env), Int64_val(size)));
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_env_set_maxreaders(value env, value readers) {
|
||
|
|
return Val_int(mdb_env_set_maxreaders(Env_val(env), Int_val(readers)));
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_env_get_maxreaders(value env) {
|
||
|
|
unsigned int readers;
|
||
|
|
mdb_env_get_maxreaders(Env_val(env), &readers);
|
||
|
|
return Val_int(readers);
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_env_set_maxdbs(value env, value dbs) {
|
||
|
|
return Val_int(mdb_env_set_maxdbs(Env_val(env), Int_val(dbs)));
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_env_get_maxkeysize(value env) {
|
||
|
|
return Val_int(mdb_env_get_maxkeysize(Env_val(env)));
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_txn_begin(value env, value flags, value parent) {
|
||
|
|
CAMLparam3(env, flags, parent);
|
||
|
|
CAMLlocal2(result, ml_txn);
|
||
|
|
|
||
|
|
int ret;
|
||
|
|
MDB_txn *parent_txn = Is_block(parent) ? Txn_val(Field(parent, 0)) : NULL;
|
||
|
|
MDB_txn *new_txn;
|
||
|
|
|
||
|
|
ret = mdb_txn_begin(Env_val(env), parent_txn, Int_val(flags), &new_txn);
|
||
|
|
|
||
|
|
if (ret) {
|
||
|
|
result = caml_alloc(1, 1);
|
||
|
|
Store_field(result, 0, Val_int(ret));
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
result = caml_alloc(1, 0);
|
||
|
|
ml_txn = alloc_txn(new_txn);
|
||
|
|
Store_field(result, 0, ml_txn);
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLreturn(result);
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_txn_env(value txn) {
|
||
|
|
CAMLparam1(txn);
|
||
|
|
CAMLlocal1(result);
|
||
|
|
MDB_env *env = mdb_txn_env(Txn_val(txn));
|
||
|
|
result = alloc_env(env);
|
||
|
|
CAMLreturn(result);
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_txn_id(value txn) {
|
||
|
|
return Val_long(mdb_txn_id(Txn_val(txn)));
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_txn_commit(value txn) {
|
||
|
|
return Val_int(mdb_txn_commit(Txn_val(txn)));
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_txn_abort(value txn) {
|
||
|
|
mdb_txn_abort(Txn_val(txn));
|
||
|
|
return Val_unit;
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_txn_reset(value txn) {
|
||
|
|
mdb_txn_reset(Txn_val(txn));
|
||
|
|
return Val_unit;
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_txn_renew(value txn) {
|
||
|
|
return Val_int(mdb_txn_renew(Txn_val(txn)));
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_dbi_open(value txn, value name, value flags) {
|
||
|
|
CAMLparam3(txn, name, flags);
|
||
|
|
CAMLlocal2(result, ml_dbi);
|
||
|
|
|
||
|
|
MDB_dbi dbi;
|
||
|
|
int ret;
|
||
|
|
const char* db_name = NULL;
|
||
|
|
|
||
|
|
if (Is_block(name)) db_name = String_val(Field(name, 0));
|
||
|
|
|
||
|
|
ret = mdb_dbi_open(Txn_val(txn), db_name, Int_val(flags), &dbi);
|
||
|
|
|
||
|
|
if (ret) {
|
||
|
|
result = caml_alloc(1, 1);
|
||
|
|
Store_field(result, 0, Val_int(ret));
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
result = caml_alloc(1, 0);
|
||
|
|
ml_dbi = caml_copy_nativeint(dbi);
|
||
|
|
Store_field(result, 0, ml_dbi);
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLreturn(result);
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_stat(value txn, value dbi) {
|
||
|
|
CAMLparam2(txn, dbi);
|
||
|
|
CAMLlocal2(result, tuple);
|
||
|
|
|
||
|
|
MDB_stat stat;
|
||
|
|
int ret;
|
||
|
|
ret = mdb_stat(Txn_val(txn), Nativeint_val(dbi), &stat);
|
||
|
|
|
||
|
|
if (ret) {
|
||
|
|
result = caml_alloc(1, 1);
|
||
|
|
Store_field(result, 0, Val_int(ret));
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
result = caml_alloc(1, 0);
|
||
|
|
tuple = caml_alloc_tuple(6);
|
||
|
|
caml_mdb_stat(tuple, &stat);
|
||
|
|
Store_field(result, 0, tuple);
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLreturn(result);
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_dbi_flags(value txn, value dbi) {
|
||
|
|
CAMLparam2(txn, dbi);
|
||
|
|
CAMLlocal1(result);
|
||
|
|
|
||
|
|
unsigned int flags;
|
||
|
|
int ret;
|
||
|
|
ret = mdb_dbi_flags(Txn_val(txn), Nativeint_val(dbi), &flags);
|
||
|
|
|
||
|
|
if (ret) {
|
||
|
|
result = caml_alloc(1, 1);
|
||
|
|
Store_field(result, 0, Val_int(ret));
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
result = caml_alloc(1, 0);
|
||
|
|
Store_field(result, 0, Val_int(flags));
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLreturn(result);
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_dbi_close(value env, value dbi) {
|
||
|
|
mdb_dbi_close(Env_val(env), Nativeint_val(dbi));
|
||
|
|
return Val_unit;
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_drop(value txn, value dbi, value del) {
|
||
|
|
return Val_int(mdb_drop(Txn_val(txn), Nativeint_val(dbi), Bool_val(del)));
|
||
|
|
}
|
||
|
|
|
||
|
|
static inline value alloc_mdb_val_ba (MDB_val *v) {
|
||
|
|
return
|
||
|
|
(v ?
|
||
|
|
caml_ba_alloc_dims(CAML_BA_UINT8 | CAML_BA_C_LAYOUT, 1, v->mv_data, v->mv_size) :
|
||
|
|
caml_ba_alloc_dims(CAML_BA_UINT8 | CAML_BA_C_LAYOUT, 1, NULL, 0));
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_get(value txn, value dbi, value key) {
|
||
|
|
CAMLparam3(txn, dbi, key);
|
||
|
|
CAMLlocal1(result);
|
||
|
|
|
||
|
|
MDB_val k, v;
|
||
|
|
int ret;
|
||
|
|
|
||
|
|
k.mv_size = caml_string_length(key);
|
||
|
|
k.mv_data = String_val(key);
|
||
|
|
|
||
|
|
ret = mdb_get(Txn_val(txn), Nativeint_val(dbi), &k, &v);
|
||
|
|
if (ret) {
|
||
|
|
result = caml_alloc(1, 1);
|
||
|
|
Store_field(result, 0, Val_int(ret));
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
result = caml_alloc(1, 0);
|
||
|
|
Store_field(result, 0, alloc_mdb_val_ba(&v));
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLreturn(result);
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_put(value txn, value dbi,
|
||
|
|
value key, value data, value flags) {
|
||
|
|
MDB_val k, v;
|
||
|
|
k.mv_size = caml_string_length(key);
|
||
|
|
k.mv_data = String_val(key);
|
||
|
|
v.mv_size = Caml_ba_array_val(data)->dim[0];
|
||
|
|
v.mv_data = Caml_ba_data_val(data);
|
||
|
|
return Val_int(mdb_put(Txn_val(txn), Nativeint_val(dbi), &k, &v, Int_val(flags)));
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_put_string(value txn, value dbi,
|
||
|
|
value key, value data, value flags) {
|
||
|
|
MDB_val k, v;
|
||
|
|
k.mv_size = caml_string_length(key);
|
||
|
|
k.mv_data = String_val(key);
|
||
|
|
v.mv_size = caml_string_length(data);
|
||
|
|
v.mv_data = String_val(data);
|
||
|
|
return Val_int(mdb_put(Txn_val(txn), Nativeint_val(dbi), &k, &v, Int_val(flags)));
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_del(value txn, value dbi, value key, value data) {
|
||
|
|
MDB_val k, v, *vp = NULL;
|
||
|
|
k.mv_size = caml_string_length(key);
|
||
|
|
k.mv_data = String_val(key);
|
||
|
|
|
||
|
|
if (Is_block(data)) {
|
||
|
|
v.mv_size = Caml_ba_array_val(Field(data, 0))->dim[0];
|
||
|
|
v.mv_data = Caml_ba_data_val(Field(data, 0));
|
||
|
|
vp = &v;
|
||
|
|
}
|
||
|
|
|
||
|
|
return Val_int(mdb_del(Txn_val(txn), Nativeint_val(dbi), &k, vp));
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_del_string(value txn, value dbi, value key, value data) {
|
||
|
|
MDB_val k, v, *vp = NULL;
|
||
|
|
k.mv_size = caml_string_length(key);
|
||
|
|
k.mv_data = String_val(key);
|
||
|
|
|
||
|
|
if (Is_block(data)) {
|
||
|
|
v.mv_size = caml_string_length(Field(data, 0));
|
||
|
|
v.mv_data = String_val(Field(data, 0));
|
||
|
|
vp = &v;
|
||
|
|
}
|
||
|
|
|
||
|
|
return Val_int(mdb_del(Txn_val(txn), Nativeint_val(dbi), &k, vp));
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_cursor_open(value txn, value dbi) {
|
||
|
|
CAMLparam2(txn, dbi);
|
||
|
|
CAMLlocal2(result, ml_cursor);
|
||
|
|
|
||
|
|
MDB_cursor *cursor;
|
||
|
|
int ret;
|
||
|
|
ret = mdb_cursor_open(Txn_val(txn), Nativeint_val(dbi), &cursor);
|
||
|
|
|
||
|
|
if (ret) {
|
||
|
|
result = caml_alloc(1, 1);
|
||
|
|
Store_field(result, 0, Val_int(ret));
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
result = caml_alloc(1, 0);
|
||
|
|
ml_cursor = alloc_cursor(cursor);
|
||
|
|
Store_field(result, 0, ml_cursor);
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLreturn(result);
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_cursor_close(value cursor) {
|
||
|
|
mdb_cursor_close(Cursor_val(cursor));
|
||
|
|
return Val_unit;
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_cursor_renew(value txn, value cursor) {
|
||
|
|
return Val_int(mdb_cursor_renew(Txn_val(txn), Cursor_val(cursor)));
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_cursor_txn(value cursor) {
|
||
|
|
return (value) mdb_cursor_txn(Cursor_val(cursor));
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_cursor_dbi(value cursor) {
|
||
|
|
return Val_int(mdb_cursor_dbi(Cursor_val(cursor)));
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_cursor_get(value cursor, value key, value data, value op) {
|
||
|
|
CAMLparam4(cursor, key, data, op);
|
||
|
|
CAMLlocal2(result, tuple);
|
||
|
|
|
||
|
|
MDB_val k, v;
|
||
|
|
int ret;
|
||
|
|
|
||
|
|
if (Is_block(key)) {
|
||
|
|
k.mv_size = caml_string_length(Field(key, 0));
|
||
|
|
k.mv_data = String_val(Field(key, 0));
|
||
|
|
}
|
||
|
|
|
||
|
|
if (Is_block(data)) {
|
||
|
|
v.mv_size = Caml_ba_array_val(Field(data, 0))->dim[0];
|
||
|
|
v.mv_data = Caml_ba_data_val(Field(data, 0));
|
||
|
|
}
|
||
|
|
|
||
|
|
ret = mdb_cursor_get(Cursor_val(cursor), &k, &v, Int_val(op));
|
||
|
|
if (ret) {
|
||
|
|
result = caml_alloc(1, 1);
|
||
|
|
Store_field(result, 0, Val_int(ret));
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
result = caml_alloc(1, 0);
|
||
|
|
tuple = caml_alloc_tuple(2);
|
||
|
|
Store_field(tuple, 0, alloc_mdb_val_ba(&k));
|
||
|
|
Store_field(tuple, 1, alloc_mdb_val_ba(&v));
|
||
|
|
Store_field(result, 0, tuple);
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLreturn(result);
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_cursor_get_string(value cursor, value key, value data, value op) {
|
||
|
|
CAMLparam4(cursor, key, data, op);
|
||
|
|
CAMLlocal2(result, tuple);
|
||
|
|
|
||
|
|
MDB_val k, v;
|
||
|
|
int ret;
|
||
|
|
|
||
|
|
if (Is_block(key)) {
|
||
|
|
k.mv_size = caml_string_length(Field(key, 0));
|
||
|
|
k.mv_data = String_val(Field(key, 0));
|
||
|
|
}
|
||
|
|
|
||
|
|
if (Is_block(data)) {
|
||
|
|
v.mv_size = caml_string_length(Field(data, 0));
|
||
|
|
v.mv_data = String_val(Field(data, 0));
|
||
|
|
}
|
||
|
|
|
||
|
|
ret = mdb_cursor_get(Cursor_val(cursor), &k, &v, Int_val(op));
|
||
|
|
if (ret) {
|
||
|
|
result = caml_alloc(1, 1);
|
||
|
|
Store_field(result, 0, Val_int(ret));
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
result = caml_alloc(1, 0);
|
||
|
|
tuple = caml_alloc_tuple(2);
|
||
|
|
Store_field(tuple, 0, alloc_mdb_val_ba(&k));
|
||
|
|
Store_field(tuple, 1, alloc_mdb_val_ba(&v));
|
||
|
|
Store_field(result, 0, tuple);
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLreturn(result);
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_cursor_put(value cursor, value key, value data, value flags) {
|
||
|
|
MDB_val k, v;
|
||
|
|
k.mv_size = caml_string_length(key);
|
||
|
|
k.mv_data = String_val(key);
|
||
|
|
v.mv_size = Caml_ba_array_val(data)->dim[0];
|
||
|
|
v.mv_data = Caml_ba_data_val(data);
|
||
|
|
return Val_int(mdb_cursor_put(Cursor_val(cursor), &k, &v, Int_val(flags)));
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_cursor_put_string(value cursor, value key, value data, value flags) {
|
||
|
|
MDB_val k, v;
|
||
|
|
k.mv_size = caml_string_length(key);
|
||
|
|
k.mv_data = String_val(key);
|
||
|
|
v.mv_size = caml_string_length(data);
|
||
|
|
v.mv_data = String_val(data);
|
||
|
|
return Val_int(mdb_cursor_put(Cursor_val(cursor), &k, &v, Int_val(flags)));
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_cursor_del(value cursor, value flags) {
|
||
|
|
return Val_int(mdb_cursor_del(Cursor_val(cursor), Int_val(flags)));
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLprim value stub_mdb_cursor_count(value cursor) {
|
||
|
|
CAMLparam1(cursor);
|
||
|
|
CAMLlocal1(result);
|
||
|
|
|
||
|
|
mdb_size_t count;
|
||
|
|
int ret;
|
||
|
|
|
||
|
|
ret = mdb_cursor_count(Cursor_val(cursor), &count);
|
||
|
|
if (ret) {
|
||
|
|
result = caml_alloc(1, 1);
|
||
|
|
Store_field(result, 0, Val_int(ret));
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
result = caml_alloc(1, 0);
|
||
|
|
Store_field(result, 0, Val_long(count));
|
||
|
|
}
|
||
|
|
|
||
|
|
CAMLreturn(result);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* --------------------------------------------------------------------------
|
||
|
|
Copyright (c) 2018 Vincent Bernardoff
|
||
|
|
|
||
|
|
Permission to use, copy, modify, and/or distribute this software for any
|
||
|
|
purpose with or without fee is hereby granted, provided that the above
|
||
|
|
copyright notice and this permission notice appear in all copies.
|
||
|
|
|
||
|
|
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||
|
|
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||
|
|
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||
|
|
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||
|
|
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||
|
|
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||
|
|
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||
|
|
--------------------------------------------------------------------------- */
|