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
1183 def associated_key_alias
1184   self[:left_key_alias]
1185 end
associated_key_array() click to toggle source

Array of associated keys used when eagerly loading.

     # File lib/sequel/model/associations.rb
1188 def associated_key_array
1189   cached_fetch(:associated_key_array) do
1190     if self[:uses_left_composite_keys]
1191       associated_key_alias.zip(predicate_keys).map{|a, k| SQL::AliasedExpression.new(k, a)}
1192     else
1193       [SQL::AliasedExpression.new(predicate_key, associated_key_alias)]
1194     end
1195   end
1196 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
1199 def associated_key_column
1200   self[:left_key]
1201 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
1204 def associated_object_keys
1205   right_primary_keys
1206 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
1210 def can_have_associated_objects?(obj)
1211   !self[:left_primary_keys].any?{|k| obj.get_column_value(k).nil?}
1212 end
cloneable?(ref) click to toggle source

one_through_one and many_to_many associations can be clones

     # File lib/sequel/model/associations.rb
1215 def cloneable?(ref)
1216   ref[:type] == :many_to_many || ref[:type] == :one_through_one
1217 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
1221 def default_associated_key_alias
1222   self[:uses_left_composite_keys] ? (0...self[:left_keys].length).map{|i| :"x_foreign_key_#{i}_x"} : :x_foreign_key_x
1223 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
1227 def default_eager_loader(eo)
1228   h = eo[:id_map]
1229   assign_singular = assign_singular?
1230   delete_rn = delete_row_number_column
1231   uses_lcks = self[:uses_left_composite_keys]
1232   left_key_alias = self[:left_key_alias]
1233   name = self[:name]
1234 
1235   self[:model].eager_load_results(self, eo) do |assoc_record|
1236     assoc_record.values.delete(delete_rn) if delete_rn
1237     hash_key = if uses_lcks
1238       left_key_alias.map{|k| assoc_record.values.delete(k)}
1239     else
1240       assoc_record.values.delete(left_key_alias)
1241     end
1242     next unless objects = h[hash_key]
1243     if assign_singular
1244       objects.each do |object| 
1245         object.associations[name] ||= assoc_record
1246       end
1247     else
1248       objects.each do |object|
1249         object.associations[name].push(assoc_record)
1250       end
1251     end
1252   end
1253 end
default_join_table() click to toggle source

Default name symbol for the join table.

     # File lib/sequel/model/associations.rb
1256 def default_join_table
1257   [self[:class_name], self[:model].name].map{|i| underscore(pluralize(demodulize(i)))}.sort.join('_').to_sym
1258 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
1262 def default_left_key
1263   :"#{underscore(demodulize(self[:model].name))}_id"
1264 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
1268 def default_right_key
1269   :"#{singularize(self[:name])}_id"
1270 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
1301 def eager_loading_use_associated_key?
1302   true
1303 end
finalize_settings() click to toggle source
     # File lib/sequel/model/associations.rb
1284 def finalize_settings
1285   FINALIZE_SETTINGS
1286 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
1313 def join_table_alias
1314   cached_fetch(:join_table_alias) do
1315     s, a = split_join_table_alias
1316     a || s
1317   end
1318 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
1307 def join_table_source
1308   cached_fetch(:join_table_source){split_join_table_alias[0]}
1309 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
1323 def need_associated_primary_key?
1324   true
1325 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
1290 def predicate_key
1291   cached_fetch(:predicate_key){qualify(join_table_alias, self[:left_key])}
1292 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
1296 def qualified_right_key
1297   cached_fetch(:qualified_right_key){qualify(join_table_alias, self[:right_key])}
1298 end
qualified_right_primary_key() click to toggle source

right_primary_key qualified by the associated table

     # File lib/sequel/model/associations.rb
1328 def qualified_right_primary_key
1329   cached_fetch(:qualified_right_primary_key){qualify_assoc(right_primary_key)}
1330 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
1333 def right_primary_key
1334   cached_fetch(:right_primary_key){associated_class.primary_key || raise(Error, "no primary key specified for #{associated_class.inspect}")}
1335 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
1344 def right_primary_key_method
1345   cached_fetch(:right_primary_key_method){right_primary_key}
1346 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
1350 def right_primary_key_methods
1351   cached_fetch(:right_primary_key_methods){Array(right_primary_key_method)}
1352 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
1338 def right_primary_keys
1339   cached_fetch(:right_primary_keys){Array(right_primary_key)}
1340 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
1355 def select
1356   cached_fetch(:select){default_select}
1357 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
1361 def _associated_dataset
1362   super.inner_join(self[:join_table], self[:right_keys].zip(right_primary_keys), :qualify=>:deep)
1363 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
1368 def default_select
1369   if (sel = associated_class.dataset.opts[:select]) && sel.all?{|c| selection_is_qualified?(c)}
1370     sel
1371   else
1372     Sequel::SQL::ColumnAll.new(associated_class.table_name)
1373   end
1374 end
filter_by_associations_conditions_associated_keys() click to toggle source
     # File lib/sequel/model/associations.rb
1376 def filter_by_associations_conditions_associated_keys
1377   qualify(join_table_alias, self[:left_keys])
1378 end
filter_by_associations_conditions_key() click to toggle source
     # File lib/sequel/model/associations.rb
1380 def filter_by_associations_conditions_key
1381   qualify(self[:model].table_name, self[:left_primary_key_column])
1382 end
filter_by_associations_limit_alias_key() click to toggle source
     # File lib/sequel/model/associations.rb
1384 def filter_by_associations_limit_alias_key
1385   aliaz = 'a'
1386   filter_by_associations_limit_key.map{|c| c.as(Sequel.identifier(aliaz = aliaz.next))}
1387 end
filter_by_associations_limit_aliases() click to toggle source
     # File lib/sequel/model/associations.rb
1389 def filter_by_associations_limit_aliases
1390   filter_by_associations_limit_alias_key.map(&:alias)
1391 end
filter_by_associations_limit_key() click to toggle source
     # File lib/sequel/model/associations.rb
1393 def filter_by_associations_limit_key
1394   qualify(join_table_alias, self[:left_keys]) + Array(qualify(associated_class.table_name, associated_class.primary_key))
1395 end
predicate_key_methods() click to toggle source
     # File lib/sequel/model/associations.rb
1397 def predicate_key_methods
1398   self[:left_primary_keys]
1399 end
reciprocal_association?(assoc_reflect) click to toggle source
     # File lib/sequel/model/associations.rb
1401 def reciprocal_association?(assoc_reflect)
1402   super && assoc_reflect[:left_keys] == self[:right_keys] &&
1403     assoc_reflect[:right_keys] == self[:left_keys] &&
1404     assoc_reflect[:join_table] == self[:join_table] &&
1405     right_primary_keys == assoc_reflect[:left_primary_key_columns] &&
1406     self[:left_primary_key_columns] == assoc_reflect.right_primary_keys
1407 end
reciprocal_type() click to toggle source
     # File lib/sequel/model/associations.rb
1409 def reciprocal_type
1410   :many_to_many
1411 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
1415 def selection_is_qualified?(c)
1416   case c
1417   when Symbol
1418     Sequel.split_symbol(c)[0]
1419   when Sequel::SQL::QualifiedIdentifier
1420     true
1421   when Sequel::SQL::AliasedExpression
1422     selection_is_qualified?(c.expression)
1423   else
1424     false
1425   end
1426 end
split_join_table_alias() click to toggle source

Split the join table into source and alias parts.

     # File lib/sequel/model/associations.rb
1429 def split_join_table_alias
1430   associated_class.dataset.split_alias(self[:join_table])
1431 end