class Sequel::Model::Associations::AssociationReflection

  1. lib/sequel/model/associations.rb
Parent: Associations

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.

Included modules

  1. Sequel::Inflections

Public Instance methods

_add_method ()

Name symbol for the _add internal association method

[show source] 
# File lib/sequel/model/associations.rb, line 21
def _add_method
  :"_add_#{singularize(self[:name])}"
end
_dataset_method ()

Name symbol for the _dataset association method

[show source] 
# File lib/sequel/model/associations.rb, line 26
def _dataset_method
  :"_#{self[:name]}_dataset"
end
_remove_all_method ()

Name symbol for the _remove_all internal association method

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

Name symbol for the _remove internal association method

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

Name symbol for the _setter association method

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

Name symbol for the add association method

[show source] 
# File lib/sequel/model/associations.rb, line 46
def add_method
  :"add_#{singularize(self[:name])}"
end
associated_class ()

The class associated to the current model class via this association

[show source] 
# File lib/sequel/model/associations.rb, line 56
def associated_class
  cached_fetch(:class){constantize(self[:class_name])}
end
association_method ()

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

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

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.

[show source] 
# File lib/sequel/model/associations.rb, line 63
def can_have_associated_objects?(obj)
  true
end
dataset_helper_method ()

Name symbol for the _helper internal association method

[show source] 
# File lib/sequel/model/associations.rb, line 73
def dataset_helper_method
  :"_#{self[:name]}_dataset_helper"
end
dataset_method ()

Name symbol for the dataset association method

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

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

[show source] 
# File lib/sequel/model/associations.rb, line 78
def dataset_need_primary_key?
  true
end
eager_graph_lazy_dataset? ()

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.

[show source] 
# File lib/sequel/model/associations.rb, line 112
def eager_graph_lazy_dataset?
  true
end
eager_limit_strategy ()

The eager limit strategy to use for this dataset.

[show source] 
# File lib/sequel/model/associations.rb, line 83
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_loading_use_associated_key? ()

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

[show source] 
# File lib/sequel/model/associations.rb, line 105
def eager_loading_use_associated_key?
  false
end
limit_and_offset ()

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

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

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

[show source] 
# File lib/sequel/model/associations.rb, line 127
def need_associated_primary_key?
  false
end
qualify (table, col)

Qualify col with the given table name. If col is an array of columns, return an array of qualified columns.

[show source] 
# File lib/sequel/model/associations.rb, line 133
def qualify(table, col)
  transform(col){|k| SQL::QualifiedIdentifier.new(table, k)}
end
qualify_assoc (col)

Qualify col with the associated model's table name.

[show source] 
# File lib/sequel/model/associations.rb, line 138
def qualify_assoc(col)
  qualify(associated_class.table_name, col)
end
qualify_cur (col)

Qualify col with the current model's table name.

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

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.

[show source] 
# File lib/sequel/model/associations.rb, line 153
def reciprocal
  cached_fetch(:reciprocal) do
    r_types = Array(reciprocal_type)
    keys = self[:keys]
    recip = nil
    associated_class.all_association_reflections.each do |assoc_reflect|
      if r_types.include?(assoc_reflect[:type]) && assoc_reflect[:keys] == keys && assoc_reflect.associated_class == self[:model]
        cached_set(:reciprocal_type, assoc_reflect[:type])
        recip = assoc_reflect[:name]
        break
      end
    end
    recip
  end
end
reciprocal_array? ()

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

[show source] 
# File lib/sequel/model/associations.rb, line 171
def reciprocal_array?
  true
end
remove_all_method ()

Name symbol for the remove_all_ association method

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

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

[show source] 
# File lib/sequel/model/associations.rb, line 182
def remove_before_destroy?
  true
end
remove_method ()

Name symbol for the remove_ association method

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

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

[show source] 
# File lib/sequel/model/associations.rb, line 192
def remove_should_check_existing?
  false
end
returns_array? ()

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

[show source] 
# File lib/sequel/model/associations.rb, line 198
def returns_array?
  true
end
select ()

The columns to select when loading the association.

[show source] 
# File lib/sequel/model/associations.rb, line 203
def select
  self[:select]
end
set_reciprocal_to_self? ()

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

[show source] 
# File lib/sequel/model/associations.rb, line 209
def set_reciprocal_to_self?
  false
end
setter_method ()

Name symbol for the setter association method

[show source] 
# File lib/sequel/model/associations.rb, line 214
def setter_method
  :"#{self[:name]}="
end