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