ninjudd-bdb 0.0.2

data/ext/bdb.h

@@ -0,0 +1,104 @@
+
+#ifndef BDB2_H
+#define BDB2_H
+
+#include <ruby.h>
+
+#ifdef stat
+  #undef stat
+#endif
+
+#ifdef close
+  #undef close
+#endif
+
+#ifdef rename
+  #undef rename
+#endif
+
+#include <version.h>
+#include <db.h>
+
+#define NOTXN NULL
+
+#ifdef OPEN_MAX
+#define LMAXFD OPEN_MAX
+#else
+#ifdef FOPEN_MAX
+#define LMAXFD FOPEN_MAX
+#endif
+#endif
+#ifndef LMAXFD
+#error "No max fd define available."
+#endif
+
+#define FNLEN 40
+
+#define filename_copy(fp,fv) \
+  strncpy(fp,RSTRING_PTR(fv),FNLEN);
+
+#define filename_dup(fpd,fps) \
+  strncpy(fpd,fps,FNLEN);
+
+typedef struct s_envh {
+  VALUE self;
+  DB_ENV *env;
+  VALUE adb; /* Ruby array holding opened databases */
+  VALUE atxn; /* Ruby array holding open transactions */
+} t_envh;
+
+typedef struct s_dbh {
+  VALUE self;
+  DB *db;
+	int db_opened;
+  VALUE aproc;
+  VALUE sproc; /* key sorting callback */
+  
+  t_envh *env; /* Parent environment, NULL if not opened from one */
+  VALUE adbc; /* Ruby array holding opened cursor */
+  char filename[FNLEN+1];
+} t_dbh;
+
+typedef struct s_dbch {
+  VALUE self;
+  DBC *dbc;
+  t_dbh *db;
+  char filename[FNLEN+1];
+} t_dbch;
+
+typedef struct s_txnh {
+  VALUE self;
+  DB_TXN *txn;
+  t_envh *env;
+} t_txnh;
+
+#define cu(b,m) \
+  rb_define_const(b,#m,UINT2NUM(m))
+
+#define ci(b,m) \
+  rb_define_const(b,#m,INT2NUM(m))
+
+#define cs(b,m) \
+  rb_define_const(b,#m,rb_str_new2(m))
+
+#define simple_set(fname) \
+VALUE db_ ## fname ## _eq(VALUE obj, VALUE v) \
+{ \
+  rb_ivar_set(obj,fv_ ## fname,v); \
+  return obj; \
+} 
+
+#define attr_writer(fname) \
+  VALUE fname ## _writer(VALUE obj, VALUE v) \
+  {					     \
+    rb_ivar_set(obj,fv_ ## fname,v); \
+    return obj; \
+  }
+
+#define attr_reader(fname) \
+  VALUE fname ## _reader(VALUE obj) \
+  { \
+    return rb_ivar_get(obj,fv_ ## fname);  \
+  }
+
+#endif

data/ext/extconf.rb

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+require 'mkmf'
+
+inc, lib = dir_config('db')
+
+# OS X compatibility
+if(PLATFORM =~ /darwin/) then
+	# test if Bdb is probably universal
+	
+	filetype = (IO.popen("file #{inc}/../db_dump").readline.chomp rescue nil)
+	# if it's not universal, ARCHFLAGS should be set
+	if((filetype !~ /universal binary/) && ENV['ARCHFLAGS'].nil?) then
+		arch = (IO.popen("uname -m").readline.chomp rescue nil)
+		$stderr.write %{
+===========   WARNING   ===========
+
+You are building this extension on OS X without setting the 
+ARCHFLAGS environment variable, and BerkeleyDB does not appear 
+to have been built as a universal binary. If you are seeing this 
+message, that means that the build will probably fail.
+
+Try setting the environment variable ARCHFLAGS 
+to '-arch #{arch}' before building.
+
+For example:
+(in bash) $ export ARCHFLAGS='-arch #{arch}'
+(in tcsh) % setenv ARCHFLAGS '-arch #{arch}'
+
+Then try building again.
+
+===================================
+
+}
+		# We don't exit here. Who knows? It might build.
+	end
+end
+
+versions=%w(db-4.7 db-4.6 db-4.5 db-4.4 db-4.3 db-4.2)
+until versions.empty?
+  (lib_ok = have_library(versions.shift,'db_version', 'db.h')) && break
+end
+
+def create_header
+  if File.exist?("bdb_aux._c")
+    message("Not writing bdb_aux._c (defines), already exists\n")
+    return
+  end
+  
+  message("Writing bdb_aux._c (defines), this takes a while\n")
+  db_header = $CPPFLAGS.split.select { |f| f =~ /^-I/ }.map { |e| 
+    f = File.join(e[2..-1], 'db.h')
+    File.exists?(f) ? f : nil
+  }.select { |e| e }.first
+  
+  n=0
+  defines=[]
+  File.open(db_header) {|fd|
+    File.open("bdb_aux._c","w") {|hd|
+      hd.puts("/* This file automatically generated by extconf.rb */\n")
+      fd.each_line {|l|
+        if l =~ %r{^#define\s+(DBC?_\w*)\s+([^\/]*)\s*(.*?)(\/\*.*)?$}
+          name = $1
+          value = $2
+          if macro_defined?(name,"#include <db.h>")
+            case value
+            when /^"/
+              hd.print(%Q{cs(mBdb,%s);\n}%[name])
+            when /^\(?(0x|\d)/
+              hd.print(%Q{cu(mBdb,%s);\n}%[name])
+            when /^\(?-/
+              hd.print(%Q{ci(mBdb,%s);\n}%[name])
+            else
+              $stderr.puts "don't know how to handle #{name} #{value.strip}, guessing UINT"
+              hd.print(%Q{cu(mBdb,%s);\n}%[name])
+            end
+            n+=1
+          end
+        end
+      }
+    }
+    message("\nwrote #{n} defines\n")
+  }
+end
+
+if lib_ok
+  create_header
+  create_makefile('bdb')
+else
+  $stderr.puts("cannot create Makefile")
+  exit 1
+end

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