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
1224 def associated_key_alias
1225   self[:left_key_alias]
1226 end
associated_key_array() click to toggle source

Array of associated keys used when eagerly loading.

     # File lib/sequel/model/associations.rb
1229 def associated_key_array
1230   cached_fetch(:associated_key_array) do
1231     if self[:uses_left_composite_keys]
1232       associated_key_alias.zip(predicate_keys).map{|a, k| SQL::AliasedExpression.new(k, a)}
1233     else
1234       [SQL::AliasedExpression.new(predicate_key, associated_key_alias)]
1235     end
1236   end
1237 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
1240 def associated_key_column
1241   self[:left_key]
1242 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
1245 def associated_object_keys
1246   right_primary_keys
1247 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
1251 def can_have_associated_objects?(obj)
1252   !self[:left_primary_keys].any?{|k| obj.get_column_value(k).nil?}
1253 end
cloneable?(ref) click to toggle source

one_through_one and many_to_many associations can be clones

     # File lib/sequel/model/associations.rb
1256 def cloneable?(ref)
1257   ref[:type] == :many_to_many || ref[:type] == :one_through_one
1258 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
1262 def default_associated_key_alias
1263   self[:uses_left_composite_keys] ? (0...self[:left_keys].length).map{|i| :"x_foreign_key_#{i}_x"} : :x_foreign_key_x
1264 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
1268 def default_eager_loader(eo)
1269   h = eo[:id_map]
1270   assign_singular = assign_singular?
1271   delete_rn = delete_row_number_column
1272   uses_lcks = self[:uses_left_composite_keys]
1273   left_key_alias = self[:left_key_alias]
1274   name = self[:name]
1275 
1276   self[:model].eager_load_results(self, eo) do |assoc_record|
1277     assoc_record.values.delete(delete_rn) if delete_rn
1278     hash_key = if uses_lcks
1279       left_key_alias.map{|k| assoc_record.values.delete(k)}
1280     else
1281       assoc_record.values.delete(left_key_alias)
1282     end
1283 
1284     objects = h[hash_key]
1285 
1286     if assign_singular
1287       objects.each do |object| 
1288         object.associations[name] ||= assoc_record
1289       end
1290     else
1291       objects.each do |object|
1292         object.associations[name].push(assoc_record)
1293       end
1294     end
1295   end
1296 end
default_join_table() click to toggle source

Default name symbol for the join table.

     # File lib/sequel/model/associations.rb
1299 def default_join_table
1300   [self[:class_name], self[:model].name].map{|i| underscore(pluralize(demodulize(i)))}.sort.join('_').to_sym
1301 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
1305 def default_left_key
1306   :"#{underscore(demodulize(self[:model].name))}_id"
1307 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
1311 def default_right_key
1312   :"#{singularize(self[:name])}_id"
1313 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
1344 def eager_loading_use_associated_key?
1345   !separate_query_per_table?
1346 end
finalize_settings() click to toggle source
     # File lib/sequel/model/associations.rb
1327 def finalize_settings
1328   FINALIZE_SETTINGS
1329 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
1356 def join_table_alias
1357   cached_fetch(:join_table_alias) do
1358     s, a = split_join_table_alias
1359     a || s
1360   end
1361 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
1350 def join_table_source
1351   cached_fetch(:join_table_source){split_join_table_alias[0]}
1352 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
1366 def need_associated_primary_key?
1367   true
1368 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
1333 def predicate_key
1334   cached_fetch(:predicate_key){qualify(join_table_alias, self[:left_key])}
1335 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
1339 def qualified_right_key
1340   cached_fetch(:qualified_right_key){qualify(join_table_alias, self[:right_key])}
1341 end
qualified_right_primary_key() click to toggle source

right_primary_key qualified by the associated table

     # File lib/sequel/model/associations.rb
1371 def qualified_right_primary_key
1372   cached_fetch(:qualified_right_primary_key){qualify_assoc(right_primary_key)}
1373 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
1376 def right_primary_key
1377   cached_fetch(:right_primary_key){associated_class.primary_key || raise(Error, "no primary key specified for #{associated_class.inspect}")}
1378 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
1387 def right_primary_key_method
1388   cached_fetch(:right_primary_key_method){right_primary_key}
1389 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
1393 def right_primary_key_methods
1394   cached_fetch(:right_primary_key_methods){Array(right_primary_key_method)}
1395 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
1381 def right_primary_keys
1382   cached_fetch(:right_primary_keys){Array(right_primary_key)}
1383 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
1398 def select
1399   cached_fetch(:select){default_select}
1400 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
1403 def separate_query_per_table?
1404   self[:join_table_db]
1405 end

Private Instance Methods

_associated_dataset() click to toggle source

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

     # File lib/sequel/model/associations.rb
1410 def _associated_dataset
1411   if separate_query_per_table?
1412     super
1413   else
1414     super.inner_join(self[:join_table], self[:right_keys].zip(right_primary_keys), :qualify=>:deep)
1415   end
1416 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
1431 def default_select
1432   if (sel = associated_class.dataset.opts[:select]) && sel.all?{|c| selection_is_qualified?(c)}
1433     sel
1434   else
1435     Sequel::SQL::ColumnAll.new(associated_class.table_name)
1436   end
1437 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.

     # File lib/sequel/model/associations.rb
1420 def eager_loading_set_predicate_condition(ds, eo)
1421   if separate_query_per_table?
1422     ds.where(right_primary_key=>eo[:right_keys])
1423   else
1424     super
1425   end
1426 end
filter_by_associations_conditions_associated_keys() click to toggle source
     # File lib/sequel/model/associations.rb
1439 def filter_by_associations_conditions_associated_keys
1440   qualify(join_table_alias, self[:left_keys])
1441 end
filter_by_associations_conditions_key() click to toggle source
     # File lib/sequel/model/associations.rb
1443 def filter_by_associations_conditions_key
1444   qualify(self[:model].table_name, self[:left_primary_key_column])
1445 end
filter_by_associations_limit_alias_key() click to toggle source
     # File lib/sequel/model/associations.rb
1447 def filter_by_associations_limit_alias_key
1448   aliaz = 'a'
1449   filter_by_associations_limit_key.map{|c| c.as(Sequel.identifier(aliaz = aliaz.next))}
1450 end
filter_by_associations_limit_aliases() click to toggle source
     # File lib/sequel/model/associations.rb
1452 def filter_by_associations_limit_aliases
1453   filter_by_associations_limit_alias_key.map(&:alias)
1454 end
filter_by_associations_limit_key() click to toggle source
     # File lib/sequel/model/associations.rb
1456 def filter_by_associations_limit_key
1457   qualify(join_table_alias, self[:left_keys]) + Array(qualify(associated_class.table_name, associated_class.primary_key))
1458 end
predicate_key_methods() click to toggle source
     # File lib/sequel/model/associations.rb
1460 def predicate_key_methods
1461   self[:left_primary_keys]
1462 end
reciprocal_association?(assoc_reflect) click to toggle source
     # File lib/sequel/model/associations.rb
1464 def reciprocal_association?(assoc_reflect)
1465   super && assoc_reflect[:left_keys] == self[:right_keys] &&
1466     assoc_reflect[:right_keys] == self[:left_keys] &&
1467     assoc_reflect[:join_table] == self[:join_table] &&
1468     right_primary_keys == assoc_reflect[:left_primary_key_columns] &&
1469     self[:left_primary_key_columns] == assoc_reflect.right_primary_keys
1470 end
reciprocal_type() click to toggle source
     # File lib/sequel/model/associations.rb
1472 def reciprocal_type
1473   :many_to_many
1474 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
1478 def selection_is_qualified?(c)
1479   case c
1480   when Symbol
1481     Sequel.split_symbol(c)[0]
1482   when Sequel::SQL::QualifiedIdentifier
1483     true
1484   when Sequel::SQL::AliasedExpression
1485     selection_is_qualified?(c.expression)
1486   else
1487     false
1488   end
1489 end
split_join_table_alias() click to toggle source

Split the join table into source and alias parts.

     # File lib/sequel/model/associations.rb
1492 def split_join_table_alias
1493   associated_class.dataset.split_alias(self[:join_table])
1494 end