class Sequel::Model::Associations::ManyToManyAssociationReflection
Constants
- FINALIZE_SETTINGS
Public Instance Methods
The alias to use for the associated key when eagerly loading
# File lib/sequel/model/associations.rb 1224 def associated_key_alias 1225 self[:left_key_alias] 1226 end
Array
of associated keys used when eagerly loading.
# File lib/sequel/model/associations.rb 1229 def associated_key_array 1230 cached_fetch(:associated_key_array) do 1231 if self[:uses_left_composite_keys] 1232 associated_key_alias.zip(predicate_keys).map{|a, k| SQL::AliasedExpression.new(k, a)} 1233 else 1234 [SQL::AliasedExpression.new(predicate_key, associated_key_alias)] 1235 end 1236 end 1237 end
The column to use for the associated key when eagerly loading
# File lib/sequel/model/associations.rb 1240 def associated_key_column 1241 self[:left_key] 1242 end
Alias of right_primary_keys
# File lib/sequel/model/associations.rb 1245 def associated_object_keys 1246 right_primary_keys 1247 end
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 1251 def can_have_associated_objects?(obj) 1252 !self[:left_primary_keys].any?{|k| obj.get_column_value(k).nil?} 1253 end
one_through_one and many_to_many associations can be clones
# File lib/sequel/model/associations.rb 1256 def cloneable?(ref) 1257 ref[:type] == :many_to_many || ref[:type] == :one_through_one 1258 end
The default associated key alias(es) to use when eager loading associations via eager.
# File lib/sequel/model/associations.rb 1262 def default_associated_key_alias 1263 self[:uses_left_composite_keys] ? (0...self[:left_keys].length).map{|i| :"x_foreign_key_#{i}_x"} : :x_foreign_key_x 1264 end
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 1268 def default_eager_loader(eo) 1269 h = eo[:id_map] 1270 assign_singular = assign_singular? 1271 delete_rn = delete_row_number_column 1272 uses_lcks = self[:uses_left_composite_keys] 1273 left_key_alias = self[:left_key_alias] 1274 name = self[:name] 1275 1276 self[:model].eager_load_results(self, eo) do |assoc_record| 1277 assoc_record.values.delete(delete_rn) if delete_rn 1278 hash_key = if uses_lcks 1279 left_key_alias.map{|k| assoc_record.values.delete(k)} 1280 else 1281 assoc_record.values.delete(left_key_alias) 1282 end 1283 1284 objects = h[hash_key] 1285 1286 if assign_singular 1287 objects.each do |object| 1288 object.associations[name] ||= assoc_record 1289 end 1290 else 1291 objects.each do |object| 1292 object.associations[name].push(assoc_record) 1293 end 1294 end 1295 end 1296 end
Default name symbol for the join table.
# File lib/sequel/model/associations.rb 1299 def default_join_table 1300 [self[:class_name], self[:model].name].map{|i| underscore(pluralize(demodulize(i)))}.sort.join('_').to_sym 1301 end
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 1305 def default_left_key 1306 :"#{underscore(demodulize(self[:model].name))}_id" 1307 end
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 1311 def default_right_key 1312 :"#{singularize(self[:name])}_id" 1313 end
many_to_many associations need to select a key in an associated table to eagerly load
# File lib/sequel/model/associations.rb 1344 def eager_loading_use_associated_key? 1345 !separate_query_per_table? 1346 end
# File lib/sequel/model/associations.rb 1327 def finalize_settings 1328 FINALIZE_SETTINGS 1329 end
The join table itself, unless it is aliased, in which case this is the alias.
# File lib/sequel/model/associations.rb 1356 def join_table_alias 1357 cached_fetch(:join_table_alias) do 1358 s, a = split_join_table_alias 1359 a || s 1360 end 1361 end
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 1350 def join_table_source 1351 cached_fetch(:join_table_source){split_join_table_alias[0]} 1352 end
Whether the associated object needs a primary key to be added/removed, true for many_to_many associations.
# File lib/sequel/model/associations.rb 1366 def need_associated_primary_key? 1367 true 1368 end
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 1333 def predicate_key 1334 cached_fetch(:predicate_key){qualify(join_table_alias, self[:left_key])} 1335 end
The right key qualified by the join table.
# File lib/sequel/model/associations.rb 1339 def qualified_right_key 1340 cached_fetch(:qualified_right_key){qualify(join_table_alias, self[:right_key])} 1341 end
right_primary_key
qualified by the associated table
# File lib/sequel/model/associations.rb 1371 def qualified_right_primary_key 1372 cached_fetch(:qualified_right_primary_key){qualify_assoc(right_primary_key)} 1373 end
The primary key column(s) to use in the associated table (can be symbol or array).
# File lib/sequel/model/associations.rb 1376 def right_primary_key 1377 cached_fetch(:right_primary_key){associated_class.primary_key || raise(Error, "no primary key specified for #{associated_class.inspect}")} 1378 end
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 1387 def right_primary_key_method 1388 cached_fetch(:right_primary_key_method){right_primary_key} 1389 end
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 1393 def right_primary_key_methods 1394 cached_fetch(:right_primary_key_methods){Array(right_primary_key_method)} 1395 end
The primary key columns to use in the associated table (always array).
# File lib/sequel/model/associations.rb 1381 def right_primary_keys 1382 cached_fetch(:right_primary_keys){Array(right_primary_key)} 1383 end
The columns to select when loading the association, associated_class.table_name.* by default.
# File lib/sequel/model/associations.rb 1398 def select 1399 cached_fetch(:select){default_select} 1400 end
Whether a separate query should be used for the join table.
# File lib/sequel/model/associations.rb 1403 def separate_query_per_table? 1404 self[:join_table_db] 1405 end
Private Instance Methods
Join to the the join table, unless using a separate query per table.
Sequel::Model::Associations::AssociationReflection#_associated_dataset
# File lib/sequel/model/associations.rb 1410 def _associated_dataset 1411 if separate_query_per_table? 1412 super 1413 else 1414 super.inner_join(self[:join_table], self[:right_keys].zip(right_primary_keys), :qualify=>:deep) 1415 end 1416 end
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 1431 def default_select 1432 if (sel = associated_class.dataset.opts[:select]) && sel.all?{|c| selection_is_qualified?(c)} 1433 sel 1434 else 1435 Sequel::SQL::ColumnAll.new(associated_class.table_name) 1436 end 1437 end
Use the right_keys from the eager loading options if using a separate query per table.
Sequel::Model::Associations::AssociationReflection#eager_loading_set_predicate_condition
# File lib/sequel/model/associations.rb 1420 def eager_loading_set_predicate_condition(ds, eo) 1421 if separate_query_per_table? 1422 ds.where(right_primary_key=>eo[:right_keys]) 1423 else 1424 super 1425 end 1426 end
# File lib/sequel/model/associations.rb 1439 def filter_by_associations_conditions_associated_keys 1440 qualify(join_table_alias, self[:left_keys]) 1441 end
# File lib/sequel/model/associations.rb 1443 def filter_by_associations_conditions_key 1444 qualify(self[:model].table_name, self[:left_primary_key_column]) 1445 end
# File lib/sequel/model/associations.rb 1447 def filter_by_associations_limit_alias_key 1448 aliaz = 'a' 1449 filter_by_associations_limit_key.map{|c| c.as(Sequel.identifier(aliaz = aliaz.next))} 1450 end
# File lib/sequel/model/associations.rb 1452 def filter_by_associations_limit_aliases 1453 filter_by_associations_limit_alias_key.map(&:alias) 1454 end
# File lib/sequel/model/associations.rb 1456 def filter_by_associations_limit_key 1457 qualify(join_table_alias, self[:left_keys]) + Array(qualify(associated_class.table_name, associated_class.primary_key)) 1458 end
# File lib/sequel/model/associations.rb 1460 def predicate_key_methods 1461 self[:left_primary_keys] 1462 end
Sequel::Model::Associations::AssociationReflection#reciprocal_association?
# File lib/sequel/model/associations.rb 1464 def reciprocal_association?(assoc_reflect) 1465 super && assoc_reflect[:left_keys] == self[:right_keys] && 1466 assoc_reflect[:right_keys] == self[:left_keys] && 1467 assoc_reflect[:join_table] == self[:join_table] && 1468 right_primary_keys == assoc_reflect[:left_primary_key_columns] && 1469 self[:left_primary_key_columns] == assoc_reflect.right_primary_keys 1470 end
# File lib/sequel/model/associations.rb 1472 def reciprocal_type 1473 :many_to_many 1474 end
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 1478 def selection_is_qualified?(c) 1479 case c 1480 when Symbol 1481 Sequel.split_symbol(c)[0] 1482 when Sequel::SQL::QualifiedIdentifier 1483 true 1484 when Sequel::SQL::AliasedExpression 1485 selection_is_qualified?(c.expression) 1486 else 1487 false 1488 end 1489 end
Split the join table into source and alias parts.
# File lib/sequel/model/associations.rb 1492 def split_join_table_alias 1493 associated_class.dataset.split_alias(self[:join_table]) 1494 end