class Sequel::Model::Associations::AssociationReflection

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.

Constants

ASSOCIATION_DATASET_PROC
FINALIZE_SETTINGS

Map of methods to cache keys used for finalizing associations.

Public Instance Methods

_add_method() click to toggle source

Name symbol for the _add internal association method

# File lib/sequel/model/associations.rb, line 34
def _add_method
  :"_add_#{singularize(self[:name])}"
end
_remove_all_method() click to toggle source

Name symbol for the _remove_all internal association method

# File lib/sequel/model/associations.rb, line 39
def _remove_all_method
  :"_remove_all_#{self[:name]}"
end
_remove_method() click to toggle source

Name symbol for the _remove internal association method

# File lib/sequel/model/associations.rb, line 44
def _remove_method
  :"_remove_#{singularize(self[:name])}"
end
_setter_method() click to toggle source

Name symbol for the _setter association method

# File lib/sequel/model/associations.rb, line 49
def _setter_method
  :"_#{self[:name]}="
end
add_method() click to toggle source

Name symbol for the add association method

# File lib/sequel/model/associations.rb, line 54
def add_method
  :"add_#{singularize(self[:name])}"
end
apply_dataset_changes(ds) click to toggle source

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

# File lib/sequel/model/associations.rb, line 82
def apply_dataset_changes(ds)
  ds = ds.with_extend(AssociationDatasetMethods).
    clone(:association_reflection => self)
  self[:extend].each{|m| ds = ds.with_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).skip_limit_check 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) click to toggle source

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

# File lib/sequel/model/associations.rb, line 135
def apply_distinct_on_eager_limit_strategy(ds)
  keys = predicate_key
  ds.distinct(*keys).order_prepend(*keys)
end
apply_eager_dataset_changes(ds) click to toggle source

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

# File lib/sequel/model/associations.rb, line 100
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) click to toggle source

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.

# File lib/sequel/model/associations.rb, line 110
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, limit_and_offset=limit_and_offset()) click to toggle source

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

# File lib/sequel/model/associations.rb, line 123
def apply_eager_limit_strategy(ds, strategy=eager_limit_strategy, limit_and_offset=limit_and_offset())
  case strategy
  when :distinct_on
    apply_distinct_on_eager_limit_strategy(ds)
  when :window_function
    apply_window_function_eager_limit_strategy(ds, limit_and_offset)
  else
    ds
  end
end
apply_ruby_eager_limit_strategy(rows, limit_and_offset = limit_and_offset()) click to toggle source

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.

# File lib/sequel/model/associations.rb, line 161
def apply_ruby_eager_limit_strategy(rows, limit_and_offset = limit_and_offset())
  name = self[:name]
  if returns_array?
    range = slice_range(limit_and_offset)
    rows.each{|o| o.associations[name] = o.associations[name][range] || []}
  elsif sr = slice_range(limit_and_offset)
    offset = sr.begin
    rows.each{|o| o.associations[name] = o.associations[name][offset]}
  end
end
apply_window_function_eager_limit_strategy(ds, limit_and_offset=limit_and_offset()) click to toggle source

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

# File lib/sequel/model/associations.rb, line 141
def apply_window_function_eager_limit_strategy(ds, limit_and_offset=limit_and_offset())
  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?() click to toggle source

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

# File lib/sequel/model/associations.rb, line 174
def assign_singular?
  !returns_array?
end
associated_class() click to toggle source

The class associated to the current model class via this association

# File lib/sequel/model/associations.rb, line 64
def associated_class
  cached_fetch(:class) do
    begin
      constantize(self[:class_name])
    rescue NameError => e
      raise NameError, "#{e.message} (this happened when attempting to find the associated class for #{inspect})", e.backtrace
    end
  end
end
associated_dataset() click to toggle source

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.

# File lib/sequel/model/associations.rb, line 77
def associated_dataset
  cached_fetch(:_dataset){apply_dataset_changes(_associated_dataset)}
end
association_dataset_for(object) click to toggle source

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

# File lib/sequel/model/associations.rb, line 211
def association_dataset_for(object)
  condition = if can_have_associated_objects?(object)
    predicate_keys.zip(predicate_key_values(object))
  else
    false
  end

  associated_dataset.where(condition)
end
association_dataset_proc() click to toggle source

Proc used to create the association dataset method.

# File lib/sequel/model/associations.rb, line 223
def association_dataset_proc
  ASSOCIATION_DATASET_PROC
end
association_method() click to toggle source

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

# File lib/sequel/model/associations.rb, line 59
def association_method
  self[:name]
end
can_have_associated_objects?(obj) click to toggle source

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.

# File lib/sequel/model/associations.rb, line 181
def can_have_associated_objects?(obj)
  true
end
cloneable?(ref) click to toggle source

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

# File lib/sequel/model/associations.rb, line 187
def cloneable?(ref)
  ref[:type] == self[:type]
end
dataset_method() click to toggle source

Name symbol for the dataset association method

# File lib/sequel/model/associations.rb, line 192
def dataset_method
  :"#{self[:name]}_dataset"
end
dataset_need_primary_key?() click to toggle source

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

# File lib/sequel/model/associations.rb, line 197
def dataset_need_primary_key?
  true
end
delete_row_number_column(ds=associated_dataset) click to toggle source

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

# File lib/sequel/model/associations.rb, line 203
def delete_row_number_column(ds=associated_dataset)
  if eager_limit_strategy == :window_function
    ds.row_number_column 
  end
end
eager_graph_lazy_dataset?() click to toggle source

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.

# File lib/sequel/model/associations.rb, line 335
def eager_graph_lazy_dataset?
  true
end
eager_graph_limit_strategy(strategy) click to toggle source

The eager_graph limit strategy to use for this dataset

# File lib/sequel/model/associations.rb, line 228
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() click to toggle source

The eager limit strategy to use for this dataset.

# File lib/sequel/model/associations.rb, line 245
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) click to toggle source

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

# File lib/sequel/model/associations.rb, line 260
def eager_load_results(eo, &block)
  rows = eo[:rows]
  initialize_association_cache(rows) unless eo[:initialize_rows] == false
  if eo[:id_map]
    ids = eo[:id_map].keys
    return ids if ids.empty?
  end
  strategy = eager_limit_strategy
  cascade = eo[:associations]
  eager_limit = nil

  if eo[:eager_block] || eo[:loader] == false
    ds = eager_loading_dataset(eo)

    strategy = ds.opts[:eager_limit_strategy] || strategy

    eager_limit =
      if el = ds.opts[:eager_limit]
        raise Error, "The :eager_limit dataset option is not supported for associations returning a single record" unless returns_array?
        strategy ||= true_eager_graph_limit_strategy
        if el.is_a?(Array)
          el
        else
          [el, nil]
        end
      else
        limit_and_offset
      end

    strategy = true_eager_graph_limit_strategy if strategy == :union
    # Correlated subqueries are not supported for regular eager loading
    strategy = :ruby if strategy == :correlated_subquery
    strategy = nil if strategy == :ruby && assign_singular?
    objects = apply_eager_limit_strategy(ds, strategy, eager_limit).all
  elsif strategy == :union
    objects = []
    ds = associated_dataset
    loader = union_eager_loader
    joiner = " UNION ALL "
    ids.each_slice(subqueries_per_union).each do |slice|
      objects.concat(ds.with_sql(slice.map{|k| loader.sql(*k)}.join(joiner)).to_a)
    end
    ds = ds.eager(cascade) if cascade
    ds.send(:post_load, objects)
  else
    loader = placeholder_eager_loader
    loader = loader.with_dataset{|dataset| dataset.eager(cascade)} if cascade
    objects = loader.all(ids)
  end

  objects.each(&block)
  if strategy == :ruby
    apply_ruby_eager_limit_strategy(rows, eager_limit || limit_and_offset)
  end
end
eager_loader_key() click to toggle source

The key to use for the key hash when eager loading

# File lib/sequel/model/associations.rb, line 317
def eager_loader_key
  self[:eager_loader_key]
end
eager_loading_predicate_key() click to toggle source

Alias of predicate_key, only for backwards compatibility.

# File lib/sequel/model/associations.rb, line 328
def eager_loading_predicate_key
  predicate_key
end
eager_loading_use_associated_key?() click to toggle source

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

# File lib/sequel/model/associations.rb, line 323
def eager_loading_use_associated_key?
  false
end
filter_by_associations_add_conditions?() click to toggle source

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

# File lib/sequel/model/associations.rb, line 341
def filter_by_associations_add_conditions?
  self[:conditions] || self[:eager_block] || self[:limit]
end
filter_by_associations_conditions_expression(obj) click to toggle source

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.

# File lib/sequel/model/associations.rb, line 349
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
finalize() click to toggle source

Finalize the association by first attempting to populate the thread-safe cache, and then transfering the thread-safe cache value to the association itself, so that a mutex is not needed to get the value.

# File lib/sequel/model/associations.rb, line 357
def finalize
  return unless cache = self[:cache]

  finalize_settings.each do |meth, key|
    next if has_key?(key)

    send(meth)
    self[key] = cache.delete(key) if cache.has_key?(key)
  end

  nil
end
finalize_settings() click to toggle source
# File lib/sequel/model/associations.rb, line 382
def finalize_settings
  FINALIZE_SETTINGS
end
handle_silent_modification_failure?() click to toggle source

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

# File lib/sequel/model/associations.rb, line 388
def handle_silent_modification_failure?
  false
end
initialize_association_cache(objects) click to toggle source

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

# File lib/sequel/model/associations.rb, line 393
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
inspect() click to toggle source

Show which type of reflection this is, and a guess at what line was used to create the association.

# File lib/sequel/model/associations.rb, line 404
def inspect
  o = self[:orig_opts].dup
  o.delete(:class)
  o.delete(:class_name)
  o.delete(:block) unless o[:block]
  o[:class] = self[:orig_class] if self[:orig_class]

  "#<#{self.class} #{self[:model]}.#{self[:type]} #{self[:name].inspect}#{", #{o.inspect[1...-1]}" unless o.empty?}>"
end
limit_and_offset() click to toggle source

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

# File lib/sequel/model/associations.rb, line 415
def limit_and_offset
  if (v = self[:limit]).is_a?(Array)
    v
  else
    [v, nil]
  end
end
need_associated_primary_key?() click to toggle source

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

# File lib/sequel/model/associations.rb, line 425
def need_associated_primary_key?
  false
end
placeholder_loader() click to toggle source

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

# File lib/sequel/model/associations.rb, line 431
def placeholder_loader
  if use_placeholder_loader?
    cached_fetch(:placeholder_loader) do
      Sequel::Dataset::PlaceholderLiteralizer.loader(associated_dataset) do |pl, ds|
        ds.where(Sequel.&(*predicate_keys.map{|k| SQL::BooleanExpression.new(:'=', k, pl.arg)}))
      end
    end
  end
end
predicate_key_values(object) click to toggle source

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

# File lib/sequel/model/associations.rb, line 447
def predicate_key_values(object)
  predicate_key_methods.map{|k| object.get_column_value(k)}
end
predicate_keys() click to toggle source

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

# File lib/sequel/model/associations.rb, line 442
def predicate_keys
  cached_fetch(:predicate_keys){Array(predicate_key)}
end
qualify(table, col) click to toggle source

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.

# File lib/sequel/model/associations.rb, line 454
def qualify(table, col)
  transform(col) do |k|
    case k
    when Symbol, SQL::Identifier
      SQL::QualifiedIdentifier.new(table, k)
    else
      Sequel::Qualifier.new(table).transform(k)
    end
  end
end
qualify_assoc(col) click to toggle source

Qualify col with the associated model's table name.

# File lib/sequel/model/associations.rb, line 466
def qualify_assoc(col)
  qualify(associated_class.table_name, col)
end
qualify_cur(col) click to toggle source

Qualify col with the current model's table name.

# File lib/sequel/model/associations.rb, line 471
def qualify_cur(col)
  qualify(self[:model].table_name, col)
end
reciprocal() click to toggle source

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.

# File lib/sequel/model/associations.rb, line 481
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 ambiguous_reciprocal_type?
      possible_recips.first[:name]
    end
  end
end
reciprocal_array?() click to toggle source

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

# File lib/sequel/model/associations.rb, line 500
def reciprocal_array?
  true
end
remove_all_method() click to toggle source

Name symbol for the remove_all_ association method

# File lib/sequel/model/associations.rb, line 505
def remove_all_method
  :"remove_all_#{self[:name]}"
end
remove_before_destroy?() click to toggle source

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

# File lib/sequel/model/associations.rb, line 511
def remove_before_destroy?
  true
end
remove_method() click to toggle source

Name symbol for the remove_ association method

# File lib/sequel/model/associations.rb, line 516
def remove_method
  :"remove_#{singularize(self[:name])}"
end
remove_should_check_existing?() click to toggle source

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

# File lib/sequel/model/associations.rb, line 521
def remove_should_check_existing?
  false
end
returns_array?() click to toggle source

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

# File lib/sequel/model/associations.rb, line 527
def returns_array?
  true
end
select() click to toggle source

The columns to select when loading the association.

# File lib/sequel/model/associations.rb, line 532
def select
  self[:select]
end
set_reciprocal_to_self?() click to toggle source

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

# File lib/sequel/model/associations.rb, line 538
def set_reciprocal_to_self?
  false
end
setter_method() click to toggle source

Name symbol for the setter association method

# File lib/sequel/model/associations.rb, line 543
def setter_method
  :"#{self[:name]}="
end
slice_range(limit_and_offset = limit_and_offset()) click to toggle source

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

# File lib/sequel/model/associations.rb, line 548
def slice_range(limit_and_offset = limit_and_offset())
  limit, offset = limit_and_offset
  if limit || offset
    (offset||0)..(limit ? (offset||0)+limit-1 : -1)
  end
end

Private Instance Methods

_associated_dataset() click to toggle source

The base dataset used for the association, before any order/conditions options have been applied.

# File lib/sequel/model/associations.rb, line 576
def _associated_dataset
  associated_class.dataset.clone
end
ambiguous_reciprocal_type?() click to toggle source

Whether for the reciprocal type for the given association can not be known in advantage, false by default.

# File lib/sequel/model/associations.rb, line 582
def ambiguous_reciprocal_type?
  false
end
apply_filter_by_associations_distinct_on_limit_strategy(ds) click to toggle source

Apply a distinct on eager limit strategy using IN with a subquery that uses DISTINCT ON to ensure only the first matching record for each key is included.

# File lib/sequel/model/associations.rb, line 602
def apply_filter_by_associations_distinct_on_limit_strategy(ds)
  k = filter_by_associations_limit_key 
  ds.where(k=>apply_distinct_on_eager_limit_strategy(associated_eager_dataset.select(*k)))
end
apply_filter_by_associations_limit_strategy(ds) click to toggle source

Apply a limit strategy to the given dataset so that filter by associations works with a limited dataset.

# File lib/sequel/model/associations.rb, line 588
def apply_filter_by_associations_limit_strategy(ds)
  case filter_by_associations_limit_strategy
  when :distinct_on
    apply_filter_by_associations_distinct_on_limit_strategy(ds)
  when :window_function
    apply_filter_by_associations_window_function_limit_strategy(ds)
  else
    ds
  end
end
apply_filter_by_associations_window_function_limit_strategy(ds) click to toggle source

Apply a distinct on eager limit strategy using IN with a subquery that uses a filter on the row_number window function to ensure that only rows inside the limit are returned.

# File lib/sequel/model/associations.rb, line 610
def apply_filter_by_associations_window_function_limit_strategy(ds)
  ds.where(filter_by_associations_limit_key=>apply_window_function_eager_limit_strategy(associated_eager_dataset.select(*filter_by_associations_limit_alias_key)).select(*filter_by_associations_limit_aliases))
end
associated_eager_dataset() click to toggle source

The #associated_dataset with the eager_block callback already applied.

# File lib/sequel/model/associations.rb, line 615
def associated_eager_dataset
  cached_fetch(:associated_eager_dataset) do
    ds = associated_dataset.unlimited
    if block = self[:eager_block]
      ds = block.call(ds)
    end
    ds
  end
end
cached_fetch(key) { || ... } click to toggle source

On non-GVL rubies, assume the need to synchronize access. Store the key in a special sub-hash that always uses this method to synchronize access.

# File lib/sequel/model/associations.rb, line 559
def cached_fetch(key)
  fetch(key) do
    return yield unless h = self[:cache]
    Sequel.synchronize{return h[key] if h.has_key?(key)}
    value = yield
    Sequel.synchronize{h[key] = value}
  end
end
cached_set(key, value) click to toggle source

Cache the value at the given key, synchronizing access.

# File lib/sequel/model/associations.rb, line 569
def cached_set(key, value)
  return unless h = self[:cache]
  Sequel.synchronize{h[key] = value}
end
default_eager_limit_strategy() click to toggle source

The default eager limit strategy to use for this association

# File lib/sequel/model/associations.rb, line 649
def default_eager_limit_strategy
  self[:model].default_eager_limit_strategy || :ruby
end
eager_loading_dataset(eo=OPTS) click to toggle source

The dataset to use for eager loading associated objects for multiple current objects, given the hash passed to the eager loader.

# File lib/sequel/model/associations.rb, line 627
def eager_loading_dataset(eo=OPTS)
  ds = eo[:dataset] || associated_eager_dataset
  if id_map = eo[:id_map]
    ds = ds.where(eager_loading_predicate_condition(id_map.keys))
  end
  if associations = eo[:associations]
    ds = ds.eager(associations)
  end
  if block = eo[:eager_block]
    ds = block.call(ds)
  end
  if eager_loading_use_associated_key?
    ds = ds.select_append(*associated_key_array)
  end
  if self[:eager_graph]
    raise(Error, "cannot eagerly load a #{self[:type]} association that uses :eager_graph") if eager_loading_use_associated_key?
    ds = ds.eager_graph(self[:eager_graph])
  end
  ds
end
eager_loading_predicate_condition(keys) click to toggle source

The predicate condition to use for the eager_loader.

# File lib/sequel/model/associations.rb, line 654
def eager_loading_predicate_condition(keys)
  {predicate_key=>keys}
end
filter_by_associations_add_conditions_dataset_filter(ds) click to toggle source

Add conditions to the dataset to not include NULL values for the associated keys, and select those keys.

# File lib/sequel/model/associations.rb, line 660
def filter_by_associations_add_conditions_dataset_filter(ds)
  k = filter_by_associations_conditions_associated_keys
  ds.select(*k).where(Sequel.negate(k.zip([])))
end
filter_by_associations_conditions_dataset() click to toggle source

The base dataset to use for the filter by associations conditions subquery, regardless of the objects that are passed in as filter values.

# File lib/sequel/model/associations.rb, line 683
def filter_by_associations_conditions_dataset
  cached_fetch(:filter_by_associations_conditions_dataset) do
    ds = associated_eager_dataset.unordered
    ds = filter_by_associations_add_conditions_dataset_filter(ds)
    ds = apply_filter_by_associations_limit_strategy(ds)
    ds
  end
end
filter_by_associations_conditions_subquery_conditions(obj) click to toggle source

The conditions to add to the filter by associations conditions subquery to restrict it to to the object(s) that was used as the filter value.

# File lib/sequel/model/associations.rb, line 668
def filter_by_associations_conditions_subquery_conditions(obj)
  key = qualify(associated_class.table_name, associated_class.primary_key)
  case obj
  when Array
    {key=>obj.map(&:pk)}
  when Sequel::Dataset
    {key=>obj.select(*Array(qualify(associated_class.table_name, associated_class.primary_key)))}
  else
    Array(key).zip(Array(obj.pk))
  end
end
filter_by_associations_limit_strategy() click to toggle source

The strategy to use to filter by a limited association

# File lib/sequel/model/associations.rb, line 693
def filter_by_associations_limit_strategy
  v = fetch(:filter_limit_strategy, self[:eager_limit_strategy])
  if v || self[:limit] || !returns_array?
    case v ||= self[:model].default_eager_limit_strategy
    when :union, :ruby
      # Can't use a union or ruby-based strategy for filtering by associations, switch to default eager graph limit
      # strategy.
      true_eager_graph_limit_strategy
    when Symbol
      v
    when true
      true_eager_graph_limit_strategy
    end
  end
end
limit_to_single_row?() click to toggle source

Whether to limit the associated dataset to a single row.

# File lib/sequel/model/associations.rb, line 710
def limit_to_single_row?
  !returns_array?
end
offset() click to toggle source

Any offset to use for this association (or nil if there is no offset).

# File lib/sequel/model/associations.rb, line 715
def offset
  limit_and_offset.last
end
placeholder_eager_loader() click to toggle source

A placeholder literalizer used to speed up eager loading.

# File lib/sequel/model/associations.rb, line 720
def placeholder_eager_loader
  cached_fetch(:placeholder_eager_loader) do
    Sequel::Dataset::PlaceholderLiteralizer.loader(associated_dataset) do |pl, ds|
      apply_eager_limit_strategy(eager_loading_dataset.where(predicate_key=>pl.arg), eager_limit_strategy)
    end
  end
end
possible_reciprocal_types() click to toggle source

The reciprocal type as an array, should be overridden in reflection subclasses that have ambiguous reciprocal types.

# File lib/sequel/model/associations.rb, line 730
def possible_reciprocal_types
  [reciprocal_type]
end
reciprocal_association?(assoc_reflect) click to toggle source

Whether the given association reflection is possible reciprocal association for the current association reflection.

# File lib/sequel/model/associations.rb, line 736
def reciprocal_association?(assoc_reflect)
  possible_reciprocal_types.include?(assoc_reflect[:type]) &&
    (begin; assoc_reflect.associated_class; rescue NameError; end) == self[:model] &&
    assoc_reflect[:conditions].nil? &&
    assoc_reflect[:block].nil?
end
subqueries_per_union() click to toggle source

The number of subqueries to use in each union query, used to eagerly load limited associations. Defaults to 40, the optimal number depends on the latency between the database and the application.

# File lib/sequel/model/associations.rb, line 746
def subqueries_per_union
  self[:subqueries_per_union] || 40
end
transform(s) { |s)| ... } click to toggle source

If s is an array, map s over the block. Otherwise, just call the block with s.

# File lib/sequel/model/associations.rb, line 752
def transform(s)
  s.is_a?(Array) ? s.map(&Proc.new) : (yield s)
end
true_eager_graph_limit_strategy() click to toggle source

The eager_graph limit strategy used when true is given as the value, choosing the best strategy based on what the database supports.

# File lib/sequel/model/associations.rb, line 770
def true_eager_graph_limit_strategy
  if associated_class.dataset.supports_window_functions?
    :window_function
  else
    :ruby
  end
end
true_eager_limit_strategy() click to toggle source

What eager limit strategy should be used when true is given as the value, defaults to UNION as that is the fastest strategy if the appropriate keys are indexed.

# File lib/sequel/model/associations.rb, line 758
def true_eager_limit_strategy
  if self[:eager_graph] || (offset && !associated_dataset.supports_offsets_in_correlated_subqueries?)
    # An SQL-based approach won't work if you are also eager graphing,
    # so use a ruby based approach in that case.
    :ruby
  else
    :union 
  end
end
union_eager_loader() click to toggle source

A placeholder literalizer used to speed up the creation of union queries when eager loading a limited association.

# File lib/sequel/model/associations.rb, line 780
def union_eager_loader
  cached_fetch(:union_eager_loader) do
    Sequel::Dataset::PlaceholderLiteralizer.loader(associated_dataset) do |pl, ds|
      ds = self[:eager_block].call(ds) if self[:eager_block]
      keys = predicate_keys
      ds = ds.where(keys.map{pl.arg}.zip(keys))
      if eager_loading_use_associated_key?
        ds = ds.select_append(*associated_key_array)
      end
      ds.from_self
    end
  end
end
use_placeholder_loader?() click to toggle source

Whether the placeholder loader can be used to load the association.

# File lib/sequel/model/associations.rb, line 795
def use_placeholder_loader?
  !self[:instance_specific] && !self[:eager_graph]
end