Class: ActiveRecord::Relation

Inherits:
Object
  • Object
show all
Includes:
Batches, Calculations, Delegation, Explain, FinderMethods, QueryMethods, SpawnMethods
Defined in:
lib/ocean-dynamo/active_record_stuff/relation.rb

Overview

Active Record Relation

Direct Known Subclasses

Associations::CollectionProxy

Defined Under Namespace

Classes: JoinOperation

Constant Summary collapse

MULTI_VALUE_METHODS = 
[:includes, :eager_load, :preload, :select, :group,
:order, :joins, :where, :having, :bind, :references,
:extending]
SINGLE_VALUE_METHODS = 
[:limit, :offset, :lock, :readonly, :from, :reordering,
:reverse_order, :distinct, :create_with, :uniq]
VALUE_METHODS = 
MULTI_VALUE_METHODS + SINGLE_VALUE_METHODS

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(klass, table, values = {}) ⇒ Relation

Returns a new instance of Relation.



23
24
25
26
27
28
29
30
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 23

def initialize(klass, table, values = {})
  @klass             = klass
  @table             = table
  @values            = values
  @implicit_readonly = nil
  @loaded            = false
  @default_scoped    = false
end

Instance Attribute Details

#default_scoped ⇒ Object Also known as: default_scoped?

Returns the value of attribute default_scoped.



18
19
20
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 18

def default_scoped
  @default_scoped
end

#klass ⇒ Object (readonly) Also known as: model

Returns the value of attribute klass.



17
18
19
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 17

def klass
  @klass
end

#loaded ⇒ Object (readonly) Also known as: loaded?

Returns the value of attribute loaded.



17
18
19
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 17

def loaded
  @loaded
end

#proxy_association ⇒ Object

Returns the value of attribute proxy_association.



18
19
20
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 18

def proxy_association
  @proxy_association
end

#table ⇒ Object (readonly)

Returns the value of attribute table.



17
18
19
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 17

def table
  @table
end

Instance Method Details

#==(other) ⇒ Object

Compares two relations for equality.



538
539
540
541
542
543
544
545
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 538

def ==(other)
  case other
  when Relation
    other.to_sql == to_sql
  when Array
    to_a == other
  end
end

#any? ⇒ Boolean

Returns true if there are any records.

Returns:

  • (Boolean) 


240
241
242
243
244
245
246
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 240

def any?
  if block_given?
    to_a.any? { |*block_args| yield(*block_args) }
  else
    !empty?
  end
end

#as_json(options = nil) ⇒ Object

:nodoc:



222
223
224
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 222

def as_json(options = nil) #:nodoc:
  to_a.as_json(options)
end

#blank? ⇒ Boolean

Returns true if relation is blank.

Returns:

  • (Boolean) 


562
563
564
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 562

def blank?
  to_a.blank?
end

#create(*args, &block) ⇒ Object

Tries to create a new record with the same scoped attributes defined in the relation. Returns the initialized object if validation fails.

Expects arguments in the same format as Base.create.

Examples

users = User.where(name: 'Oscar')
users.create # #<User id: 3, name: "oscar", ...>

users.create(name: 'fxn')
users.create # #<User id: 4, name: "fxn", ...>

users.create { |user| user.name = 'tenderlove' }
# #<User id: 5, name: "tenderlove", ...>

users.create(name: nil) # validation on name
# #<User id: nil, name: nil, ...>



118
119
120
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 118

def create(*args, &block)
  scoping { @klass.create(*args, &block) }
end

#create!(*args, &block) ⇒ Object

Similar to #create, but calls create! on the base class. Raises an exception if a validation error occurs.

Expects arguments in the same format as Base.create!.



126
127
128
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 126

def create!(*args, &block)
  scoping { @klass.create!(*args, &block) }
end

#delete(id_or_array) ⇒ Object

Deletes the row with a primary key matching the id argument, using a SQL DELETE statement, and returns the number of rows deleted. Active Record objects are not instantiated, so the object’s callbacks are not executed, including any :dependent association options.

You can delete multiple rows at once by passing an Array of ids.

Note: Although it is often much faster than the alternative, #destroy, skipping callbacks might bypass business logic in your application that ensures referential integrity or performs other essential jobs.

Examples

# Delete a single row
Todo.delete(1)

# Delete multiple rows
Todo.delete([2,3,4])



458
459
460
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 458

def delete(id_or_array)
  where(primary_key => id_or_array).delete_all
end

#delete_all(conditions = nil) ⇒ Object

Deletes the records matching conditions without instantiating the records first, and hence not calling the destroy method nor invoking callbacks. This is a single SQL DELETE statement that goes straight to the database, much more efficient than destroy_all. Be careful with relations though, in particular :dependent rules defined on associations are not honored. Returns the number of rows affected.

Post.delete_all("person_id = 5 AND (category = 'Something' OR category = 'Else')")
Post.delete_all(["person_id = ? AND (category = ? OR category = ?)", 5, 'Something', 'Else'])
Post.where(person_id: 5).where(category: ['Something', 'Else']).delete_all

Both calls delete the affected posts all at once with a single DELETE statement. If you need to destroy dependent associations or call your before_* or after_destroy callbacks, use the destroy_all method instead.

If a limit scope is supplied, delete_all raises an ActiveRecord error:

Post.limit(100).delete_all
# => ActiveRecord::ActiveRecordError: delete_all doesn't support limit scope

Raises:

  • (ActiveRecordError) 


417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 417

def delete_all(conditions = nil)
  raise ActiveRecordError.new("delete_all doesn't support limit scope") if self.limit_value

  if conditions
    where(conditions).delete_all
  else
    stmt = Arel::DeleteManager.new(arel.engine)
    stmt.from(table)

    if with_default_scope.joins_values.any?
      @klass.connection.join_to_delete(stmt, arel, table[primary_key])
    else
      stmt.wheres = arel.constraints
    end

    affected = @klass.connection.delete(stmt, 'SQL', bind_values)

    reset
    affected
  end
end

#destroy(id) ⇒ Object

Destroy an object (or multiple objects) that has the given id. The object is instantiated first, therefore all callbacks and filters are fired off before the object is deleted. This method is less efficient than ActiveRecord#delete but allows cleanup methods and other actions to be run.

This essentially finds the object (or multiple objects) with the given id, creates a new object from the attributes, and then calls destroy on it.

Parameters

  • id - Can be either an Integer or an Array of Integers.

Examples

# Destroy a single object
Todo.destroy(1)

# Destroy multiple objects
todos = [1,2,3]
Todo.destroy(todos)



390
391
392
393
394
395
396
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 390

def destroy(id)
  if id.is_a?(Array)
    id.map { |one_id| destroy(one_id) }
  else
    find(id).destroy
  end
end

#destroy_all(conditions = nil) ⇒ Object

Destroys the records matching conditions by instantiating each record and calling its destroy method. Each object’s callbacks are executed (including :dependent association options). Returns the collection of objects that were destroyed; each will be frozen, to reflect that no changes should be made (since they can’t be persisted).

Note: Instantiation, callback execution, and deletion of each record can be time consuming when you’re removing many records at once. It generates at least one SQL DELETE query per record (or possibly more, to enforce your callbacks). If you want to delete many rows quickly, without concern for their associations or callbacks, use delete_all instead.

Parameters

  • conditions - A string, array, or hash that specifies which records to destroy. If omitted, all records are destroyed. See the Conditions section in the introduction to ActiveRecord::Base for more information.

Examples

Person.destroy_all("last_login < '2004-04-04'")
Person.destroy_all(status: "inactive")
Person.where(age: 0..18).destroy_all



363
364
365
366
367
368
369
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 363

def destroy_all(conditions = nil)
  if conditions
    where(conditions).destroy_all
  else
    to_a.each {|object| object.destroy }.tap { reset }
  end
end

#eager_loading? ⇒ Boolean

Returns true if relation needs eager loading.

Returns:

  • (Boolean) 


517
518
519
520
521
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 517

def eager_loading?
  @should_eager_load ||=
    eager_load_values.any? ||
    includes_values.any? && (joined_includes_values.any? || references_eager_loaded_tables?)
end

#empty? ⇒ Boolean

Returns true if there are no records.

Returns:

  • (Boolean) 


232
233
234
235
236
237
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 232

def empty?
  return @records.empty? if loaded?

  c = count
  c.respond_to?(:zero?) ? c.zero? : c.empty?
end

#explain ⇒ Object

Runs EXPLAIN on the query or queries triggered by this relation and returns the result as a string. The string is formatted imitating the ones printed by the database shell.

Note that this method actually runs the queries, since the results of some are needed by the next ones when eager loading is going on.

Please see further details in the Active Record Query Interface guide.



212
213
214
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 212

def explain
  exec_explain(collecting_queries_for_explain { exec_queries })
end

#find_or_create_by(attributes, &block) ⇒ Object

Finds the first record with the given attributes, or creates a record with the attributes if one is not found:

# Find the first user named "Penélope" or create a new one.
User.find_or_create_by(first_name: 'Penélope')
# => #<User id: 1, first_name: "Penélope", last_name: nil>

# Find the first user named "Penélope" or create a new one.
# We already have one so the existing record will be returned.
User.find_or_create_by(first_name: 'Penélope')
# => #<User id: 1, first_name: "Penélope", last_name: nil>

# Find the first user named "Scarlett" or create a new one with
# a particular last name.
User.create_with(last_name: 'Johansson').find_or_create_by(first_name: 'Scarlett')
# => #<User id: 2, first_name: "Scarlett", last_name: "Johansson">

This method accepts a block, which is passed down to create. The last example above can be alternatively written this way:

# Find the first user named "Scarlett" or create a new one with a
# different last name.
User.find_or_create_by(first_name: 'Scarlett') do |user|
  user.last_name = 'Johansson'
end
# => #<User id: 2, first_name: "Scarlett", last_name: "Johansson">

This method always returns a record, but if creation was attempted and failed due to validation errors it won’t be persisted, you get what create returns in such situation.

Please note *this method is not atomic*, it runs first a SELECT, and if there are no results an INSERT is attempted. If there are other threads or processes there is a race condition between both calls and it could be the case that you end up with two similar records.

Whether that is a problem or not depends on the logic of the application, but in the particular case in which rows have a UNIQUE constraint an exception may be raised, just retry:

begin
  CreditAccount.find_or_create_by(user_id: user.id)
rescue ActiveRecord::RecordNotUnique
  retry
end



188
189
190
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 188

def find_or_create_by(attributes, &block)
  find_by(attributes) || create(attributes, &block)
end

#find_or_create_by!(attributes, &block) ⇒ Object

Like find_or_create_by, but calls create! so an exception is raised if the created record is invalid.



194
195
196
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 194

def find_or_create_by!(attributes, &block)
  find_by(attributes) || create!(attributes, &block)
end

#find_or_initialize_by(attributes, &block) ⇒ Object

Like find_or_create_by, but calls new instead of create.



199
200
201
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 199

def find_or_initialize_by(attributes, &block)
  find_by(attributes) || new(attributes, &block)
end

#first_or_create(attributes = nil, &block) ⇒ Object

:nodoc:



130
131
132
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 130

def first_or_create(attributes = nil, &block) # :nodoc:
  first || create(attributes, &block)
end

#first_or_create!(attributes = nil, &block) ⇒ Object

:nodoc:



134
135
136
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 134

def first_or_create!(attributes = nil, &block) # :nodoc:
  first || create!(attributes, &block)
end

#first_or_initialize(attributes = nil, &block) ⇒ Object

:nodoc:



138
139
140
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 138

def first_or_initialize(attributes = nil, &block) # :nodoc:
  first || new(attributes, &block)
end

#initialize_copy(other) ⇒ Object 



32
33
34
35
36
37
38
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 32

def initialize_copy(other)
  # This method is a hot spot, so for now, use Hash[] to dup the hash.
  #   https://bugs.ruby-lang.org/issues/7166
  @values        = Hash[@values]
  @values[:bind] = @values[:bind].dup if @values.key? :bind
  reset
end

#insert(values) ⇒ Object 



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 40

def insert(values)
  primary_key_value = nil

  if primary_key && Hash === values
    primary_key_value = values[values.keys.find { |k|
      k.name == primary_key
    }]

    if !primary_key_value && connection.prefetch_primary_key?(klass.table_name)
      primary_key_value = connection.next_sequence_value(klass.sequence_name)
      values[klass.arel_table[klass.primary_key]] = primary_key_value
    end
  end

  im = arel.create_insert
  im.into @table

  conn = @klass.connection

  substitutes = values.sort_by { |arel_attr,_| arel_attr.name }
  binds       = substitutes.map do |arel_attr, value|
    [@klass.columns_hash[arel_attr.name], value]
  end

  substitutes.each_with_index do |tuple, i|
    tuple[1] = conn.substitute_at(binds[i][0], i)
  end

  if values.empty? # empty insert
    im.values = Arel.sql(connection.empty_insert_statement_value)
  else
    im.insert substitutes
  end

  conn.insert(
    im,
    'SQL',
    primary_key,
    primary_key_value,
    nil,
    binds)
end

#inspect ⇒ Object 



570
571
572
573
574
575
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 570

def inspect
  entries = to_a.take([limit_value, 11].compact.min).map!(&:inspect)
  entries[10] = '...' if entries.size == 11

  "#<#{self.class.name} [#{entries.join(', ')}]>"
end

#joined_includes_values ⇒ Object

Joins that are also marked for preloading. In which case we should just eager load them. Note that this is a naive implementation because we could have strings and symbols which represent the same association, but that aren’t matched by this. Also, we could have nested hashes which partially match, e.g. { a: :b } & { a: [:b, :c] }



527
528
529
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 527

def joined_includes_values
  includes_values & joins_values
end

#load ⇒ Object

Causes the records to be loaded from the database if they have not been loaded already. You can use this if for some reason you need to explicitly load some records before actually using them. The return value is the relation itself, not the records.

Post.where(published: true).load # => #<ActiveRecord::Relation>



468
469
470
471
472
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 468

def load
  exec_queries unless loaded?

  self
end

#many? ⇒ Boolean

Returns true if there is more than one record.

Returns:

  • (Boolean) 


249
250
251
252
253
254
255
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 249

def many?
  if block_given?
    to_a.many? { |*block_args| yield(*block_args) }
  else
    limit_value ? to_a.many? : size > 1
  end
end

#new(*args, &block) ⇒ Object Also known as: build

Initializes new record from relation while maintaining the current scope.

Expects arguments in the same format as Base.new.

users = User.where(name: 'DHH')
user = users.new # => #<User id: nil, name: "DHH", created_at: nil, updated_at: nil>

You can also pass a block to new with the new record as argument:

user = users.new { |user| user.name = 'Oscar' }
user.name # => Oscar



95
96
97
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 95

def new(*args, &block)
  scoping { @klass.new(*args, &block) }
end

#pretty_print(q) ⇒ Object 



547
548
549
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 547

def pretty_print(q)
  q.pp(self.to_a)
end

#reload ⇒ Object

Forces reloading of relation.



475
476
477
478
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 475

def reload
  reset
  load
end

#reset ⇒ Object 



480
481
482
483
484
485
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 480

def reset
  @first = @last = @to_sql = @order_clause = @scope_for_create = @arel = @loaded = nil
  @should_eager_load = @join_dependency = nil
  @records = []
  self
end

#scope_for_create ⇒ Object 



512
513
514
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 512

def scope_for_create
  @scope_for_create ||= where_values_hash.merge(create_with_value)
end

#scoping ⇒ Object

Scope all queries to the current scope.

Comment.where(post_id: 1).scoping do
  Comment.first
end
# => SELECT "comments".* FROM "comments" WHERE "comments"."post_id" = 1 ORDER BY "comments"."id" ASC LIMIT 1

Please check unscoped if you want to remove all previous scopes (including the default_scope) during the execution of a block.



266
267
268
269
270
271
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 266

def scoping
  previous, klass.current_scope = klass.current_scope, self
  yield
ensure
  klass.current_scope = previous
end

#size ⇒ Object

Returns size of the records.



227
228
229
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 227

def size
  loaded? ? @records.length : count
end

#to_a ⇒ Object

Converts relation objects to Array.



217
218
219
220
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 217

def to_a
  load
  @records
end

#to_sql ⇒ Object

Returns sql statement for the relation.

User.where(name: 'Oscar').to_sql
# => SELECT "users".* FROM "users"  WHERE "users"."name" = 'Oscar'



491
492
493
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 491

def to_sql
  @to_sql ||= klass.connection.to_sql(arel, bind_values.dup)
end

#uniq_value ⇒ Object

uniq and uniq! are silently deprecated. uniq_value delegates to distinct_value to maintain backwards compatibility. Use distinct_value instead.



533
534
535
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 533

def uniq_value
  distinct_value
end

#update(id, attributes) ⇒ Object

Updates an object (or multiple objects) and saves it to the database, if validations pass. The resulting object is returned whether the object was saved successfully to the database or not.

Parameters

  • id - This should be the id or an array of ids to be updated.

  • attributes - This should be a hash of attributes or an array of hashes.

Examples

# Updates one record
Person.update(15, user_name: 'Samuel', group: 'expert')

# Updates multiple records
people = { 1 => { "first_name" => "David" }, 2 => { "first_name" => "Jeremy" } }
Person.update(people.keys, people.values)



328
329
330
331
332
333
334
335
336
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 328

def update(id, attributes)
  if id.is_a?(Array)
    id.map.with_index { |one_id, idx| update(one_id, attributes[idx]) }
  else
    object = find(id)
    object.update(attributes)
    object
  end
end

#update_all(updates) ⇒ Object

Updates all records with details given if they match a set of conditions supplied, limits and order can also be supplied. This method constructs a single SQL UPDATE statement and sends it straight to the database. It does not instantiate the involved models and it does not trigger Active Record callbacks or validations.

Parameters

  • updates - A string, array, or hash representing the SET part of an SQL statement.

Examples

# Update all customers with the given attributes
Customer.update_all wants_email: true

# Update all books with 'Rails' in their title
Book.where('title LIKE ?', '%Rails%').update_all(author: 'David')

# Update all books that match conditions, but limit it to 5 ordered by date
Book.where('title LIKE ?', '%Rails%').order(:created_at).limit(5).update_all(author: 'David')

Raises:

  • (ArgumentError) 


292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 292

def update_all(updates)
  raise ArgumentError, "Empty list of attributes to change" if updates.blank?

  stmt = Arel::UpdateManager.new(arel.engine)

  stmt.set Arel.sql(@klass.send(:sanitize_sql_for_assignment, updates))
  stmt.table(table)
  stmt.key = table[primary_key]

  if with_default_scope.joins_values.any?
    @klass.connection.join_to_update(stmt, arel)
  else
    stmt.take(arel.limit)
    stmt.order(*arel.orders)
    stmt.wheres = arel.constraints
  end

  @klass.connection.update stmt, 'SQL', bind_values
end

#values ⇒ Object 



566
567
568
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 566

def values
  Hash[@values]
end

#where_values_hash ⇒ Object

Returns a hash of where conditions.

User.where(name: 'Oscar').where_values_hash
# => {name: "Oscar"}



499
500
501
502
503
504
505
506
507
508
509
510
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 499

def where_values_hash
  equalities = with_default_scope.where_values.grep(Arel::Nodes::Equality).find_all { |node|
    node.left.relation.name == table_name
  }

  binds = Hash[bind_values.find_all(&:first).map { |column, v| [column.name, v] }]

  Hash[equalities.map { |where|
    name = where.left.name
    [name, binds.fetch(name.to_s) { where.right }]
  }]
end

#with_default_scope ⇒ Object

:nodoc:



551
552
553
554
555
556
557
558
559
 
# File 'lib/ocean-dynamo/active_record_stuff/relation.rb', line 551

def with_default_scope #:nodoc:
  if default_scoped? && default_scope = klass.send(:build_default_scope)
    default_scope = default_scope.merge(self)
    default_scope.default_scoped = false
    default_scope
  else
    self
  end
end