linkage 0.0.8 → 0.1.0.pre

data/test/integration/test_database_result_set.rb

@@ -0,0 +1,55 @@
+require 'helper'
+
+class IntegrationTests::TestDatabaseResultSet < Test::Unit::TestCase
+  def setup
+    @dir = Dir.mktmpdir('linkage')
+    @data_uri = "sqlite://" + File.join(@dir, "foo")
+    @results_uri = "sqlite://" + File.join(@dir, "bar")
+  end
+
+  def teardown
+    FileUtils.remove_entry_secure(@dir)
+  end
+
+  def data_database(options = {}, &block)
+    Sequel.connect(@data_uri, options, &block)
+  end
+
+  def results_database(options = {}, &block)
+    Sequel.connect(@results_uri, options, &block)
+  end
+
+  test "using a database for storing results" do
+    data_database do |db|
+      db.create_table(:foo) { primary_key(:id); Integer(:foo); Integer(:bar) }
+      db[:foo].import([:id, :foo, :bar], Array.new(10) { |i| [i, i, i] })
+    end
+
+    ds = Linkage::Dataset.new(@data_uri, 'foo')
+    result_set = Linkage::ResultSet['database'].new(@results_uri)
+    conf = ds.link_with(ds, result_set) do |conf|
+      conf.compare([:foo], [:bar], :equal)
+      conf.algorithm = :mean
+      conf.threshold = 1
+    end
+    runner = Linkage::Runner.new(conf)
+    runner.execute
+
+    results_database do |db|
+      assert db.table_exists?(:scores)
+      assert_equal 10, db[:scores].count
+      db[:scores].order(:id_1, :id_2).each do |row|
+        assert_equal row[:id_1], row[:id_2]
+        assert_equal 1, row[:comparator_id]
+        assert_same 1.0, row[:score]
+      end
+
+      assert db.table_exists?(:matches)
+      assert_equal 10, db[:matches].count
+      db[:matches].order(:id_1, :id_2).each do |row|
+        assert_equal row[:id_1], row[:id_2]
+        assert_same 1.0, row[:score]
+      end
+    end
+  end
+end

data/test/integration/test_dual_linkage.rb

@@ -15,7 +15,7 @@ module IntegrationTests
       FileUtils.remove_entry_secure(@tmpdir)
     end
 
-    test "one mandatory field equality on single threaded runner" do
+    test "one-field equality on single threaded runner" do
       # create the test data
       database do |db|
         db.create_table(:foo) { primary_key(:id); String(:ssn) }
@@ -27,108 +27,33 @@ module IntegrationTests
           Array.new(100) { |i| [i, "12345678#{i%10}"] })
       end
 
+      result_set = Linkage::ResultSet['csv'].new(@tmpdir)
       ds_1 = Linkage::Dataset.new(@tmpuri, "foo", :single_threaded => true)
       ds_2 = Linkage::Dataset.new(@tmpuri, "bar", :single_threaded => true)
       tmpuri = @tmpuri
-      conf = ds_1.link_with(ds_2) do
-        lhs[:ssn].must == rhs[:ssn]
-        save_results_in(tmpuri)
+      conf = ds_1.link_with(ds_2, result_set) do |conf|
+        conf.compare([:ssn], [:ssn], :equal)
+        conf.algorithm = :mean
+        conf.threshold = 1.0
       end
-      assert_equal :dual, conf.linkage_type
 
-      runner = Linkage::SingleThreadedRunner.new(conf)
+      runner = Linkage::Runner.new(conf)
       runner.execute
 
-      database do |db|
-        assert_equal 10, db[:groups].count
-        db[:groups].order(:ssn).each_with_index do |row, i|
-          assert_equal "12345678#{i%10}", row[:ssn]
-        end
-
-        assert_equal 1000, db[:matches].count
-        db[:matches].order(:record_1_id, :record_2_id).each do |row|
-          assert_equal row[:record_1_id] % 10, row[:record_2_id] % 10
-        end
+      score_csv = CSV.read(File.join(@tmpdir, 'scores.csv'), :headers => true)
+      assert_equal 1000, score_csv.length
+      score_csv.each do |row|
+        id_1 = row['id_1'].to_i
+        id_2 = row['id_2'].to_i
+        assert (id_1 % 10) == (id_2 % 10)
       end
-    end
 
-    test "don't ignore 1-record groups before the combining phase" do
-      # create the test data
-      database do |db|
-        db.create_table(:foo) { primary_key(:id); String(:ssn) }
-        db[:foo].import([:id, :ssn],
-          Array.new(100) { |i| [i, "1234567%03d" % i] })
-
-        db.create_table(:bar) { primary_key(:id); String(:ssn) }
-        db[:bar].import([:id, :ssn],
-          Array.new(100) { |i| [i, "1234567%03d" % i] })
-      end
-
-      ds_1 = Linkage::Dataset.new(@tmpuri, "foo", :single_threaded => true)
-      ds_2 = Linkage::Dataset.new(@tmpuri, "bar", :single_threaded => true)
-      tmpuri = @tmpuri
-      conf = ds_1.link_with(ds_2) do
-        lhs[:ssn].must == rhs[:ssn]
-        save_results_in(tmpuri)
-      end
-      runner = Linkage::SingleThreadedRunner.new(conf)
-      runner.execute
-
-      database do |db|
-        assert_equal 100, db[:groups].count
-        db[:groups].order(:ssn).each_with_index do |row, i|
-          assert_equal "1234567%03d" % i, row[:ssn]
-        end
-      end
-    end
-
-    test "reacts properly when using two databases with different string equality methods" do
-      foo_logger = nil #prefixed_logger("FOO")
-      bar_logger = nil #prefixed_logger("BAR")
-
-      database_for('mysql', :logger => foo_logger) do |db|
-        db.create_table!(:foo) do
-          primary_key(:id)
-          String :baz, :collate => "latin1_swedish_ci"
-        end
-        db[:foo].import([:id, :baz], [
-          [1, "tEst"],
-          [2, "teSt"],
-          [3, "tesT "],
-          [4, "TEST"],
-          [5, "junk"]
-        ])
-      end
-
-      database_for('mysql', :logger => bar_logger) do |db|
-        db.create_table!(:bar) do
-          primary_key(:id)
-          String :baz, :collate => "latin1_swedish_ci"
-        end
-        db[:bar].import([:id, :baz], [
-          [1, "Test  "],
-          [2, "tEst "],
-          [3, "teSt"],
-          [4, "TEST"],
-          [5, "junk"]
-        ])
-      end
-
-      options = database_options_for('mysql')
-      ds_1 = Linkage::Dataset.new(options, "foo", :logger => foo_logger)
-      ds_2 = Linkage::Dataset.new(options, "bar", :logger => bar_logger)
-      tmpuri = @tmpuri
-      results_logger = nil #prefixed_logger("RESULTS")
-      conf = ds_1.link_with(ds_2) do
-        lhs[:baz].must == rhs[:baz]
-        save_results_in(tmpuri, :logger => results_logger)
-      end
-
-      runner = Linkage::SingleThreadedRunner.new(conf)
-      runner.execute
-
-      database do |db|
-        assert_equal 2, db[:groups].count
+      match_csv = CSV.read(File.join(@tmpdir, 'matches.csv'), :headers => true)
+      assert_equal 1000, match_csv.length
+      match_csv.each do |row|
+        id_1 = row['id_1'].to_i
+        id_2 = row['id_2'].to_i
+        assert (id_1 % 10) == (id_2 % 10)
       end
     end
   end

data/test/integration/test_self_linkage.rb

@@ -1,224 +1,121 @@
 require 'helper'
 
-module IntegrationTests
-  class TestSelfLinkage < Test::Unit::TestCase
-    def setup
-      @tmpdir = Dir.mktmpdir('linkage')
-      @tmpuri = "sqlite://" + File.join(@tmpdir, "foo")
+class IntegrationTests::TestSelfLinkage < Test::Unit::TestCase
+  def setup
+    @tmpdir = Dir.mktmpdir('linkage')
+    @tmpuri = "sqlite://" + File.join(@tmpdir, "foo")
+  end
+
+  def database(&block)
+    Sequel.connect(@tmpuri, &block)
+  end
+
+  def teardown
+    FileUtils.remove_entry_secure(@tmpdir)
+  end
+
+  test "one-field equality" do
+    # insert the test data
+    database do |db|
+      db.create_table(:foo) { primary_key(:id); String(:ssn) }
+      db[:foo].import([:id, :ssn],
+        Array.new(100) { |i| [i, "12345678#{i%10}"] })
     end
 
-    def database(&block)
-      Sequel.connect(@tmpuri, &block)
+    result_set = Linkage::ResultSet['csv'].new(@tmpdir)
+    dataset = Linkage::Dataset.new(@tmpuri, "foo", :single_threaded => true)
+    conf = dataset.link_with(dataset, result_set) do |conf|
+      conf.compare([:ssn], [:ssn], :equal)
+      conf.algorithm = :mean
+      conf.threshold = 1.0
     end
 
-    def teardown
-      FileUtils.remove_entry_secure(@tmpdir)
+    runner = Linkage::Runner.new(conf)
+    runner.execute
+
+    score_csv = CSV.read(File.join(@tmpdir, 'scores.csv'), :headers => true)
+    assert_equal 450, score_csv.length
+    score_csv.each do |row|
+      assert_equal row['id_1'].to_i % 10, row['id_2'].to_i % 10
     end
 
-    test "one mandatory field equality on single threaded runner" do
-      # insert the test data
-      database do |db|
-        db.create_table(:foo) { primary_key(:id); String(:ssn) }
-        db[:foo].import([:id, :ssn],
-          Array.new(100) { |i| [i, "12345678#{i%10}"] })
-      end
-
-      ds = Linkage::Dataset.new(@tmpuri, "foo", :single_threaded => true)
-      tmpuri = @tmpuri
-      conf = ds.link_with(ds) do
-        lhs[:ssn].must == rhs[:ssn]
-        save_results_in(tmpuri)
-      end
-      runner = Linkage::SingleThreadedRunner.new(conf)
-      result_set = runner.execute
-      assert_kind_of Linkage::ResultSet, result_set
-
-      database do |db|
-        assert_equal 10, db[:groups].count
-        db[:groups].order(:ssn).each_with_index do |row, i|
-          assert_equal "12345678#{i%10}", row[:ssn]
-
-          group = Linkage::Group.from_row(row)
-          dataset, _ = result_set.groups_records_datasets(group)
-          assert_equal 10, dataset.count
-        end
-
-        assert_equal 450, db[:matches].count
-        db[:matches].order(:record_1_id, :record_2_id).each do |row|
-          assert_equal row[:record_1_id] % 10, row[:record_2_id] % 10
-        end
-      end
+    match_csv = CSV.read(File.join(@tmpdir, 'matches.csv'), :headers => true)
+    assert_equal 450, match_csv.length
+    match_csv.each do |row|
+      assert_equal row['id_1'].to_i % 10, row['id_2'].to_i % 10
     end
+  end
 
-    test "two mandatory field equalities on single threaded runner" do
-      # insert the test data
-      database do |db|
-        db.create_table(:foo) { primary_key(:id); String(:ssn); Date(:dob) }
-        db[:foo].import([:id, :ssn, :dob],
-          Array.new(100) { |i| [i, "12345678#{i%10}", Date.civil(1985, 1, (i % 20) + 1)] })
-      end
-
-      ds = Linkage::Dataset.new(@tmpuri, "foo", :single_threaded => true)
-      tmpuri = @tmpuri
-      conf = ds.link_with(ds) do
-        lhs[:ssn].must == rhs[:ssn]
-        lhs[:dob].must == rhs[:dob]
-        save_results_in(tmpuri)
-      end
-      runner = Linkage::SingleThreadedRunner.new(conf)
-      runner.execute
-
-      database do |db|
-        assert_equal 20, db[:groups].count
-        db[:groups].order(:ssn).each_with_index do |row, i|
-          assert_equal "12345678#{i/2}", row[:ssn]
-          assert_equal Date.civil(1985, 1, i / 2 + 1 + (i % 2 == 0 ? 0 : 10)), row[:dob]
-        end
-
-        #assert_equal 100, db[:groups_records].count
-        #expected_group_id = nil
-        #db[:groups_records].order(:record_id).each do |row|
-          #v = row[:record_id] % 20
-          #expected_group_id = v < 10 ? 1 + 2 * v : 2 * (v % 10 + 1)
-          #assert_equal expected_group_id, row[:group_id], "Record #{row[:record_id]} should have been in group #{expected_group_id}"
-        #end
-      end
+  test "two-field equality" do
+    # insert the test data
+    database do |db|
+      db.create_table(:foo) { primary_key(:id); String(:ssn); Date(:dob) }
+      db[:foo].import([:id, :ssn, :dob],
+        Array.new(100) { |i| [i, "12345678#{i%10}", Date.civil(1985, 1, (i % 20) + 1)] })
     end
 
-    test "one mandatory field equality on single threaded runner, with filter" do
-      # insert the test data
-      database do |db|
-        db.create_table(:foo) { primary_key(:id); String(:ssn); Integer(:mod_5) }
-        db[:foo].import([:id, :ssn, :mod_5],
-          Array.new(100) { |i| [i, "12345678#{i%10}", i % 5] })
-      end
-
-      ds = Linkage::Dataset.new(@tmpuri, "foo", :single_threaded => true)
-      tmpuri = @tmpuri
-      conf = ds.link_with(ds) do
-        lhs[:ssn].must == rhs[:ssn]
-        lhs[:mod_5].must == 3
-        save_results_in(tmpuri)
-      end
-      runner = Linkage::SingleThreadedRunner.new(conf)
-      runner.execute
-
-      database do |db|
-        assert_equal 2, db[:groups].count
-        db[:groups].order(:ssn).each_with_index do |row, i|
-          assert_equal "12345678#{(i * 5) + 3}", row[:ssn]
-        end
-
-        #assert_equal 20, db[:groups_records].count
-        #expected_group_id = nil
-        #db[:groups_records].order(:record_id).each do |row|
-          #expected_group_id = (row[:record_id] / 5) % 2 + 1
-          #assert_equal expected_group_id, row[:group_id], "Record #{row[:record_id]} should have been in group #{expected_group_id}"
-        #end
-      end
+    result_set = Linkage::ResultSet['csv'].new(@tmpdir)
+    dataset = Linkage::Dataset.new(@tmpuri, "foo", :single_threaded => true)
+    conf = dataset.link_with(dataset, result_set) do |conf|
+      conf.compare([:ssn, :dob], [:ssn, :dob], :equal)
     end
 
-    test "one mandatory field equality on single threaded runner, with inequality filters" do
-      # insert the test data
-      database do |db|
-        db.create_table(:foo) { primary_key(:id); String(:ssn); Integer(:mod_5) }
-        db[:foo].import([:id, :ssn, :mod_5],
-          Array.new(100) { |i| [i, "12345678#{i%10}", i % 5] })
-      end
-
-      ds = Linkage::Dataset.new(@tmpuri, "foo", :single_threaded => true)
-      tmpuri = @tmpuri
-      conf = ds.link_with(ds) do
-        lhs[:ssn].must == rhs[:ssn]
-        lhs[:mod_5].must > 2
-        lhs[:mod_5].must <= 3
-        save_results_in(tmpuri)
-      end
-      runner = Linkage::SingleThreadedRunner.new(conf)
-      runner.execute
-
-      database do |db|
-        assert_equal 2, db[:groups].count
-        db[:groups].order(:ssn).each_with_index do |row, i|
-          assert_equal "12345678#{(i * 5) + 3}", row[:ssn]
-        end
-
-        #assert_equal 20, db[:groups_records].count
-        #expected_group_id = nil
-        #db[:groups_records].order(:record_id).each do |row|
-          #expected_group_id = (row[:record_id] / 5) % 2 + 1
-          #assert_equal expected_group_id, row[:group_id], "Record #{row[:record_id]} should have been in group #{expected_group_id}"
-        #end
-      end
+    runner = Linkage::Runner.new(conf)
+    runner.execute
+
+    score_csv = CSV.read(File.join(@tmpdir, 'scores.csv'), :headers => true)
+    assert_equal 200, score_csv.length
+    score_csv.each do |row|
+      id_1 = row['id_1'].to_i
+      id_2 = row['id_2'].to_i
+      assert id_1 % 10 == id_2 % 10
+      assert id_1 % 20 == id_2 % 20
     end
 
-    test "one mandatory field equality on single threaded runner, with field filter" do
-      # insert the test data
-      database do |db|
-        db.create_table(:foo) { primary_key(:id); String(:ssn); Integer(:mod_5); Integer(:mod_20) }
-        db[:foo].import([:id, :ssn, :mod_5, :mod_20],
-          Array.new(100) { |i| [i, "123456789#{i%10}", i % 5, i % 20] })
-      end
-
-      ds = Linkage::Dataset.new(@tmpuri, "foo", :single_threaded => true)
-      tmpuri = @tmpuri
-      conf = ds.link_with(ds) do
-        lhs[:ssn].must == rhs[:ssn]
-        lhs[:mod_5].must == lhs[:mod_20]
-        save_results_in(tmpuri)
-      end
-      assert_equal :self, conf.linkage_type
-      runner = Linkage::SingleThreadedRunner.new(conf)
-      runner.execute
-
-      database do |db|
-        assert_equal 5, db[:groups].count
-        db[:groups].order(:ssn).each_with_index do |row, i|
-          assert_equal "123456789#{i}", row[:ssn]
-        end
-
-        #assert_equal 25, db[:groups_records].count
-        #expected_group_id = nil
-        #db[:groups_records].order(:record_id).each do |row|
-          #expected_group_id = row[:record_id] % 5 + 1
-          #assert_equal expected_group_id, row[:group_id], "Record #{row[:record_id]} should have been in group #{expected_group_id}"
-        #end
-      end
+    match_csv = CSV.read(File.join(@tmpdir, 'matches.csv'), :headers => true)
+    assert_equal 200, match_csv.length
+    match_csv.each do |row|
+      id_1 = row['id_1'].to_i
+      id_2 = row['id_2'].to_i
+      assert id_1 % 10 == id_2 % 10
+      assert id_1 % 20 == id_2 % 20
+    end
+  end
+
+  test "one-field equality with blocking" do
+    # insert the test data
+    database do |db|
+      db.create_table(:foo) { primary_key(:id); String(:ssn); Integer(:mod_5) }
+      db[:foo].import([:id, :ssn, :mod_5],
+        Array.new(100) { |i| [i, "12345678#{i%10}", i % 5] })
+    end
+
+    result_set = Linkage::ResultSet['csv'].new(@tmpdir)
+    dataset = Linkage::Dataset.new(@tmpuri, "foo", :single_threaded => true)
+    dataset = dataset.filter(:mod_5 => 3)
+    conf = dataset.link_with(dataset, result_set) do |conf|
+      conf.compare([:ssn], [:ssn], :equal)
+    end
+
+    runner = Linkage::Runner.new(conf)
+    runner.execute
+
+    score_csv = CSV.read(File.join(@tmpdir, 'scores.csv'), :headers => true)
+    assert_equal 90, score_csv.length
+    score_csv.each do |row|
+      id_1 = row['id_1'].to_i
+      id_2 = row['id_2'].to_i
+      assert id_1 % 10 == id_2 % 10
+      assert id_1 % 5 == id_2 % 5
     end
 
-    test "one mandatory field equality on single threaded runner, with identical filters" do
-      # insert the test data
-      database do |db|
-        db.create_table(:foo) { primary_key(:id); String(:ssn); Integer(:mod_5); Integer(:mod_20) }
-        db[:foo].import([:id, :ssn, :mod_5, :mod_20],
-          Array.new(100) { |i| [i, "123456789#{i%10}", i % 5, i % 20] })
-      end
-
-      ds = Linkage::Dataset.new(@tmpuri, "foo", :single_threaded => true)
-      tmpuri = @tmpuri
-      conf = ds.link_with(ds) do
-        lhs[:ssn].must == rhs[:ssn]
-        lhs[:mod_5].must == lhs[:mod_20]
-        rhs[:mod_5].must == rhs[:mod_20]
-        save_results_in(tmpuri)
-      end
-      assert_equal :self, conf.linkage_type
-      runner = Linkage::SingleThreadedRunner.new(conf)
-      runner.execute
-
-      database do |db|
-        assert_equal 5, db[:groups].count
-        db[:groups].order(:ssn).each_with_index do |row, i|
-          assert_equal "123456789#{i}", row[:ssn]
-        end
-
-        #assert_equal 25, db[:groups_records].count
-        #expected_group_id = nil
-        #db[:groups_records].order(:record_id).each do |row|
-          #expected_group_id = row[:record_id] % 5 + 1
-          #assert_equal expected_group_id, row[:group_id], "Record #{row[:record_id]} should have been in group #{expected_group_id}"
-        #end
-      end
+    match_csv = CSV.read(File.join(@tmpdir, 'matches.csv'), :headers => true)
+    assert_equal 90, match_csv.length
+    match_csv.each do |row|
+      id_1 = row['id_1'].to_i
+      id_2 = row['id_2'].to_i
+      assert id_1 % 10 == id_2 % 10
+      assert id_1 % 5 == id_2 % 5
     end
   end
 end

data/test/integration/test_within_comparator.rb

@@ -2,97 +2,44 @@ require 'helper'
 
 module IntegrationTests
   class TestWithinComparator < Test::Unit::TestCase
-    test "within comparator with no simple expectations" do
-      database_for('sqlite') do |db|
-        db.create_table(:foo) { primary_key(:id); Integer(:num) }
-        db.create_table(:bar) { primary_key(:id); Integer(:num) }
-        db[:foo].import([:id, :num], (1..10).collect { |i| [i, i] })
-        db[:bar].import([:id, :num], (1..10).collect { |i| [i, i] })
-      end
-
-      db_opts = database_options_for('sqlite')
-      dataset_1 = Linkage::Dataset.new(db_opts, "foo")
-      dataset_2 = Linkage::Dataset.new(db_opts, "bar")
-      conf = dataset_1.link_with(dataset_2) do
-        lhs[:num].must be_within(5).of(rhs[:num])
-        save_results_in(db_opts)
-      end
-
-      runner = Linkage::SingleThreadedRunner.new(conf)
-      runner.execute
-
-      database_for('sqlite') do |db|
-        assert_equal db[:scores].count, 100
-        db[:scores].order(:record_1_id, :record_2_id).each do |score|
-          if (score[:record_2_id] - score[:record_1_id]).abs <= 5
-            assert_equal 1, score[:score], score.inspect
-          else
-            assert_equal 0, score[:score], score.inspect
-          end
-        end
-      end
+    def setup
+      @tmpdir = Dir.mktmpdir('linkage')
     end
 
-    test "within comparator with simple expectations" do
-      database_for('sqlite') do |db|
-        db.create_table(:foo) { primary_key(:id); Integer(:num); String(:parity) }
-        db.create_table(:bar) { primary_key(:id); Integer(:num); String(:parity)  }
-        db[:foo].import([:id, :num, :parity], (1..10).collect { |i| [i, i, i % 2 == 0 ? "even" : "odd"] })
-        db[:bar].import([:id, :num, :parity], (1..10).collect { |i| [i, i, i % 2 == 0 ? "even" : "odd"] })
-      end
-
-      db_opts = database_options_for('sqlite')
-      dataset_1 = Linkage::Dataset.new(db_opts, "foo")
-      dataset_2 = Linkage::Dataset.new(db_opts, "bar")
-      conf = dataset_1.link_with(dataset_2) do
-        lhs[:parity].must == rhs[:parity]
-        lhs[:num].must be_within(5).of(rhs[:num])
-        save_results_in(db_opts)
-      end
-
-      runner = Linkage::SingleThreadedRunner.new(conf)
-      runner.execute
-
-      database_for('sqlite') do |db|
-        assert_equal db[:scores].count, 50
-        db[:scores].order(:record_1_id, :record_2_id).each do |score|
-          if (score[:record_2_id] - score[:record_1_id]).abs <= 5
-            assert_equal 1, score[:score]
-          else
-            assert_equal 0, score[:score]
-          end
-        end
-      end
+    def teardown
+      FileUtils.remove_entry_secure(@tmpdir)
     end
 
-    test "within comparator with simple expectations and functions" do
+    test "within comparator" do
       database_for('sqlite') do |db|
-        db.create_table(:foo) { primary_key(:id); Integer(:num); String(:parity) }
-        db.create_table(:bar) { primary_key(:id); Integer(:num); String(:parity)  }
-        db[:foo].import([:id, :num, :parity], (1..10).collect { |i| [i, i, i % 2 == 0 ? "even" : "odd"] })
-        db[:bar].import([:id, :num, :parity], (1..10).collect { |i| [i, i, i % 2 == 0 ? "even" : "odd"] })
+        db.create_table(:foo) { primary_key(:id); Integer(:num) }
+        db.create_table(:bar) { primary_key(:id); Integer(:num) }
+        db[:foo].import([:id, :num], (1..10).collect { |i| [i, i] })
+        db[:bar].import([:id, :num], (1..10).collect { |i| [i, i] })
       end
 
+      result_set = Linkage::ResultSet['csv'].new(@tmpdir)
       db_opts = database_options_for('sqlite')
       dataset_1 = Linkage::Dataset.new(db_opts, "foo")
       dataset_2 = Linkage::Dataset.new(db_opts, "bar")
-      conf = dataset_1.link_with(dataset_2) do
-        lhs[:parity].must == rhs[:parity]
-        cast(lhs[:num], 'integer').must be_within(5).of(cast(rhs[:num], 'integer'))
-        save_results_in(db_opts)
+      conf = dataset_1.link_with(dataset_2, result_set) do |conf|
+        conf.within(:num, :num, 5)
       end
 
-      runner = Linkage::SingleThreadedRunner.new(conf)
+      runner = Linkage::Runner.new(conf)
       runner.execute
 
-      database_for('sqlite') do |db|
-        assert_equal db[:scores].count, 50
-        db[:scores].order(:record_1_id, :record_2_id).each do |score|
-          if (score[:record_2_id] - score[:record_1_id]).abs <= 5
-            assert_equal 1, score[:score]
-          else
-            assert_equal 0, score[:score]
-          end
+      score_csv = CSV.read(File.join(@tmpdir, 'scores.csv'), :headers => true)
+      assert_equal 100, score_csv.length
+      score_csv.each do |row|
+        assert_equal "1", row['comparator_id']
+        # ids same as values
+        id_1 = row['id_1'].to_i
+        id_2 = row['id_2'].to_i
+        if (id_2 - id_1).abs <= 5
+          assert_equal 1, row['score'].to_i, row
+        else
+          assert_equal 0, row['score'].to_i
         end
       end
     end