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
1188 def associated_key_alias
1189   self[:left_key_alias]
1190 end
associated_key_array() click to toggle source

Array of associated keys used when eagerly loading.

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

one_through_one and many_to_many associations can be clones

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

Default name symbol for the join table.

     # File lib/sequel/model/associations.rb
1261 def default_join_table
1262   [self[:class_name], self[:model].name].map{|i| underscore(pluralize(demodulize(i)))}.sort.join('_').to_sym
1263 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
1267 def default_left_key
1268   :"#{underscore(demodulize(self[:model].name))}_id"
1269 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
1273 def default_right_key
1274   :"#{singularize(self[:name])}_id"
1275 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
1306 def eager_loading_use_associated_key?
1307   true
1308 end
finalize_settings() click to toggle source
     # File lib/sequel/model/associations.rb
1289 def finalize_settings
1290   FINALIZE_SETTINGS
1291 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
1318 def join_table_alias
1319   cached_fetch(:join_table_alias) do
1320     s, a = split_join_table_alias
1321     a || s
1322   end
1323 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
1312 def join_table_source
1313   cached_fetch(:join_table_source){split_join_table_alias[0]}
1314 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
1328 def need_associated_primary_key?
1329   true
1330 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
1295 def predicate_key
1296   cached_fetch(:predicate_key){qualify(join_table_alias, self[:left_key])}
1297 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
1301 def qualified_right_key
1302   cached_fetch(:qualified_right_key){qualify(join_table_alias, self[:right_key])}
1303 end
qualified_right_primary_key() click to toggle source

right_primary_key qualified by the associated table

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

Split the join table into source and alias parts.

     # File lib/sequel/model/associations.rb
1434 def split_join_table_alias
1435   associated_class.dataset.split_alias(self[:join_table])
1436 end