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
1214 def associated_key_alias
1215   self[:left_key_alias]
1216 end
associated_key_array() click to toggle source

Array of associated keys used when eagerly loading.

     # File lib/sequel/model/associations.rb
1219 def associated_key_array
1220   cached_fetch(:associated_key_array) do
1221     if self[:uses_left_composite_keys]
1222       associated_key_alias.zip(predicate_keys).map{|a, k| SQL::AliasedExpression.new(k, a)}
1223     else
1224       [SQL::AliasedExpression.new(predicate_key, associated_key_alias)]
1225     end
1226   end
1227 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
1230 def associated_key_column
1231   self[:left_key]
1232 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
1235 def associated_object_keys
1236   right_primary_keys
1237 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
1241 def can_have_associated_objects?(obj)
1242   !self[:left_primary_keys].any?{|k| obj.get_column_value(k).nil?}
1243 end
cloneable?(ref) click to toggle source

one_through_one and many_to_many associations can be clones

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

Default name symbol for the join table.

     # File lib/sequel/model/associations.rb
1289 def default_join_table
1290   [self[:class_name], self[:model].name].map{|i| underscore(pluralize(demodulize(i)))}.sort.join('_').to_sym
1291 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
1295 def default_left_key
1296   :"#{underscore(demodulize(self[:model].name))}_id"
1297 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
1301 def default_right_key
1302   :"#{singularize(self[:name])}_id"
1303 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
1334 def eager_loading_use_associated_key?
1335   !separate_query_per_table?
1336 end
finalize_settings() click to toggle source
     # File lib/sequel/model/associations.rb
1317 def finalize_settings
1318   FINALIZE_SETTINGS
1319 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
1346 def join_table_alias
1347   cached_fetch(:join_table_alias) do
1348     s, a = split_join_table_alias
1349     a || s
1350   end
1351 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
1340 def join_table_source
1341   cached_fetch(:join_table_source){split_join_table_alias[0]}
1342 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
1356 def need_associated_primary_key?
1357   true
1358 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
1323 def predicate_key
1324   cached_fetch(:predicate_key){qualify(join_table_alias, self[:left_key])}
1325 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
1329 def qualified_right_key
1330   cached_fetch(:qualified_right_key){qualify(join_table_alias, self[:right_key])}
1331 end
qualified_right_primary_key() click to toggle source

right_primary_key qualified by the associated table

     # File lib/sequel/model/associations.rb
1361 def qualified_right_primary_key
1362   cached_fetch(:qualified_right_primary_key){qualify_assoc(right_primary_key)}
1363 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
1366 def right_primary_key
1367   cached_fetch(:right_primary_key){associated_class.primary_key || raise(Error, "no primary key specified for #{associated_class.inspect}")}
1368 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
1377 def right_primary_key_method
1378   cached_fetch(:right_primary_key_method){right_primary_key}
1379 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
1383 def right_primary_key_methods
1384   cached_fetch(:right_primary_key_methods){Array(right_primary_key_method)}
1385 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
1371 def right_primary_keys
1372   cached_fetch(:right_primary_keys){Array(right_primary_key)}
1373 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
1388 def select
1389   cached_fetch(:select){default_select}
1390 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
1393 def separate_query_per_table?
1394   self[:join_table_db]
1395 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
1400 def _associated_dataset
1401   if separate_query_per_table?
1402     super
1403   else
1404     super.inner_join(self[:join_table], self[:right_keys].zip(right_primary_keys), :qualify=>:deep)
1405   end
1406 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
1421 def default_select
1422   if (sel = associated_class.dataset.opts[:select]) && sel.all?{|c| selection_is_qualified?(c)}
1423     sel
1424   else
1425     Sequel::SQL::ColumnAll.new(associated_class.table_name)
1426   end
1427 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
1410 def eager_loading_set_predicate_condition(ds, eo)
1411   if separate_query_per_table?
1412     ds.where(right_primary_key=>eo[:right_keys])
1413   else
1414     super
1415   end
1416 end
filter_by_associations_conditions_associated_keys() click to toggle source
     # File lib/sequel/model/associations.rb
1429 def filter_by_associations_conditions_associated_keys
1430   qualify(join_table_alias, self[:left_keys])
1431 end
filter_by_associations_conditions_key() click to toggle source
     # File lib/sequel/model/associations.rb
1433 def filter_by_associations_conditions_key
1434   qualify(self[:model].table_name, self[:left_primary_key_column])
1435 end
filter_by_associations_limit_alias_key() click to toggle source
     # File lib/sequel/model/associations.rb
1437 def filter_by_associations_limit_alias_key
1438   aliaz = 'a'
1439   filter_by_associations_limit_key.map{|c| c.as(Sequel.identifier(aliaz = aliaz.next))}
1440 end
filter_by_associations_limit_aliases() click to toggle source
     # File lib/sequel/model/associations.rb
1442 def filter_by_associations_limit_aliases
1443   filter_by_associations_limit_alias_key.map(&:alias)
1444 end
filter_by_associations_limit_key() click to toggle source
     # File lib/sequel/model/associations.rb
1446 def filter_by_associations_limit_key
1447   qualify(join_table_alias, self[:left_keys]) + Array(qualify(associated_class.table_name, associated_class.primary_key))
1448 end
predicate_key_methods() click to toggle source
     # File lib/sequel/model/associations.rb
1450 def predicate_key_methods
1451   self[:left_primary_keys]
1452 end
reciprocal_association?(assoc_reflect) click to toggle source
     # File lib/sequel/model/associations.rb
1454 def reciprocal_association?(assoc_reflect)
1455   super && assoc_reflect[:left_keys] == self[:right_keys] &&
1456     assoc_reflect[:right_keys] == self[:left_keys] &&
1457     assoc_reflect[:join_table] == self[:join_table] &&
1458     right_primary_keys == assoc_reflect[:left_primary_key_columns] &&
1459     self[:left_primary_key_columns] == assoc_reflect.right_primary_keys
1460 end
reciprocal_type() click to toggle source
     # File lib/sequel/model/associations.rb
1462 def reciprocal_type
1463   :many_to_many
1464 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
1468 def selection_is_qualified?(c)
1469   case c
1470   when Symbol
1471     Sequel.split_symbol(c)[0]
1472   when Sequel::SQL::QualifiedIdentifier
1473     true
1474   when Sequel::SQL::AliasedExpression
1475     selection_is_qualified?(c.expression)
1476   else
1477     false
1478   end
1479 end
split_join_table_alias() click to toggle source

Split the join table into source and alias parts.

     # File lib/sequel/model/associations.rb
1482 def split_join_table_alias
1483   associated_class.dataset.split_alias(self[:join_table])
1484 end