Class: Linkage::ResultSet

Inherits:
Object
  • Object
show all
Defined in:
lib/linkage/result_set.rb

Instance Method Summary (collapse)

Constructor Details

- (ResultSet) initialize(config)

A new instance of ResultSet



3
4
5
6
7
 
# File 'lib/linkage/result_set.rb', line 3

def initialize(config)
  @config = config
  @next_group_id = 1
  @next_group_mutex = Mutex.new
end

Instance Method Details

- (Object) add_group(group, dataset_id = nil) 



48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/linkage/result_set.rb', line 48

def add_group(group, dataset_id = nil)
  if @config.decollation_needed?
    original_values = group.values
    values = group.decollated_values
    if !@groups_buffer
      groups_headers = [:id] + values.keys
      @groups_buffer = ImportBuffer.new(database[@config.groups_table_name],
        groups_headers)

      original_groups_headers = [:id] + original_values.keys
      @original_groups_buffer = ImportBuffer.new(
        database[@config.original_groups_table_name],
        original_groups_headers)
    end

    group_id = next_group_id
    @groups_buffer.add([group_id] + values.values)
    @original_groups_buffer.add([group_id] + original_values.values)
  else
    # Non-DRY for minute speed improvements
    values = group.values
    if !@groups_buffer
      groups_headers = [:id] + values.keys
      @groups_buffer = ImportBuffer.new(database[@config.groups_table_name],
        groups_headers)
    end
    group_id = next_group_id
    @groups_buffer.add([group_id] + values.values)
  end
end

- (Object) add_match(record_1_id, record_2_id, total_score) 



88
89
90
91
92
93
94
95
 
# File 'lib/linkage/result_set.rb', line 88

def add_match(record_1_id, record_2_id, total_score)
  if !@matches_buffer
    matches_headers = [:record_1_id, :record_2_id, :total_score]
    @matches_buffer = ImportBuffer.new(database[@config.matches_table_name],
      matches_headers)
  end
  @matches_buffer.add([record_1_id, record_2_id, total_score])
end

- (Object) add_score(comparator_id, record_1_id, record_2_id, score) 



79
80
81
82
83
84
85
86
 
# File 'lib/linkage/result_set.rb', line 79

def add_score(comparator_id, record_1_id, record_2_id, score)
  if !@scores_buffer
    scores_headers = [:comparator_id, :record_1_id, :record_2_id, :score]
    @scores_buffer = ImportBuffer.new(database[@config.scores_table_name],
      scores_headers)
  end
  @scores_buffer.add([comparator_id, record_1_id, record_2_id, score])
end

- (Object) create_tables! 



21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/linkage/result_set.rb', line 21

def create_tables!
  if @config.groups_table_needed?
    schema = @config.groups_table_schema
    if @config.decollation_needed?
      database.create_table(@config.original_groups_table_name) do
        schema.each { |col| column(*col) }
      end
    end

    database.create_table(@config.groups_table_name) do
      schema.each { |col| column(*col) }
    end
  end

  if @config.scores_table_needed?
    schema = @config.scores_table_schema
    database.create_table(@config.scores_table_name) do
      schema.each { |col| column(*col) }
    end
  end

  schema = @config.matches_table_schema
  database.create_table(@config.matches_table_name) do
    schema.each { |col| column(*col) }
  end
end

- (Object) database 



13
14
15
16
17
18
19
 
# File 'lib/linkage/result_set.rb', line 13

def database
  # FIXME: If the results database is the same as one of the datasets
  # being linked, there will be two connections to said database. This
  # could result in unexpected locking for non-concurrent databases (like
  # SQLite).
  @database ||= Sequel.connect(@config.results_uri, @config.results_uri_options)
end

- (Object) flush! 



97
98
99
100
101
102
 
# File 'lib/linkage/result_set.rb', line 97

def flush!
  @groups_buffer.flush if @groups_buffer
  @original_groups_buffer.flush if @original_groups_buffer
  @scores_buffer.flush if @scores_buffer
  @matches_buffer.flush if @matches_buffer
end

- (Object) get_group(index) 



104
105
106
107
 
# File 'lib/linkage/result_set.rb', line 104

def get_group(index)
  values = groups_dataset.order(:id).limit(1, index).first
  Group.from_row(values)
end

- (Object) groups_dataset 



9
10
11
 
# File 'lib/linkage/result_set.rb', line 9

def groups_dataset
  @groups_dataset ||= Dataset.new(database[:groups])
end

- (Object) groups_records_datasets(group) 



109
110
111
112
 
# File 'lib/linkage/result_set.rb', line 109

def groups_records_datasets(group)
  datasets = @config.datasets_with_applied_simple_expectations
  datasets.collect! { |ds| ds.dataset_for_group(group) }
end