lmdb 0.1.0 → 0.2.0

data/ext/lmdb_ext/lmdb_ext.h

@@ -0,0 +1,124 @@
+#ifndef _LMDB_EXT_H
+#define _LMDB_EXT_H
+
+#include "ruby.h"
+#include "lmdb.h"
+
+#define ENV_FLAGS (                             \
+                MDB_FIXEDMAP    |               \
+                MDB_NOSUBDIR    |               \
+                MDB_NOSYNC      |               \
+                MDB_RDONLY      |               \
+                MDB_NOMETASYNC  |               \
+                MDB_WRITEMAP    |               \
+                MDB_MAPASYNC    |               \
+                MDB_NOTLS)
+
+#define ENVIRONMENT(var, var_env)                       \
+        Environment* var_env;                           \
+        Data_Get_Struct(var, Environment, var_env);     \
+        environment_check(var_env)
+
+#define DATABASE(var, var_db)                   \
+        Database* var_db;                       \
+        Data_Get_Struct(var, Database, var_db);
+
+#define TRANSACTION(var, var_txn)                       \
+        Transaction* var_txn;                           \
+        Data_Get_Struct(var, Transaction, var_txn)
+
+#define CURSOR(var, var_cur)                    \
+        Cursor* var_cur;                        \
+        Data_Get_Struct(var, Cursor, var_cur);  \
+        cursor_check(var_cur)
+
+typedef struct Transaction Transaction;
+
+typedef struct Transaction {
+        VALUE    env;
+        VALUE    parent;
+        MDB_txn* txn;
+        int      refcount;
+} Transaction;
+
+typedef struct {
+        MDB_env* env;
+        VALUE    txn;
+        int      refcount;
+} Environment;
+
+typedef struct {
+        VALUE   env;
+        MDB_dbi dbi;
+        int     refcount;
+} Database;
+
+typedef struct {
+        VALUE       db;
+        MDB_cursor* cur;
+} Cursor;
+
+typedef struct {
+        VALUE self;
+        const char* name;
+        int argc;
+        const VALUE* argv;
+} HelperArgs;
+
+static VALUE cEnvironment, cDatabase, cTransaction, cCursor, cError;
+
+#define ERROR(name) static VALUE cError_##name;
+#include "errors.h"
+#undef ERROR
+
+// BEGIN PROTOTYPES
+void Init_lmdb_ext();
+static VALUE call_with_transaction(VALUE venv, VALUE self, const char* name, int argc, const VALUE* argv, int flags);
+static VALUE call_with_transaction_helper(VALUE arg);
+static void check(int code);
+static void cursor_check(Cursor* cursor);
+static VALUE cursor_close(VALUE self);
+static VALUE cursor_count(VALUE self);
+static VALUE cursor_delete(int argc, VALUE *argv, VALUE self);
+static VALUE cursor_first(VALUE self);
+static void cursor_free(Cursor* cursor);
+static VALUE cursor_get(VALUE self);
+static void cursor_mark(Cursor* cursor);
+static VALUE cursor_next(VALUE self);
+static VALUE cursor_prev(VALUE self);
+static VALUE cursor_put(int argc, VALUE* argv, VALUE self);
+static VALUE cursor_set(VALUE self, VALUE vkey);
+static VALUE cursor_set_range(VALUE self, VALUE vkey);
+static VALUE database_clear(VALUE self);
+static VALUE database_cursor(VALUE self);
+static VALUE database_delete(int argc, VALUE *argv, VALUE self);
+static void database_deref(Database* database);
+static VALUE database_drop(VALUE self);
+static VALUE database_get(VALUE self, VALUE vkey);
+static void database_mark(Database* database);
+static VALUE database_put(int argc, VALUE *argv, VALUE self);
+static VALUE database_stat(VALUE self);
+static void environment_check(Environment* environment);
+static VALUE environment_close(VALUE self);
+static VALUE environment_copy(VALUE self, VALUE path);
+static VALUE environment_database(int argc, VALUE *argv, VALUE self);
+static void environment_deref(Environment *environment);
+static VALUE environment_flags(VALUE self);
+static VALUE environment_info(VALUE self);
+static MDB_txn* environment_need_txn(VALUE self);
+static VALUE environment_open(int argc, VALUE *argv, VALUE klass);
+static VALUE environment_path(VALUE self);
+static VALUE environment_set_flags(VALUE self, VALUE vflags);
+static VALUE environment_stat(VALUE self);
+static VALUE environment_sync(int argc, VALUE *argv, VALUE self);
+static VALUE environment_transaction(int argc, VALUE *argv, VALUE self);
+static MDB_txn* environment_txn(VALUE self);
+static VALUE stat2hash(const MDB_stat* stat);
+static VALUE transaction_abort(VALUE self);
+static VALUE transaction_commit(VALUE self);
+static void transaction_deref(Transaction* transaction);
+static void transaction_mark(Transaction* transaction);
+static VALUE with_transaction(VALUE venv, VALUE(*fn)(VALUE), VALUE arg, int flags);
+// END PROTOTYPES
+
+#endif

data/ext/lmdb_ext/prototypes.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+ctags -f - lmdb_ext.c | grep -P '\tf\t|f$' | sed -e 's#.*/\^##' -e 's#\$/.*##' -e 's# {#;#' > prototypes.h
+sed -i -ne '/BEGIN PROTOTYPES/ {p; r prototypes.h' -e ':a; n; /END PROTOTYPES/ {p; b}; ba}; p' lmdb_ext.h
+rm prototypes.h

data/lib/lmdb.rb

@@ -1,14 +1,29 @@
 require 'lmdb_ext'
 
 module LMDB
+  class Database
+    include Enumerable
 
-  # @see LMDB::Environment#new
-  def self.new(*a, &b)
-    LMDB::Environment.new(*a, &b)
-  end
+    def each
+      cursor do |c|
+        while i = c.next
+          yield(i)
+        end
+      end
+    end
 
-end
+    def [](key)
+      get(key)
+    end
+
+    def []=(key, value)
+      put(key, value)
+      value
+    end
 
-%w|environment database|.each do |name|
-  require "lmdb/#{name}"
+    def size
+      stat[:entries]
+    end
+  end
 end
+

data/lmdb.gemspec

@@ -1,22 +1,22 @@
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
-  s.name        = File.basename(__FILE__, ".gemspec")
-  s.version     = "0.1.0"
+  s.name        = File.basename(__FILE__, '.gemspec')
+  s.version     = '0.2.0'
   s.platform    = Gem::Platform::RUBY
-  s.licenses    = ["MIT"]
-  s.summary     = "Ruby bindings to Lightning MDB"
-  s.email       = "mail@daniel-mendler.de"
-  s.homepage    = "https://github.com/minad/mdb"
-  s.description = "imdb is a Ruby binding to OpenLDAP Lightning MDB."
-  s.authors     = ["Daniel Mendler", "Black Square Media"]
-  s.extensions  = Dir["ext/**/extconf.rb"]
+  s.licenses    = ['MIT']
+  s.summary     = 'Ruby bindings to Lightning MDB'
+  s.email       = 'mail@daniel-mendler.de'
+  s.homepage    = 'https://github.com/minad/lmdb'
+  s.description = 'imdb is a Ruby binding to OpenLDAP Lightning MDB.'
+  s.authors     = ['Daniel Mendler']
+  s.extensions  = Dir['ext/**/extconf.rb']
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- spec/*`.split("\n")
-  s.require_paths = ["lib"]
+  s.require_paths = ['lib']
 
-  s.add_development_dependency "rake"
-  s.add_development_dependency "rake-compiler"
-  s.add_development_dependency "rspec"
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rake-compiler'
+  s.add_development_dependency 'rspec'
 end

data/spec/helper.rb

@@ -0,0 +1,28 @@
+require 'lmdb'
+require 'rspec'
+require 'fileutils'
+
+SPEC_ROOT = File.dirname(__FILE__)
+TEMP_ROOT = File.join(SPEC_ROOT, 'tmp')
+
+module LMDB::SpecHelper
+  def mkpath(name = 'env')
+    path = File.join(TEMP_ROOT, name)
+    FileUtils.mkpath(path)
+    path
+  end
+
+  def path
+    @path ||= mkpath
+  end
+
+  def env
+    @env ||= LMDB::Environment.new path: path
+  end
+end
+
+RSpec.configure do |c|
+  c.include LMDB::SpecHelper
+  c.after { FileUtils.rm_rf TEMP_ROOT }
+end
+

data/spec/lmdb_spec.rb

@@ -1,41 +1,266 @@
-require 'spec_helper'
+# coding: binary
+require 'helper'
 
 describe LMDB do
+  let(:env) { LMDB.open(path) }
+  after     { env.close rescue nil }
 
-  describe "constants" do
-    it 'has version constants' do
-      LMDB::VERSION_MAJOR.should be_instance_of(Fixnum)
-      LMDB::VERSION_MINOR.should be_instance_of(Fixnum)
-      LMDB::VERSION_PATCH.should be_instance_of(Fixnum)
-      LMDB::VERSION.should be_instance_of(String)
-    end
-
-    it 'has environment flags' do
-      LMDB::FIXEDMAP.should be_instance_of(Fixnum)
-      LMDB::NOSUBDIR.should be_instance_of(Fixnum)
-      LMDB::NOSYNC.should be_instance_of(Fixnum)
-      LMDB::RDONLY.should be_instance_of(Fixnum)
-      LMDB::NOMETASYNC.should be_instance_of(Fixnum)
-      LMDB::WRITEMAP.should be_instance_of(Fixnum)
-      LMDB::MAPASYNC.should be_instance_of(Fixnum)
-    end
-
-    it 'has database flags' do
-      LMDB::REVERSEKEY.should be_instance_of(Fixnum)
-      LMDB::DUPSORT.should be_instance_of(Fixnum)
-      LMDB::INTEGERKEY.should be_instance_of(Fixnum)
-      LMDB::DUPFIXED.should be_instance_of(Fixnum)
-      LMDB::INTEGERDUP.should be_instance_of(Fixnum)
-      LMDB::REVERSEDUP.should be_instance_of(Fixnum)
-      LMDB::CREATE.should be_instance_of(Fixnum)
-      LMDB::NOOVERWRITE.should be_instance_of(Fixnum)
-      LMDB::NODUPDATA.should be_instance_of(Fixnum)
-      LMDB::CURRENT.should be_instance_of(Fixnum)
-      LMDB::RESERVE.should be_instance_of(Fixnum)
-      LMDB::APPEND.should be_instance_of(Fixnum)
-      LMDB::APPENDDUP.should be_instance_of(Fixnum)
-      LMDB::MULTIPLE.should be_instance_of(Fixnum)
+  let(:db)  { env.database }
+
+  it 'has version constants' do
+    LMDB::VERSION_MAJOR.should be_instance_of(Fixnum)
+    LMDB::VERSION_MINOR.should be_instance_of(Fixnum)
+    LMDB::VERSION_PATCH.should be_instance_of(Fixnum)
+    LMDB::VERSION.should be_instance_of(String)
+  end
+
+  it 'has environment flags' do
+    LMDB::FIXEDMAP.should be_instance_of(Fixnum)
+    LMDB::NOSUBDIR.should be_instance_of(Fixnum)
+    LMDB::NOSYNC.should be_instance_of(Fixnum)
+    LMDB::RDONLY.should be_instance_of(Fixnum)
+    LMDB::NOMETASYNC.should be_instance_of(Fixnum)
+    LMDB::WRITEMAP.should be_instance_of(Fixnum)
+    LMDB::MAPASYNC.should be_instance_of(Fixnum)
+    LMDB::NOTLS.should be_instance_of(Fixnum)
+  end
+
+  it 'has database flags' do
+    LMDB::REVERSEKEY.should be_instance_of(Fixnum)
+    LMDB::DUPSORT.should be_instance_of(Fixnum)
+    LMDB::INTEGERKEY.should be_instance_of(Fixnum)
+    LMDB::DUPFIXED.should be_instance_of(Fixnum)
+    LMDB::INTEGERDUP.should be_instance_of(Fixnum)
+    LMDB::REVERSEDUP.should be_instance_of(Fixnum)
+    LMDB::CREATE.should be_instance_of(Fixnum)
+    LMDB::NOOVERWRITE.should be_instance_of(Fixnum)
+    LMDB::NODUPDATA.should be_instance_of(Fixnum)
+    LMDB::CURRENT.should be_instance_of(Fixnum)
+    LMDB::RESERVE.should be_instance_of(Fixnum)
+    LMDB::APPEND.should be_instance_of(Fixnum)
+    LMDB::APPENDDUP.should be_instance_of(Fixnum)
+    LMDB::MULTIPLE.should be_instance_of(Fixnum)
+  end
+
+  describe LMDB::Environment do
+    subject { env }
+
+    its(:path)  { should == path }
+    its(:flags) { should == 0 }
+
+    describe 'open' do
+      it 'returns environment' do
+        env = LMDB::Environment.open(path)
+        env.should be_instance_of(described_class::Environment)
+        env.close
+      end
+
+      it 'accepts block' do
+        LMDB::Environment.open(path) do |env|
+          env.should be_instance_of(described_class::Environment)
+          42
+        end.should == 42
+      end
+
+      it 'accepts options' do
+        env = LMDB::Environment.open(path, :flags => LMDB::NOSYNC, :mode => 0777, :maxreaders => 777, :mapsize => 111111, :maxdbs => 666)
+        env.should be_instance_of(described_class::Environment)
+        env.info[:maxreaders].should == 777
+        env.info[:mapsize].should == 111111
+        env.close
+      end
+    end
+
+    it 'should return stat' do
+      stat = env.stat
+      stat[:psize].should be_instance_of(Fixnum)
+      stat[:depth].should be_instance_of(Fixnum)
+      stat[:branch_pages].should be_instance_of(Fixnum)
+      stat[:leaf_pages].should be_instance_of(Fixnum)
+      stat[:overflow_pages].should be_instance_of(Fixnum)
+      stat[:entries].should be_instance_of(Fixnum)
+    end
+
+    it 'should return info' do
+      info = env.info
+      info[:mapaddr].should be_instance_of(Fixnum)
+      info[:mapsize].should be_instance_of(Fixnum)
+      info[:last_pgno].should be_instance_of(Fixnum)
+      info[:last_txnid].should be_instance_of(Fixnum)
+      info[:maxreaders].should be_instance_of(Fixnum)
+      info[:numreaders].should be_instance_of(Fixnum)
+    end
+
+    it 'should copy' do
+      target = mkpath('copy')
+      subject.copy(target).should be_nil
+    end
+
+    it 'should sync' do
+      subject.sync.should be_nil
+    end
+
+    it 'should force-sync' do
+      subject.sync(true).should be_nil
+    end
+
+    it 'should accept custom flags' do
+      (subject.flags = LMDB::NOSYNC).should == LMDB::NOSYNC
+      subject.flags.should == LMDB::NOSYNC
+
+      (subject.flags = 0).should == 0
+      subject.flags.should == 0
+    end
+
+    describe 'transaction' do
+      subject { env}
+
+      it 'should create transactions' do
+        subject.transaction do |txn|
+          txn.should be_instance_of(described_class::Transaction)
+          txn.abort
+        end
+      end
+
+      it 'should create read-only transactions' do
+        subject.transaction(true) do |txn|
+          txn.should be_instance_of(described_class::Transaction)
+          txn.abort
+        end
+      end
+
+      it 'can create child transactions' do
+        env.transaction do |txn|
+          txn.should be_instance_of(described_class::Transaction)
+          env.transaction do |ctxn|
+            ctxn.should be_instance_of(described_class::Transaction)
+            ctxn.abort
+          end
+        end
+      end
+
+      it 'should support aborting parent transaction' do
+        env.transaction do |txn|
+          env.transaction do |ctxn|
+            db['key'] = 'value'
+            txn.abort
+          end
+        end
+        db['key'].should be(nil)
+      end
+
+      it 'should support comitting parent transaction' do
+        env.transaction do |txn|
+          env.transaction do |ctxn|
+            db['key'] = 'value'
+            txn.commit
+          end
+        end
+        db['key'].should == 'value'
+      end
     end
   end
 
-end
+  describe LMDB::Database do
+    subject { db }
+
+    it 'should get/put data' do
+      subject.get('cat').should be_nil
+      subject.put('cat', 'garfield').should be_nil
+      subject.get('cat').should == 'garfield'
+    end
+
+    it 'stores key/values in same transaction' do
+      db.put('key', 'value').should be_nil
+      db.get('key').should == 'value'
+    end
+
+    it 'stores key/values in different transactions' do
+      env.transaction do
+        db.put('key', 'value').should be_nil
+        db.put('key2', 'value2').should be_nil
+        env.transaction do
+          db.put('key3', 'value3').should be_nil
+        end
+      end
+
+      env.transaction do
+        db.get('key').should == 'value'
+        db.get('key2').should == 'value2'
+        env.transaction do
+          db.get('key3').should == 'value3'
+        end
+      end
+    end
+
+    it 'should return stat' do
+      db.stat.should be_instance_of(Hash)
+    end
+
+    it 'should return size' do
+      db.size.should == 0
+      db.put('key', 'value')
+      db.size.should == 1
+      db.put('key2', 'value2')
+      db.size.should == 2
+    end
+
+    it 'should be enumerable' do
+      db['k1'] = 'v1'
+      db['k2'] = 'v2'
+      db.to_a.should == [['k1', 'v1'], ['k2', 'v2']]
+    end
+
+    it 'should have shortcuts' do
+      db['key'] = 'value'
+      db['key'].should == 'value'
+    end
+
+    it 'should store binary' do
+      bin1 = "\xAAx\BB\xCC1"
+      bin2 = "\xAAx\BB\xCC2"
+      db[bin1] = bin2
+      db['key'] = bin2
+      db[bin1].should == bin2
+      db['key'].should == bin2
+    end
+  end
+
+  describe LMDB::Cursor do
+    before do
+      db.put('key1', 'value1')
+      db.put('key2', 'value2')
+    end
+
+    it 'should get next key/value' do
+      db.cursor do |c|
+        c.first.should == ['key1', 'value1']
+      end
+    end
+
+    it 'should get next key/value' do
+      db.cursor do |c|
+        c.first
+        c.next.should == ['key2', 'value2']
+      end
+    end
+
+    it 'should seek to key' do
+      db.cursor do |c|
+        c.set('key1').should == ['key1', 'value1']
+      end
+    end
+
+    it 'should seek to closest key' do
+      db.cursor do |c|
+        c.set_range('key0').should == ['key1', 'value1']
+      end
+    end
+
+    it 'should seek to key with nuls' do
+      db.cursor do |c|
+        c.set_range('\x00').should == ['key1', 'value1']
+      end
+    end
+  end
+end