bdb 0.1.0

data/lib/bdb/partitioned_database.rb

@@ -0,0 +1,74 @@
+require 'bdb/base'
+
+class Bdb::PartitionedDatabase < Bdb::Base
+  SEPARATOR = '__'
+  PARTITION_PATTERN = /^[-\w]*$/
+
+  def initialize(base_name, opts = {})
+    @base_name    = base_name
+    @partition_by = opts.delete(:partition_by)
+    super(opts)
+  end
+  attr_reader :base_name, :partition_by, :partition
+
+  def databases
+    @databases ||= {}
+  end
+
+  def database(partition = nil)
+    partition ||= self.partition
+    raise 'partition value required' if partition.nil?
+    partition = partition.to_s
+    raise "invalid partition value: #{partition}" unless partition =~ PARTITION_PATTERN
+
+    databases[partition] ||= begin
+      name = [partition, base_name].join(SEPARATOR)
+      database = Bdb::Database.new(name, config)
+      indexes.each do |field, opts|
+        database.index_by(field, opts)
+      end
+      database
+    end
+  end
+
+  def partitions
+    Dir[environment.path + "/*#{SEPARATOR}#{base_name}"].collect do |file|
+      File.basename(file).split(SEPARATOR).first
+    end
+  end
+
+  def with_partition(partition)
+    @partition, old_partition = partition, @partition
+    yield
+  ensure
+    @partition = old_partition
+  end
+
+  def close
+    databases.each do |partition, database|
+      database.close
+    end
+    @databases.clear
+  end
+
+  def get(*keys, &block)
+    opts = keys.last.kind_of?(Hash) ? keys.last : {}
+    database(opts[partition_by]).get(*keys, &block)
+  end
+
+  def set(key, value, opts = {})
+    partition = get_field(partition_by, value)
+    database(partition).set(key, value, opts)
+  end
+
+  def delete(key, opts = {})
+    database(opts[partition_by]).delete(key)
+  end
+
+  # Deletes all records in the database. Beware!
+  def truncate!
+    partitions.each do |partition|
+      database(partition).truncate!
+    end
+  end
+end

data/lib/bdb/result_set.rb

@@ -0,0 +1,41 @@
+class Bdb::ResultSet
+  class LimitReached < Exception; end
+  
+  def initialize(opts, &block)
+    @block  = block
+    @count  = 0
+    @limit  = opts[:limit] || opts[:per_page]
+    @limit  = @limit.to_i if @limit
+    @offset = opts[:offset] || (opts[:page] ? @limit * (opts[:page] - 1) : 0)
+    @offset = @offset.to_i if @offset
+    
+    if @group = opts[:group]
+      raise 'block not supported with group' if @block     
+      @results = hash_class.new
+    else
+      @results = []
+    end
+  end
+  attr_reader :count, :group, :limit, :offset, :results
+  
+  def hash_class
+    @hash_class ||= defined?(ActiveSupport::OrderedHash) ? ActiveSupport::OrderedHash : Hash
+  end
+  
+  def <<(item)
+    @count += 1
+    return if count <= offset
+    
+    raise LimitReached if limit and count > limit + offset
+    
+    if group
+      key = item.bdb_locator_key
+      group_key = group.is_a?(Fixnum) ? key[0,group] : key
+      (results[group_key] ||= []) << item
+    elsif @block
+      @block.call(item)
+    else
+      results << item
+    end
+  end
+end

data/test/benchmark.rb

@@ -0,0 +1,31 @@
+require 'rubygems'
+require File.dirname(__FILE__) + '/../lib/bdb/simple'
+require 'benchmark'
+
+N = 10_000
+A = [5, 6, "foo", :bar, "bar", {}, :foo, [1,2,4], true, [1,2,3], false, [1], [2], nil].collect {|i| Marshal.dump(i)}
+
+puts "compare_absolute (#{N} times)"
+t = Benchmark.measure do
+  N.times do
+    A.sort {|a,b| Bdb::Simple.compare_absolute(Marshal.load(a), Marshal.load(b)) }
+  end
+end
+puts t
+
+puts "compare_hash (#{N} times)"
+t = Benchmark.measure do
+  N.times do
+    A.sort {|a,b| Marshal.load(a).hash <=> Marshal.load(b).hash }
+  end
+end
+puts t
+
+puts "compare_raw (#{N} times)"
+t = Benchmark.measure do
+  N.times do
+    A.sort
+  end
+end
+puts t
+

data/test/cursor_test.rb

@@ -0,0 +1,150 @@
+require 'test_helper'
+
+class CursorTest < Test::Unit::TestCase
+  
+  def setup
+    mkdir File.join(File.dirname(__FILE__), 'tmp')
+    @db = Bdb::Db.new
+    @db.open(nil, File.join(File.dirname(__FILE__), 'tmp', 'test.db'), nil, Bdb::Db::BTREE, Bdb::DB_CREATE, 0)    
+    10.times { |i| @db.put(nil, i.to_s, "data-#{i}", 0)}
+    @cursor = @db.cursor(nil, 0)
+  end
+  
+  def teardown
+    @cursor.close if @cursor
+    assert(@db.close(0)) if @db
+    rm_rf File.join(File.dirname(__FILE__), 'tmp')
+  end
+
+  def test_get
+    key, value = @cursor.get(nil, nil, Bdb::DB_FIRST)
+    assert_equal '0', key
+    assert_equal 'data-0', value
+  end
+
+  def test_get_range
+    keys = []
+    key, value = @cursor.get("4", nil, Bdb::DB_SET_RANGE)
+    while key and key <= "9"
+      keys << key
+      key, value = @cursor.get(nil, nil, Bdb::DB_NEXT)
+    end
+
+    assert_equal (4..9).collect {|i| i.to_s}, keys
+  end
+  
+  def test_pget
+    @db1 = Bdb::Db.new
+    @db1.flags = Bdb::DB_DUPSORT
+    @db1.open(nil, File.join(File.dirname(__FILE__), 'tmp', 'test1.db'), nil, Bdb::Db::HASH, Bdb::DB_CREATE, 0)
+
+    @db.associate(nil, @db1, 0, proc { |sdb, key, data| key.split('-')[0] })
+    
+    @db.put(nil, '1234-5678', 'data', 0)
+    @db.put(nil, '5678-1234', 'atad', 0)
+    
+    @cursor1 = @db1.cursor(nil, 0)
+    key, pkey, value = @cursor1.pget(nil, nil, Bdb::DB_FIRST)
+    assert_equal '1234', key
+    assert_equal '1234-5678', pkey
+    assert_equal 'data', value
+    
+    @cursor1.close
+    @db1.close(0)
+  end
+  
+  def test_put
+    @cursor.put('10_000', 'data-10_000', Bdb::DB_KEYLAST)
+    value = @db.get(nil, '10_000', nil, 0)
+    assert_equal 'data-10_000', value
+  end
+  
+  def test_del
+    key, value = @cursor.get(nil, nil, Bdb::DB_FIRST) 
+    value = @db.get(nil, '0', nil, 0)
+    assert_equal '0', key
+    assert_equal 'data-0', value
+    @cursor.del
+    value = @db.get(nil, '0', nil, 0)
+    assert_nil value
+  end
+  
+  def test_count
+    @cursor.get(nil, nil, Bdb::DB_FIRST) 
+    assert_equal 1, @cursor.count
+  end  
+
+  def test_get_all_in_order
+    all = []
+    while pair = @cursor.get(nil, nil, Bdb::DB_NEXT)      
+      all << pair.first
+    end
+    assert_equal (0..9).collect {|i| i.to_s}, all
+  end
+
+  def test_get_all_with_btree_compare
+    @db1 = Bdb::Db.new
+    @db1.btree_compare = proc {|db, key1, key2| key2 <=> key1}
+    @db1.open(nil, File.join(File.dirname(__FILE__), 'tmp', 'test1.db'), nil, Bdb::Db::BTREE, Bdb::DB_CREATE, 0)    
+    10.times { |i| @db1.put(nil, i.to_s, "data-#{i}", 0)}
+    @cursor1 = @db1.cursor(nil, 0)
+
+    all = []
+    while pair = @cursor1.get(nil, nil, Bdb::DB_NEXT)      
+      all << pair.first
+    end
+    assert_equal (0..9).collect {|i| i.to_s}.reverse, all
+    @cursor1.close
+    @db1.close(0)
+  end
+
+  def test_btree_compare_raises_if_fixnum_not_returned
+    @db1 = Bdb::Db.new
+    @db1.btree_compare = proc {|db, key1, key2| key1}
+    @db1.open(nil, File.join(File.dirname(__FILE__), 'tmp', 'test1.db'), nil, Bdb::Db::BTREE, Bdb::DB_CREATE, 0)    
+
+    assert_raises(TypeError) do
+      @db1.put(nil, "no", "way", 0)
+      @db1.put(nil, "ho", "say", 0)
+    end
+    @db1.close(Bdb::DB_NOSYNC)
+  end
+
+  def test_join
+    @personnel_db = Bdb::Db.new
+    @personnel_db.open(nil, File.join(File.dirname(__FILE__), 'tmp', 'personnel_db.db'), nil, Bdb::Db::HASH, Bdb::DB_CREATE, 0)
+
+    @names_db = Bdb::Db.new
+    @names_db.flags = Bdb::DB_DUPSORT
+    @names_db.open(nil, File.join(File.dirname(__FILE__), 'tmp', 'names_db.db'), nil, Bdb::Db::HASH, Bdb::DB_CREATE, 0)
+
+    @jobs_db = Bdb::Db.new
+    @jobs_db.flags = Bdb::DB_DUPSORT
+    @jobs_db.open(nil, File.join(File.dirname(__FILE__), 'tmp', 'jobs_db.db'), nil, Bdb::Db::HASH, Bdb::DB_CREATE, 0)
+    
+    [{:ssn => '111-11-1111', :lastname => 'Smith',  :job => 'welder'},
+     {:ssn => '222-22-2222', :lastname => 'Jones', :job => 'welder'},
+     {:ssn => '333-33-3333', :lastname => 'Smith', :job => 'painter'}].each do |e|
+      @personnel_db.put(nil, e[:ssn], Marshal.dump([e[:ssn], e[:lastname], e[:job]]), 0)
+      @names_db.put(nil, e[:lastname], e[:ssn], 0)
+      @jobs_db.put(nil, e[:job], e[:ssn], 0)
+    end
+    
+    @name_cursor = @names_db.cursor(nil, 0)
+    @name_cursor.get('Smith', nil, Bdb::DB_SET)
+    assert_equal 2, @name_cursor.count
+    @job_cursor = @jobs_db.cursor(nil, 0)
+    @job_cursor.get('welder', nil, Bdb::DB_SET)
+    assert_equal 2, @job_cursor.count
+    @personnel_cursor = @personnel_db.join([@name_cursor, @job_cursor], 0)
+    assert_equal '111-11-1111', @personnel_cursor.get(nil, nil, 0).first
+
+    @personnel_cursor.close
+    @name_cursor.close
+    @job_cursor.close
+    
+    @jobs_db.close(0)
+    @names_db.close(0)
+    @personnel_db.close(0)
+  end
+end

data/test/db_test.rb

@@ -0,0 +1,157 @@
+require 'test_helper'
+
+class DbTest < Test::Unit::TestCase
+
+  def setup
+    mkdir File.join(File.dirname(__FILE__), 'tmp')
+    @db = Bdb::Db.new
+    @db.open(nil, File.join(File.dirname(__FILE__), 'tmp', 'test.db'), nil, Bdb::Db::BTREE, Bdb::DB_CREATE, 0)
+  end
+  
+  def teardown
+    assert(@db.close(0)) if @db
+    rm_rf File.join(File.dirname(__FILE__), 'tmp')
+  end
+  
+  def test_put_and_get
+    @db.put(nil, 'key', 'data', 0)
+    result = @db.get(nil, 'key', nil, 0)
+    assert_equal 'data', result
+  end
+  
+  def test_del
+    @db.put(nil, 'key', 'data', 0)
+    result = @db.get(nil, 'key', nil, 0)
+    assert_equal 'data', result
+    @db.del(nil, 'key', 0)    
+    result = @db.get(nil, 'key', nil, 0)
+    assert_nil result
+  end
+  
+  def test_flags_set_and_get
+    @db1 = Bdb::Db.new
+    @db1.flags = Bdb::DB_DUPSORT
+    assert Bdb::DB_DUPSORT, @db1.flags
+  end
+    
+  def test_associate_and_pget
+    @db1 = Bdb::Db.new
+    @db1.flags = Bdb::DB_DUPSORT
+    @db1.open(nil, File.join(File.dirname(__FILE__), 'tmp', 'test1.db'), nil, Bdb::Db::HASH, Bdb::DB_CREATE, 0)
+
+    @db.associate(nil, @db1, 0, proc { |sdb, key, data| key.split('-')[0] })
+    
+    @db.put(nil, '1234-5678', 'data', 0)
+    @db.put(nil, '5678-1234', 'atad', 0)
+    
+    result = @db.get(nil, '1234-5678', nil, 0)
+    assert_equal 'data', result
+    result = @db1.get(nil, '5678', nil, 0)
+    assert_equal 'atad', result
+    
+    result = @db1.pget(nil, '1234', nil, 0)
+    assert_equal ['1234-5678', 'data'], result
+    
+    @db1.close(0)
+  end
+
+  def test_associate_with_multiple_keys
+    @db1 = Bdb::Db.new
+    @db1.flags = Bdb::DB_DUPSORT
+    @db1.open(nil, File.join(File.dirname(__FILE__), 'tmp', 'test1.db'), nil, Bdb::Db::HASH, Bdb::DB_CREATE, 0)
+
+    @db.associate(nil, @db1, 0, proc { |sdb, key, data| key.split('-') })
+    
+    @db.put(nil, '1234-5678', 'data', 0)
+    @db.put(nil, '8765-4321', 'atad', 0)
+    
+    result = @db.get(nil, '1234-5678', nil, 0)
+    assert_equal 'data', result
+    result = @db1.get(nil, '5678', nil, 0)
+    assert_equal 'data', result
+    result = @db1.get(nil, '1234', nil, 0)
+    assert_equal 'data', result
+    result = @db1.get(nil, '8765', nil, 0)
+    assert_equal 'atad', result
+    result = @db1.get(nil, '4321', nil, 0)
+    assert_equal 'atad', result
+    
+    @db1.close(0)
+  end
+
+  def test_aset_and_aget
+    @db['key'] = 'data'
+    result = @db.get(nil, 'key', nil, 0)
+    assert_equal 'data', result
+    result = @db['key']
+    assert_equal 'data', result
+    @db['key'] = 'data1'
+    result = @db['key']
+    assert_equal 'data1', result
+  end
+  
+  def test_get_byteswapped
+    @db.get_byteswapped
+  end
+  
+  def test_get_type
+    assert_equal Bdb::Db::BTREE, @db.get_type
+  end
+  
+  def test_remove
+    @db1 = Bdb::Db.new
+    @db1.open(nil, File.join(File.dirname(__FILE__), 'tmp', 'other_test.db'), nil, Bdb::Db::BTREE, Bdb::DB_CREATE, 0)
+    @db1.close(0)
+    Bdb::Db.new.remove(File.join(File.dirname(__FILE__), 'tmp', 'other_test.db'), nil, 0)
+    assert !File.exists?(File.join(File.dirname(__FILE__), 'tmp', 'other_test.db'))
+  end
+  
+  def test_key_range
+    10.times { |i| @db.put(nil, i.to_s, 'data', 0) }
+    @db.key_range(nil, '2', 0)
+  end
+  
+  def test_rename
+    @db1 = Bdb::Db.new
+    @db1.open(nil, File.join(File.dirname(__FILE__), 'tmp', 'other_test.db'), nil, Bdb::Db::BTREE, Bdb::DB_CREATE, 0)
+    @db1.close(0)
+    assert Bdb::Db.new.rename(File.join(File.dirname(__FILE__), 'tmp', 'other_test.db'), nil, File.join(File.dirname(__FILE__), 'tmp', 'other2_test.db'), 0)
+    assert File.exists?(File.join(File.dirname(__FILE__), 'tmp', 'other2_test.db'))
+  end
+  
+  def test_pagesize_get_and_set
+    @db1 = Bdb::Db.new
+    @db1.pagesize = 1024
+    assert_equal 1024, @db1.pagesize
+  end
+  
+  def test_h_ffactor_get_and_set
+    @db1 = Bdb::Db.new
+    @db1.h_ffactor = 5
+    assert_equal 5, @db1.h_ffactor
+  end
+  
+  def test_h_nelem_get_and_set
+    @db1 = Bdb::Db.new
+    @db1.h_nelem = 10_000
+    assert_equal 10_000, @db1.h_nelem
+  end
+  
+  def test_sync
+    assert @db.sync
+  end
+  
+  def test_truncate
+    @db.put(nil, 'key', 'data', 0)
+    result = @db.get(nil, 'key', nil, 0)
+    assert_equal 'data', result
+    @db.truncate(nil)
+    result = @db.get(nil, 'key', nil, 0)
+    assert_nil result    
+  end
+  
+  def test_compact
+    assert @db.compact(nil, nil, nil, nil, 0)
+  end  
+  
+end