Parent

Included Modules

Class/Module Index [+]

Quicksearch

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.

Public Instance Methods

_add_method() click to toggle source

Name symbol for the _add internal association method

# File lib/sequel/model/associations.rb, line 21
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 26
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 31
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 36
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 41
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 62
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 !returns_array? && self[:key]
  ds = ds.eager(*self[:eager]) if self[:eager]
  ds = ds.distinct if self[:distinct]
  ds
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 51
def associated_class
  cached_fetch(:class){constantize(self[:class_name])}
end
associated_dataset() click to toggle source

The dataset associated via this association, with the non-instance specific changes already applied.

# File lib/sequel/model/associations.rb, line 57
def associated_dataset
  cached_fetch(:_dataset){apply_dataset_changes(associated_class.dataset.clone)}
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 46
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 81
def can_have_associated_objects?(obj)
  true
end
dataset_method() click to toggle source

Name symbol for the dataset association method

# File lib/sequel/model/associations.rb, line 86
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 91
def dataset_need_primary_key?
  true
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 135
def eager_graph_lazy_dataset?
  true
end
eager_limit_strategy() click to toggle source

The eager limit strategy to use for this dataset.

# File lib/sequel/model/associations.rb, line 96
def eager_limit_strategy
  cached_fetch(:_eager_limit_strategy) do
    if self[:limit]
      case s = cached_fetch(:eager_limit_strategy){self[:model].default_eager_limit_strategy || :ruby}
      when true
        ds = associated_class.dataset
        if ds.supports_window_functions?
          :window_function
        else
          :ruby
        end
      else
        s
      end
    else
      nil
    end
  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 117
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 128
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 123
def eager_loading_use_associated_key?
  false
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 140
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 150
def need_associated_primary_key?
  false
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 155
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 162
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) click to toggle source

Qualify col with the associated model's table name.

# File lib/sequel/model/associations.rb, line 174
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 179
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 189
def reciprocal
  cached_fetch(:reciprocal) do
    possible_recips = []
    fallback_recips = []

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

    Sequel::Deprecation.deprecate("Multiple reciprocal association candidates found for #{self[:name]} association (#{possible_recips.map{|r| r[:name]}.join(', ')}).  Choosing the first candidate is", "Please explicitly specify the reciprocal option for the #{self[:name]} association") if possible_recips.size >= 2
    if possible_recips.empty? && !fallback_recips.empty?
      possible_recips = fallback_recips
      Sequel::Deprecation.deprecate("All reciprocal association candidates found for #{self[:name]} association have conditions, blocks, or differing primary keys (#{possible_recips.map{|r| r[:name]}.join(', ')}).  Automatic choosing of an reciprocal association with conditions or blocks is", "Please explicitly specify the reciprocal option for the #{self[:name]} association")
    end

    unless possible_recips.empty?
      cached_set(:reciprocal_type, possible_recips.first[:type]) if reciprocal_type.is_a?(Array)
      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 219
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 224
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 230
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 235
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 240
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 246
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 251
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 257
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 262
def setter_method
  :"#{self[:name]}="
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.