Module: ActiveRecord::Core::ClassMethods

Defined in:
lib/active_record/core.rb

Instance Method Summary collapse

Instance Method Details

#===(object) ⇒ Object

Overwrite the default class equality method to provide support for association proxies.



262
263
264
 
# File 'lib/active_record/core.rb', line 262

def ===(object)
  object.is_a?(self)
end

#allocate ⇒ Object 



153
154
155
156
 
# File 'lib/active_record/core.rb', line 153

def allocate
  define_attribute_methods
  super
end

#arel_attribute(name, table = arel_table) ⇒ Object

:nodoc:



285
286
287
288
 
# File 'lib/active_record/core.rb', line 285

def arel_attribute(name, table = arel_table) # :nodoc:
  name = attribute_alias(name) if attribute_alias?(name)
  table[name]
end

#arel_engine ⇒ Object

Returns the Arel engine.



276
277
278
279
280
281
282
283
 
# File 'lib/active_record/core.rb', line 276

def arel_engine # :nodoc:
  @arel_engine ||=
    if Base == self || connection_handler.retrieve_connection_pool(connection_specification_name)
      self
    else
      superclass.arel_engine
    end
end

#arel_table ⇒ Object

Returns an instance of Arel::Table loaded with the current table name.

class Post < ActiveRecord::Base
  scope :published_and_commented, -> { published.and(arel_table[:comments_count].gt(0)) }
end



271
272
273
 
# File 'lib/active_record/core.rb', line 271

def arel_table # :nodoc:
  @arel_table ||= Arel::Table.new(table_name, type_caster: type_caster)
end

#find(*ids) ⇒ Object

:nodoc:



168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
 
# File 'lib/active_record/core.rb', line 168

def find(*ids) # :nodoc:
  # We don't have cache keys for this stuff yet
  return super unless ids.length == 1
  return super if block_given? ||
                  primary_key.nil? ||
                  scope_attributes? ||
                  columns_hash.include?(inheritance_column)

  id = ids.first

  return super if id.kind_of?(Array) ||
                   id.is_a?(ActiveRecord::Base)

  key = primary_key

  statement = cached_find_by_statement(key) { |params|
    where(key => params.bind).limit(1)
  }

  record = statement.execute([id], self, connection).first
  unless record
    raise RecordNotFound.new("Couldn't find #{name} with '#{primary_key}'=#{id}",
                             name, primary_key, id)
  end
  record
rescue ::RangeError
  raise RecordNotFound.new("Couldn't find #{name} with an out of range value for '#{primary_key}'",
                           name, primary_key)
end

#find_by(*args) ⇒ Object

:nodoc:



198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
 
# File 'lib/active_record/core.rb', line 198

def find_by(*args) # :nodoc:
  return super if scope_attributes? || reflect_on_all_aggregations.any?

  hash = args.first

  return super if !(Hash === hash) || hash.values.any? { |v|
    v.nil? || Array === v || Hash === v || Relation === v || Base === v
  }

  # We can't cache Post.find_by(author: david) ...yet
  return super unless hash.keys.all? { |k| columns_hash.has_key?(k.to_s) }

  keys = hash.keys

  statement = cached_find_by_statement(keys) { |params|
    wheres = keys.each_with_object({}) { |param, o|
      o[param] = params.bind
    }
    where(wheres).limit(1)
  }
  begin
    statement.execute(hash.values, self, connection).first
  rescue TypeError
    raise ActiveRecord::StatementInvalid
  rescue ::RangeError
    nil
  end
end

#find_by!(*args) ⇒ Object

:nodoc:



227
228
229
 
# File 'lib/active_record/core.rb', line 227

def find_by!(*args) # :nodoc:
  find_by(*args) || raise(RecordNotFound.new("Couldn't find #{name}", name))
end

#generated_association_methods ⇒ Object 



235
236
237
238
239
240
241
242
243
 
# File 'lib/active_record/core.rb', line 235

def generated_association_methods
  @generated_association_methods ||= begin
    mod = const_set(:GeneratedAssociationMethods, Module.new)
    private_constant :GeneratedAssociationMethods
    include mod

    mod
  end
end

#inherited(child_class) ⇒ Object

:nodoc:



162
163
164
165
166
 
# File 'lib/active_record/core.rb', line 162

def inherited(child_class) # :nodoc:
  # initialize cache at class definition for thread safety
  child_class.initialize_find_by_cache
  super
end

#initialize_find_by_cache ⇒ Object

:nodoc:



158
159
160
 
# File 'lib/active_record/core.rb', line 158

def initialize_find_by_cache # :nodoc:
  @find_by_statement_cache = { true => {}.extend(Mutex_m), false => {}.extend(Mutex_m) }
end

#initialize_generated_modules ⇒ Object

:nodoc:



231
232
233
 
# File 'lib/active_record/core.rb', line 231

def initialize_generated_modules # :nodoc:
  generated_association_methods
end

#inspect ⇒ Object

Returns a string like ‘Post(id:integer, title:string, body:text)’



246
247
248
249
250
251
252
253
254
255
256
257
258
259
 
# File 'lib/active_record/core.rb', line 246

def inspect
  if self == Base
    super
  elsif abstract_class?
    "#{super}(abstract)"
  elsif !connected?
    "#{super} (call '#{super}.connection' to establish a connection)"
  elsif table_exists?
    attr_list = attribute_types.map { |name, type| "#{name}: #{type.type}" } * ", "
    "#{super}(#{attr_list})"
  else
    "#{super}(Table doesn't exist)"
  end
end

#predicate_builder ⇒ Object

:nodoc:



290
291
292
 
# File 'lib/active_record/core.rb', line 290

def predicate_builder # :nodoc:
  @predicate_builder ||= PredicateBuilder.new(table_metadata)
end

#type_caster ⇒ Object

:nodoc:



294
295
296
 
# File 'lib/active_record/core.rb', line 294

def type_caster # :nodoc:
  TypeCaster::Map.new(self)
end