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
1361 def associated_key_alias
1362   self[:left_key_alias]
1363 end

associated_key_array() click to toggle source

Array of associated keys used when eagerly loading.

     # File lib/sequel/model/associations.rb
1366 def associated_key_array
1367   cached_fetch(:associated_key_array) do
1368     if self[:uses_left_composite_keys]
1369       associated_key_alias.zip(predicate_keys).map{|a, k| SQL::AliasedExpression.new(k, a)}
1370     else
1371       [SQL::AliasedExpression.new(predicate_key, associated_key_alias)]
1372     end
1373   end
1374 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
1377 def associated_key_column
1378   self[:left_key]
1379 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
1382 def associated_object_keys
1383   right_primary_keys
1384 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
1388 def can_have_associated_objects?(obj)
1389   !self[:left_primary_keys].any?{|k| obj.get_column_value(k).nil?}
1390 end

cloneable?(ref) click to toggle source

one_through_one and many_to_many associations can be clones

     # File lib/sequel/model/associations.rb
1393 def cloneable?(ref)
1394   ref[:type] == :many_to_many || ref[:type] == :one_through_one
1395 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
1399 def default_associated_key_alias
1400   self[:uses_left_composite_keys] ? (0...self[:left_keys].length).map{|i| :"x_foreign_key_#{i}_x"} : :x_foreign_key_x
1401 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
1405 def default_eager_loader(eo)
1406   h = eo[:id_map]
1407   assign_singular = assign_singular?
1408   delete_rn = delete_row_number_column
1409   uses_lcks = self[:uses_left_composite_keys]
1410   left_key_alias = self[:left_key_alias]
1411   name = self[:name]
1412 
1413   self[:model].eager_load_results(self, eo) do |assoc_record|
1414     assoc_record.remove_key!(delete_rn) if delete_rn
1415     hash_key = if uses_lcks
1416       left_key_alias.map{|k| assoc_record.remove_key!(k)}
1417     else
1418       assoc_record.remove_key!(left_key_alias)
1419     end
1420 
1421     objects = h[hash_key]
1422 
1423     if assign_singular
1424       objects.each do |object| 
1425         object.associations[name] ||= assoc_record
1426       end
1427     else
1428       objects.each do |object|
1429         object.associations[name].push(assoc_record)
1430       end
1431     end
1432   end
1433 end

default_join_table() click to toggle source

Default name symbol for the join table.

     # File lib/sequel/model/associations.rb
1436 def default_join_table
1437   [self[:class_name], self[:model].name].map{|i| underscore(pluralize(demodulize(i)))}.sort.join('_').to_sym
1438 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
1442 def default_left_key
1443   :"#{underscore(demodulize(self[:model].name))}_id"
1444 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
1448 def default_right_key
1449   :"#{singularize(self[:name])}_id"
1450 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
1481 def eager_loading_use_associated_key?
1482   !separate_query_per_table?
1483 end

finalize_settings() click to toggle source

     # File lib/sequel/model/associations.rb
1464 def finalize_settings
1465   FINALIZE_SETTINGS
1466 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
1493 def join_table_alias
1494   cached_fetch(:join_table_alias) do
1495     s, a = split_join_table_alias
1496     a || s
1497   end
1498 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
1487 def join_table_source
1488   cached_fetch(:join_table_source){split_join_table_alias[0]}
1489 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
1503 def need_associated_primary_key?
1504   true
1505 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
1470 def predicate_key
1471   cached_fetch(:predicate_key){qualify(join_table_alias, self[:left_key])}
1472 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
1476 def qualified_right_key
1477   cached_fetch(:qualified_right_key){qualify(join_table_alias, self[:right_key])}
1478 end

qualified_right_primary_key() click to toggle source

right_primary_key qualified by the associated table

     # File lib/sequel/model/associations.rb
1508 def qualified_right_primary_key
1509   cached_fetch(:qualified_right_primary_key){qualify_assoc(right_primary_key)}
1510 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
1513 def right_primary_key
1514   cached_fetch(:right_primary_key){associated_class.primary_key || raise(Error, "no primary key specified for #{associated_class.inspect}")}
1515 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
1524 def right_primary_key_method
1525   cached_fetch(:right_primary_key_method){right_primary_key}
1526 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
1530 def right_primary_key_methods
1531   cached_fetch(:right_primary_key_methods){Array(right_primary_key_method)}
1532 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
1518 def right_primary_keys
1519   cached_fetch(:right_primary_keys){Array(right_primary_key)}
1520 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
1535 def select
1536   cached_fetch(:select){default_select}
1537 end

separate_query_per_table?() click to toggle source

Whether a separate query should be used for the join table.

     # File lib/sequel/model/associations.rb
1540 def separate_query_per_table?
1541   self[:join_table_db]
1542 end

Private Instance Methods

_associated_dataset() click to toggle source

Join to the the join table, unless using a separate query per table.

Calls superclass method Sequel::Model::Associations::AssociationReflection#_associated_dataset

     # File lib/sequel/model/associations.rb
1547 def _associated_dataset
1548   if separate_query_per_table?
1549     super
1550   else
1551     super.inner_join(self[:join_table], self[:right_keys].zip(right_primary_keys), :qualify=>:deep)
1552   end
1553 end

apply_lateral_subquery_eager_graph_limit_strategy(ds) click to toggle source

     # File lib/sequel/model/associations.rb
1593 def apply_lateral_subquery_eager_graph_limit_strategy(ds)
1594   ds.
1595     limit(*limit_and_offset).
1596     where(qualify(join_table_alias, self[:left_keys]).zip(qualify(ds.opts[:eager_options][:implicit_qualifier], self[:left_primary_key_columns]))).
1597     order(*self[:order]).
1598     lateral
1599 end

apply_lateral_subquery_eager_limit_strategy(ds, ids, limit_and_offset) click to toggle source

Calls superclass method Sequel::Model::Associations::AssociationReflection#apply_lateral_subquery_eager_limit_strategy

     # File lib/sequel/model/associations.rb
1585 def apply_lateral_subquery_eager_limit_strategy(ds, ids, limit_and_offset)
1586   table_name = self[:model].table_name
1587   super.
1588     select_all(associated_class.table_name).
1589     select_append(*qualify(table_name, self[:left_primary_keys]).zip(Array(self[:left_key_alias])).map{|id, aliaz| Sequel.as(id, aliaz)}).
1590     where(qualify(table_name, self[:left_primary_key]) => ids)
1591 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
1614 def default_select
1615   if (sel = associated_class.dataset.opts[:select]) && sel.all?{|c| selection_is_qualified?(c)}
1616     sel
1617   else
1618     Sequel::SQL::ColumnAll.new(associated_class.table_name)
1619   end
1620 end

eager_loading_set_predicate_condition(ds, eo) click to toggle source

Use the right_keys from the eager loading options if using a separate query per table.

Calls superclass method Sequel::Model::Associations::AssociationReflection#eager_loading_set_predicate_condition

     # File lib/sequel/model/associations.rb
1603 def eager_loading_set_predicate_condition(ds, eo)
1604   if separate_query_per_table?
1605     ds.where(right_primary_key=>eo[:right_keys])
1606   else
1607     super
1608   end
1609 end

filter_by_associations_conditions_associated_keys() click to toggle source

     # File lib/sequel/model/associations.rb
1622 def filter_by_associations_conditions_associated_keys
1623   qualify(join_table_alias, self[:left_keys])
1624 end

filter_by_associations_conditions_key() click to toggle source

     # File lib/sequel/model/associations.rb
1626 def filter_by_associations_conditions_key
1627   qualify(self[:model].table_name, self[:left_primary_key_column])
1628 end

filter_by_associations_limit_alias_key() click to toggle source

     # File lib/sequel/model/associations.rb
1630 def filter_by_associations_limit_alias_key
1631   aliaz = 'a'
1632   filter_by_associations_limit_key.map{|c| c.as(Sequel.identifier(aliaz = aliaz.next))}
1633 end

filter_by_associations_limit_aliases() click to toggle source

     # File lib/sequel/model/associations.rb
1635 def filter_by_associations_limit_aliases
1636   filter_by_associations_limit_alias_key.map(&:alias)
1637 end

filter_by_associations_limit_key() click to toggle source

     # File lib/sequel/model/associations.rb
1639 def filter_by_associations_limit_key
1640   qualify(join_table_alias, self[:left_keys]) + Array(qualify(associated_class.table_name, associated_class.primary_key))
1641 end

lateral_subquery_eager_limit_strategy_lateral_dataset(ds, limit_and_offset) click to toggle source

Calls superclass method Sequel::Model::Associations::AssociationReflection#lateral_subquery_eager_limit_strategy_lateral_dataset

     # File lib/sequel/model/associations.rb
1577 def lateral_subquery_eager_limit_strategy_lateral_dataset(ds, limit_and_offset)
1578   ds = super
1579   select = ds.opts[:select].dup
1580   left_key_alias = self[:left_key_alias]
1581   select.pop while (s = select.last).is_a?(Sequel::SQL::AliasedExpression) && (left_key_alias.is_a?(Array) ? left_key_alias.include?(s.alias) : s.alias == left_key_alias)
1582   ds = ds.clone(:select=>select)
1583 end

lateral_subquery_filter_limit_strategy_conditions(obj) click to toggle source

     # File lib/sequel/model/associations.rb
1555 def lateral_subquery_filter_limit_strategy_conditions(obj)
1556   _lateral_subquery_filter_limit_strategy_conditions(obj, lateral_subquery_filter_limit_strategy_conditions_key, right_primary_key_method, right_primary_key)
1557 end

lateral_subquery_filter_limit_strategy_conditions_key() click to toggle source

     # File lib/sequel/model/associations.rb
1559 def lateral_subquery_filter_limit_strategy_conditions_key
1560   self[:right_key]
1561 end

lateral_subquery_filter_limit_strategy_filter_dataset(ds, obj) click to toggle source

     # File lib/sequel/model/associations.rb
1567 def lateral_subquery_filter_limit_strategy_filter_dataset(ds, obj)
1568   ds.where(filter_by_associations_conditions_key => ds.db.from(self[:join_table]).
1569     select(*self[:left_key]).
1570     where(lateral_subquery_filter_limit_strategy_conditions(obj)))
1571 end

lateral_subquery_filter_limit_strategy_filter_lateral_dataset(ds) click to toggle source

     # File lib/sequel/model/associations.rb
1563 def lateral_subquery_filter_limit_strategy_filter_lateral_dataset(ds)
1564   ds.where(Array(filter_by_associations_conditions_key).zip(Array(filter_by_associations_conditions_associated_keys)))
1565 end

lateral_subquery_filter_limit_strategy_lateral_dataset_select() click to toggle source

     # File lib/sequel/model/associations.rb
1573 def lateral_subquery_filter_limit_strategy_lateral_dataset_select
1574   qualify(self[:model].table_name, self[:left_primary_key])
1575 end

predicate_key_methods() click to toggle source

     # File lib/sequel/model/associations.rb
1643 def predicate_key_methods
1644   self[:left_primary_keys]
1645 end

reciprocal_association?(assoc_reflect) click to toggle source

Calls superclass method Sequel::Model::Associations::AssociationReflection#reciprocal_association?

     # File lib/sequel/model/associations.rb
1647 def reciprocal_association?(assoc_reflect)
1648   super && assoc_reflect[:left_keys] == self[:right_keys] &&
1649     assoc_reflect[:right_keys] == self[:left_keys] &&
1650     assoc_reflect[:join_table] == self[:join_table] &&
1651     right_primary_keys == assoc_reflect[:left_primary_key_columns] &&
1652     self[:left_primary_key_columns] == assoc_reflect.right_primary_keys
1653 end

reciprocal_type() click to toggle source

     # File lib/sequel/model/associations.rb
1655 def reciprocal_type
1656   :many_to_many
1657 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
1661 def selection_is_qualified?(c)
1662   case c
1663   when Symbol
1664     Sequel.split_symbol(c)[0]
1665   when Sequel::SQL::QualifiedIdentifier
1666     true
1667   when Sequel::SQL::AliasedExpression
1668     selection_is_qualified?(c.expression)
1669   else
1670     false
1671   end
1672 end

split_join_table_alias() click to toggle source

Split the join table into source and alias parts.

     # File lib/sequel/model/associations.rb
1675 def split_join_table_alias
1676   associated_class.dataset.split_alias(self[:join_table])
1677 end