oklahoma_mixer 0.2.0 → 0.3.0

data/lib/oklahoma_mixer/table_database/c.rb

@@ -0,0 +1,104 @@
+require "oklahoma_mixer/utilities"
+
+module OklahomaMixer
+  class TableDatabase < HashDatabase
+    module C  # :nodoc:
+      extend OklahomaMixer::Utilities::FFIDSL
+      
+      prefix :tctdb
+
+      const :OPTS, %w[TLARGE TDEFLATE TBZIP TTCBS]
+      INDEXES  = enum :TDBITLEXICAL,  0,
+                      :TDBITDECIMAL,  1,
+                      :TDBITTOKEN,    2,
+                      :TDBITQGRAM,    3,
+                      :TDBITOPT,      9998,
+                      :TDBITVOID,     9999,
+                      :TDBITKEEP,     1 << 24
+      FLAGS    = enum :TDBQPPUT,      1 << 0,
+                      :TDBQPOUT,      1 << 1,
+                      :TDBQPSTOP,     1 << 24
+      SEARCHES = enum :TDBMSUNION, 0,
+                      :TDBMSISECT, 1,
+                      :TDBMSDIFF,  2
+      
+      
+      def_core_database_consts_and_funcs
+      
+      func :name    => :tune,
+           :args    => [:pointer, :int64, :int8, :int8, OPTS],
+           :returns => :bool
+      func :name    => :setcache,
+           :args    => [:pointer, :int32, :int32, :int32],
+           :returns => :bool
+      func :name    => :setxmsiz,
+           :args    => [:pointer, :int64],
+           :returns => :bool
+      func :name    => :setdfunit,
+           :args    => [:pointer, :int32],
+           :returns => :bool
+      func :name    => :optimize,
+           :args    => [:pointer, :int64, :int8, :int8, OPTS],
+           :returns => :bool
+      
+      func :name    => :put,
+           :args    => [:pointer, :pointer, :int, :pointer],
+           :returns => :bool
+      func :name    => :putkeep,
+           :args    => [:pointer, :pointer, :int, :pointer],
+           :returns => :bool
+      func :name    => :putcat,
+           :args    => [:pointer, :pointer, :int, :pointer],
+           :returns => :bool
+      call :name    => :TCPDPROC,
+           :args    => [:pointer, :int, :pointer, :pointer],
+           :returns => :pointer
+      func :name    => :putproc,
+           :args    => [:pointer, :pointer, :int, :pointer, :int, :TCPDPROC,
+                        :pointer],
+           :returns => :bool
+      func :name    => :addint,
+           :args    => [:pointer, :pointer, :int, :int],
+           :returns => :int
+      func :name    => :adddouble,
+           :args    => [:pointer, :pointer, :int, :double],
+           :returns => :double
+      func :name    => :out,
+           :args    => [:pointer, :pointer, :int],
+           :returns => :bool
+      func :name    => :get,
+           :args    => [:pointer, :pointer, :int],
+           :returns => :pointer
+      func :name    => :fwmkeys,
+           :args    => [:pointer, :pointer, :int, :int],
+           :returns => :pointer
+      func :name    => :genuid,
+           :args    => :pointer,
+           :returns => :int64
+      
+      func :name    => :iterinit,
+           :args    => :pointer,
+           :returns => :bool
+      func :name    => :iternext,
+           :args    => [:pointer, :pointer],
+           :returns => :pointer
+      func :name    => :iternext3,
+           :args    => :pointer,
+           :returns => :pointer
+
+      func :name    => :setindex,
+           :args    => [:pointer, :string, INDEXES],
+           :returns => :bool
+
+      call :name    => :TDBQRYPROC,
+           :args    => [:pointer, :int, :pointer, :pointer],
+           :returns => :int
+      func :name    => :qryproc,
+           :args    => [:pointer, :TDBQRYPROC, :pointer],
+           :returns => :bool
+      func :name    => :metasearch,
+           :args    => [:pointer, :int, SEARCHES],
+           :returns => :pointer
+    end
+  end
+end

data/lib/oklahoma_mixer/utilities.rb

@@ -1,3 +1,5 @@
+require "ffi"
+
 module OklahomaMixer
   module Utilities  # :nodoc:
     module FFIDSL   # :nodoc:
@@ -38,13 +40,15 @@ module OklahomaMixer
       end
       
       def read_from_func(func, *args)
+        no_free = args.shift if args.first.is_a?(Symbol) and
+                                args.first == :no_free
         Utilities.temp_int do |size|
           begin
             args    << size
             pointer =  send(func, *args)
             pointer.address.zero? ? nil : pointer.get_bytes(0, size.get_int(0))
           ensure
-            Utilities.free(pointer) if pointer
+            Utilities.free(pointer) if pointer and not no_free
           end
         end
       end
@@ -166,6 +170,13 @@ module OklahomaMixer
     end
     INT_MIN = int_min && int_min.to_i
     
+    def self.temp_pointer(size)
+      pointer = FFI::MemoryPointer.new(:pointer, size)
+      yield pointer
+    ensure
+      pointer.free if pointer
+    end
+    
     def self.temp_int
       int = FFI::MemoryPointer.new(:int)
       yield int
@@ -179,6 +190,20 @@ module OklahomaMixer
     ensure
       xstr.free if xstr
     end
+
+    def self.temp_list(size)
+      list = ArrayList.new(size)
+      yield list
+    ensure
+      list.free if list
+    end
+
+    def self.temp_map
+      map = HashMap.new
+      yield map
+    ensure
+      map.free if map
+    end
     
     extend FFIDSL
     

data/test/{b_tree_binary_data_test.rb → b_tree_database/b_tree_binary_data_test.rb}

@@ -1,5 +1,5 @@
 require "test_helper"
-require "shared_binary_data"
+require "shared/binary_data_tests"
 
 class TestBTreeBinaryData < Test::Unit::TestCase
   def setup
@@ -15,7 +15,7 @@ class TestBTreeBinaryData < Test::Unit::TestCase
     remove_db_files
   end
   
-  include SharedBinaryData
+  include BinaryDataTests
 
   def test_null_bytes_are_preserved_during_value_iteration
     @db.each_value do |value|

data/test/{b_tree_tuning_test.rb → b_tree_database/b_tree_tuning_test.rb}

@@ -1,12 +1,12 @@
 require "test_helper"
-require "shared_tuning"
+require "shared/tuning_tests"
 
 class TestBTreeTuning < Test::Unit::TestCase
   def teardown
     remove_db_files
   end
   
-  include SharedTuning
+  include TuningTests
   
   def test_leaf_members_can_be_set_with_other_tuning_defaults
     members = rand(1_000) + 1

data/test/{cursor_based_iteration_test.rb → b_tree_database/cursor_based_iteration_test.rb}

@@ -1,5 +1,5 @@
 require "test_helper"
-require "shared_iteration"
+require "shared/iteration_tests"
 
 class TestCursorBasedIteration < Test::Unit::TestCase
   def setup
@@ -16,7 +16,7 @@ class TestCursorBasedIteration < Test::Unit::TestCase
     remove_db_files
   end
   
-  include SharedIteration
+  include IterationTests
   
   def test_each_key_can_begin_iteration_at_a_passed_key
     @db.each_key("b") do |key|

data/test/{duplicate_storage_test.rb → b_tree_database/duplicate_storage_test.rb}

@@ -11,9 +11,15 @@ class TestDuplicateStorage < Test::Unit::TestCase
   end
   
   def test_duplicates_can_be_stored
-    assert(@db.store("Gray", "Dana",  :dup), "Failed to store initial value")
-    assert(@db.store("Gray", "James", :dup), "Failed to store duplicate value")
-    assert_equal("Dana", @db["Gray"])  # always returns the first
+    assert_equal("Dana",  @db.store("Gray", "Dana",  :dup))
+    assert_equal("James", @db.store("Gray", "James",  :dup))
+    assert_equal("Dana",  @db["Gray"])  # always returns the first
+  end
+  
+  def test_multiple_duplicates_can_be_stored_at_once
+    assert_equal(%w[a b c], @db.store(:letters, %w[a b c], :dup))
+    assert_equal("a",       @db[:letters])
+    assert_equal(%w[a b c], @db.values(:letters))
   end
   
   def test_keys_are_a_unique_listing_not_showing_duplicates
@@ -27,9 +33,9 @@ class TestDuplicateStorage < Test::Unit::TestCase
     @db[:other] = "one record"
     assert_equal(["one record"], @db.values)
     assert_equal([ ],            @db.values("Gray"))
-    assert(@db.store("Gray", "Dana", :dup), "Failed to store initial value")
-    assert_equal(%w[Dana], @db.values("Gray"))
-    assert(@db.store("Gray", "James", :dup), "Failed to store duplicate value")
+    assert_equal("Dana",         @db.store("Gray", "Dana",  :dup))
+    assert_equal(%w[Dana],       @db.values("Gray"))
+    assert_equal("James",        @db.store("Gray", "James",  :dup))
     assert_equal(%w[Dana James], @db.values("Gray"))
   end
   
@@ -57,12 +63,12 @@ class TestDuplicateStorage < Test::Unit::TestCase
   
   def test_size_can_be_scoped_to_a_key_to_retrieve_all_duplicates
     @db[:other] = "one record"
-    assert_equal(1, @db.size)
-    assert_equal(0, @db.size("Gray"))
-    assert(@db.store("Gray", "Dana", :dup), "Failed to store initial value")
-    assert_equal(1, @db.size("Gray"))
-    assert(@db.store("Gray", "James", :dup), "Failed to store duplicate value")
-    assert_equal(2, @db.size("Gray"))
+    assert_equal(1,       @db.size)
+    assert_equal(0,       @db.size("Gray"))
+    assert_equal("Dana",  @db.store("Gray", "Dana",  :dup))
+    assert_equal(1,       @db.size("Gray"))
+    assert_equal("James", @db.store("Gray", "James",  :dup))
+    assert_equal(2,       @db.size("Gray"))
   end
   
   def test_duplicates_show_up_in_cursor_based_iteration_of_keys

data/test/{binary_data_test.rb → core_database/binary_data_test.rb}

@@ -1,5 +1,5 @@
 require "test_helper"
-require "shared_binary_data"
+require "shared/binary_data_tests"
 
 class TestBinaryData < Test::Unit::TestCase
   def setup
@@ -14,7 +14,7 @@ class TestBinaryData < Test::Unit::TestCase
     remove_db_files
   end
   
-  include SharedBinaryData
+  include BinaryDataTests
   
   def test_keys_and_values_can_be_read_with_null_bytes
     assert_equal(@value, @db[@key])

data/test/{getting_and_setting_keys_test.rb → core_database/getting_and_setting_keys_test.rb}

@@ -1,4 +1,5 @@
 require "test_helper"
+require "shared/storage_tests"
 
 class TestGettingAndSettingKeys < Test::Unit::TestCase
   def setup
@@ -10,6 +11,8 @@ class TestGettingAndSettingKeys < Test::Unit::TestCase
     remove_db_files
   end
 
+  include StorageTests
+
   def test_a_key_value_pair_can_be_stored_and_fetched_from_the_database
     assert_equal("value", @db.store("key", "value"))
     assert_equal("value", @db.fetch("key"))  # later
@@ -20,27 +23,6 @@ class TestGettingAndSettingKeys < Test::Unit::TestCase
     assert_equal("42", @db.fetch("num"))  # effectively the same key
   end
   
-  def test_fetching_a_missing_value_fails_with_an_index_error
-    assert_raise(IndexError) do
-      @db.fetch(:missing)
-    end
-  end
-  
-  def test_fetch_can_return_a_default_for_a_missing_value
-    assert_equal(42, @db.fetch(:missing, 42))
-  end
-  
-  def test_fetch_can_run_a_block_returning_its_result_for_a_missing_value
-    assert_equal(:missing, @db.fetch(:missing) { |key| key })
-  end
-  
-  def test_fetching_with_a_block_overrides_a_default_and_triggers_a_warning
-    warning = capture_stderr do
-      assert_equal(42, @db.fetch(:missing, 13) { 42 })
-    end
-    assert(!warning.empty?, "A warning was not issued for a default and block")
-  end
-  
   def test_storing_with_keep_mode_adds_a_value_only_if_it_didnt_already_exist
     assert(@db.store(:key, :new, :keep), "Failed to store a new key")
     assert_equal("new", @db.fetch(:key))
@@ -117,9 +99,28 @@ class TestGettingAndSettingKeys < Test::Unit::TestCase
       warning = capture_stderr do
         assert_equal(:value, db.store(:key, :value, :async))  # normal store
       end
-      assert(!warning.empty?, "A warning was not issued for an unsupported mode")
+      assert( !warning.empty?,
+              "A warning was not issued for an unsupported mode" )
       assert_equal("value", db[:key])
     end
+    
+    fdb do |db|
+      warning = capture_stderr do
+        assert_equal(:value, db.store(1, :value, :async))  # normal store
+      end
+      assert( !warning.empty?,
+              "A warning was not issued for an unsupported mode" )
+      assert_equal("value", db[1])
+    end
+    
+    tdb do |db|
+      warning = capture_stderr do
+        assert_equal({ }, db.store(:key, { }, :async))  # normal store
+      end
+      assert( !warning.empty?,
+              "A warning was not issued for an unsupported mode" )
+      assert_equal({ }, db[:key])
+    end
   end
   
   def test_store_and_fetch_can_also_be_used_through_the_indexing_brackets
@@ -127,36 +128,6 @@ class TestGettingAndSettingKeys < Test::Unit::TestCase
     assert_equal("42", @db[:num])
   end
   
-  def test_indexing_returns_nil_instead_of_failing_with_index_error
-    assert_nil(@db[:missing])
-  end
-  
-  def test_a_default_can_be_set_for_indexing_to_return
-    @db.default = 42
-    assert_equal(42, @db[:missing])
-  end
-  
-  def test_the_indexing_default_will_be_run_if_it_is_a_proc
-    @db.default = lambda { |key| "is #{key}" }
-    assert_equal("is missing", @db[:missing])
-  end
-  
-  def test_the_indexing_default_for_a_given_key_can_be_retrieved
-    @db.default = lambda { |key| "is #{key}" }
-    assert_equal("is ",        @db.default)
-    assert_equal("is missing", @db.default(:missing))
-  end
-  
-  def test_the_indexing_default_can_be_changed
-    assert_nil(@db[:missing])
-    assert_equal(42, @db.default = 42)
-    assert_equal(42, @db[:missing])
-    proc = lambda { |key| fail RuntimeError, "%p not found" % [key]}
-    assert_equal(proc, @db.default = proc)
-    error = assert_raise(RuntimeError) { @db[:missing] }
-    assert_equal(":missing not found", error.message)
-  end
-  
   def test_include_and_aliases_can_be_used_to_check_for_the_existance_of_a_key
     @db[:exist] = true
     %w[include? has_key? key? member?].each do |query|
@@ -228,14 +199,6 @@ class TestGettingAndSettingKeys < Test::Unit::TestCase
     assert_nil(@db[:key])
   end
   
-  def test_delete_returns_nil_for_a_missing_key
-    assert_nil(@db.delete(:missing))
-  end
-  
-  def test_delete_can_be_passed_a_block_to_handle_missing_keys
-    assert_equal(42, @db.delete(:missing) { 42 })
-  end
-  
   def test_clear_removes_all_keys_from_the_database
     @db.update(:a => 1, :b => 2, :c => 3)
     assert_equal(@db, @db.clear)
@@ -249,4 +212,12 @@ class TestGettingAndSettingKeys < Test::Unit::TestCase
     assert_equal(3, @db.size)
     assert_equal(3, @db.length)
   end
+  
+  def test_empty_returns_true_while_no_pairs_are_in_the_database
+    assert(@db.empty?, "An empty database was not detected")
+    @db[:key] = :value
+    assert(!@db.empty?, "A non-empty database was reported empty")
+    @db.delete(:key)
+    assert(@db.empty?, "An empty database was not detected")
+  end
 end

data/test/{iteration_test.rb → core_database/iteration_test.rb}

@@ -1,5 +1,5 @@
 require "test_helper"
-require "shared_iteration"
+require "shared/iteration_tests"
 
 class TestIteration < Test::Unit::TestCase
   def setup
@@ -16,5 +16,5 @@ class TestIteration < Test::Unit::TestCase
     remove_db_files
   end
   
-  include SharedIteration
+  include IterationTests
 end

data/test/core_database/tuning_test.rb

@@ -0,0 +1,31 @@
+require "test_helper"
+require "shared/hash_tuning_tests"
+
+class TestTuning < Test::Unit::TestCase
+  def teardown
+    remove_db_files
+  end
+  
+  include HashTuningTests
+  
+  def test_limit_for_cached_records_can_be_set
+    limit = rand(1_000) + 1
+    assert_option_calls([:setcache, limit], :rcnum => limit)
+  end
+  
+  def test_limit_for_cached_records_is_converted_to_an_int
+    assert_option_calls([:setcache, 42], :rcnum => "42")
+  end
+  
+  #######
+  private
+  #######
+  
+  def lib
+    OKMixer::HashDatabase::C
+  end
+  
+  def db(*args, &block)
+    hdb(*args, &block)
+  end
+end