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
1197 def associated_key_alias
1198   self[:left_key_alias]
1199 end
associated_key_array() click to toggle source

Array of associated keys used when eagerly loading.

     # File lib/sequel/model/associations.rb
1202 def associated_key_array
1203   cached_fetch(:associated_key_array) do
1204     if self[:uses_left_composite_keys]
1205       associated_key_alias.zip(predicate_keys).map{|a, k| SQL::AliasedExpression.new(k, a)}
1206     else
1207       [SQL::AliasedExpression.new(predicate_key, associated_key_alias)]
1208     end
1209   end
1210 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
1213 def associated_key_column
1214   self[:left_key]
1215 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
1218 def associated_object_keys
1219   right_primary_keys
1220 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
1224 def can_have_associated_objects?(obj)
1225   !self[:left_primary_keys].any?{|k| obj.get_column_value(k).nil?}
1226 end
cloneable?(ref) click to toggle source

one_through_one and many_to_many associations can be clones

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

Default name symbol for the join table.

     # File lib/sequel/model/associations.rb
1272 def default_join_table
1273   [self[:class_name], self[:model].name].map{|i| underscore(pluralize(demodulize(i)))}.sort.join('_').to_sym
1274 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
1278 def default_left_key
1279   :"#{underscore(demodulize(self[:model].name))}_id"
1280 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
1284 def default_right_key
1285   :"#{singularize(self[:name])}_id"
1286 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
1317 def eager_loading_use_associated_key?
1318   true
1319 end
finalize_settings() click to toggle source
     # File lib/sequel/model/associations.rb
1300 def finalize_settings
1301   FINALIZE_SETTINGS
1302 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
1329 def join_table_alias
1330   cached_fetch(:join_table_alias) do
1331     s, a = split_join_table_alias
1332     a || s
1333   end
1334 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
1323 def join_table_source
1324   cached_fetch(:join_table_source){split_join_table_alias[0]}
1325 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
1339 def need_associated_primary_key?
1340   true
1341 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
1306 def predicate_key
1307   cached_fetch(:predicate_key){qualify(join_table_alias, self[:left_key])}
1308 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
1312 def qualified_right_key
1313   cached_fetch(:qualified_right_key){qualify(join_table_alias, self[:right_key])}
1314 end
qualified_right_primary_key() click to toggle source

right_primary_key qualified by the associated table

     # File lib/sequel/model/associations.rb
1344 def qualified_right_primary_key
1345   cached_fetch(:qualified_right_primary_key){qualify_assoc(right_primary_key)}
1346 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
1349 def right_primary_key
1350   cached_fetch(:right_primary_key){associated_class.primary_key || raise(Error, "no primary key specified for #{associated_class.inspect}")}
1351 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
1360 def right_primary_key_method
1361   cached_fetch(:right_primary_key_method){right_primary_key}
1362 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
1366 def right_primary_key_methods
1367   cached_fetch(:right_primary_key_methods){Array(right_primary_key_method)}
1368 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
1354 def right_primary_keys
1355   cached_fetch(:right_primary_keys){Array(right_primary_key)}
1356 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
1371 def select
1372   cached_fetch(:select){default_select}
1373 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
1377 def _associated_dataset
1378   super.inner_join(self[:join_table], self[:right_keys].zip(right_primary_keys), :qualify=>:deep)
1379 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
1384 def default_select
1385   if (sel = associated_class.dataset.opts[:select]) && sel.all?{|c| selection_is_qualified?(c)}
1386     sel
1387   else
1388     Sequel::SQL::ColumnAll.new(associated_class.table_name)
1389   end
1390 end
filter_by_associations_conditions_associated_keys() click to toggle source
     # File lib/sequel/model/associations.rb
1392 def filter_by_associations_conditions_associated_keys
1393   qualify(join_table_alias, self[:left_keys])
1394 end
filter_by_associations_conditions_key() click to toggle source
     # File lib/sequel/model/associations.rb
1396 def filter_by_associations_conditions_key
1397   qualify(self[:model].table_name, self[:left_primary_key_column])
1398 end
filter_by_associations_limit_alias_key() click to toggle source
     # File lib/sequel/model/associations.rb
1400 def filter_by_associations_limit_alias_key
1401   aliaz = 'a'
1402   filter_by_associations_limit_key.map{|c| c.as(Sequel.identifier(aliaz = aliaz.next))}
1403 end
filter_by_associations_limit_aliases() click to toggle source
     # File lib/sequel/model/associations.rb
1405 def filter_by_associations_limit_aliases
1406   filter_by_associations_limit_alias_key.map(&:alias)
1407 end
filter_by_associations_limit_key() click to toggle source
     # File lib/sequel/model/associations.rb
1409 def filter_by_associations_limit_key
1410   qualify(join_table_alias, self[:left_keys]) + Array(qualify(associated_class.table_name, associated_class.primary_key))
1411 end
predicate_key_methods() click to toggle source
     # File lib/sequel/model/associations.rb
1413 def predicate_key_methods
1414   self[:left_primary_keys]
1415 end
reciprocal_association?(assoc_reflect) click to toggle source
     # File lib/sequel/model/associations.rb
1417 def reciprocal_association?(assoc_reflect)
1418   super && assoc_reflect[:left_keys] == self[:right_keys] &&
1419     assoc_reflect[:right_keys] == self[:left_keys] &&
1420     assoc_reflect[:join_table] == self[:join_table] &&
1421     right_primary_keys == assoc_reflect[:left_primary_key_columns] &&
1422     self[:left_primary_key_columns] == assoc_reflect.right_primary_keys
1423 end
reciprocal_type() click to toggle source
     # File lib/sequel/model/associations.rb
1425 def reciprocal_type
1426   :many_to_many
1427 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
1431 def selection_is_qualified?(c)
1432   case c
1433   when Symbol
1434     Sequel.split_symbol(c)[0]
1435   when Sequel::SQL::QualifiedIdentifier
1436     true
1437   when Sequel::SQL::AliasedExpression
1438     selection_is_qualified?(c.expression)
1439   else
1440     false
1441   end
1442 end
split_join_table_alias() click to toggle source

Split the join table into source and alias parts.

     # File lib/sequel/model/associations.rb
1445 def split_join_table_alias
1446   associated_class.dataset.split_alias(self[:join_table])
1447 end