class Sequel::Model::Associations::ManyToManyAssociationReflection

     # File lib/sequel/model/associations.rb
1361 def associated_key_alias
1362   self[:left_key_alias]
1363 end

     # 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

     # File lib/sequel/model/associations.rb
1377 def associated_key_column
1378   self[:left_key]
1379 end

     # File lib/sequel/model/associations.rb
1382 def associated_object_keys
1383   right_primary_keys
1384 end

     # 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

     # File lib/sequel/model/associations.rb
1393 def cloneable?(ref)
1394   ref[:type] == :many_to_many || ref[:type] == :one_through_one
1395 end

     # 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

     # 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

     # 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

     # File lib/sequel/model/associations.rb
1442 def default_left_key
1443   :"#{underscore(demodulize(self[:model].name))}_id"
1444 end

     # File lib/sequel/model/associations.rb
1448 def default_right_key
1449   :"#{singularize(self[:name])}_id"
1450 end

     # File lib/sequel/model/associations.rb
1481 def eager_loading_use_associated_key?
1482   !separate_query_per_table?
1483 end

     # File lib/sequel/model/associations.rb
1464 def finalize_settings
1465   FINALIZE_SETTINGS
1466 end

     # 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

     # File lib/sequel/model/associations.rb
1487 def join_table_source
1488   cached_fetch(:join_table_source){split_join_table_alias[0]}
1489 end

     # File lib/sequel/model/associations.rb
1503 def need_associated_primary_key?
1504   true
1505 end

     # File lib/sequel/model/associations.rb
1470 def predicate_key
1471   cached_fetch(:predicate_key){qualify(join_table_alias, self[:left_key])}
1472 end

     # 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

     # 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

     # 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

     # File lib/sequel/model/associations.rb
1524 def right_primary_key_method
1525   cached_fetch(:right_primary_key_method){right_primary_key}
1526 end

     # 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

     # File lib/sequel/model/associations.rb
1518 def right_primary_keys
1519   cached_fetch(:right_primary_keys){Array(right_primary_key)}
1520 end

     # File lib/sequel/model/associations.rb
1535 def select
1536   cached_fetch(:select){default_select}
1537 end

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

     # 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

     # 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

     # 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

     # 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

     # 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

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

     # 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

     # 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

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

     # 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

     # 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

     # 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

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

     # 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

     # 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

     # 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

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

     # 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

     # File lib/sequel/model/associations.rb
1655 def reciprocal_type
1656   :many_to_many
1657 end

     # 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

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