class Sequel::Model::Associations::AssociationReflection
AssociationReflection
is a Hash
subclass that keeps information on Sequel::Model
associations. It provides methods to reduce internal code duplication. It should not be instantiated by the user.
Constants
- ASSOCIATION_DATASET_PROC
- FINALIZE_SETTINGS
Map of methods to cache keys used for finalizing associations.
Public Instance Methods
Name symbol for the _add internal association method
# File lib/sequel/model/associations.rb 36 def _add_method 37 self[:_add_method] 38 end
Name symbol for the _remove_all internal association method
# File lib/sequel/model/associations.rb 41 def _remove_all_method 42 self[:_remove_all_method] 43 end
Name symbol for the _remove internal association method
# File lib/sequel/model/associations.rb 46 def _remove_method 47 self[:_remove_method] 48 end
Name symbol for the _setter association method
# File lib/sequel/model/associations.rb 51 def _setter_method 52 self[:_setter_method] 53 end
Name symbol for the add association method
# File lib/sequel/model/associations.rb 56 def add_method 57 self[:add_method] 58 end
Apply all non-instance specific changes to the given dataset and return it.
# File lib/sequel/model/associations.rb 84 def apply_dataset_changes(ds) 85 ds = ds.with_extend(AssociationDatasetMethods).clone(:association_reflection => self) 86 if exts = self[:reverse_extend] 87 ds = ds.with_extend(*exts) 88 end 89 ds = ds.select(*select) if select 90 if c = self[:conditions] 91 ds = (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c) 92 end 93 ds = ds.order(*self[:order]) if self[:order] 94 ds = ds.limit(*self[:limit]) if self[:limit] 95 ds = ds.limit(1).skip_limit_check if limit_to_single_row? 96 ds = ds.eager(self[:eager]) if self[:eager] 97 ds = ds.distinct if self[:distinct] 98 ds 99 end
Use DISTINCT ON and ORDER BY clauses to limit the results to the first record with matching keys.
# File lib/sequel/model/associations.rb 138 def apply_distinct_on_eager_limit_strategy(ds) 139 keys = predicate_key 140 ds.distinct(*keys).order_prepend(*keys) 141 end
Apply all non-instance specific changes and the eager_block option to the given dataset and return it.
# File lib/sequel/model/associations.rb 103 def apply_eager_dataset_changes(ds) 104 ds = apply_dataset_changes(ds) 105 if block = self[:eager_block] 106 ds = block.call(ds) 107 end 108 ds 109 end
Apply the eager graph limit strategy to the dataset to graph into the current dataset, or return the dataset unmodified if no SQL
limit strategy is needed.
# File lib/sequel/model/associations.rb 113 def apply_eager_graph_limit_strategy(strategy, ds) 114 case strategy 115 when :distinct_on 116 apply_distinct_on_eager_limit_strategy(ds.order_prepend(*self[:order])) 117 when :window_function 118 apply_window_function_eager_limit_strategy(ds.order_prepend(*self[:order])).select(*ds.columns) 119 else 120 ds 121 end 122 end
Apply an eager limit strategy to the dataset, or return the dataset unmodified if it doesn't need an eager limit strategy.
# File lib/sequel/model/associations.rb 126 def apply_eager_limit_strategy(ds, strategy=eager_limit_strategy, limit_and_offset=limit_and_offset()) 127 case strategy 128 when :distinct_on 129 apply_distinct_on_eager_limit_strategy(ds) 130 when :window_function 131 apply_window_function_eager_limit_strategy(ds, limit_and_offset) 132 else 133 ds 134 end 135 end
If the ruby eager limit strategy is being used, slice the array using the slice range to return the object(s) at the correct offset/limit.
# File lib/sequel/model/associations.rb 165 def apply_ruby_eager_limit_strategy(rows, limit_and_offset = limit_and_offset()) 166 name = self[:name] 167 return unless range = slice_range(limit_and_offset) 168 if returns_array? 169 rows.each{|o| o.associations[name] = o.associations[name][range] || []} 170 else 171 offset = range.begin 172 rows.each{|o| o.associations[name] = o.associations[name][offset]} 173 end 174 end
Use a window function to limit the results of the eager loading dataset.
# File lib/sequel/model/associations.rb 144 def apply_window_function_eager_limit_strategy(ds, limit_and_offset=limit_and_offset()) 145 rn = ds.row_number_column 146 limit, offset = limit_and_offset 147 ds = ds.unordered.select_append{|o| o.row_number.function.over(:partition=>predicate_key, :order=>ds.opts[:order]).as(rn)}.from_self 148 ds = ds.order(rn) if ds.db.database_type == :mysql 149 ds = if !returns_array? 150 ds.where(rn => offset ? offset+1 : 1) 151 elsif offset 152 offset += 1 153 if limit 154 ds.where(rn => (offset...(offset+limit))) 155 else 156 ds.where{SQL::Identifier.new(rn) >= offset} 157 end 158 else 159 ds.where{SQL::Identifier.new(rn) <= limit} 160 end 161 end
Whether the associations cache should use an array when storing the associated records during eager loading.
# File lib/sequel/model/associations.rb 178 def assign_singular? 179 !returns_array? 180 end
The class associated to the current model class via this association
# File lib/sequel/model/associations.rb 66 def associated_class 67 cached_fetch(:class) do 68 begin 69 constantize(self[:class_name]) 70 rescue NameError => e 71 raise NameError, "#{e.message} (this happened when attempting to find the associated class for #{inspect})", e.backtrace 72 end 73 end 74 end
The dataset associated via this association, with the non-instance specific changes already applied. This will be a joined dataset if the association requires joining tables.
# File lib/sequel/model/associations.rb 79 def associated_dataset 80 cached_fetch(:_dataset){apply_dataset_changes(_associated_dataset)} 81 end
Return an dataset that will load the appropriate associated objects for the given object using this association.
# File lib/sequel/model/associations.rb 215 def association_dataset_for(object) 216 condition = if can_have_associated_objects?(object) 217 predicate_keys.zip(predicate_key_values(object)) 218 else 219 false 220 end 221 222 associated_dataset.where(condition) 223 end
Proc used to create the association dataset method.
# File lib/sequel/model/associations.rb 227 def association_dataset_proc 228 ASSOCIATION_DATASET_PROC 229 end
Name symbol for association method, the same as the name of the association.
# File lib/sequel/model/associations.rb 61 def association_method 62 self[:name] 63 end
Whether this association can have associated objects, given the current object. Should be false if obj cannot have associated objects because the necessary key columns are NULL.
# File lib/sequel/model/associations.rb 185 def can_have_associated_objects?(obj) 186 true 187 end
Whether you are able to clone from the given association type to the current association type, true by default only if the types match.
# File lib/sequel/model/associations.rb 191 def cloneable?(ref) 192 ref[:type] == self[:type] 193 end
Name symbol for the dataset association method
# File lib/sequel/model/associations.rb 196 def dataset_method 197 self[:dataset_method] 198 end
Whether the dataset needs a primary key to function, true by default.
# File lib/sequel/model/associations.rb 201 def dataset_need_primary_key? 202 true 203 end
Return the symbol used for the row number column if the window function eager limit strategy is being used, or nil otherwise.
# File lib/sequel/model/associations.rb 207 def delete_row_number_column(ds=associated_dataset) 208 if eager_limit_strategy == :window_function 209 ds.row_number_column 210 end 211 end
Whether to eagerly graph a lazy dataset, true by default. If this is false, the association won't respect the :eager_graph option when loading the association for a single record.
# File lib/sequel/model/associations.rb 344 def eager_graph_lazy_dataset? 345 true 346 end
The eager_graph limit strategy to use for this dataset
# File lib/sequel/model/associations.rb 232 def eager_graph_limit_strategy(strategy) 233 if self[:limit] || !returns_array? 234 strategy = strategy[self[:name]] if strategy.is_a?(Hash) 235 case strategy 236 when true 237 true_eager_graph_limit_strategy 238 when Symbol 239 strategy 240 else 241 if returns_array? || offset 242 :ruby 243 end 244 end 245 end 246 end
The eager limit strategy to use for this dataset.
# File lib/sequel/model/associations.rb 249 def eager_limit_strategy 250 cached_fetch(:_eager_limit_strategy) do 251 if self[:limit] || !returns_array? 252 case s = cached_fetch(:eager_limit_strategy){default_eager_limit_strategy} 253 when true 254 true_eager_limit_strategy 255 else 256 s 257 end 258 end 259 end 260 end
Eager load the associated objects using the hash of eager options, yielding each row to the block.
# File lib/sequel/model/associations.rb 264 def eager_load_results(eo, &block) 265 rows = eo[:rows] 266 unless eo[:initialize_rows] == false 267 Sequel.synchronize_with(eo[:mutex]){initialize_association_cache(rows)} 268 end 269 if eo[:id_map] 270 ids = eo[:id_map].keys 271 return ids if ids.empty? 272 end 273 strategy = eager_limit_strategy 274 cascade = eo[:associations] 275 eager_limit = nil 276 277 if eo[:no_results] 278 no_results = true 279 elsif eo[:eager_block] || eo[:loader] == false || !use_placeholder_loader? 280 ds = eager_loading_dataset(eo) 281 282 strategy = ds.opts[:eager_limit_strategy] || strategy 283 284 eager_limit = 285 if el = ds.opts[:eager_limit] 286 raise Error, "The :eager_limit dataset option is not supported for associations returning a single record" unless returns_array? 287 strategy ||= true_eager_graph_limit_strategy 288 if el.is_a?(Array) 289 el 290 else 291 [el, nil] 292 end 293 else 294 limit_and_offset 295 end 296 297 strategy = true_eager_graph_limit_strategy if strategy == :union 298 # Correlated subqueries are not supported for regular eager loading 299 strategy = :ruby if strategy == :correlated_subquery 300 strategy = nil if strategy == :ruby && assign_singular? 301 objects = apply_eager_limit_strategy(ds, strategy, eager_limit).all 302 303 if strategy == :window_function 304 delete_rn = ds.row_number_column 305 objects.each{|obj| obj.values.delete(delete_rn)} 306 end 307 elsif strategy == :union 308 objects = [] 309 ds = associated_dataset 310 loader = union_eager_loader 311 joiner = " UNION ALL " 312 ids.each_slice(subqueries_per_union).each do |slice| 313 objects.concat(ds.with_sql(slice.map{|k| loader.sql(*k)}.join(joiner)).to_a) 314 end 315 ds = ds.eager(cascade) if cascade 316 ds.send(:post_load, objects) 317 else 318 loader = placeholder_eager_loader 319 loader = loader.with_dataset{|dataset| dataset.eager(cascade)} if cascade 320 objects = loader.all(ids) 321 end 322 323 Sequel.synchronize_with(eo[:mutex]){objects.each(&block)} unless no_results 324 325 if strategy == :ruby 326 apply_ruby_eager_limit_strategy(rows, eager_limit || limit_and_offset) 327 end 328 end
The key to use for the key hash when eager loading
# File lib/sequel/model/associations.rb 331 def eager_loader_key 332 self[:eager_loader_key] 333 end
By default associations do not need to select a key in an associated table to eagerly load.
# File lib/sequel/model/associations.rb 337 def eager_loading_use_associated_key? 338 false 339 end
Whether additional conditions should be added when using the filter by associations support.
# File lib/sequel/model/associations.rb 350 def filter_by_associations_add_conditions? 351 self[:conditions] || self[:eager_block] || self[:limit] 352 end
The expression to use for the additional conditions to be added for the filter by association support, when the association itself is filtered. Works by using a subquery to test that the objects passed also meet the association filter criteria.
# File lib/sequel/model/associations.rb 358 def filter_by_associations_conditions_expression(obj) 359 ds = filter_by_associations_conditions_dataset.where(filter_by_associations_conditions_subquery_conditions(obj)) 360 {filter_by_associations_conditions_key=>ds} 361 end
Finalize the association by first attempting to populate the thread-safe cache, and then transfering the thread-safe cache value to the association itself, so that a mutex is not needed to get the value.
# File lib/sequel/model/associations.rb 366 def finalize 367 return unless cache = self[:cache] 368 369 finalizer = proc do |meth, key| 370 next if has_key?(key) 371 372 # Allow calling private methods to make sure caching is done appropriately 373 send(meth) 374 self[key] = cache.delete(key) if cache.has_key?(key) 375 end 376 377 finalize_settings.each(&finalizer) 378 379 unless self[:instance_specific] 380 finalizer.call(:associated_eager_dataset, :associated_eager_dataset) 381 finalizer.call(:filter_by_associations_conditions_dataset, :filter_by_associations_conditions_dataset) 382 end 383 384 nil 385 end
# File lib/sequel/model/associations.rb 397 def finalize_settings 398 FINALIZE_SETTINGS 399 end
Whether to handle silent modification failure when adding/removing associated records, false by default.
# File lib/sequel/model/associations.rb 403 def handle_silent_modification_failure? 404 false 405 end
Initialize the associations cache for the current association for the given objects.
# File lib/sequel/model/associations.rb 408 def initialize_association_cache(objects) 409 name = self[:name] 410 if assign_singular? 411 objects.each{|object| object.associations[name] = nil} 412 else 413 objects.each{|object| object.associations[name] = []} 414 end 415 end
Show which type of reflection this is, and a guess at what code was used to create the association.
# File lib/sequel/model/associations.rb 419 def inspect 420 o = self[:orig_opts].dup 421 o.delete(:class) 422 o.delete(:class_name) 423 o.delete(:block) unless o[:block] 424 o[:class] = self[:orig_class] if self[:orig_class] 425 426 "#<#{self.class} #{self[:model]}.#{self[:type]} #{self[:name].inspect}#{", #{o.inspect[1...-1]}" unless o.empty?}>" 427 end
The limit and offset for this association (returned as a two element array).
# File lib/sequel/model/associations.rb 430 def limit_and_offset 431 if (v = self[:limit]).is_a?(Array) 432 v 433 else 434 [v, nil] 435 end 436 end
Whether the associated object needs a primary key to be added/removed, false by default.
# File lib/sequel/model/associations.rb 440 def need_associated_primary_key? 441 false 442 end
A placeholder literalizer that can be used to lazily load the association. If one can't be used, returns nil.
# File lib/sequel/model/associations.rb 446 def placeholder_loader 447 if use_placeholder_loader? 448 cached_fetch(:placeholder_loader) do 449 Sequel::Dataset::PlaceholderLiteralizer.loader(associated_dataset) do |pl, ds| 450 ds = ds.where(Sequel.&(*predicate_keys.map{|k| SQL::BooleanExpression.new(:'=', k, pl.arg)})) 451 if self[:block] 452 ds = self[:block].call(ds) 453 end 454 ds 455 end 456 end 457 end 458 end
The values that predicate_keys
should match for objects to be associated.
# File lib/sequel/model/associations.rb 466 def predicate_key_values(object) 467 predicate_key_methods.map{|k| object.get_column_value(k)} 468 end
The keys to use for loading of the regular dataset, as an array.
# File lib/sequel/model/associations.rb 461 def predicate_keys 462 cached_fetch(:predicate_keys){Array(predicate_key)} 463 end
Qualify col
with the given table name.
# File lib/sequel/model/associations.rb 471 def qualify(table, col) 472 transform(col) do |k| 473 case k 474 when Symbol, SQL::Identifier 475 SQL::QualifiedIdentifier.new(table, k) 476 else 477 Sequel::Qualifier.new(table).transform(k) 478 end 479 end 480 end
Qualify col with the associated model's table name.
# File lib/sequel/model/associations.rb 483 def qualify_assoc(col) 484 qualify(associated_class.table_name, col) 485 end
Qualify col with the current model's table name.
# File lib/sequel/model/associations.rb 488 def qualify_cur(col) 489 qualify(self[:model].table_name, col) 490 end
Returns the reciprocal association variable, if one exists. The reciprocal association is the association in the associated class that is the opposite of the current association. For example, Album.many_to_one :artist and Artist.one_to_many :albums are reciprocal associations. This information is to populate reciprocal associations. For example, when you do this_artist.add_album(album) it sets album.artist to this_artist.
# File lib/sequel/model/associations.rb 498 def reciprocal 499 cached_fetch(:reciprocal) do 500 possible_recips = [] 501 502 associated_class.all_association_reflections.each do |assoc_reflect| 503 if reciprocal_association?(assoc_reflect) 504 possible_recips << assoc_reflect 505 end 506 end 507 508 if possible_recips.length == 1 509 cached_set(:reciprocal_type, possible_recips.first[:type]) if ambiguous_reciprocal_type? 510 possible_recips.first[:name] 511 end 512 end 513 end
Whether the reciprocal of this association returns an array of objects instead of a single object, true by default.
# File lib/sequel/model/associations.rb 517 def reciprocal_array? 518 true 519 end
Name symbol for the remove_all_ association method
# File lib/sequel/model/associations.rb 522 def remove_all_method 523 self[:remove_all_method] 524 end
Whether associated objects need to be removed from the association before being destroyed in order to preserve referential integrity.
# File lib/sequel/model/associations.rb 528 def remove_before_destroy? 529 true 530 end
Name symbol for the remove_ association method
# File lib/sequel/model/associations.rb 533 def remove_method 534 self[:remove_method] 535 end
Whether to check that an object to be disassociated is already associated to this object, false by default.
# File lib/sequel/model/associations.rb 538 def remove_should_check_existing? 539 false 540 end
Whether this association returns an array of objects instead of a single object, true by default.
# File lib/sequel/model/associations.rb 544 def returns_array? 545 true 546 end
The columns to select when loading the association.
# File lib/sequel/model/associations.rb 549 def select 550 self[:select] 551 end
Whether to set the reciprocal association to self when loading associated records, false by default.
# File lib/sequel/model/associations.rb 555 def set_reciprocal_to_self? 556 false 557 end
Name symbol for the setter association method
# File lib/sequel/model/associations.rb 560 def setter_method 561 self[:setter_method] 562 end
The range used for slicing when using the :ruby eager limit strategy.
# File lib/sequel/model/associations.rb 565 def slice_range(limit_and_offset = limit_and_offset()) 566 limit, offset = limit_and_offset 567 if limit || offset 568 (offset||0)..(limit ? (offset||0)+limit-1 : -1) 569 end 570 end
Private Instance Methods
The base dataset used for the association, before any order/conditions options have been applied.
# File lib/sequel/model/associations.rb 595 def _associated_dataset 596 associated_class.dataset 597 end
Whether for the reciprocal type for the given association cannot be known in advantage, false by default.
# File lib/sequel/model/associations.rb 601 def ambiguous_reciprocal_type? 602 false 603 end
Apply a distinct on eager limit strategy using IN with a subquery that uses DISTINCT ON to ensure only the first matching record for each key is included.
# File lib/sequel/model/associations.rb 621 def apply_filter_by_associations_distinct_on_limit_strategy(ds) 622 k = filter_by_associations_limit_key 623 ds.where(k=>apply_distinct_on_eager_limit_strategy(associated_eager_dataset.select(*k))) 624 end
Apply a limit strategy to the given dataset so that filter by associations works with a limited dataset.
# File lib/sequel/model/associations.rb 607 def apply_filter_by_associations_limit_strategy(ds) 608 case filter_by_associations_limit_strategy 609 when :distinct_on 610 apply_filter_by_associations_distinct_on_limit_strategy(ds) 611 when :window_function 612 apply_filter_by_associations_window_function_limit_strategy(ds) 613 else 614 ds 615 end 616 end
Apply a distinct on eager limit strategy using IN with a subquery that uses a filter on the row_number window function to ensure that only rows inside the limit are returned.
# File lib/sequel/model/associations.rb 629 def apply_filter_by_associations_window_function_limit_strategy(ds) 630 ds.where(filter_by_associations_limit_key=>apply_window_function_eager_limit_strategy(associated_eager_dataset.select(*filter_by_associations_limit_alias_key)).select(*filter_by_associations_limit_aliases)) 631 end
The associated_dataset
with the eager_block callback already applied.
# File lib/sequel/model/associations.rb 634 def associated_eager_dataset 635 cached_fetch(:associated_eager_dataset) do 636 ds = associated_dataset.unlimited 637 if block = self[:eager_block] 638 ds = block.call(ds) 639 end 640 ds 641 end 642 end
If the key exists in the reflection hash, return it. If the key doesn't exist and association reflections are uncached, then yield to get the value. If the key doesn't exist and association reflection are cached, check the cache and return the value if present, or yield to get the value, cache the value, and return it.
# File lib/sequel/model/associations.rb 578 def cached_fetch(key) 579 fetch(key) do 580 return yield unless h = self[:cache] 581 Sequel.synchronize{return h[key] if h.has_key?(key)} 582 value = yield 583 Sequel.synchronize{h[key] = value} 584 end 585 end
Cache the value at the given key if caching.
# File lib/sequel/model/associations.rb 588 def cached_set(key, value) 589 return unless h = self[:cache] 590 Sequel.synchronize{h[key] = value} 591 end
The default eager limit strategy to use for this association
# File lib/sequel/model/associations.rb 671 def default_eager_limit_strategy 672 self[:model].default_eager_limit_strategy || :ruby 673 end
The dataset to use for eager loading associated objects for multiple current objects, given the hash passed to the eager loader.
# File lib/sequel/model/associations.rb 646 def eager_loading_dataset(eo=OPTS) 647 ds = eo[:dataset] || associated_eager_dataset 648 ds = eager_loading_set_predicate_condition(ds, eo) 649 if associations = eo[:associations] 650 ds = ds.eager(associations) 651 end 652 if block = eo[:eager_block] 653 orig_ds = ds 654 ds = block.call(ds) 655 end 656 if eager_loading_use_associated_key? 657 ds = if ds.opts[:eager_graph] && !orig_ds.opts[:eager_graph] 658 block.call(orig_ds.select_append(*associated_key_array)) 659 else 660 ds.select_append(*associated_key_array) 661 end 662 end 663 if self[:eager_graph] 664 raise(Error, "cannot eagerly load a #{self[:type]} association that uses :eager_graph") if eager_loading_use_associated_key? 665 ds = ds.eager_graph(self[:eager_graph]) 666 end 667 ds 668 end
The predicate condition to use for the eager_loader.
# File lib/sequel/model/associations.rb 685 def eager_loading_predicate_condition(keys) 686 {predicate_key=>keys} 687 end
Set the predicate condition for the eager loading dataset based on the id map in the eager loading options.
# File lib/sequel/model/associations.rb 677 def eager_loading_set_predicate_condition(ds, eo) 678 if id_map = eo[:id_map] 679 ds = ds.where(eager_loading_predicate_condition(id_map.keys)) 680 end 681 ds 682 end
Add conditions to the dataset to not include NULL values for the associated keys, and select those keys.
# File lib/sequel/model/associations.rb 691 def filter_by_associations_add_conditions_dataset_filter(ds) 692 k = filter_by_associations_conditions_associated_keys 693 ds.select(*k).where(Sequel.negate(k.zip([]))) 694 end
The base dataset to use for the filter by associations conditions subquery, regardless of the objects that are passed in as filter values.
# File lib/sequel/model/associations.rb 714 def filter_by_associations_conditions_dataset 715 cached_fetch(:filter_by_associations_conditions_dataset) do 716 ds = associated_eager_dataset.unordered 717 ds = filter_by_associations_add_conditions_dataset_filter(ds) 718 ds = apply_filter_by_associations_limit_strategy(ds) 719 ds 720 end 721 end
The conditions to add to the filter by associations conditions subquery to restrict it to to the object(s) that was used as the filter value.
# File lib/sequel/model/associations.rb 699 def filter_by_associations_conditions_subquery_conditions(obj) 700 key = qualify(associated_class.table_name, associated_class.primary_key) 701 case obj 702 when Array 703 {key=>obj.map(&:pk)} 704 when Sequel::Dataset 705 {key=>obj.select(*Array(qualify(associated_class.table_name, associated_class.primary_key)))} 706 else 707 Array(key).zip(Array(obj.pk)) 708 end 709 end
The strategy to use to filter by a limited association
# File lib/sequel/model/associations.rb 724 def filter_by_associations_limit_strategy 725 v = fetch(:filter_limit_strategy, self[:eager_limit_strategy]) 726 if v || self[:limit] || !returns_array? 727 case v ||= self[:model].default_eager_limit_strategy 728 when true, :union, :ruby 729 # Can't use a union or ruby-based strategy for filtering by associations, switch to default eager graph limit 730 # strategy. 731 true_eager_graph_limit_strategy 732 when Symbol 733 v 734 end 735 end 736 end
Whether to limit the associated dataset to a single row.
# File lib/sequel/model/associations.rb 739 def limit_to_single_row? 740 !returns_array? 741 end
Any offset to use for this association (or nil if there is no offset).
# File lib/sequel/model/associations.rb 744 def offset 745 limit_and_offset.last 746 end
A placeholder literalizer used to speed up eager loading.
# File lib/sequel/model/associations.rb 749 def placeholder_eager_loader 750 cached_fetch(:placeholder_eager_loader) do 751 Sequel::Dataset::PlaceholderLiteralizer.loader(associated_dataset) do |pl, ds| 752 apply_eager_limit_strategy(eager_loading_dataset.where(predicate_key=>pl.arg), eager_limit_strategy) 753 end 754 end 755 end
The reciprocal type as an array, should be overridden in reflection subclasses that have ambiguous reciprocal types.
# File lib/sequel/model/associations.rb 759 def possible_reciprocal_types 760 [reciprocal_type] 761 end
Whether the given association reflection is possible reciprocal association for the current association reflection.
# File lib/sequel/model/associations.rb 765 def reciprocal_association?(assoc_reflect) 766 possible_reciprocal_types.include?(assoc_reflect[:type]) && 767 (begin; assoc_reflect.associated_class; rescue NameError; end) == self[:model] && 768 assoc_reflect[:conditions].nil? && 769 assoc_reflect[:block].nil? 770 end
The number of subqueries to use in each union query, used to eagerly load limited associations. Defaults to 40, the optimal number depends on the latency between the database and the application.
# File lib/sequel/model/associations.rb 775 def subqueries_per_union 776 self[:subqueries_per_union] || 40 777 end
If s
is an array, map s
over the block. Otherwise, just call the block with s
.
# File lib/sequel/model/associations.rb 781 def transform(s, &block) 782 s.is_a?(Array) ? s.map(&block) : (yield s) 783 end
The eager_graph limit strategy used when true is given as the value, choosing the best strategy based on what the database supports.
# File lib/sequel/model/associations.rb 799 def true_eager_graph_limit_strategy 800 if associated_class.dataset.supports_window_functions? 801 :window_function 802 else 803 :ruby 804 end 805 end
What eager limit strategy should be used when true is given as the value, defaults to UNION as that is the fastest strategy if the appropriate keys are indexed.
# File lib/sequel/model/associations.rb 787 def true_eager_limit_strategy 788 if self[:eager_graph] || (offset && !associated_dataset.supports_offsets_in_correlated_subqueries?) 789 # An SQL-based approach won't work if you are also eager graphing, 790 # so use a ruby based approach in that case. 791 :ruby 792 else 793 :union 794 end 795 end
A placeholder literalizer used to speed up the creation of union queries when eager loading a limited association.
# File lib/sequel/model/associations.rb 809 def union_eager_loader 810 cached_fetch(:union_eager_loader) do 811 Sequel::Dataset::PlaceholderLiteralizer.loader(associated_dataset) do |pl, ds| 812 ds = self[:eager_block].call(ds) if self[:eager_block] 813 keys = predicate_keys 814 ds = ds.where(keys.map{pl.arg}.zip(keys)) 815 if eager_loading_use_associated_key? 816 ds = ds.select_append(*associated_key_array) 817 end 818 ds.from_self 819 end 820 end 821 end
Whether the placeholder loader can be used to load the association.
# File lib/sequel/model/associations.rb 824 def use_placeholder_loader? 825 self[:use_placeholder_loader] && _associated_dataset.supports_placeholder_literalizer? 826 end