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
1200 def associated_key_alias
1201   self[:left_key_alias]
1202 end
associated_key_array() click to toggle source

Array of associated keys used when eagerly loading.

     # File lib/sequel/model/associations.rb
1205 def associated_key_array
1206   cached_fetch(:associated_key_array) do
1207     if self[:uses_left_composite_keys]
1208       associated_key_alias.zip(predicate_keys).map{|a, k| SQL::AliasedExpression.new(k, a)}
1209     else
1210       [SQL::AliasedExpression.new(predicate_key, associated_key_alias)]
1211     end
1212   end
1213 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
1216 def associated_key_column
1217   self[:left_key]
1218 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
1221 def associated_object_keys
1222   right_primary_keys
1223 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
1227 def can_have_associated_objects?(obj)
1228   !self[:left_primary_keys].any?{|k| obj.get_column_value(k).nil?}
1229 end
cloneable?(ref) click to toggle source

one_through_one and many_to_many associations can be clones

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

Default name symbol for the join table.

     # File lib/sequel/model/associations.rb
1275 def default_join_table
1276   [self[:class_name], self[:model].name].map{|i| underscore(pluralize(demodulize(i)))}.sort.join('_').to_sym
1277 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
1281 def default_left_key
1282   :"#{underscore(demodulize(self[:model].name))}_id"
1283 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
1287 def default_right_key
1288   :"#{singularize(self[:name])}_id"
1289 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
1320 def eager_loading_use_associated_key?
1321   true
1322 end
finalize_settings() click to toggle source
     # File lib/sequel/model/associations.rb
1303 def finalize_settings
1304   FINALIZE_SETTINGS
1305 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
1332 def join_table_alias
1333   cached_fetch(:join_table_alias) do
1334     s, a = split_join_table_alias
1335     a || s
1336   end
1337 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
1326 def join_table_source
1327   cached_fetch(:join_table_source){split_join_table_alias[0]}
1328 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
1342 def need_associated_primary_key?
1343   true
1344 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
1309 def predicate_key
1310   cached_fetch(:predicate_key){qualify(join_table_alias, self[:left_key])}
1311 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
1315 def qualified_right_key
1316   cached_fetch(:qualified_right_key){qualify(join_table_alias, self[:right_key])}
1317 end
qualified_right_primary_key() click to toggle source

right_primary_key qualified by the associated table

     # File lib/sequel/model/associations.rb
1347 def qualified_right_primary_key
1348   cached_fetch(:qualified_right_primary_key){qualify_assoc(right_primary_key)}
1349 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
1352 def right_primary_key
1353   cached_fetch(:right_primary_key){associated_class.primary_key || raise(Error, "no primary key specified for #{associated_class.inspect}")}
1354 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
1363 def right_primary_key_method
1364   cached_fetch(:right_primary_key_method){right_primary_key}
1365 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
1369 def right_primary_key_methods
1370   cached_fetch(:right_primary_key_methods){Array(right_primary_key_method)}
1371 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
1357 def right_primary_keys
1358   cached_fetch(:right_primary_keys){Array(right_primary_key)}
1359 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
1374 def select
1375   cached_fetch(:select){default_select}
1376 end

Private Instance Methods

_associated_dataset() click to toggle source
Calls superclass method Sequel::Model::Associations::AssociationReflection#_associated_dataset
     # File lib/sequel/model/associations.rb
1380 def _associated_dataset
1381   super.inner_join(self[:join_table], self[:right_keys].zip(right_primary_keys), :qualify=>:deep)
1382 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
1387 def default_select
1388   if (sel = associated_class.dataset.opts[:select]) && sel.all?{|c| selection_is_qualified?(c)}
1389     sel
1390   else
1391     Sequel::SQL::ColumnAll.new(associated_class.table_name)
1392   end
1393 end
filter_by_associations_conditions_associated_keys() click to toggle source
     # File lib/sequel/model/associations.rb
1395 def filter_by_associations_conditions_associated_keys
1396   qualify(join_table_alias, self[:left_keys])
1397 end
filter_by_associations_conditions_key() click to toggle source
     # File lib/sequel/model/associations.rb
1399 def filter_by_associations_conditions_key
1400   qualify(self[:model].table_name, self[:left_primary_key_column])
1401 end
filter_by_associations_limit_alias_key() click to toggle source
     # File lib/sequel/model/associations.rb
1403 def filter_by_associations_limit_alias_key
1404   aliaz = 'a'
1405   filter_by_associations_limit_key.map{|c| c.as(Sequel.identifier(aliaz = aliaz.next))}
1406 end
filter_by_associations_limit_aliases() click to toggle source
     # File lib/sequel/model/associations.rb
1408 def filter_by_associations_limit_aliases
1409   filter_by_associations_limit_alias_key.map(&:alias)
1410 end
filter_by_associations_limit_key() click to toggle source
     # File lib/sequel/model/associations.rb
1412 def filter_by_associations_limit_key
1413   qualify(join_table_alias, self[:left_keys]) + Array(qualify(associated_class.table_name, associated_class.primary_key))
1414 end
predicate_key_methods() click to toggle source
     # File lib/sequel/model/associations.rb
1416 def predicate_key_methods
1417   self[:left_primary_keys]
1418 end
reciprocal_association?(assoc_reflect) click to toggle source
     # File lib/sequel/model/associations.rb
1420 def reciprocal_association?(assoc_reflect)
1421   super && assoc_reflect[:left_keys] == self[:right_keys] &&
1422     assoc_reflect[:right_keys] == self[:left_keys] &&
1423     assoc_reflect[:join_table] == self[:join_table] &&
1424     right_primary_keys == assoc_reflect[:left_primary_key_columns] &&
1425     self[:left_primary_key_columns] == assoc_reflect.right_primary_keys
1426 end
reciprocal_type() click to toggle source
     # File lib/sequel/model/associations.rb
1428 def reciprocal_type
1429   :many_to_many
1430 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
1434 def selection_is_qualified?(c)
1435   case c
1436   when Symbol
1437     Sequel.split_symbol(c)[0]
1438   when Sequel::SQL::QualifiedIdentifier
1439     true
1440   when Sequel::SQL::AliasedExpression
1441     selection_is_qualified?(c.expression)
1442   else
1443     false
1444   end
1445 end
split_join_table_alias() click to toggle source

Split the join table into source and alias parts.

     # File lib/sequel/model/associations.rb
1448 def split_join_table_alias
1449   associated_class.dataset.split_alias(self[:join_table])
1450 end