class Sequel::Model::Associations::ManyToManyAssociationReflection

Constants

FINALIZE_SETTINGS

Public Instance Methods

associated_key_alias() click to toggle source

The alias to use for the associated key when eagerly loading

# File lib/sequel/model/associations.rb, line 1185
def associated_key_alias
  self[:left_key_alias]
end
associated_key_array() click to toggle source

Array of associated keys used when eagerly loading.

# File lib/sequel/model/associations.rb, line 1190
def associated_key_array
  cached_fetch(:associated_key_array) do
    if self[:uses_left_composite_keys]
      associated_key_alias.zip(predicate_keys).map{|a, k| SQL::AliasedExpression.new(k, a)}
    else
      [SQL::AliasedExpression.new(predicate_key, associated_key_alias)]
    end
  end
end
associated_key_column() click to toggle source

The column to use for the associated key when eagerly loading

# File lib/sequel/model/associations.rb, line 1201
def associated_key_column
  self[:left_key]
end
associated_key_table()
Alias for: join_table_alias
associated_object_keys() click to toggle source

Alias of #right_primary_keys

# File lib/sequel/model/associations.rb, line 1206
def associated_object_keys
  right_primary_keys
end
can_have_associated_objects?(obj) click to toggle source

many_to_many associations can only have associated objects if none of the :left_primary_keys options have a nil value.

# File lib/sequel/model/associations.rb, line 1212
def can_have_associated_objects?(obj)
  !self[:left_primary_keys].any?{|k| obj.get_column_value(k).nil?}
end
cloneable?(ref) click to toggle source

one_through_one and many_to_many associations can be clones

# File lib/sequel/model/associations.rb, line 1217
def cloneable?(ref)
  ref[:type] == :many_to_many || ref[:type] == :one_through_one
end
default_associated_key_alias() click to toggle source

The default associated key alias(es) to use when eager loading associations via eager.

# File lib/sequel/model/associations.rb, line 1223
def default_associated_key_alias
  self[:uses_left_composite_keys] ? (0...self[:left_keys].length).map{|i| :"x_foreign_key_#{i}_x"} : :x_foreign_key_x
end
default_eager_loader(eo) click to toggle source

The default eager loader used if the user doesn't override it. Extracted to a method so the code can be shared with the many_through_many plugin.

# File lib/sequel/model/associations.rb, line 1229
def default_eager_loader(eo)
  h = eo[:id_map]
  assign_singular = assign_singular?
  delete_rn = delete_row_number_column
  uses_lcks = self[:uses_left_composite_keys]
  left_key_alias = self[:left_key_alias]
  name = self[:name]

  self[:model].eager_load_results(self, eo) do |assoc_record|
    assoc_record.values.delete(delete_rn) if delete_rn
    hash_key = if uses_lcks
      left_key_alias.map{|k| assoc_record.values.delete(k)}
    else
      assoc_record.values.delete(left_key_alias)
    end
    next unless objects = h[hash_key]
    if assign_singular
      objects.each do |object| 
        object.associations[name] ||= assoc_record
      end
    else
      objects.each do |object|
        object.associations[name].push(assoc_record)
      end
    end
  end
end
default_join_table() click to toggle source

Default name symbol for the join table.

# File lib/sequel/model/associations.rb, line 1258
def default_join_table
  [self[:class_name], self[:model].name].map{|i| underscore(pluralize(demodulize(i)))}.sort.join('_').to_sym
end
default_left_key() click to toggle source

Default foreign key name symbol for key in join table that points to current table's primary key (or :left_primary_key column).

# File lib/sequel/model/associations.rb, line 1264
def default_left_key
  :"#{underscore(demodulize(self[:model].name))}_id"
end
default_right_key() click to toggle source

Default foreign key name symbol for foreign key in join table that points to the association's table's primary key (or :right_primary_key column).

# File lib/sequel/model/associations.rb, line 1270
def default_right_key
  :"#{singularize(self[:name])}_id"
end
eager_loading_use_associated_key?() click to toggle source

many_to_many associations need to select a key in an associated table to eagerly load

# File lib/sequel/model/associations.rb, line 1303
def eager_loading_use_associated_key?
  true
end
finalize_settings() click to toggle source
# File lib/sequel/model/associations.rb, line 1286
def finalize_settings
  FINALIZE_SETTINGS
end
join_table_alias() click to toggle source

The join table itself, unless it is aliased, in which case this is the alias.

# File lib/sequel/model/associations.rb, line 1315
def join_table_alias
  cached_fetch(:join_table_alias) do
    s, a = split_join_table_alias
    a || s
  end
end
Also aliased as: associated_key_table
join_table_source() click to toggle source

The source of the join table. This is the join table itself, unless it is aliased, in which case it is the unaliased part.

# File lib/sequel/model/associations.rb, line 1309
def join_table_source
  cached_fetch(:join_table_source){split_join_table_alias[0]}
end
need_associated_primary_key?() click to toggle source

Whether the associated object needs a primary key to be added/removed, true for many_to_many associations.

# File lib/sequel/model/associations.rb, line 1325
def need_associated_primary_key?
  true
end
predicate_key() click to toggle source

The hash key to use for the eager loading predicate (left side of IN (1, 2, 3)). The left key qualified by the join table.

# File lib/sequel/model/associations.rb, line 1292
def predicate_key
  cached_fetch(:predicate_key){qualify(join_table_alias, self[:left_key])}
end
Also aliased as: qualified_left_key
qualified_left_key()
Alias for: predicate_key
qualified_right_key() click to toggle source

The right key qualified by the join table.

# File lib/sequel/model/associations.rb, line 1298
def qualified_right_key
  cached_fetch(:qualified_right_key){qualify(join_table_alias, self[:right_key])}
end
qualified_right_primary_key() click to toggle source

#right_primary_key qualified by the associated table

# File lib/sequel/model/associations.rb, line 1330
def qualified_right_primary_key
  cached_fetch(:qualified_right_primary_key){qualify_assoc(right_primary_key)}
end
right_primary_key() click to toggle source

The primary key column(s) to use in the associated table (can be symbol or array).

# File lib/sequel/model/associations.rb, line 1335
def right_primary_key
  cached_fetch(:right_primary_key){associated_class.primary_key || raise(Error, "no primary key specified for #{associated_class.inspect}")}
end
right_primary_key_method() click to toggle source

The method symbol or array of method symbols to call on the associated objects to get the foreign key values for the join table.

# File lib/sequel/model/associations.rb, line 1346
def right_primary_key_method
  cached_fetch(:right_primary_key_method){right_primary_key}
end
right_primary_key_methods() click to toggle source

The array of method symbols to call on the associated objects to get the foreign key values for the join table.

# File lib/sequel/model/associations.rb, line 1352
def right_primary_key_methods
  cached_fetch(:right_primary_key_methods){Array(right_primary_key_method)}
end
right_primary_keys() click to toggle source

The primary key columns to use in the associated table (always array).

# File lib/sequel/model/associations.rb, line 1340
def right_primary_keys
  cached_fetch(:right_primary_keys){Array(right_primary_key)}
end
select() click to toggle source

The columns to select when loading the association, associated_class.table_name.* by default.

# File lib/sequel/model/associations.rb, line 1357
def select
  cached_fetch(:select){default_select}
end

Private Instance Methods

_associated_dataset() click to toggle source
Calls superclass method Sequel::Model::Associations::AssociationReflection#_associated_dataset
# File lib/sequel/model/associations.rb, line 1363
def _associated_dataset
  super.inner_join(self[:join_table], self[:right_keys].zip(right_primary_keys), :qualify=>:deep)
end
default_select() click to toggle source

The default selection for associations that require joins. These do not use the default model selection unless all entries in the select are explicitly qualified identifiers, as other it can include unqualified columns which would be made ambiguous by joining.

# File lib/sequel/model/associations.rb, line 1370
def default_select
  if (sel = associated_class.dataset.opts[:select]) && sel.all?{|c| selection_is_qualified?(c)}
    sel
  else
    Sequel::SQL::ColumnAll.new(associated_class.table_name)
  end
end
filter_by_associations_conditions_associated_keys() click to toggle source
# File lib/sequel/model/associations.rb, line 1378
def filter_by_associations_conditions_associated_keys
  qualify(join_table_alias, self[:left_keys])
end
filter_by_associations_conditions_key() click to toggle source
# File lib/sequel/model/associations.rb, line 1382
def filter_by_associations_conditions_key
  qualify(self[:model].table_name, self[:left_primary_key_column])
end
filter_by_associations_limit_alias_key() click to toggle source
# File lib/sequel/model/associations.rb, line 1386
def filter_by_associations_limit_alias_key
  aliaz = 'a'
  filter_by_associations_limit_key.map{|c| c.as(Sequel.identifier(aliaz = aliaz.next))}
end
filter_by_associations_limit_aliases() click to toggle source
# File lib/sequel/model/associations.rb, line 1391
def filter_by_associations_limit_aliases
  filter_by_associations_limit_alias_key.map(&:alias)
end
filter_by_associations_limit_key() click to toggle source
# File lib/sequel/model/associations.rb, line 1395
def filter_by_associations_limit_key
  qualify(join_table_alias, self[:left_keys]) + Array(qualify(associated_class.table_name, associated_class.primary_key))
end
predicate_key_methods() click to toggle source
# File lib/sequel/model/associations.rb, line 1399
def predicate_key_methods
  self[:left_primary_keys]
end
reciprocal_association?(assoc_reflect) click to toggle source
# File lib/sequel/model/associations.rb, line 1403
def reciprocal_association?(assoc_reflect)
  super && assoc_reflect[:left_keys] == self[:right_keys] &&
    assoc_reflect[:right_keys] == self[:left_keys] &&
    assoc_reflect[:join_table] == self[:join_table] &&
    right_primary_keys == assoc_reflect[:left_primary_key_columns] &&
    self[:left_primary_key_columns] == assoc_reflect.right_primary_keys
end
reciprocal_type() click to toggle source
# File lib/sequel/model/associations.rb, line 1411
def reciprocal_type
  :many_to_many
end
selection_is_qualified?(c) click to toggle source

Whether the given expression represents a qualified identifier. Used to determine if it is OK to use directly when joining.

# File lib/sequel/model/associations.rb, line 1417
def selection_is_qualified?(c)
  case c
  when Symbol
    Sequel.split_symbol(c)[0]
  when Sequel::SQL::QualifiedIdentifier
    true
  when Sequel::SQL::AliasedExpression
    selection_is_qualified?(c.expression)
  else
    false
  end
end
split_join_table_alias() click to toggle source

Split the join table into source and alias parts.

# File lib/sequel/model/associations.rb, line 1431
def split_join_table_alias
  associated_class.dataset.split_alias(self[:join_table])
end