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 1209 def associated_key_alias 1210 self[:left_key_alias] 1211 end
Array
of associated keys used when eagerly loading.
# File lib/sequel/model/associations.rb 1214 def associated_key_array 1215 cached_fetch(:associated_key_array) do 1216 if self[:uses_left_composite_keys] 1217 associated_key_alias.zip(predicate_keys).map{|a, k| SQL::AliasedExpression.new(k, a)} 1218 else 1219 [SQL::AliasedExpression.new(predicate_key, associated_key_alias)] 1220 end 1221 end 1222 end
The column to use for the associated key when eagerly loading
# File lib/sequel/model/associations.rb 1225 def associated_key_column 1226 self[:left_key] 1227 end
Alias of right_primary_keys
# File lib/sequel/model/associations.rb 1230 def associated_object_keys 1231 right_primary_keys 1232 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 1236 def can_have_associated_objects?(obj) 1237 !self[:left_primary_keys].any?{|k| obj.get_column_value(k).nil?} 1238 end
one_through_one and many_to_many associations can be clones
# File lib/sequel/model/associations.rb 1241 def cloneable?(ref) 1242 ref[:type] == :many_to_many || ref[:type] == :one_through_one 1243 end
The default associated key alias(es) to use when eager loading associations via eager.
# File lib/sequel/model/associations.rb 1247 def default_associated_key_alias 1248 self[:uses_left_composite_keys] ? (0...self[:left_keys].length).map{|i| :"x_foreign_key_#{i}_x"} : :x_foreign_key_x 1249 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 1253 def default_eager_loader(eo) 1254 h = eo[:id_map] 1255 assign_singular = assign_singular? 1256 delete_rn = delete_row_number_column 1257 uses_lcks = self[:uses_left_composite_keys] 1258 left_key_alias = self[:left_key_alias] 1259 name = self[:name] 1260 1261 self[:model].eager_load_results(self, eo) do |assoc_record| 1262 assoc_record.values.delete(delete_rn) if delete_rn 1263 hash_key = if uses_lcks 1264 left_key_alias.map{|k| assoc_record.values.delete(k)} 1265 else 1266 assoc_record.values.delete(left_key_alias) 1267 end 1268 1269 objects = h[hash_key] 1270 1271 if assign_singular 1272 objects.each do |object| 1273 object.associations[name] ||= assoc_record 1274 end 1275 else 1276 objects.each do |object| 1277 object.associations[name].push(assoc_record) 1278 end 1279 end 1280 end 1281 end
Default name symbol for the join table.
# File lib/sequel/model/associations.rb 1284 def default_join_table 1285 [self[:class_name], self[:model].name].map{|i| underscore(pluralize(demodulize(i)))}.sort.join('_').to_sym 1286 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 1290 def default_left_key 1291 :"#{underscore(demodulize(self[:model].name))}_id" 1292 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 1296 def default_right_key 1297 :"#{singularize(self[:name])}_id" 1298 end
many_to_many associations need to select a key in an associated table to eagerly load
# File lib/sequel/model/associations.rb 1329 def eager_loading_use_associated_key? 1330 !separate_query_per_table? 1331 end
# File lib/sequel/model/associations.rb 1312 def finalize_settings 1313 FINALIZE_SETTINGS 1314 end
The join table itself, unless it is aliased, in which case this is the alias.
# File lib/sequel/model/associations.rb 1341 def join_table_alias 1342 cached_fetch(:join_table_alias) do 1343 s, a = split_join_table_alias 1344 a || s 1345 end 1346 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 1335 def join_table_source 1336 cached_fetch(:join_table_source){split_join_table_alias[0]} 1337 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 1351 def need_associated_primary_key? 1352 true 1353 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 1318 def predicate_key 1319 cached_fetch(:predicate_key){qualify(join_table_alias, self[:left_key])} 1320 end
The right key qualified by the join table.
# File lib/sequel/model/associations.rb 1324 def qualified_right_key 1325 cached_fetch(:qualified_right_key){qualify(join_table_alias, self[:right_key])} 1326 end
right_primary_key
qualified by the associated table
# File lib/sequel/model/associations.rb 1356 def qualified_right_primary_key 1357 cached_fetch(:qualified_right_primary_key){qualify_assoc(right_primary_key)} 1358 end
The primary key column(s) to use in the associated table (can be symbol or array).
# File lib/sequel/model/associations.rb 1361 def right_primary_key 1362 cached_fetch(:right_primary_key){associated_class.primary_key || raise(Error, "no primary key specified for #{associated_class.inspect}")} 1363 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 1372 def right_primary_key_method 1373 cached_fetch(:right_primary_key_method){right_primary_key} 1374 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 1378 def right_primary_key_methods 1379 cached_fetch(:right_primary_key_methods){Array(right_primary_key_method)} 1380 end
The primary key columns to use in the associated table (always array).
# File lib/sequel/model/associations.rb 1366 def right_primary_keys 1367 cached_fetch(:right_primary_keys){Array(right_primary_key)} 1368 end
The columns to select when loading the association, associated_class.table_name.* by default.
# File lib/sequel/model/associations.rb 1383 def select 1384 cached_fetch(:select){default_select} 1385 end
Whether a separate query should be used for the join table.
# File lib/sequel/model/associations.rb 1388 def separate_query_per_table? 1389 self[:join_table_db] 1390 end
Private Instance Methods
Join to the the join table, unless using a separate query per table.
# File lib/sequel/model/associations.rb 1395 def _associated_dataset 1396 if separate_query_per_table? 1397 super 1398 else 1399 super.inner_join(self[:join_table], self[:right_keys].zip(right_primary_keys), :qualify=>:deep) 1400 end 1401 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 1416 def default_select 1417 if (sel = associated_class.dataset.opts[:select]) && sel.all?{|c| selection_is_qualified?(c)} 1418 sel 1419 else 1420 Sequel::SQL::ColumnAll.new(associated_class.table_name) 1421 end 1422 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 1405 def eager_loading_set_predicate_condition(ds, eo) 1406 if separate_query_per_table? 1407 ds.where(right_primary_key=>eo[:right_keys]) 1408 else 1409 super 1410 end 1411 end
# File lib/sequel/model/associations.rb 1424 def filter_by_associations_conditions_associated_keys 1425 qualify(join_table_alias, self[:left_keys]) 1426 end
# File lib/sequel/model/associations.rb 1428 def filter_by_associations_conditions_key 1429 qualify(self[:model].table_name, self[:left_primary_key_column]) 1430 end
# File lib/sequel/model/associations.rb 1432 def filter_by_associations_limit_alias_key 1433 aliaz = 'a' 1434 filter_by_associations_limit_key.map{|c| c.as(Sequel.identifier(aliaz = aliaz.next))} 1435 end
# File lib/sequel/model/associations.rb 1437 def filter_by_associations_limit_aliases 1438 filter_by_associations_limit_alias_key.map(&:alias) 1439 end
# File lib/sequel/model/associations.rb 1441 def filter_by_associations_limit_key 1442 qualify(join_table_alias, self[:left_keys]) + Array(qualify(associated_class.table_name, associated_class.primary_key)) 1443 end
# File lib/sequel/model/associations.rb 1445 def predicate_key_methods 1446 self[:left_primary_keys] 1447 end
Sequel::Model::Associations::AssociationReflection#reciprocal_association?
# File lib/sequel/model/associations.rb 1449 def reciprocal_association?(assoc_reflect) 1450 super && assoc_reflect[:left_keys] == self[:right_keys] && 1451 assoc_reflect[:right_keys] == self[:left_keys] && 1452 assoc_reflect[:join_table] == self[:join_table] && 1453 right_primary_keys == assoc_reflect[:left_primary_key_columns] && 1454 self[:left_primary_key_columns] == assoc_reflect.right_primary_keys 1455 end
# File lib/sequel/model/associations.rb 1457 def reciprocal_type 1458 :many_to_many 1459 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 1463 def selection_is_qualified?(c) 1464 case c 1465 when Symbol 1466 Sequel.split_symbol(c)[0] 1467 when Sequel::SQL::QualifiedIdentifier 1468 true 1469 when Sequel::SQL::AliasedExpression 1470 selection_is_qualified?(c.expression) 1471 else 1472 false 1473 end 1474 end
Split the join table into source and alias parts.
# File lib/sequel/model/associations.rb 1477 def split_join_table_alias 1478 associated_class.dataset.split_alias(self[:join_table]) 1479 end