Class: ActiveRecord::DisableJoinsAssociationRelation

Do not use. This class is for internal use only.

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Class Chain: self, `Relation`
Instance Chain: self, `Relation`, `FinderMethods`, `Calculations`, `SpawnMethods`, `QueryMethods`, `::ActiveModel::ForbiddenAttributesProtection`, `Batches`, `Explain`, `Delegation`, `::Enumerable`, `::ActiveSupport::EnumerableCoreExt::Constants`
Inherits:	ActiveRecord::Relation `::Object` ActiveRecord::Relation ActiveRecord::DisableJoinsAssociationRelation
Defined in:	activerecord/lib/active_record/disable_joins_association_relation.rb

Constant Summary

Class Method Summary

.new(klass, key, ids) ⇒ DisableJoinsAssociationRelation constructor

`Relation` - Inherited

.new

Instance Attribute Summary

#ids readonly
#key readonly

`Relation` - Inherited

#blank?	Returns true if relation is blank.
#eager_loading?	Returns true if relation needs eager loading.
#empty?	Returns true if there are no records.
#klass,
#loaded?	Alias for Relation#loaded.
#many?	Returns true if there is more than one record.
#model	Alias for Relation#klass.
#predicate_builder,
#scheduled?	Returns `true` if the relation was scheduled on the background thread pool.
#skip_preloading_value, #table, #references_eager_loaded_tables?, #empty_scope?, #has_limit_or_offset?

`QueryMethods` - Included

#null_relation?

`Delegation` - Included

#compact, #connection, #each, #encode_with, #in_groups, #in_groups_of, #index, #join, #length, #primary_key, #reverse, #rindex, #rotate, #sample, #shuffle, #slice, #split, #transaction

`::Enumerable` - Included

#many?

Returns true if the enumerable has more than 1 element.

`Relation` - Inherited

#==	Compares two relations for equality.
#any?	Returns true if there are any records.
#build	Alias for Relation#new.
#cache_key	Returns a stable cache key that can be used to identify this query.
#cache_key_with_version	Returns a cache key along with the version.
#cache_version	Returns a cache version that can be used together with the cache key to form a recyclable caching scheme.
#create	Tries to create a new record with the same scoped attributes defined in the relation.
#create!	Similar to `#create`, but calls create! on the base class.
#create_or_find_by	Attempts to create a record with the given attributes in a table that has a unique database constraint on one or several of its columns.
#create_or_find_by!	Like `#create_or_find_by`, but calls create! so an exception is raised if the created record is invalid.
#delete_all	Deletes the records without instantiating the records first, and hence not calling the #destroy method nor invoking callbacks.
#delete_by	Finds and deletes all records matching the specified conditions.
#destroy_all	Destroys the records by instantiating each record and calling its #destroy method.
#destroy_by	Finds and destroys all records matching the specified conditions.
#encode_with	Serializes the relation objects `::Array`.
#explain	Runs EXPLAIN on the query or queries triggered by this relation and returns the result as a string.
#find_or_create_by	Finds the first record with the given attributes, or creates a record with the attributes if one is not found:
#find_or_create_by!	Like `#find_or_create_by`, but calls create! so an exception is raised if the created record is invalid.
#find_or_initialize_by	Like `#find_or_create_by`, but calls `new` instead of create.
#initialize_copy, #inspect,
#joined_includes_values	Joins that are also marked for preloading.
#load	Causes the records to be loaded from the database if they have not been loaded already.
#load_async	Schedule the query to be performed from a background thread pool.
#loaded, #locked?,
#new	Initializes new record from relation while maintaining the current scope.
#none?	Returns true if there are no records.
#one?	Returns true if there is exactly one record.
#pretty_print,
#reload	Forces reloading of relation.
#reset, #scope_for_create,
#scoping	Scope all queries to the current scope.
#size	Returns size of the records.
#to_a	Alias for Relation#to_ary.
#to_ary	Converts relation objects to `::Array`.
#to_sql	Returns sql statement for the relation.
#touch_all	Touches all records in the current relation, setting the `updated_at`/`updated_on` attributes to the current time or the time specified.
#update_all	Updates all records in the current relation with details given.
#update_counters	Updates the counters of the records in the current relation.
#values, #load_records, #_create, #_create!, #_increment_attribute, #_new, #_scoping, #_substitute_values, #already_in_scope?, #current_scope_restoring_block, #exec_main_query, #exec_queries, #global_scope?, #instantiate_records, #limited_count, #skip_query_cache_if_necessary, #tables_in_string, #_exec_scope, #alias_tracker, #bind_attribute, #first_or_create, #first_or_create!, #first_or_initialize, #preload_associations, #records, #update, #update!, #values_for_queries,
#where_values_hash	Returns a hash of where conditions.
#compute_cache_key, #compute_cache_version

`FinderMethods` - Included

#exists?	Returns true if a record exists in the table that matches the `id` or conditions given, or false otherwise.
#fifth	Find the fifth record.
#fifth!	Same as `#fifth` but raises `RecordNotFound` if no record is found.
#find	Find by id - This can either be a specific id (ID), a list of ids (ID, ID, ID), or an array of ids ([ID, ID, ID]).
#find_by	Finds the first record matching the specified conditions.
#find_by!	Like `#find_by`, except that if no record is found, raises an `RecordNotFound` error.
#find_sole_by	Finds the sole matching record.
#first	Find the first record (or first N records if a parameter is supplied).
#first!	Same as #first but raises `RecordNotFound` if no record is found.
#forty_two	Find the forty-second record.
#forty_two!	Same as `#forty_two` but raises `RecordNotFound` if no record is found.
#fourth	Find the fourth record.
#fourth!	Same as `#fourth` but raises `RecordNotFound` if no record is found.
#include?	Returns true if the relation contains the given record or false otherwise.
#last	Find the last record (or last N records if a parameter is supplied).
#last!	Same as `#last` but raises `RecordNotFound` if no record is found.
#member?	Alias for FinderMethods#include?.
#second	Find the second record.
#second!	Same as `#second` but raises `RecordNotFound` if no record is found.
#second_to_last	Find the second-to-last record.
#second_to_last!	Same as `#second_to_last` but raises `RecordNotFound` if no record is found.
#sole	Finds the sole matching record.
#take	Gives a record (or N records if a parameter is supplied) without any implied order.
#take!	Same as `#take` but raises `RecordNotFound` if no record is found.
#third	Find the third record.
#third!	Same as `#third` but raises `RecordNotFound` if no record is found.
#third_to_last	Find the third-to-last record.
#third_to_last!	Same as `#third_to_last` but raises `RecordNotFound` if no record is found.
#_order_columns, #apply_join_dependency, #construct_relation_for_exists, #find_last, #find_nth, #find_nth_from_last, #find_nth_with_limit, #find_one, #find_some, #find_some_ordered, #find_take, #find_take_with_limit, #find_with_ids, #ordered_relation, #using_limitable_reflections?,
#raise_record_not_found_exception!	This method is called whenever no records are found with either a single id or multiple ids and raises an `RecordNotFound` exception.

`Calculations` - Included

#async_average	Same as `#average`, but performs the query asynchronously and returns an `Promise`.
#async_count	Same as `#count`, but performs the query asynchronously and returns an `Promise`.
#async_ids	Same as #ids, but performs the query asynchronously and returns an `Promise`.
#async_maximum	Same as `#maximum`, but performs the query asynchronously and returns an `Promise`.
#async_minimum	Same as `#minimum`, but performs the query asynchronously and returns an `Promise`.
#async_pick	Same as `#pick`, but performs the query asynchronously and returns an `Promise`.
#async_pluck	Same as `#pluck`, but performs the query asynchronously and returns an `Promise`.
#async_sum	Same as `#sum`, but performs the query asynchronously and returns an `Promise`.
#average	Calculates the average value on a given column.
#calculate	This calculates aggregate values in the given column.
#count	Count the records.
#ids	Returns the base model’s ID’s for the relation using the table’s primary key.
#maximum	Calculates the maximum value on a given column.
#minimum	Calculates the minimum value on a given column.
#pick	Pick the value(s) from the named column(s) in the current relation.
#pluck	Use `#pluck` as a shortcut to select one or more attributes without loading an entire record object per row.
#sum	Calculates the sum of values on a given column.
#aggregate_column, #all_attributes?, #build_count_subquery, #distinct_select?, #has_include?, #lookup_cast_type_from_join_dependencies, #operation_over_aggregate_column, #perform_calculation, #select_for_count, #type_cast_calculated_value, #type_cast_pluck_values, #type_for, #execute_grouped_calculation, #execute_simple_calculation

`SpawnMethods` - Included

#except	Removes from the query the condition(s) specified in `skips`.
#merge	Merges in the conditions from `other`, if `other` is an `Relation`.
#only	Removes any condition from the query other than the one(s) specified in `onlies`.
#relation_with, #merge!, #spawn

`QueryMethods` - Included

#and	Returns a new relation, which is the logical intersection of this relation and the one passed as an argument.
#annotate	Adds an SQL comment to queries generated from this relation.
#create_with	Sets attributes to be used when creating new records from a relation object.
#distinct	Specifies whether the records should be unique or not.
#eager_load	Specify associations `args` to be eager loaded using a `LEFT OUTER JOIN`.
#excluding	Excludes the specified record (or collection of records) from the resulting relation.
#extending	Used to extend a scope with additional methods, either through a module or through a block provided.
#extensions,
#extract_associated	Extracts a named `association` from the relation.
#from	Specifies the table from which the records will be fetched.
#group	Allows to specify a group attribute:
#having	Allows to specify a HAVING clause.
#in_order_of	Allows to specify an order by a specific set of values.
#includes	Specify associations `args` to be eager loaded to prevent N + 1 queries.
#invert_where	Allows you to invert an entire where clause instead of manually applying conditions.
#joins	Performs JOINs on `args`.
#left_joins	Alias for QueryMethods#left_outer_joins.
#left_outer_joins	Performs LEFT OUTER JOINs on `args`:
#limit	Specifies a limit for the number of records to retrieve.
#lock	Specifies locking settings (default to `true`).
#none	Returns a chainable relation with zero records.
#offset	Specifies the number of rows to skip before returning rows.
#optimizer_hints	Specify optimizer hints to be used in the SELECT statement.
#or	Returns a new relation, which is the logical union of this relation and the one passed as an argument.
#order	Applies an `ORDER BY` clause to a query.
#preload	Specify associations `args` to be eager loaded using separate queries.
#readonly	Mark a relation as readonly.
#references	Use to indicate that the given `table_names` are referenced by an SQL string, and should therefore be `JOIN`ed in any query rather than loaded separately.
#regroup	Allows you to change a previously set group statement.
#reorder	Replaces any existing order defined on the relation with the specified order.
#reselect	Allows you to change a previously set select statement.
#reverse_order	Reverse the existing order clause on the relation.
#rewhere	Allows you to change a previously set where condition for a given attribute, instead of appending to that condition.
#select	Works in two unique ways.
#strict_loading	Sets the returned relation to strict_loading mode.
#structurally_compatible?	Checks whether the given relation is structurally compatible with this relation, to determine if it’s possible to use the `#and` and `#or` methods without raising an error.
#uniq!	Deduplicate multiple values.
#unscope	Removes an unwanted relation that is already defined on a chain of relations.
#where	Returns a new relation, which is the result of filtering the current relation according to the conditions in the arguments.
#with	Add a Common Table Expression (CTE) that you can then reference within another SELECT statement.
#without	Alias for QueryMethods#excluding.
#async!,
#build_having_clause	Alias for QueryMethods#build_where_clause.
#arel_column, #arel_columns, #assert_mutability!, #async, #build_arel, #build_case_for_value_position, #build_cast_value, #build_from, #build_join_buckets, #build_join_dependencies, #build_joins, #build_order, #build_select, #build_with, #build_with_join_node, #build_with_value_from_hash,
#check_if_method_has_arguments!	Checks to make sure that the arguments are not blank.
#column_references, #does_not_support_reverse?, #each_join_dependencies, #lookup_table_klass_from_join_dependencies, #order_column, #preprocess_order_args, #process_select_args, #resolve_arel_attributes, #reverse_sql_order, #sanitize_order_arguments, #select_association_list, #select_named_joins, #table_name_matches?, #transform_select_hash_values, #validate_order_args, #_select!, #and!,
#annotate!	Like `#annotate`, but modifies relation in place.
#arel	Returns the `::Arel` object associated with the relation.
#construct_join_dependency, #create_with!,
#distinct!	Like `#distinct`, but modifies relation in place.
#eager_load!, #excluding!, #extending!, #from!, #group!, #having!, #includes!, #invert_where!, #joins!, #left_outer_joins!, #limit!, #lock!, #none!, #offset!, #optimizer_hints!, #or!,
#order!	Same as `#order` but operates on relation in-place instead of copying.
#preload!, #readonly!, #references!,
#regroup!	Same as `#regroup` but operates on relation in-place instead of copying.
#reorder!	Same as `#reorder` but operates on relation in-place instead of copying.
#reselect!	Same as `#reselect` but operates on relation in-place instead of copying.
#reverse_order!, #skip_preloading!, #skip_query_cache!, #strict_loading!, #unscope!, #where!,
#with!	Like `#with`, but modifies relation in place.
#build_subquery, #build_where_clause, #structurally_incompatible_values_for

`::ActiveModel::ForbiddenAttributesProtection` - Included

#sanitize_for_mass_assignment,
#sanitize_forbidden_attributes	Alias for ActiveModel::ForbiddenAttributesProtection#sanitize_for_mass_assignment.

`Batches` - Included

#find_each	Looping through a collection of records from the database (using the Scoping::Named::ClassMethods#all method, for example) is very inefficient since it will try to instantiate all the objects at once.
#find_in_batches	Yields each batch of records that was found by the find options as an array.
#in_batches	Yields `Relation` objects to work with a batch of records.
#act_on_ignored_order, #apply_finish_limit, #apply_limits, #apply_start_limit, #batch_condition, #batch_on_loaded_relation, #batch_on_unloaded_relation, #build_batch_orders, #get_the_order_of_primary_key

`Explain` - Included

#build_explain_clause, #connection_explain, #render_bind,
#collecting_queries_for_explain	Executes the block with the collect flag enabled.
#exec_explain	Makes the adapter execute EXPLAIN for the tuples of queries and bindings.

`Delegation` - Included

#&, #+, #-, #[], #as_json, #intersect?, #to_formatted_s, #to_fs, #to_sentence, #to_xml, #|, #respond_to_missing?

`::Enumerable` - Included

#compact_blank	Returns a new `::Array` without the blank items.
#exclude?	The negative of the `Enumerable#include?`.
#excluding	Returns a copy of the enumerable excluding the specified elements.
#in_order_of	Returns a new `::Array` where the order has been set to that provided in the `series`, based on the #key of the objects in the original enumerable.
#including	Returns a new array that includes the passed elements.
#index_by	Convert an enumerable to a hash, using the block result as the key and the element as the value.
#index_with	Convert an enumerable to a hash, using the element as the key and the block result as the value.
#maximum	Calculates the maximum from the extracted elements.
#minimum	Calculates the minimum from the extracted elements.
#pick	Extract the given key from the first element in the enumerable.
#pluck	Extract the given key from each element in the enumerable.
#sole	Returns the sole item in the enumerable.
#without	Alias for Enumerable#excluding.
#as_json

`::ActiveSupport::EnumerableCoreExt::Constants` - Included

#const_missing

Constructor Details

.new(klass, key, ids) ⇒ `DisableJoinsAssociationRelation`

[ GitHub ]

# File 'activerecord/lib/active_record/disable_joins_association_relation.rb', line 7


def initialize(klass, key, ids)
  @ids = ids.uniq
  @key = key
  super(klass)
end

Instance Attribute Details

#ids (readonly)

[ GitHub ]

# File 'activerecord/lib/active_record/disable_joins_association_relation.rb', line 5


attr_reader :ids, :key

#key (readonly)

[ GitHub ]

# File 'activerecord/lib/active_record/disable_joins_association_relation.rb', line 5


attr_reader :ids, :key

Instance Method Details

#first(limit = nil)

[ GitHub ]

# File 'activerecord/lib/active_record/disable_joins_association_relation.rb', line 17


def first(limit = nil)
  if limit
    records.limit(limit).first
  else
    records.first
  end
end

#limit(value)

[ GitHub ]

# File 'activerecord/lib/active_record/disable_joins_association_relation.rb', line 13


def limit(value)
  records.take(value)
end

#load

[ GitHub ]

# File 'activerecord/lib/active_record/disable_joins_association_relation.rb', line 25


def load
  super
  records = @records

  records_by_id = records.group_by do |record|
    record[key]
  end

  records = ids.flat_map { |id| records_by_id[id] }
  records.compact!

  @records = records
end

Class: ActiveRecord::DisableJoinsAssociationRelation

Constant Summary

Batches - Included

QueryMethods - Included

FinderMethods - Included

Relation - Inherited

Class Method Summary

Relation - Inherited

Instance Attribute Summary

Relation - Inherited

QueryMethods - Included

Delegation - Included

::Enumerable - Included

Instance Method Summary

Relation - Inherited

FinderMethods - Included

Calculations - Included

SpawnMethods - Included

QueryMethods - Included

::ActiveModel::ForbiddenAttributesProtection - Included

Batches - Included

Explain - Included

Delegation - Included

::Enumerable - Included

::ActiveSupport::EnumerableCoreExt::Constants - Included

Constructor Details

.new(klass, key, ids) ⇒ DisableJoinsAssociationRelation

Instance Attribute Details

#ids (readonly)

#key (readonly)

Instance Method Details

#first(limit = nil)

#limit(value)

#load

`Batches` - Included

`QueryMethods` - Included

`FinderMethods` - Included

`Relation` - Inherited

`Relation` - Inherited

`Relation` - Inherited

`QueryMethods` - Included

`Delegation` - Included

`::Enumerable` - Included

`Relation` - Inherited

`FinderMethods` - Included

`Calculations` - Included

`SpawnMethods` - Included

`QueryMethods` - Included

`::ActiveModel::ForbiddenAttributesProtection` - Included

`Batches` - Included

`Explain` - Included

`Delegation` - Included

`::Enumerable` - Included

`::ActiveSupport::EnumerableCoreExt::Constants` - Included

.new(klass, key, ids) ⇒ `DisableJoinsAssociationRelation`