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