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 1241 def associated_key_alias 1242 self[:left_key_alias] 1243 end
Array
of associated keys used when eagerly loading.
# File lib/sequel/model/associations.rb 1246 def associated_key_array 1247 cached_fetch(:associated_key_array) do 1248 if self[:uses_left_composite_keys] 1249 associated_key_alias.zip(predicate_keys).map{|a, k| SQL::AliasedExpression.new(k, a)} 1250 else 1251 [SQL::AliasedExpression.new(predicate_key, associated_key_alias)] 1252 end 1253 end 1254 end
The column to use for the associated key when eagerly loading
# File lib/sequel/model/associations.rb 1257 def associated_key_column 1258 self[:left_key] 1259 end
Alias of right_primary_keys
# File lib/sequel/model/associations.rb 1262 def associated_object_keys 1263 right_primary_keys 1264 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 1268 def can_have_associated_objects?(obj) 1269 !self[:left_primary_keys].any?{|k| obj.get_column_value(k).nil?} 1270 end
one_through_one and many_to_many associations can be clones
# File lib/sequel/model/associations.rb 1273 def cloneable?(ref) 1274 ref[:type] == :many_to_many || ref[:type] == :one_through_one 1275 end
The default associated key alias(es) to use when eager loading associations via eager.
# File lib/sequel/model/associations.rb 1279 def default_associated_key_alias 1280 self[:uses_left_composite_keys] ? (0...self[:left_keys].length).map{|i| :"x_foreign_key_#{i}_x"} : :x_foreign_key_x 1281 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 1285 def default_eager_loader(eo) 1286 h = eo[:id_map] 1287 assign_singular = assign_singular? 1288 delete_rn = delete_row_number_column 1289 uses_lcks = self[:uses_left_composite_keys] 1290 left_key_alias = self[:left_key_alias] 1291 name = self[:name] 1292 1293 self[:model].eager_load_results(self, eo) do |assoc_record| 1294 assoc_record.values.delete(delete_rn) if delete_rn 1295 hash_key = if uses_lcks 1296 left_key_alias.map{|k| assoc_record.values.delete(k)} 1297 else 1298 assoc_record.values.delete(left_key_alias) 1299 end 1300 1301 objects = h[hash_key] 1302 1303 if assign_singular 1304 objects.each do |object| 1305 object.associations[name] ||= assoc_record 1306 end 1307 else 1308 objects.each do |object| 1309 object.associations[name].push(assoc_record) 1310 end 1311 end 1312 end 1313 end
Default name symbol for the join table.
# File lib/sequel/model/associations.rb 1316 def default_join_table 1317 [self[:class_name], self[:model].name].map{|i| underscore(pluralize(demodulize(i)))}.sort.join('_').to_sym 1318 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 1322 def default_left_key 1323 :"#{underscore(demodulize(self[:model].name))}_id" 1324 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 1328 def default_right_key 1329 :"#{singularize(self[:name])}_id" 1330 end
many_to_many associations need to select a key in an associated table to eagerly load
# File lib/sequel/model/associations.rb 1361 def eager_loading_use_associated_key? 1362 !separate_query_per_table? 1363 end
# File lib/sequel/model/associations.rb 1344 def finalize_settings 1345 FINALIZE_SETTINGS 1346 end
The join table itself, unless it is aliased, in which case this is the alias.
# File lib/sequel/model/associations.rb 1373 def join_table_alias 1374 cached_fetch(:join_table_alias) do 1375 s, a = split_join_table_alias 1376 a || s 1377 end 1378 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 1367 def join_table_source 1368 cached_fetch(:join_table_source){split_join_table_alias[0]} 1369 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 1383 def need_associated_primary_key? 1384 true 1385 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 1350 def predicate_key 1351 cached_fetch(:predicate_key){qualify(join_table_alias, self[:left_key])} 1352 end
The right key qualified by the join table.
# File lib/sequel/model/associations.rb 1356 def qualified_right_key 1357 cached_fetch(:qualified_right_key){qualify(join_table_alias, self[:right_key])} 1358 end
right_primary_key
qualified by the associated table
# File lib/sequel/model/associations.rb 1388 def qualified_right_primary_key 1389 cached_fetch(:qualified_right_primary_key){qualify_assoc(right_primary_key)} 1390 end
The primary key column(s) to use in the associated table (can be symbol or array).
# File lib/sequel/model/associations.rb 1393 def right_primary_key 1394 cached_fetch(:right_primary_key){associated_class.primary_key || raise(Error, "no primary key specified for #{associated_class.inspect}")} 1395 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 1404 def right_primary_key_method 1405 cached_fetch(:right_primary_key_method){right_primary_key} 1406 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 1410 def right_primary_key_methods 1411 cached_fetch(:right_primary_key_methods){Array(right_primary_key_method)} 1412 end
The primary key columns to use in the associated table (always array).
# File lib/sequel/model/associations.rb 1398 def right_primary_keys 1399 cached_fetch(:right_primary_keys){Array(right_primary_key)} 1400 end
The columns to select when loading the association, associated_class.table_name.* by default.
# File lib/sequel/model/associations.rb 1415 def select 1416 cached_fetch(:select){default_select} 1417 end
Whether a separate query should be used for the join table.
# File lib/sequel/model/associations.rb 1420 def separate_query_per_table? 1421 self[:join_table_db] 1422 end
Private Instance Methods
Join to the the join table, unless using a separate query per table.
# File lib/sequel/model/associations.rb 1427 def _associated_dataset 1428 if separate_query_per_table? 1429 super 1430 else 1431 super.inner_join(self[:join_table], self[:right_keys].zip(right_primary_keys), :qualify=>:deep) 1432 end 1433 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 1448 def default_select 1449 if (sel = associated_class.dataset.opts[:select]) && sel.all?{|c| selection_is_qualified?(c)} 1450 sel 1451 else 1452 Sequel::SQL::ColumnAll.new(associated_class.table_name) 1453 end 1454 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 1437 def eager_loading_set_predicate_condition(ds, eo) 1438 if separate_query_per_table? 1439 ds.where(right_primary_key=>eo[:right_keys]) 1440 else 1441 super 1442 end 1443 end
# File lib/sequel/model/associations.rb 1456 def filter_by_associations_conditions_associated_keys 1457 qualify(join_table_alias, self[:left_keys]) 1458 end
# File lib/sequel/model/associations.rb 1460 def filter_by_associations_conditions_key 1461 qualify(self[:model].table_name, self[:left_primary_key_column]) 1462 end
# File lib/sequel/model/associations.rb 1464 def filter_by_associations_limit_alias_key 1465 aliaz = 'a' 1466 filter_by_associations_limit_key.map{|c| c.as(Sequel.identifier(aliaz = aliaz.next))} 1467 end
# File lib/sequel/model/associations.rb 1469 def filter_by_associations_limit_aliases 1470 filter_by_associations_limit_alias_key.map(&:alias) 1471 end
# File lib/sequel/model/associations.rb 1473 def filter_by_associations_limit_key 1474 qualify(join_table_alias, self[:left_keys]) + Array(qualify(associated_class.table_name, associated_class.primary_key)) 1475 end
# File lib/sequel/model/associations.rb 1477 def predicate_key_methods 1478 self[:left_primary_keys] 1479 end
Sequel::Model::Associations::AssociationReflection#reciprocal_association?
# File lib/sequel/model/associations.rb 1481 def reciprocal_association?(assoc_reflect) 1482 super && assoc_reflect[:left_keys] == self[:right_keys] && 1483 assoc_reflect[:right_keys] == self[:left_keys] && 1484 assoc_reflect[:join_table] == self[:join_table] && 1485 right_primary_keys == assoc_reflect[:left_primary_key_columns] && 1486 self[:left_primary_key_columns] == assoc_reflect.right_primary_keys 1487 end
# File lib/sequel/model/associations.rb 1489 def reciprocal_type 1490 :many_to_many 1491 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 1495 def selection_is_qualified?(c) 1496 case c 1497 when Symbol 1498 Sequel.split_symbol(c)[0] 1499 when Sequel::SQL::QualifiedIdentifier 1500 true 1501 when Sequel::SQL::AliasedExpression 1502 selection_is_qualified?(c.expression) 1503 else 1504 false 1505 end 1506 end
Split the join table into source and alias parts.
# File lib/sequel/model/associations.rb 1509 def split_join_table_alias 1510 associated_class.dataset.split_alias(self[:join_table]) 1511 end