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 1197 def associated_key_alias 1198 self[:left_key_alias] 1199 end
Array
of associated keys used when eagerly loading.
# File lib/sequel/model/associations.rb 1202 def associated_key_array 1203 cached_fetch(:associated_key_array) do 1204 if self[:uses_left_composite_keys] 1205 associated_key_alias.zip(predicate_keys).map{|a, k| SQL::AliasedExpression.new(k, a)} 1206 else 1207 [SQL::AliasedExpression.new(predicate_key, associated_key_alias)] 1208 end 1209 end 1210 end
The column to use for the associated key when eagerly loading
# File lib/sequel/model/associations.rb 1213 def associated_key_column 1214 self[:left_key] 1215 end
Alias of right_primary_keys
# File lib/sequel/model/associations.rb 1218 def associated_object_keys 1219 right_primary_keys 1220 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 1224 def can_have_associated_objects?(obj) 1225 !self[:left_primary_keys].any?{|k| obj.get_column_value(k).nil?} 1226 end
one_through_one and many_to_many associations can be clones
# File lib/sequel/model/associations.rb 1229 def cloneable?(ref) 1230 ref[:type] == :many_to_many || ref[:type] == :one_through_one 1231 end
The default associated key alias(es) to use when eager loading associations via eager.
# File lib/sequel/model/associations.rb 1235 def default_associated_key_alias 1236 self[:uses_left_composite_keys] ? (0...self[:left_keys].length).map{|i| :"x_foreign_key_#{i}_x"} : :x_foreign_key_x 1237 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 1241 def default_eager_loader(eo) 1242 h = eo[:id_map] 1243 assign_singular = assign_singular? 1244 delete_rn = delete_row_number_column 1245 uses_lcks = self[:uses_left_composite_keys] 1246 left_key_alias = self[:left_key_alias] 1247 name = self[:name] 1248 1249 self[:model].eager_load_results(self, eo) do |assoc_record| 1250 assoc_record.values.delete(delete_rn) if delete_rn 1251 hash_key = if uses_lcks 1252 left_key_alias.map{|k| assoc_record.values.delete(k)} 1253 else 1254 assoc_record.values.delete(left_key_alias) 1255 end 1256 1257 objects = h[hash_key] 1258 1259 if assign_singular 1260 objects.each do |object| 1261 object.associations[name] ||= assoc_record 1262 end 1263 else 1264 objects.each do |object| 1265 object.associations[name].push(assoc_record) 1266 end 1267 end 1268 end 1269 end
Default name symbol for the join table.
# File lib/sequel/model/associations.rb 1272 def default_join_table 1273 [self[:class_name], self[:model].name].map{|i| underscore(pluralize(demodulize(i)))}.sort.join('_').to_sym 1274 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 1278 def default_left_key 1279 :"#{underscore(demodulize(self[:model].name))}_id" 1280 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 1284 def default_right_key 1285 :"#{singularize(self[:name])}_id" 1286 end
many_to_many associations need to select a key in an associated table to eagerly load
# File lib/sequel/model/associations.rb 1317 def eager_loading_use_associated_key? 1318 true 1319 end
# File lib/sequel/model/associations.rb 1300 def finalize_settings 1301 FINALIZE_SETTINGS 1302 end
The join table itself, unless it is aliased, in which case this is the alias.
# File lib/sequel/model/associations.rb 1329 def join_table_alias 1330 cached_fetch(:join_table_alias) do 1331 s, a = split_join_table_alias 1332 a || s 1333 end 1334 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 1323 def join_table_source 1324 cached_fetch(:join_table_source){split_join_table_alias[0]} 1325 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 1339 def need_associated_primary_key? 1340 true 1341 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 1306 def predicate_key 1307 cached_fetch(:predicate_key){qualify(join_table_alias, self[:left_key])} 1308 end
The right key qualified by the join table.
# File lib/sequel/model/associations.rb 1312 def qualified_right_key 1313 cached_fetch(:qualified_right_key){qualify(join_table_alias, self[:right_key])} 1314 end
right_primary_key
qualified by the associated table
# File lib/sequel/model/associations.rb 1344 def qualified_right_primary_key 1345 cached_fetch(:qualified_right_primary_key){qualify_assoc(right_primary_key)} 1346 end
The primary key column(s) to use in the associated table (can be symbol or array).
# File lib/sequel/model/associations.rb 1349 def right_primary_key 1350 cached_fetch(:right_primary_key){associated_class.primary_key || raise(Error, "no primary key specified for #{associated_class.inspect}")} 1351 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 1360 def right_primary_key_method 1361 cached_fetch(:right_primary_key_method){right_primary_key} 1362 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 1366 def right_primary_key_methods 1367 cached_fetch(:right_primary_key_methods){Array(right_primary_key_method)} 1368 end
The primary key columns to use in the associated table (always array).
# File lib/sequel/model/associations.rb 1354 def right_primary_keys 1355 cached_fetch(:right_primary_keys){Array(right_primary_key)} 1356 end
The columns to select when loading the association, associated_class.table_name.* by default.
# File lib/sequel/model/associations.rb 1371 def select 1372 cached_fetch(:select){default_select} 1373 end
Private Instance Methods
# File lib/sequel/model/associations.rb 1377 def _associated_dataset 1378 super.inner_join(self[:join_table], self[:right_keys].zip(right_primary_keys), :qualify=>:deep) 1379 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 1384 def default_select 1385 if (sel = associated_class.dataset.opts[:select]) && sel.all?{|c| selection_is_qualified?(c)} 1386 sel 1387 else 1388 Sequel::SQL::ColumnAll.new(associated_class.table_name) 1389 end 1390 end
# File lib/sequel/model/associations.rb 1392 def filter_by_associations_conditions_associated_keys 1393 qualify(join_table_alias, self[:left_keys]) 1394 end
# File lib/sequel/model/associations.rb 1396 def filter_by_associations_conditions_key 1397 qualify(self[:model].table_name, self[:left_primary_key_column]) 1398 end
# File lib/sequel/model/associations.rb 1400 def filter_by_associations_limit_alias_key 1401 aliaz = 'a' 1402 filter_by_associations_limit_key.map{|c| c.as(Sequel.identifier(aliaz = aliaz.next))} 1403 end
# File lib/sequel/model/associations.rb 1405 def filter_by_associations_limit_aliases 1406 filter_by_associations_limit_alias_key.map(&:alias) 1407 end
# File lib/sequel/model/associations.rb 1409 def filter_by_associations_limit_key 1410 qualify(join_table_alias, self[:left_keys]) + Array(qualify(associated_class.table_name, associated_class.primary_key)) 1411 end
# File lib/sequel/model/associations.rb 1413 def predicate_key_methods 1414 self[:left_primary_keys] 1415 end
Sequel::Model::Associations::AssociationReflection#reciprocal_association?
# File lib/sequel/model/associations.rb 1417 def reciprocal_association?(assoc_reflect) 1418 super && assoc_reflect[:left_keys] == self[:right_keys] && 1419 assoc_reflect[:right_keys] == self[:left_keys] && 1420 assoc_reflect[:join_table] == self[:join_table] && 1421 right_primary_keys == assoc_reflect[:left_primary_key_columns] && 1422 self[:left_primary_key_columns] == assoc_reflect.right_primary_keys 1423 end
# File lib/sequel/model/associations.rb 1425 def reciprocal_type 1426 :many_to_many 1427 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 1431 def selection_is_qualified?(c) 1432 case c 1433 when Symbol 1434 Sequel.split_symbol(c)[0] 1435 when Sequel::SQL::QualifiedIdentifier 1436 true 1437 when Sequel::SQL::AliasedExpression 1438 selection_is_qualified?(c.expression) 1439 else 1440 false 1441 end 1442 end
Split the join table into source and alias parts.
# File lib/sequel/model/associations.rb 1445 def split_join_table_alias 1446 associated_class.dataset.split_alias(self[:join_table]) 1447 end