Class: Sequel::Model::Associations::AssociationReflection

Inherits:
Hash
  • Object
show all
Includes:
Inflections
Defined in:
lib/sequel/model/associations.rb

Overview

AssociationReflection is a Hash subclass that keeps information on Sequel::Model associations. It provides methods to reduce internal code duplication. It should not be instantiated by the user.

Constant Summary collapse

ASSOCIATION_DATASET_PROC = 
proc{|r| r.association_dataset_for(self)}

Constants included from Inflections

Inflections::CAMELIZE_CONVERT_REGEXP, Inflections::CAMELIZE_MODULE_REGEXP, Inflections::DASH, Inflections::DEMODULIZE_CONVERT_REGEXP, Inflections::EMPTY_STRING, Inflections::SLASH, Inflections::UNDERSCORE, Inflections::UNDERSCORE_CONVERT_REGEXP1, Inflections::UNDERSCORE_CONVERT_REGEXP2, Inflections::UNDERSCORE_CONVERT_REPLACE, Inflections::UNDERSCORE_MODULE_REGEXP, Inflections::VALID_CONSTANT_NAME_REGEXP

Instance Method Summary collapse

Methods included from Inflections

clear, irregular, plural, singular, uncountable

Methods inherited from Hash

#&, #case, #hstore, #pg_json, #pg_jsonb, #sql_expr, #sql_negate, #sql_or, #|, #~

Instance Method Details

#_add_method ⇒ Object

Name symbol for the _add internal association method



22
23
24
 
# File 'lib/sequel/model/associations.rb', line 22

def _add_method
  :"_add_#{singularize(self[:name])}"
end

#_remove_all_method ⇒ Object

Name symbol for the _remove_all internal association method



27
28
29
 
# File 'lib/sequel/model/associations.rb', line 27

def _remove_all_method
  :"_remove_all_#{self[:name]}"
end

#_remove_method ⇒ Object

Name symbol for the _remove internal association method



32
33
34
 
# File 'lib/sequel/model/associations.rb', line 32

def _remove_method
  :"_remove_#{singularize(self[:name])}"
end

#_setter_method ⇒ Object

Name symbol for the _setter association method



37
38
39
 
# File 'lib/sequel/model/associations.rb', line 37

def _setter_method
  :"_#{self[:name]}="
end

#add_method ⇒ Object

Name symbol for the add association method



42
43
44
 
# File 'lib/sequel/model/associations.rb', line 42

def add_method
  :"add_#{singularize(self[:name])}"
end

#apply_dataset_changes(ds) ⇒ Object

Apply all non-instance specific changes to the given dataset and return it.



64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/sequel/model/associations.rb', line 64

def apply_dataset_changes(ds)
  ds.extend(AssociationDatasetMethods)
  ds.association_reflection = self
  self[:extend].each{|m| ds.extend(m)}
  ds = ds.select(*select) if select
  if c = self[:conditions]
    ds = (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
  end
  ds = ds.order(*self[:order]) if self[:order]
  ds = ds.limit(*self[:limit]) if self[:limit]
  ds = ds.limit(1) if limit_to_single_row?
  ds = ds.eager(*self[:eager]) if self[:eager]
  ds = ds.distinct if self[:distinct]
  ds
end

#apply_distinct_on_eager_limit_strategy(ds) ⇒ Object

Use DISTINCT ON and ORDER BY clauses to limit the results to the first record with matching keys.



117
118
119
120
 
# File 'lib/sequel/model/associations.rb', line 117

def apply_distinct_on_eager_limit_strategy(ds)
  keys = predicate_key
  ds.distinct(*keys).order_prepend(*keys)
end

#apply_eager_dataset_changes(ds) ⇒ Object

Apply all non-instance specific changes and the eager_block option to the given dataset and return it.



82
83
84
85
86
87
88
 
# File 'lib/sequel/model/associations.rb', line 82

def apply_eager_dataset_changes(ds)
  ds = apply_dataset_changes(ds)
  if block = self[:eager_block]
    ds = block.call(ds)
  end
  ds
end

#apply_eager_graph_limit_strategy(strategy, ds) ⇒ Object

Apply the eager graph limit strategy to the dataset to graph into the current dataset, or return the dataset unmodified if no SQL limit strategy is needed.



92
93
94
95
96
97
98
99
100
101
 
# File 'lib/sequel/model/associations.rb', line 92

def apply_eager_graph_limit_strategy(strategy, ds)
  case strategy
  when :distinct_on
    apply_distinct_on_eager_limit_strategy(ds.order_prepend(*self[:order]))
  when :window_function
    apply_window_function_eager_limit_strategy(ds.order_prepend(*self[:order])).select(*ds.columns)
  else
    ds
  end
end

#apply_eager_limit_strategy(ds, strategy = eager_limit_strategy) ⇒ Object

Apply an eager limit strategy to the dataset, or return the dataset unmodified if it doesn’t need an eager limit strategy.



105
106
107
108
109
110
111
112
113
114
 
# File 'lib/sequel/model/associations.rb', line 105

def apply_eager_limit_strategy(ds, strategy=eager_limit_strategy)
  case strategy
  when :distinct_on
    apply_distinct_on_eager_limit_strategy(ds)
  when :window_function
    apply_window_function_eager_limit_strategy(ds)
  else
    ds
  end
end

#apply_ruby_eager_limit_strategy(rows) ⇒ Object

If the ruby eager limit strategy is being used, slice the array using the slice range to return the object(s) at the correct offset/limit.



143
144
145
146
147
148
149
150
151
152
153
154
 
# File 'lib/sequel/model/associations.rb', line 143

def apply_ruby_eager_limit_strategy(rows)
  if eager_limit_strategy == :ruby
    name = self[:name]
    if returns_array?
      range = slice_range
      rows.each{|o| o.associations[name] = o.associations[name][range] || []}
    elsif slice_range
      offset = slice_range.begin
      rows.each{|o| o.associations[name] = o.associations[name][offset]}
    end
  end
end

#apply_window_function_eager_limit_strategy(ds) ⇒ Object

Use a window function to limit the results of the eager loading dataset.



123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
 
# File 'lib/sequel/model/associations.rb', line 123

def apply_window_function_eager_limit_strategy(ds)
  rn = ds.row_number_column 
  limit, offset = limit_and_offset
  ds = ds.unordered.select_append{|o| o.row_number{}.over(:partition=>predicate_key, :order=>ds.opts[:order]).as(rn)}.from_self
  ds = if !returns_array?
    ds.where(rn => offset ? offset+1 : 1)
  elsif offset
    offset += 1
    if limit
      ds.where(rn => (offset...(offset+limit))) 
    else
      ds.where{SQL::Identifier.new(rn) >= offset} 
    end
  else
    ds.where{SQL::Identifier.new(rn) <= limit} 
  end
end

#assign_singular? ⇒ Boolean

Whether the associations cache should use an array when storing the associated records during eager loading.

Returns:

  • (Boolean) 


158
159
160
 
# File 'lib/sequel/model/associations.rb', line 158

def assign_singular?
  !returns_array?
end

#associated_class ⇒ Object

The class associated to the current model class via this association



52
53
54
 
# File 'lib/sequel/model/associations.rb', line 52

def associated_class
  cached_fetch(:class){constantize(self[:class_name])}
end

#associated_dataset ⇒ Object

The dataset associated via this association, with the non-instance specific changes already applied. This will be a joined dataset if the association requires joining tables.



59
60
61
 
# File 'lib/sequel/model/associations.rb', line 59

def associated_dataset
  cached_fetch(:_dataset){apply_dataset_changes(_associated_dataset)}
end

#association_dataset_for(object) ⇒ Object

Return an dataset that will load the appropriate associated objects for the given object using this association.



195
196
197
 
# File 'lib/sequel/model/associations.rb', line 195

def association_dataset_for(object)
  associated_dataset.where(predicate_keys.zip(predicate_key_values(object)))
end

#association_dataset_proc ⇒ Object

Proc used to create the association dataset method.



201
202
203
 
# File 'lib/sequel/model/associations.rb', line 201

def association_dataset_proc
  ASSOCIATION_DATASET_PROC
end

#association_method ⇒ Object

Name symbol for association method, the same as the name of the association.



47
48
49
 
# File 'lib/sequel/model/associations.rb', line 47

def association_method
  self[:name]
end

#can_have_associated_objects?(obj) ⇒ Boolean

Whether this association can have associated objects, given the current object. Should be false if obj cannot have associated objects because the necessary key columns are NULL.

Returns:

  • (Boolean) 


165
166
167
 
# File 'lib/sequel/model/associations.rb', line 165

def can_have_associated_objects?(obj)
  true
end

#cloneable?(ref) ⇒ Boolean

Whether you are able to clone from the given association type to the current association type, true by default only if the types match.

Returns:

  • (Boolean) 


171
172
173
 
# File 'lib/sequel/model/associations.rb', line 171

def cloneable?(ref)
  ref[:type] == self[:type]
end

#dataset_method ⇒ Object

Name symbol for the dataset association method



176
177
178
 
# File 'lib/sequel/model/associations.rb', line 176

def dataset_method
  :"#{self[:name]}_dataset"
end

#dataset_need_primary_key? ⇒ Boolean

Whether the dataset needs a primary key to function, true by default.

Returns:

  • (Boolean) 


181
182
183
 
# File 'lib/sequel/model/associations.rb', line 181

def dataset_need_primary_key?
  true
end

#delete_row_number_column(ds = associated_dataset) ⇒ Object

Return the symbol used for the row number column if the window function eager limit strategy is being used, or nil otherwise.



187
188
189
190
191
 
# File 'lib/sequel/model/associations.rb', line 187

def delete_row_number_column(ds=associated_dataset)
  if eager_limit_strategy == :window_function
    ds.row_number_column 
  end
end

#eager_graph_lazy_dataset? ⇒ Boolean

Whether to eagerly graph a lazy dataset, true by default. If this is false, the association won’t respect the :eager_graph option when loading the association for a single record.

Returns:

  • (Boolean) 


287
288
289
 
# File 'lib/sequel/model/associations.rb', line 287

def eager_graph_lazy_dataset?
  true
end

#eager_graph_limit_strategy(strategy) ⇒ Object

The eager_graph limit strategy to use for this dataset



206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
 
# File 'lib/sequel/model/associations.rb', line 206

def eager_graph_limit_strategy(strategy)
  if self[:limit] || !returns_array?
    strategy = strategy[self[:name]] if strategy.is_a?(Hash)
    case strategy
    when true
      true_eager_graph_limit_strategy
    when Symbol
      strategy
    else
      if returns_array? || offset
        :ruby
      end
    end
  end
end

#eager_limit_strategy ⇒ Object

The eager limit strategy to use for this dataset.



223
224
225
226
227
228
229
230
231
232
233
234
 
# File 'lib/sequel/model/associations.rb', line 223

def eager_limit_strategy
  cached_fetch(:_eager_limit_strategy) do
    if self[:limit] || !returns_array?
      case s = cached_fetch(:eager_limit_strategy){default_eager_limit_strategy}
      when true
        true_eager_limit_strategy
      else
        s
      end
    end
  end
end

#eager_load_results(eo, &block) ⇒ Object

Eager load the associated objects using the hash of eager options, yielding each row to the block.



238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
 
# File 'lib/sequel/model/associations.rb', line 238

def eager_load_results(eo, &block)
  rows = eo[:rows]
  initialize_association_cache(rows) unless eo[:initialize_rows] == false
  strategy = eager_limit_strategy
  cascade = eo[:associations]

  if eo[:eager_block] || eo[:loader] == false
    strategy = true_eager_graph_limit_strategy if strategy == :union
    objects = apply_eager_limit_strategy(eager_loading_dataset(eo), strategy).all
    cascade = nil
  elsif strategy == :union
    objects = []
    ds = associated_dataset
    loader = union_eager_loader
    joiner = " UNION ALL "
    eo[:id_map].keys.each_slice(subqueries_per_union).each do |slice|
      objects.concat(ds.with_sql(slice.map{|k| loader.sql(*k)}.join(joiner)).to_a)
    end
  else
    objects = placeholder_eager_loader.all(eo[:id_map].keys)
  end

  if cascade && !(cascade = associated_dataset.send(:eager_options_for_associations, [cascade])).empty?
    associated_eager_dataset.send(:eager_load, objects, cascade)
  end

  objects.each(&block)
  apply_ruby_eager_limit_strategy(rows)
end

#eager_loader_key ⇒ Object

The key to use for the key hash when eager loading



269
270
271
 
# File 'lib/sequel/model/associations.rb', line 269

def eager_loader_key
  self[:eager_loader_key]
end

#eager_loading_predicate_key ⇒ Object

Alias of predicate_key, only for backwards compatibility.



280
281
282
 
# File 'lib/sequel/model/associations.rb', line 280

def eager_loading_predicate_key
  predicate_key
end

#eager_loading_use_associated_key? ⇒ Boolean

By default associations do not need to select a key in an associated table to eagerly load.

Returns:

  • (Boolean) 


275
276
277
 
# File 'lib/sequel/model/associations.rb', line 275

def eager_loading_use_associated_key?
  false
end

#filter_by_associations_add_conditions? ⇒ Boolean

Whether additional conditions should be added when using the filter by associations support.

Returns:

  • (Boolean) 


293
294
295
 
# File 'lib/sequel/model/associations.rb', line 293

def filter_by_associations_add_conditions?
  self[:conditions] || self[:eager_block] || self[:limit]
end

#filter_by_associations_conditions_expression(obj) ⇒ Object

The expression to use for the additional conditions to be added for the filter by association support, when the association itself is filtered. Works by using a subquery to test that the objects passed also meet the association filter criteria.



301
302
303
304
 
# File 'lib/sequel/model/associations.rb', line 301

def filter_by_associations_conditions_expression(obj)
  ds = filter_by_associations_conditions_dataset.where(filter_by_associations_conditions_subquery_conditions(obj))
  {filter_by_associations_conditions_key=>ds}
end

#handle_silent_modification_failure? ⇒ Boolean

Whether to handle silent modification failure when adding/removing associated records, false by default.

Returns:

  • (Boolean) 


308
309
310
 
# File 'lib/sequel/model/associations.rb', line 308

def handle_silent_modification_failure?
  false
end

#initialize_association_cache(objects) ⇒ Object

Initialize the associations cache for the current association for the given objects.



313
314
315
316
317
318
319
320
 
# File 'lib/sequel/model/associations.rb', line 313

def initialize_association_cache(objects)
  name = self[:name]
  if assign_singular?
    objects.each{|object| object.associations[name] = nil}
  else
    objects.each{|object| object.associations[name] = []}
  end
end

#limit_and_offset ⇒ Object

The limit and offset for this association (returned as a two element array).



323
324
325
326
327
328
329
 
# File 'lib/sequel/model/associations.rb', line 323

def limit_and_offset
  if (v = self[:limit]).is_a?(Array)
    v
  else
    [v, nil]
  end
end

#need_associated_primary_key? ⇒ Boolean

Whether the associated object needs a primary key to be added/removed, false by default.

Returns:

  • (Boolean) 


333
334
335
 
# File 'lib/sequel/model/associations.rb', line 333

def need_associated_primary_key?
  false
end

#placeholder_loader ⇒ Object

A placeholder literalizer that can be used to lazily load the association. If one can’t be used, returns nil.



339
340
341
342
343
344
345
346
347
 
# File 'lib/sequel/model/associations.rb', line 339

def placeholder_loader
  if use_placeholder_loader?
    cached_fetch(:placeholder_loader) do
      Sequel::Dataset::PlaceholderLiteralizer.loader(associated_dataset) do |pl, ds|
        ds.where(*predicate_keys.map{|k| SQL::BooleanExpression.new(:'=', k, pl.arg)})
      end
    end
  end
end

#predicate_key_values(object) ⇒ Object

The values that predicate_keys should match for objects to be associated.



355
356
357
 
# File 'lib/sequel/model/associations.rb', line 355

def predicate_key_values(object)
  predicate_key_methods.map{|k| object.send(k)}
end

#predicate_keys ⇒ Object

The keys to use for loading of the regular dataset, as an array.



350
351
352
 
# File 'lib/sequel/model/associations.rb', line 350

def predicate_keys
  cached_fetch(:predicate_keys){Array(predicate_key)}
end

#qualify(table, col) ⇒ Object

Qualify col with the given table name. If col is an array of columns, return an array of qualified columns. Only qualifies Symbols and SQL::Identifier values, other values are not modified.



362
363
364
365
366
367
368
369
370
371
 
# File 'lib/sequel/model/associations.rb', line 362

def qualify(table, col)
  transform(col) do |k|
    case k
    when Symbol, SQL::Identifier
      SQL::QualifiedIdentifier.new(table, k)
    else
      Sequel::Qualifier.new(self[:model].dataset, table).transform(k)
    end
  end
end

#qualify_assoc(col) ⇒ Object

Qualify col with the associated model’s table name.



374
375
376
 
# File 'lib/sequel/model/associations.rb', line 374

def qualify_assoc(col)
  qualify(associated_class.table_name, col)
end

#qualify_cur(col) ⇒ Object

Qualify col with the current model’s table name.



379
380
381
 
# File 'lib/sequel/model/associations.rb', line 379

def qualify_cur(col)
  qualify(self[:model].table_name, col)
end

#reciprocal ⇒ Object

Returns the reciprocal association variable, if one exists. The reciprocal association is the association in the associated class that is the opposite of the current association. For example, Album.many_to_one :artist and Artist.one_to_many :albums are reciprocal associations. This information is to populate reciprocal associations. For example, when you do this_artist.add_album(album) it sets album.artist to this_artist.



389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
 
# File 'lib/sequel/model/associations.rb', line 389

def reciprocal
  cached_fetch(:reciprocal) do
    possible_recips = []

    associated_class.all_association_reflections.each do |assoc_reflect|
      if reciprocal_association?(assoc_reflect)
        possible_recips << assoc_reflect
      end
    end

    if possible_recips.length == 1
      cached_set(:reciprocal_type, possible_recips.first[:type]) if reciprocal_type.is_a?(Array)
      possible_recips.first[:name]
    end
  end
end

#reciprocal_array? ⇒ Boolean

Whether the reciprocal of this association returns an array of objects instead of a single object, true by default.

Returns:

  • (Boolean) 


408
409
410
 
# File 'lib/sequel/model/associations.rb', line 408

def reciprocal_array?
  true
end

#remove_all_method ⇒ Object

Name symbol for the remove_all_ association method



413
414
415
 
# File 'lib/sequel/model/associations.rb', line 413

def remove_all_method
  :"remove_all_#{self[:name]}"
end

#remove_before_destroy? ⇒ Boolean

Whether associated objects need to be removed from the association before being destroyed in order to preserve referential integrity.

Returns:

  • (Boolean) 


419
420
421
 
# File 'lib/sequel/model/associations.rb', line 419

def remove_before_destroy?
  true
end

#remove_method ⇒ Object

Name symbol for the remove_ association method



424
425
426
 
# File 'lib/sequel/model/associations.rb', line 424

def remove_method
  :"remove_#{singularize(self[:name])}"
end

#remove_should_check_existing? ⇒ Boolean

Whether to check that an object to be disassociated is already associated to this object, false by default.

Returns:

  • (Boolean) 


429
430
431
 
# File 'lib/sequel/model/associations.rb', line 429

def remove_should_check_existing?
  false
end

#returns_array? ⇒ Boolean

Whether this association returns an array of objects instead of a single object, true by default.

Returns:

  • (Boolean) 


435
436
437
 
# File 'lib/sequel/model/associations.rb', line 435

def returns_array?
  true
end

#select ⇒ Object

The columns to select when loading the association.



440
441
442
 
# File 'lib/sequel/model/associations.rb', line 440

def select
  self[:select]
end

#set_reciprocal_to_self? ⇒ Boolean

Whether to set the reciprocal association to self when loading associated records, false by default.

Returns:

  • (Boolean) 


446
447
448
 
# File 'lib/sequel/model/associations.rb', line 446

def set_reciprocal_to_self?
  false
end

#setter_method ⇒ Object

Name symbol for the setter association method



451
452
453
 
# File 'lib/sequel/model/associations.rb', line 451

def setter_method
  :"#{self[:name]}="
end

#slice_range ⇒ Object

The range used for slicing when using the :ruby eager limit strategy.



456
457
458
459
460
461
 
# File 'lib/sequel/model/associations.rb', line 456

def slice_range
  limit, offset = limit_and_offset
  if limit || offset
    (offset||0)..(limit ? (offset||0)+limit-1 : -1)
  end
end