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 1188 def associated_key_alias 1189 self[:left_key_alias] 1190 end
Array
of associated keys used when eagerly loading.
# File lib/sequel/model/associations.rb 1193 def associated_key_array 1194 cached_fetch(:associated_key_array) do 1195 if self[:uses_left_composite_keys] 1196 associated_key_alias.zip(predicate_keys).map{|a, k| SQL::AliasedExpression.new(k, a)} 1197 else 1198 [SQL::AliasedExpression.new(predicate_key, associated_key_alias)] 1199 end 1200 end 1201 end
The column to use for the associated key when eagerly loading
# File lib/sequel/model/associations.rb 1204 def associated_key_column 1205 self[:left_key] 1206 end
Alias of right_primary_keys
# File lib/sequel/model/associations.rb 1209 def associated_object_keys 1210 right_primary_keys 1211 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 1215 def can_have_associated_objects?(obj) 1216 !self[:left_primary_keys].any?{|k| obj.get_column_value(k).nil?} 1217 end
one_through_one and many_to_many associations can be clones
# File lib/sequel/model/associations.rb 1220 def cloneable?(ref) 1221 ref[:type] == :many_to_many || ref[:type] == :one_through_one 1222 end
The default associated key alias(es) to use when eager loading associations via eager.
# File lib/sequel/model/associations.rb 1226 def default_associated_key_alias 1227 self[:uses_left_composite_keys] ? (0...self[:left_keys].length).map{|i| :"x_foreign_key_#{i}_x"} : :x_foreign_key_x 1228 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 1232 def default_eager_loader(eo) 1233 h = eo[:id_map] 1234 assign_singular = assign_singular? 1235 delete_rn = delete_row_number_column 1236 uses_lcks = self[:uses_left_composite_keys] 1237 left_key_alias = self[:left_key_alias] 1238 name = self[:name] 1239 1240 self[:model].eager_load_results(self, eo) do |assoc_record| 1241 assoc_record.values.delete(delete_rn) if delete_rn 1242 hash_key = if uses_lcks 1243 left_key_alias.map{|k| assoc_record.values.delete(k)} 1244 else 1245 assoc_record.values.delete(left_key_alias) 1246 end 1247 next unless objects = h[hash_key] 1248 if assign_singular 1249 objects.each do |object| 1250 object.associations[name] ||= assoc_record 1251 end 1252 else 1253 objects.each do |object| 1254 object.associations[name].push(assoc_record) 1255 end 1256 end 1257 end 1258 end
Default name symbol for the join table.
# File lib/sequel/model/associations.rb 1261 def default_join_table 1262 [self[:class_name], self[:model].name].map{|i| underscore(pluralize(demodulize(i)))}.sort.join('_').to_sym 1263 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 1267 def default_left_key 1268 :"#{underscore(demodulize(self[:model].name))}_id" 1269 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 1273 def default_right_key 1274 :"#{singularize(self[:name])}_id" 1275 end
many_to_many associations need to select a key in an associated table to eagerly load
# File lib/sequel/model/associations.rb 1306 def eager_loading_use_associated_key? 1307 true 1308 end
# File lib/sequel/model/associations.rb 1289 def finalize_settings 1290 FINALIZE_SETTINGS 1291 end
The join table itself, unless it is aliased, in which case this is the alias.
# File lib/sequel/model/associations.rb 1318 def join_table_alias 1319 cached_fetch(:join_table_alias) do 1320 s, a = split_join_table_alias 1321 a || s 1322 end 1323 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 1312 def join_table_source 1313 cached_fetch(:join_table_source){split_join_table_alias[0]} 1314 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 1328 def need_associated_primary_key? 1329 true 1330 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 1295 def predicate_key 1296 cached_fetch(:predicate_key){qualify(join_table_alias, self[:left_key])} 1297 end
The right key qualified by the join table.
# File lib/sequel/model/associations.rb 1301 def qualified_right_key 1302 cached_fetch(:qualified_right_key){qualify(join_table_alias, self[:right_key])} 1303 end
right_primary_key
qualified by the associated table
# File lib/sequel/model/associations.rb 1333 def qualified_right_primary_key 1334 cached_fetch(:qualified_right_primary_key){qualify_assoc(right_primary_key)} 1335 end
The primary key column(s) to use in the associated table (can be symbol or array).
# File lib/sequel/model/associations.rb 1338 def right_primary_key 1339 cached_fetch(:right_primary_key){associated_class.primary_key || raise(Error, "no primary key specified for #{associated_class.inspect}")} 1340 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 1349 def right_primary_key_method 1350 cached_fetch(:right_primary_key_method){right_primary_key} 1351 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 1355 def right_primary_key_methods 1356 cached_fetch(:right_primary_key_methods){Array(right_primary_key_method)} 1357 end
The primary key columns to use in the associated table (always array).
# File lib/sequel/model/associations.rb 1343 def right_primary_keys 1344 cached_fetch(:right_primary_keys){Array(right_primary_key)} 1345 end
The columns to select when loading the association, associated_class.table_name.* by default.
# File lib/sequel/model/associations.rb 1360 def select 1361 cached_fetch(:select){default_select} 1362 end
Private Instance Methods
# File lib/sequel/model/associations.rb 1366 def _associated_dataset 1367 super.inner_join(self[:join_table], self[:right_keys].zip(right_primary_keys), :qualify=>:deep) 1368 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 1373 def default_select 1374 if (sel = associated_class.dataset.opts[:select]) && sel.all?{|c| selection_is_qualified?(c)} 1375 sel 1376 else 1377 Sequel::SQL::ColumnAll.new(associated_class.table_name) 1378 end 1379 end
# File lib/sequel/model/associations.rb 1381 def filter_by_associations_conditions_associated_keys 1382 qualify(join_table_alias, self[:left_keys]) 1383 end
# File lib/sequel/model/associations.rb 1385 def filter_by_associations_conditions_key 1386 qualify(self[:model].table_name, self[:left_primary_key_column]) 1387 end
# File lib/sequel/model/associations.rb 1389 def filter_by_associations_limit_alias_key 1390 aliaz = 'a' 1391 filter_by_associations_limit_key.map{|c| c.as(Sequel.identifier(aliaz = aliaz.next))} 1392 end
# File lib/sequel/model/associations.rb 1394 def filter_by_associations_limit_aliases 1395 filter_by_associations_limit_alias_key.map(&:alias) 1396 end
# File lib/sequel/model/associations.rb 1398 def filter_by_associations_limit_key 1399 qualify(join_table_alias, self[:left_keys]) + Array(qualify(associated_class.table_name, associated_class.primary_key)) 1400 end
# File lib/sequel/model/associations.rb 1402 def predicate_key_methods 1403 self[:left_primary_keys] 1404 end
Sequel::Model::Associations::AssociationReflection#reciprocal_association?
# File lib/sequel/model/associations.rb 1406 def reciprocal_association?(assoc_reflect) 1407 super && assoc_reflect[:left_keys] == self[:right_keys] && 1408 assoc_reflect[:right_keys] == self[:left_keys] && 1409 assoc_reflect[:join_table] == self[:join_table] && 1410 right_primary_keys == assoc_reflect[:left_primary_key_columns] && 1411 self[:left_primary_key_columns] == assoc_reflect.right_primary_keys 1412 end
# File lib/sequel/model/associations.rb 1414 def reciprocal_type 1415 :many_to_many 1416 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 1420 def selection_is_qualified?(c) 1421 case c 1422 when Symbol 1423 Sequel.split_symbol(c)[0] 1424 when Sequel::SQL::QualifiedIdentifier 1425 true 1426 when Sequel::SQL::AliasedExpression 1427 selection_is_qualified?(c.expression) 1428 else 1429 false 1430 end 1431 end
Split the join table into source and alias parts.
# File lib/sequel/model/associations.rb 1434 def split_join_table_alias 1435 associated_class.dataset.split_alias(self[:join_table]) 1436 end