Class: LMDB::Environment

Inherits:

Object

• Object
• LMDB::Environment

Defined in:

ext/lmdb_ext/lmdb_ext.c

Class Method Summary

• .new(*args) ⇒ Object

Instance Method Summary

• #active_txn ⇒ Object
• #clear_flags(*args) ⇒ Object
• #close ⇒ Object
• #copy(path) ⇒ Object
• #database(*args) ⇒ Object
• #flags ⇒ Object
• #info ⇒ Object
• #path ⇒ Object
• #set_flags(*args) ⇒ Object
• #stat ⇒ Object
• #sync(*args) ⇒ Object
• #transaction(*args) ⇒ Object

Class Method Details

.new(*args) ⇒ Object

# File 'ext/lmdb_ext/lmdb_ext.c', line 232

static VALUE environment_new(int argc, VALUE *argv, VALUE klass) {
        VALUE path, option_hash;
        rb_scan_args(argc, argv, "1:", &path, &option_hash);

        EnvironmentOptions options = {
                .flags = MDB_NOTLS,
                .maxreaders = -1,
                .maxdbs = 128,
                .mapsize = 0,
                .mode = 0755,
        };
        if (!NIL_P(option_hash))
                rb_hash_foreach(option_hash, environment_options, (VALUE)&options);

        MDB_env* env;
        check(mdb_env_create(&env));

        Environment* environment;
        VALUE venv = Data_Make_Struct(cEnvironment, Environment, environment_mark, environment_free, environment);
        environment->env = env;
        environment->thread_txn_hash = rb_hash_new();
        environment->txn_thread_hash = rb_hash_new();

        if (options.maxreaders > 0)
                check(mdb_env_set_maxreaders(env, options.maxreaders));
        if (options.mapsize > 0)
                check(mdb_env_set_mapsize(env, options.mapsize));

        check(mdb_env_set_maxdbs(env, options.maxdbs <= 0 ? 1 : options.maxdbs));
        check(mdb_env_open(env, StringValueCStr(path), options.flags, options.mode));

        if (rb_block_given_p())
                return rb_ensure(rb_yield, venv, environment_close, venv);

        return venv;
}

Instance Method Details

#active_txn ⇒ Object

# File 'ext/lmdb_ext/lmdb_ext.c', line 316

static VALUE environment_active_txn(VALUE self) {
        ENVIRONMENT(self, environment);
        return rb_hash_aref(environment->thread_txn_hash, rb_thread_current());
}

#clear_flags(*args) ⇒ Object

# File 'ext/lmdb_ext/lmdb_ext.c', line 311

static VALUE environment_clear_flags(int argc, VALUE* argv, VALUE self) {
        environment_change_flags(argc, argv, self, 0);
        return Qnil;
}

#close ⇒ Object

# File 'ext/lmdb_ext/lmdb_ext.c', line 143

static VALUE environment_close(VALUE self) {
        ENVIRONMENT(self, environment);
        mdb_env_close(environment->env);
        environment->env = 0;
        return Qnil;
}

#copy(path) ⇒ Object

# File 'ext/lmdb_ext/lmdb_ext.c', line 192

static VALUE environment_copy(VALUE self, VALUE path) {
        ENVIRONMENT(self, environment);
        check(mdb_env_copy(environment->env, StringValueCStr(path)));
        return Qnil;
}

#database(*args) ⇒ Object

# File 'ext/lmdb_ext/lmdb_ext.c', line 376

static VALUE environment_database(int argc, VALUE *argv, VALUE self) {
        ENVIRONMENT(self, environment);
        if (!active_txn(self))
                return call_with_transaction(self, self, "database", argc, argv, 0);

        VALUE name, option_hash;
        rb_scan_args(argc, argv, "01:", &name, &option_hash);

        int flags = 0;
        if (!NIL_P(option_hash))
                rb_hash_foreach(option_hash, database_flags, (VALUE)&flags);

        MDB_dbi dbi;
        check(mdb_dbi_open(need_txn(self), NIL_P(name) ? 0 : StringValueCStr(name), flags, &dbi));

        Database* database;
        VALUE vdb = Data_Make_Struct(cDatabase, Database, database_mark, free, database);
        database->dbi = dbi;
        database->env = self;

        return vdb;
}

#flags ⇒ Object

# File 'ext/lmdb_ext/lmdb_ext.c', line 269

static VALUE environment_flags(VALUE self) {
        unsigned int flags;
        ENVIRONMENT(self, environment);
        check(mdb_env_get_flags(environment->env, &flags));

        VALUE ret = rb_ary_new();
#define FLAG(const, name) if (flags & MDB_##const) rb_ary_push(ret, ID2SYM(rb_intern(#name)));
#include "env_flags.h"
#undef FLAG

        return ret;
}

#info ⇒ Object

# File 'ext/lmdb_ext/lmdb_ext.c', line 172

static VALUE environment_info(VALUE self) {
        MDB_envinfo info;

        ENVIRONMENT(self, environment);
        check(mdb_env_info(environment->env, &info));

        VALUE ret = rb_hash_new();

#define INFO_SET(name) rb_hash_aset(ret, ID2SYM(rb_intern(#name)), INT2NUM((size_t)info.me_##name));
        INFO_SET(mapaddr);
        INFO_SET(mapsize);
        INFO_SET(last_pgno);
        INFO_SET(last_txnid);
        INFO_SET(maxreaders);
        INFO_SET(numreaders);
#undef INFO_SET

        return ret;
}

#path ⇒ Object

# File 'ext/lmdb_ext/lmdb_ext.c', line 282

static VALUE environment_path(VALUE self) {
        const char* path;
        ENVIRONMENT(self, environment);
        check(mdb_env_get_path(environment->env, &path));
        return rb_str_new2(path);
}

#set_flags(*args) ⇒ Object

# File 'ext/lmdb_ext/lmdb_ext.c', line 306

static VALUE environment_set_flags(int argc, VALUE* argv, VALUE self) {
        environment_change_flags(argc, argv, self, 1);
        return Qnil;
}

#stat ⇒ Object

# File 'ext/lmdb_ext/lmdb_ext.c', line 165

static VALUE environment_stat(VALUE self) {
        ENVIRONMENT(self, environment);
        MDB_stat stat;
        check(mdb_env_stat(environment->env, &stat));
        return stat2hash(&stat);
}

#sync(*args) ⇒ Object

# File 'ext/lmdb_ext/lmdb_ext.c', line 198

static VALUE environment_sync(int argc, VALUE *argv, VALUE self) {
        ENVIRONMENT(self, environment);

        VALUE force;
        rb_scan_args(argc, argv, "01", &force);

        check(mdb_env_sync(environment->env, RTEST(force)));
        return Qnil;
}

#transaction(*args) ⇒ Object

# File 'ext/lmdb_ext/lmdb_ext.c', line 356

static VALUE environment_transaction(int argc, VALUE *argv, VALUE self) {
        rb_need_block();

        VALUE readonly;
        rb_scan_args(argc, argv, "01", &readonly);
        unsigned int flags = RTEST(readonly) ? MDB_RDONLY : 0;

        return with_transaction(self, rb_yield, Qnil, flags);
}