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
1235 def associated_key_alias
1236   self[:left_key_alias]
1237 end
associated_key_array() click to toggle source

Array of associated keys used when eagerly loading.

     # File lib/sequel/model/associations.rb
1240 def associated_key_array
1241   cached_fetch(:associated_key_array) do
1242     if self[:uses_left_composite_keys]
1243       associated_key_alias.zip(predicate_keys).map{|a, k| SQL::AliasedExpression.new(k, a)}
1244     else
1245       [SQL::AliasedExpression.new(predicate_key, associated_key_alias)]
1246     end
1247   end
1248 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
1251 def associated_key_column
1252   self[:left_key]
1253 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
1256 def associated_object_keys
1257   right_primary_keys
1258 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
1262 def can_have_associated_objects?(obj)
1263   !self[:left_primary_keys].any?{|k| obj.get_column_value(k).nil?}
1264 end
cloneable?(ref) click to toggle source

one_through_one and many_to_many associations can be clones

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

Default name symbol for the join table.

     # File lib/sequel/model/associations.rb
1310 def default_join_table
1311   [self[:class_name], self[:model].name].map{|i| underscore(pluralize(demodulize(i)))}.sort.join('_').to_sym
1312 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
1316 def default_left_key
1317   :"#{underscore(demodulize(self[:model].name))}_id"
1318 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
1322 def default_right_key
1323   :"#{singularize(self[:name])}_id"
1324 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
1355 def eager_loading_use_associated_key?
1356   !separate_query_per_table?
1357 end
finalize_settings() click to toggle source
     # File lib/sequel/model/associations.rb
1338 def finalize_settings
1339   FINALIZE_SETTINGS
1340 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
1367 def join_table_alias
1368   cached_fetch(:join_table_alias) do
1369     s, a = split_join_table_alias
1370     a || s
1371   end
1372 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
1361 def join_table_source
1362   cached_fetch(:join_table_source){split_join_table_alias[0]}
1363 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
1377 def need_associated_primary_key?
1378   true
1379 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
1344 def predicate_key
1345   cached_fetch(:predicate_key){qualify(join_table_alias, self[:left_key])}
1346 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
1350 def qualified_right_key
1351   cached_fetch(:qualified_right_key){qualify(join_table_alias, self[:right_key])}
1352 end
qualified_right_primary_key() click to toggle source

right_primary_key qualified by the associated table

     # File lib/sequel/model/associations.rb
1382 def qualified_right_primary_key
1383   cached_fetch(:qualified_right_primary_key){qualify_assoc(right_primary_key)}
1384 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
1387 def right_primary_key
1388   cached_fetch(:right_primary_key){associated_class.primary_key || raise(Error, "no primary key specified for #{associated_class.inspect}")}
1389 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
1398 def right_primary_key_method
1399   cached_fetch(:right_primary_key_method){right_primary_key}
1400 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
1404 def right_primary_key_methods
1405   cached_fetch(:right_primary_key_methods){Array(right_primary_key_method)}
1406 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
1392 def right_primary_keys
1393   cached_fetch(:right_primary_keys){Array(right_primary_key)}
1394 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
1409 def select
1410   cached_fetch(:select){default_select}
1411 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
1414 def separate_query_per_table?
1415   self[:join_table_db]
1416 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
1421 def _associated_dataset
1422   if separate_query_per_table?
1423     super
1424   else
1425     super.inner_join(self[:join_table], self[:right_keys].zip(right_primary_keys), :qualify=>:deep)
1426   end
1427 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
1442 def default_select
1443   if (sel = associated_class.dataset.opts[:select]) && sel.all?{|c| selection_is_qualified?(c)}
1444     sel
1445   else
1446     Sequel::SQL::ColumnAll.new(associated_class.table_name)
1447   end
1448 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
1431 def eager_loading_set_predicate_condition(ds, eo)
1432   if separate_query_per_table?
1433     ds.where(right_primary_key=>eo[:right_keys])
1434   else
1435     super
1436   end
1437 end
filter_by_associations_conditions_associated_keys() click to toggle source
     # File lib/sequel/model/associations.rb
1450 def filter_by_associations_conditions_associated_keys
1451   qualify(join_table_alias, self[:left_keys])
1452 end
filter_by_associations_conditions_key() click to toggle source
     # File lib/sequel/model/associations.rb
1454 def filter_by_associations_conditions_key
1455   qualify(self[:model].table_name, self[:left_primary_key_column])
1456 end
filter_by_associations_limit_alias_key() click to toggle source
     # File lib/sequel/model/associations.rb
1458 def filter_by_associations_limit_alias_key
1459   aliaz = 'a'
1460   filter_by_associations_limit_key.map{|c| c.as(Sequel.identifier(aliaz = aliaz.next))}
1461 end
filter_by_associations_limit_aliases() click to toggle source
     # File lib/sequel/model/associations.rb
1463 def filter_by_associations_limit_aliases
1464   filter_by_associations_limit_alias_key.map(&:alias)
1465 end
filter_by_associations_limit_key() click to toggle source
     # File lib/sequel/model/associations.rb
1467 def filter_by_associations_limit_key
1468   qualify(join_table_alias, self[:left_keys]) + Array(qualify(associated_class.table_name, associated_class.primary_key))
1469 end
predicate_key_methods() click to toggle source
     # File lib/sequel/model/associations.rb
1471 def predicate_key_methods
1472   self[:left_primary_keys]
1473 end
reciprocal_association?(assoc_reflect) click to toggle source
     # File lib/sequel/model/associations.rb
1475 def reciprocal_association?(assoc_reflect)
1476   super && assoc_reflect[:left_keys] == self[:right_keys] &&
1477     assoc_reflect[:right_keys] == self[:left_keys] &&
1478     assoc_reflect[:join_table] == self[:join_table] &&
1479     right_primary_keys == assoc_reflect[:left_primary_key_columns] &&
1480     self[:left_primary_key_columns] == assoc_reflect.right_primary_keys
1481 end
reciprocal_type() click to toggle source
     # File lib/sequel/model/associations.rb
1483 def reciprocal_type
1484   :many_to_many
1485 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
1489 def selection_is_qualified?(c)
1490   case c
1491   when Symbol
1492     Sequel.split_symbol(c)[0]
1493   when Sequel::SQL::QualifiedIdentifier
1494     true
1495   when Sequel::SQL::AliasedExpression
1496     selection_is_qualified?(c.expression)
1497   else
1498     false
1499   end
1500 end
split_join_table_alias() click to toggle source

Split the join table into source and alias parts.

     # File lib/sequel/model/associations.rb
1503 def split_join_table_alias
1504   associated_class.dataset.split_alias(self[:join_table])
1505 end