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 1200 def associated_key_alias 1201 self[:left_key_alias] 1202 end
Array
of associated keys used when eagerly loading.
# File lib/sequel/model/associations.rb 1205 def associated_key_array 1206 cached_fetch(:associated_key_array) do 1207 if self[:uses_left_composite_keys] 1208 associated_key_alias.zip(predicate_keys).map{|a, k| SQL::AliasedExpression.new(k, a)} 1209 else 1210 [SQL::AliasedExpression.new(predicate_key, associated_key_alias)] 1211 end 1212 end 1213 end
The column to use for the associated key when eagerly loading
# File lib/sequel/model/associations.rb 1216 def associated_key_column 1217 self[:left_key] 1218 end
Alias of right_primary_keys
# File lib/sequel/model/associations.rb 1221 def associated_object_keys 1222 right_primary_keys 1223 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 1227 def can_have_associated_objects?(obj) 1228 !self[:left_primary_keys].any?{|k| obj.get_column_value(k).nil?} 1229 end
one_through_one and many_to_many associations can be clones
# File lib/sequel/model/associations.rb 1232 def cloneable?(ref) 1233 ref[:type] == :many_to_many || ref[:type] == :one_through_one 1234 end
The default associated key alias(es) to use when eager loading associations via eager.
# File lib/sequel/model/associations.rb 1238 def default_associated_key_alias 1239 self[:uses_left_composite_keys] ? (0...self[:left_keys].length).map{|i| :"x_foreign_key_#{i}_x"} : :x_foreign_key_x 1240 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 1244 def default_eager_loader(eo) 1245 h = eo[:id_map] 1246 assign_singular = assign_singular? 1247 delete_rn = delete_row_number_column 1248 uses_lcks = self[:uses_left_composite_keys] 1249 left_key_alias = self[:left_key_alias] 1250 name = self[:name] 1251 1252 self[:model].eager_load_results(self, eo) do |assoc_record| 1253 assoc_record.values.delete(delete_rn) if delete_rn 1254 hash_key = if uses_lcks 1255 left_key_alias.map{|k| assoc_record.values.delete(k)} 1256 else 1257 assoc_record.values.delete(left_key_alias) 1258 end 1259 1260 objects = h[hash_key] 1261 1262 if assign_singular 1263 objects.each do |object| 1264 object.associations[name] ||= assoc_record 1265 end 1266 else 1267 objects.each do |object| 1268 object.associations[name].push(assoc_record) 1269 end 1270 end 1271 end 1272 end
Default name symbol for the join table.
# File lib/sequel/model/associations.rb 1275 def default_join_table 1276 [self[:class_name], self[:model].name].map{|i| underscore(pluralize(demodulize(i)))}.sort.join('_').to_sym 1277 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 1281 def default_left_key 1282 :"#{underscore(demodulize(self[:model].name))}_id" 1283 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 1287 def default_right_key 1288 :"#{singularize(self[:name])}_id" 1289 end
many_to_many associations need to select a key in an associated table to eagerly load
# File lib/sequel/model/associations.rb 1320 def eager_loading_use_associated_key? 1321 true 1322 end
# File lib/sequel/model/associations.rb 1303 def finalize_settings 1304 FINALIZE_SETTINGS 1305 end
The join table itself, unless it is aliased, in which case this is the alias.
# File lib/sequel/model/associations.rb 1332 def join_table_alias 1333 cached_fetch(:join_table_alias) do 1334 s, a = split_join_table_alias 1335 a || s 1336 end 1337 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 1326 def join_table_source 1327 cached_fetch(:join_table_source){split_join_table_alias[0]} 1328 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 1342 def need_associated_primary_key? 1343 true 1344 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 1309 def predicate_key 1310 cached_fetch(:predicate_key){qualify(join_table_alias, self[:left_key])} 1311 end
The right key qualified by the join table.
# File lib/sequel/model/associations.rb 1315 def qualified_right_key 1316 cached_fetch(:qualified_right_key){qualify(join_table_alias, self[:right_key])} 1317 end
right_primary_key
qualified by the associated table
# File lib/sequel/model/associations.rb 1347 def qualified_right_primary_key 1348 cached_fetch(:qualified_right_primary_key){qualify_assoc(right_primary_key)} 1349 end
The primary key column(s) to use in the associated table (can be symbol or array).
# File lib/sequel/model/associations.rb 1352 def right_primary_key 1353 cached_fetch(:right_primary_key){associated_class.primary_key || raise(Error, "no primary key specified for #{associated_class.inspect}")} 1354 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 1363 def right_primary_key_method 1364 cached_fetch(:right_primary_key_method){right_primary_key} 1365 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 1369 def right_primary_key_methods 1370 cached_fetch(:right_primary_key_methods){Array(right_primary_key_method)} 1371 end
The primary key columns to use in the associated table (always array).
# File lib/sequel/model/associations.rb 1357 def right_primary_keys 1358 cached_fetch(:right_primary_keys){Array(right_primary_key)} 1359 end
The columns to select when loading the association, associated_class.table_name.* by default.
# File lib/sequel/model/associations.rb 1374 def select 1375 cached_fetch(:select){default_select} 1376 end
Private Instance Methods
# File lib/sequel/model/associations.rb 1380 def _associated_dataset 1381 super.inner_join(self[:join_table], self[:right_keys].zip(right_primary_keys), :qualify=>:deep) 1382 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 1387 def default_select 1388 if (sel = associated_class.dataset.opts[:select]) && sel.all?{|c| selection_is_qualified?(c)} 1389 sel 1390 else 1391 Sequel::SQL::ColumnAll.new(associated_class.table_name) 1392 end 1393 end
# File lib/sequel/model/associations.rb 1395 def filter_by_associations_conditions_associated_keys 1396 qualify(join_table_alias, self[:left_keys]) 1397 end
# File lib/sequel/model/associations.rb 1399 def filter_by_associations_conditions_key 1400 qualify(self[:model].table_name, self[:left_primary_key_column]) 1401 end
# File lib/sequel/model/associations.rb 1403 def filter_by_associations_limit_alias_key 1404 aliaz = 'a' 1405 filter_by_associations_limit_key.map{|c| c.as(Sequel.identifier(aliaz = aliaz.next))} 1406 end
# File lib/sequel/model/associations.rb 1408 def filter_by_associations_limit_aliases 1409 filter_by_associations_limit_alias_key.map(&:alias) 1410 end
# File lib/sequel/model/associations.rb 1412 def filter_by_associations_limit_key 1413 qualify(join_table_alias, self[:left_keys]) + Array(qualify(associated_class.table_name, associated_class.primary_key)) 1414 end
# File lib/sequel/model/associations.rb 1416 def predicate_key_methods 1417 self[:left_primary_keys] 1418 end
Sequel::Model::Associations::AssociationReflection#reciprocal_association?
# File lib/sequel/model/associations.rb 1420 def reciprocal_association?(assoc_reflect) 1421 super && assoc_reflect[:left_keys] == self[:right_keys] && 1422 assoc_reflect[:right_keys] == self[:left_keys] && 1423 assoc_reflect[:join_table] == self[:join_table] && 1424 right_primary_keys == assoc_reflect[:left_primary_key_columns] && 1425 self[:left_primary_key_columns] == assoc_reflect.right_primary_keys 1426 end
# File lib/sequel/model/associations.rb 1428 def reciprocal_type 1429 :many_to_many 1430 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 1434 def selection_is_qualified?(c) 1435 case c 1436 when Symbol 1437 Sequel.split_symbol(c)[0] 1438 when Sequel::SQL::QualifiedIdentifier 1439 true 1440 when Sequel::SQL::AliasedExpression 1441 selection_is_qualified?(c.expression) 1442 else 1443 false 1444 end 1445 end
Split the join table into source and alias parts.
# File lib/sequel/model/associations.rb 1448 def split_join_table_alias 1449 associated_class.dataset.split_alias(self[:join_table]) 1450 end