lmdb 0.1.0

data/lib/lmdb.rb

@@ -0,0 +1,14 @@
+require 'lmdb_ext'
+
+module LMDB
+
+  # @see LMDB::Environment#new
+  def self.new(*a, &b)
+    LMDB::Environment.new(*a, &b)
+  end
+
+end
+
+%w|environment database|.each do |name|
+  require "lmdb/#{name}"
+end

data/lib/lmdb/database.rb

@@ -0,0 +1,66 @@
+class LMDB::Database
+
+  class << self
+    private :new
+  end
+
+  # @attr_reader [String] name
+  attr_reader :name
+
+  # @attr_reader [LMDB::Environment] env
+  attr_reader :env
+
+  # @param [LMDB::Environment] env
+  # @param [String] name the DB name
+  def initialize(env, name)
+    @env  = env
+    @name = name.to_s
+  end
+
+  # Closes the DB, doesn't fail if already closed
+  def close
+    raw.close if loaded?
+  end
+
+  # Reads a key
+  # @param [String] key
+  def get(key)
+    ensure_db!
+    rtxn {|txn| raw.get(txn, key) }
+  rescue LMDB::Ext::Error::NOTFOUND
+  end
+  alias_method :[], :get
+
+  # Sets a key to a new value
+  # @param [String] key
+  # @param [String] value
+  def set(key, value)
+    ensure_db!
+    rtxn {|txn| raw.put(txn, key, value) }
+  end
+  alias_method :put, :set
+  alias_method :[]=, :set
+
+  private
+
+    def raw
+      @raw ||= rtxn {|txn| renv.open(txn, name, LMDB::CREATE) }
+    end
+
+    def renv
+      @renv ||= env.send(:raw)
+    end
+
+    def rtxn(&block)
+      env.send(:rtxn, &block)
+    end
+
+    def loaded?
+      !!@raw
+    end
+
+    def ensure_db!
+      raw unless loaded?
+    end
+
+end

data/lib/lmdb/environment.rb

@@ -0,0 +1,135 @@
+class LMDB::Environment
+
+  DEFAULT_OPTS = {
+    path: ".",
+    mode: 0755,
+    max_size: (2**28-1), # 4G
+    # max_size: 1_000_000,
+    max_dbs: 16,
+    max_readers: 126,
+    sub_dirs: true,
+    read_only: false,
+    mmap: false,
+    sync: true,
+    meta_sync: false
+  }.freeze
+
+  INFO_MAP = {
+    mapaddr:    :address,
+    mapsize:    :max_size,
+    last_pgno:  :last_page,
+    last_txnid: :last_transaction_id,
+    maxreaders: :maxreaders,
+    numreaders: :readers
+  }.freeze
+
+  STAT_MAP = {
+    psize:          :page_size,
+    depth:          :depth,
+    branch_pages:   :branch_pages,
+    leaf_pages:     :leaf_pages,
+    overflow_pages: :overflow_pages,
+    entries:        :entries
+  }.freeze
+
+  # @attr_reader [String] path environment path
+  attr_reader :path
+
+  # Constructor, opens an environment
+  #
+  # @param [Hash] opts options
+  # @option opts [String] :path
+  #   the environment path, defaults to current path
+  # @option opts [String] :mode
+  #   the file mode, defaults to 0755
+  # @option opts [Integer] :max_size
+  #   the maximum environment size in bytes, defaults to 4G
+  # @option opts [Integer] :max_dbs
+  #   the maximum number of databases, defaults to 16
+  # @option opts [Integer] :max_readers
+  #   the maximum number of readers, defaults to 126
+  # @option opts [Boolean] :sub_dirs
+  #   allow subdirectories, defaults to true
+  # @option opts [Boolean] :read_only
+  #   open in read-only mode, defaults to false
+  # @option opts [Boolean] :mmap
+  #   use memory map, faster, but less durable, incompatible with nested transactions, defaults to false
+  # @option opts [Boolean] :sync
+  #   flushes system buffers at the end of a transaction; slower, but more durable, defaults to true
+  # @option opts [Boolean] :meta_sync
+  #   flush system buffers on every write and not only at the end of a transaction; slower, but more durable, defaults to false
+  # @raises [LMDB::Error] on errors
+  def initialize(opts = {})
+    opts  = DEFAULT_OPTS.merge(opts)
+    @path = opts[:path].to_s
+    @raw  = LMDB::Ext::Environment.open path, parse(opts)
+  end
+
+  # Manually sync the environment
+  #
+  # @param [Hash] opts options
+  # @option opts [Boolean] :force force sync, default false
+  # @return [Boolean] true if successful
+  # @raises [LMDB::Error] on errors
+  def sync(opts = {})
+    @raw.sync !!opts[:force]
+    true
+  end
+
+  # @return [Hash] environment info & stats
+  def info
+    info, stat = @raw.info, @raw.stat
+    hash = {}
+    INFO_MAP.each {|m, f| hash[f] = info.send(m) }
+    STAT_MAP.each {|m, f| hash[f] = stat.send(m) }
+    hash
+  end
+
+  # TODO: Thread-safe global transactions
+  #
+  # Executes a transaction
+  # @yield a transaction
+  # @yieldparam [LMDB::Transaction] txn the transaction instance
+  # def transaction(&block)
+  #   LMDB::Transaction.send(:new, self, &block)
+  # end
+
+  # Opens a database
+  # @param [String] name
+  # @return [LMDB::Database] the database
+  def database(name)
+    LMDB::Database.send(:new, self, name)
+  end
+  alias_method :db, :database
+
+  # @return [String] introspection
+  def inspect
+    "#<#{self.class.name} @path=#{path.inspect}>"
+  end
+
+  private
+
+    def raw
+      @raw
+    end
+
+    def rtxn(&block)
+      @raw.transaction(&block)
+    end
+
+    def parse(opts)
+      flags = 0
+      flags |= LMDB::NOSUBDIR   unless opts[:sub_dirs]
+      flags |= LMDB::RDONLY     if opts[:read_only]
+      flags |= LMDB::WRITEMAP   if opts[:mmap]
+      flags |= LMDB::NOSYNC     unless opts[:sync]
+      flags |= LMDB::NOMETASYNC unless opts[:meta_sync]
+
+      { flags: flags,
+        mode: opts[:mode],
+        maxreaders: opts[:max_readers].to_i,
+        mapsize: opts[:max_size].to_i,
+        maxdbs: opts[:max_dbs].to_i }
+    end
+
+end

data/lmdb.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name        = File.basename(__FILE__, ".gemspec")
+  s.version     = "0.1.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.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- spec/*`.split("\n")
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rake-compiler"
+  s.add_development_dependency "rspec"
+end

data/spec/lmdb/database_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe LMDB::Database do
+
+  subject    { env.db(:pets) }
+  after      { subject.close }
+
+  its(:name) { should == "pets" }
+  its(:env)  { should == env }
+
+  it 'should get/set data' do
+    subject.get("cat").should be_nil
+    subject.set("cat", "garfield").should be_nil
+    subject.get("cat").should == "garfield"
+  end
+
+  it 'should get/set data' do
+    subject.get("cat").should be_nil
+    subject.set("cat", "garfield").should be_nil
+    subject.get("cat").should == "garfield"
+  end
+
+end

data/spec/lmdb/environment_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe LMDB::Environment do
+
+  subject    { env }
+
+  it  { should be_instance_of(described_class) }
+  its(:path) { should be_instance_of(String) }
+  its(:info) { should be_instance_of(Hash) }
+  its("info.keys") { should =~ [:address, :branch_pages, :depth, :entries, :last_page, :last_transaction_id, :leaf_pages, :max_size, :maxreaders, :overflow_pages, :page_size, :readers] }
+
+  it 'should sync' do
+    subject.sync.should be(true)
+    subject.sync(force: true).should be(true)
+  end
+
+  it 'should open databases' do
+    subject.database(:pets).should be_instance_of(LMDB::Database)
+    subject.db(:pets).should be_instance_of(LMDB::Database)
+  end
+
+end

data/spec/lmdb/lmdb_ext_spec.rb

@@ -0,0 +1,253 @@
+require 'spec_helper'
+
+shared_examples "an environment" do
+  describe 'open' do
+    it 'returns environment' do
+      env = subject.open(path)
+      env.should be_instance_of(described_class::Environment)
+      env.close
+    end
+
+    it 'accepts block' do
+      subject.open(path) do |env|
+        env.should be_instance_of(described_class::Environment)
+        42
+      end.should == 42
+    end
+
+    it 'accepts options' do
+      env = subject.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
+end
+
+describe LMDB::Ext do
+
+  let(:env)  { LMDB::Ext.open(path) }
+  after      { env.close }
+
+  it_behaves_like "an environment" do
+    subject { LMDB::Ext }
+  end
+
+  describe "Stat" do
+    subject { env.stat }
+
+    it { should be_instance_of(described_class::Stat) }
+    its(:psize) { should be_instance_of(Fixnum) }
+    its(:depth) { should be_instance_of(Fixnum) }
+    its(:branch_pages) { should be_instance_of(Fixnum) }
+    its(:leaf_pages) { should be_instance_of(Fixnum) }
+    its(:overflow_pages) { should be_instance_of(Fixnum) }
+    its(:entries) { should be_instance_of(Fixnum) }
+  end
+
+  describe "Info" do
+    subject { env.info }
+
+    it { should be_instance_of(described_class::Info) }
+    its(:mapaddr) { should be_instance_of(Fixnum) }
+    its(:mapsize) { should be_instance_of(Fixnum) }
+    its(:last_pgno) { should be_instance_of(Fixnum) }
+    its(:last_txnid) { should be_instance_of(Fixnum) }
+    its(:maxreaders) { should be_instance_of(Fixnum) }
+    its(:numreaders) { should be_instance_of(Fixnum) }
+  end
+
+  describe "Environment" do
+    it_behaves_like "an environment" do
+      subject { described_class::Environment }
+    end
+
+    subject { env }
+
+    its(:path)  { should == path }
+    its(:flags) { should == 0 }
+
+    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
+
+    it 'should create transactions' do
+      txn = subject.transaction
+      txn.should be_instance_of(described_class::Transaction)
+      txn.parent.should be_nil
+      txn.environment.should == subject
+      txn.abort
+    end
+
+    it 'should create read-only transactions' do
+      txn = subject.transaction(true)
+      txn.should be_instance_of(described_class::Transaction)
+      txn.abort
+    end
+
+    it 'should create transactions blocks' do
+      subject.transaction do |txn|
+        txn.should be_instance_of(described_class::Transaction)
+        txn.environment.should == subject
+        txn.parent.should be_nil
+      end
+    end
+  end
+
+  describe "Transaction" do
+    subject { env.transaction }
+    after   { subject.abort rescue nil }
+
+    its(:environment) { should == env }
+    its(:parent) { should be_nil }
+
+    it 'can create child transactions' do
+      txn = subject.transaction
+      txn.should be_instance_of(described_class::Transaction)
+      txn.parent.should == subject
+      txn.environment.should == env
+      txn.abort
+    end
+
+    it 'can create block transactions' do
+      subject.transaction do |txn|
+        txn.should be_instance_of(described_class::Transaction)
+        txn.parent.should == subject
+      end
+    end
+  end
+
+  describe "Database" do
+
+    subject do
+      env.transaction do |txn|
+        env.open(txn, 'db', LMDB::CREATE)
+      end
+    end
+    let!(:db) { subject }
+    after     { subject.close rescue nil }
+
+    it 'stores key/values in same transaction' do
+      env.transaction do |txn|
+        db.put(txn, 'key', 'value').should be_nil
+        db.get(txn, 'key').should == 'value'
+      end
+    end
+
+    it 'stores key/values in different transactions' do
+      env.transaction do |txn|
+        db.put(txn, 'key', 'value').should be_nil
+      end
+
+      env.transaction do |txn|
+        db.get(txn, 'key').should == 'value'
+      end
+    end
+
+    it 'should return cursor' do
+      env.transaction do |txn|
+        cursor = db.cursor(txn)
+        cursor.should be_instance_of(described_class::Cursor)
+        cursor.close
+      end
+    end
+
+    it 'should return stat' do
+      env.transaction do |txn|
+        db.stat(txn).should be_instance_of(described_class::Stat)
+      end
+    end
+
+    it 'should close' do
+      db.close.should be_nil
+      -> { db.close }.should raise_error(LMDB::Ext::Error, /closed/)
+    end
+
+    it "should be correctly GC'd", segfault: true do
+      db = env.transaction {|t| env.open(t, 'db', LMDB::CREATE) }
+      db = nil
+      GC.start
+      db = env.transaction {|t| env.open(t, 'db', LMDB::CREATE) }
+    end
+
+  end
+
+  describe "Cursor" do
+
+    let! :db do
+      env.transaction {|txn| env.open(txn, 'db', LMDB::CREATE) }
+    end
+
+    before do
+      env.transaction do |txn|
+        db.put(txn, 'key1', 'value1')
+        db.put(txn, 'key2', 'value2')
+      end
+    end
+
+    after do
+      db.close
+    end
+
+    def with_cursor
+      env.transaction do |txn|
+        cursor = db.cursor(txn)
+        begin
+          yield cursor
+        ensure
+          cursor.close
+        end
+      end
+    end
+
+    it 'should get next key/value' do
+      with_cursor do |c|
+        c.first.should == ['key1', 'value1']
+      end
+    end
+
+    it 'should get next key/value' do
+      with_cursor do |c|
+        c.first
+        c.next.should == ['key2', 'value2']
+      end
+    end
+
+    it 'should seek to key' do
+      with_cursor do |c|
+        c.set('key1').should == ['key1', 'value1']
+      end
+    end
+
+    it 'should seek to closest key' do
+      with_cursor do |c|
+        c.set_range('key0').should == ['key1', 'value1']
+      end
+    end
+
+    it 'should seek to key with nuls' do
+      with_cursor do |c|
+        c.set_range("\x00").should == ['key1', 'value1']
+      end
+    end
+
+  end
+end