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
1209 def associated_key_alias
1210   self[:left_key_alias]
1211 end
associated_key_array() click to toggle source

Array of associated keys used when eagerly loading.

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

one_through_one and many_to_many associations can be clones

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

Default name symbol for the join table.

     # File lib/sequel/model/associations.rb
1284 def default_join_table
1285   [self[:class_name], self[:model].name].map{|i| underscore(pluralize(demodulize(i)))}.sort.join('_').to_sym
1286 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
1290 def default_left_key
1291   :"#{underscore(demodulize(self[:model].name))}_id"
1292 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
1296 def default_right_key
1297   :"#{singularize(self[:name])}_id"
1298 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
1329 def eager_loading_use_associated_key?
1330   !separate_query_per_table?
1331 end
finalize_settings() click to toggle source
     # File lib/sequel/model/associations.rb
1312 def finalize_settings
1313   FINALIZE_SETTINGS
1314 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
1341 def join_table_alias
1342   cached_fetch(:join_table_alias) do
1343     s, a = split_join_table_alias
1344     a || s
1345   end
1346 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
1335 def join_table_source
1336   cached_fetch(:join_table_source){split_join_table_alias[0]}
1337 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
1351 def need_associated_primary_key?
1352   true
1353 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
1318 def predicate_key
1319   cached_fetch(:predicate_key){qualify(join_table_alias, self[:left_key])}
1320 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
1324 def qualified_right_key
1325   cached_fetch(:qualified_right_key){qualify(join_table_alias, self[:right_key])}
1326 end
qualified_right_primary_key() click to toggle source

right_primary_key qualified by the associated table

     # File lib/sequel/model/associations.rb
1356 def qualified_right_primary_key
1357   cached_fetch(:qualified_right_primary_key){qualify_assoc(right_primary_key)}
1358 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
1361 def right_primary_key
1362   cached_fetch(:right_primary_key){associated_class.primary_key || raise(Error, "no primary key specified for #{associated_class.inspect}")}
1363 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
1372 def right_primary_key_method
1373   cached_fetch(:right_primary_key_method){right_primary_key}
1374 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
1378 def right_primary_key_methods
1379   cached_fetch(:right_primary_key_methods){Array(right_primary_key_method)}
1380 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
1366 def right_primary_keys
1367   cached_fetch(:right_primary_keys){Array(right_primary_key)}
1368 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
1383 def select
1384   cached_fetch(:select){default_select}
1385 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
1388 def separate_query_per_table?
1389   self[:join_table_db]
1390 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
1395 def _associated_dataset
1396   if separate_query_per_table?
1397     super
1398   else
1399     super.inner_join(self[:join_table], self[:right_keys].zip(right_primary_keys), :qualify=>:deep)
1400   end
1401 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
1416 def default_select
1417   if (sel = associated_class.dataset.opts[:select]) && sel.all?{|c| selection_is_qualified?(c)}
1418     sel
1419   else
1420     Sequel::SQL::ColumnAll.new(associated_class.table_name)
1421   end
1422 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
1405 def eager_loading_set_predicate_condition(ds, eo)
1406   if separate_query_per_table?
1407     ds.where(right_primary_key=>eo[:right_keys])
1408   else
1409     super
1410   end
1411 end
filter_by_associations_conditions_associated_keys() click to toggle source
     # File lib/sequel/model/associations.rb
1424 def filter_by_associations_conditions_associated_keys
1425   qualify(join_table_alias, self[:left_keys])
1426 end
filter_by_associations_conditions_key() click to toggle source
     # File lib/sequel/model/associations.rb
1428 def filter_by_associations_conditions_key
1429   qualify(self[:model].table_name, self[:left_primary_key_column])
1430 end
filter_by_associations_limit_alias_key() click to toggle source
     # File lib/sequel/model/associations.rb
1432 def filter_by_associations_limit_alias_key
1433   aliaz = 'a'
1434   filter_by_associations_limit_key.map{|c| c.as(Sequel.identifier(aliaz = aliaz.next))}
1435 end
filter_by_associations_limit_aliases() click to toggle source
     # File lib/sequel/model/associations.rb
1437 def filter_by_associations_limit_aliases
1438   filter_by_associations_limit_alias_key.map(&:alias)
1439 end
filter_by_associations_limit_key() click to toggle source
     # File lib/sequel/model/associations.rb
1441 def filter_by_associations_limit_key
1442   qualify(join_table_alias, self[:left_keys]) + Array(qualify(associated_class.table_name, associated_class.primary_key))
1443 end
predicate_key_methods() click to toggle source
     # File lib/sequel/model/associations.rb
1445 def predicate_key_methods
1446   self[:left_primary_keys]
1447 end
reciprocal_association?(assoc_reflect) click to toggle source
     # File lib/sequel/model/associations.rb
1449 def reciprocal_association?(assoc_reflect)
1450   super && assoc_reflect[:left_keys] == self[:right_keys] &&
1451     assoc_reflect[:right_keys] == self[:left_keys] &&
1452     assoc_reflect[:join_table] == self[:join_table] &&
1453     right_primary_keys == assoc_reflect[:left_primary_key_columns] &&
1454     self[:left_primary_key_columns] == assoc_reflect.right_primary_keys
1455 end
reciprocal_type() click to toggle source
     # File lib/sequel/model/associations.rb
1457 def reciprocal_type
1458   :many_to_many
1459 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
1463 def selection_is_qualified?(c)
1464   case c
1465   when Symbol
1466     Sequel.split_symbol(c)[0]
1467   when Sequel::SQL::QualifiedIdentifier
1468     true
1469   when Sequel::SQL::AliasedExpression
1470     selection_is_qualified?(c.expression)
1471   else
1472     false
1473   end
1474 end
split_join_table_alias() click to toggle source

Split the join table into source and alias parts.

     # File lib/sequel/model/associations.rb
1477 def split_join_table_alias
1478   associated_class.dataset.split_alias(self[:join_table])
1479 end