Class: ActiveRecord::Base

Inherits:
Object
  • Object
show all
Extended by:
ActiveModel::Naming, CounterCache, DynamicMatchers, Explain, QueryCache::ClassMethods, Querying, Translation, ActiveSupport::Benchmarkable, ActiveSupport::DescendantsTracker
Includes:
ActiveModel::Conversion, ActiveModel::Observing, ActiveModel::SecurePassword, Aggregations, Associations, AttributeAssignment, AttributeMethods, AutosaveAssociation, Callbacks, IdentityMap, Inheritance, Integration, Locking::Optimistic, Locking::Pessimistic, ModelSchema, NestedAttributes, Persistence, ReadonlyAttributes, Reflection, Sanitization, Scoping, Serialization, Store, Timestamp, Transactions, Validations
Defined in:
lib/active_record/base.rb,
lib/active_record/connection_adapters/mysql_adapter.rb,
lib/active_record/connection_adapters/mysql2_adapter.rb,
lib/active_record/connection_adapters/sqlite3_adapter.rb,
lib/active_record/connection_adapters/postgresql_adapter.rb,
lib/active_record/connection_adapters/abstract/connection_specification.rb

Overview

Active Record

Active Record objects don’t specify their attributes directly, but rather infer them from the table definition with which they’re linked. Adding, removing, and changing attributes and their type is done directly in the database. Any change is instantly reflected in the Active Record objects. The mapping that binds a given Active Record class to a certain database table will happen automatically in most common cases, but can be overwritten for the uncommon ones.

See the mapping rules in table_name and the full example in files/activerecord/README_rdoc.html for more insight.

Creation

Active Records accept constructor parameters either in a hash or as a block. The hash method is especially useful when you’re receiving the data from somewhere else, like an HTTP request. It works like this:

user = User.new(:name => "David", :occupation => "Code Artist")
user.name # => "David"

You can also use block initialization:

user = User.new do |u|
  u.name = "David"
  u.occupation = "Code Artist"
end

And of course you can just create a bare object and specify the attributes after the fact:

user = User.new
user.name = "David"
user.occupation = "Code Artist"

Conditions

Conditions can either be specified as a string, array, or hash representing the WHERE-part of an SQL statement. The array form is to be used when the condition input is tainted and requires sanitization. The string form can be used for statements that don’t involve tainted data. The hash form works much like the array form, except only equality and range is possible. Examples:

class User < ActiveRecord::Base
  def self.authenticate_unsafely(user_name, password)
    where("user_name = '#{user_name}' AND password = '#{password}'").first
  end

  def self.authenticate_safely(user_name, password)
    where("user_name = ? AND password = ?", user_name, password).first
  end

  def self.authenticate_safely_simply(user_name, password)
    where(:user_name => user_name, :password => password).first
  end
end

The authenticate_unsafely method inserts the parameters directly into the query and is thus susceptible to SQL-injection attacks if the user_name and password parameters come directly from an HTTP request. The authenticate_safely and authenticate_safely_simply both will sanitize the user_name and password before inserting them in the query, which will ensure that an attacker can’t escape the query and fake the login (or worse).

When using multiple parameters in the conditions, it can easily become hard to read exactly what the fourth or fifth question mark is supposed to represent. In those cases, you can resort to named bind variables instead. That’s done by replacing the question marks with symbols and supplying a hash with values for the matching symbol keys:

Company.where(
  "id = :id AND name = :name AND division = :division AND created_at > :accounting_date",
  { :id => 3, :name => "37signals", :division => "First", :accounting_date => '2005-01-01' }
).first

Similarly, a simple hash without a statement will generate conditions based on equality with the SQL AND operator. For instance:

Student.where(:first_name => "Harvey", :status => 1)
Student.where(params[:student])

A range may be used in the hash to use the SQL BETWEEN operator:

Student.where(:grade => 9..12)

An array may be used in the hash to use the SQL IN operator:

Student.where(:grade => [9,11,12])

When joining tables, nested hashes or keys written in the form ‘table_name.column_name’ can be used to qualify the table name of a particular condition. For instance:

Student.joins(:schools).where(:schools => { :category => 'public' })
Student.joins(:schools).where('schools.category' => 'public' )

Overwriting default accessors

All column values are automatically available through basic accessors on the Active Record object, but sometimes you want to specialize this behavior. This can be done by overwriting the default accessors (using the same name as the attribute) and calling read_attribute(attr_name) and write_attribute(attr_name, value) to actually change things.

class Song < ActiveRecord::Base
  # Uses an integer of seconds to hold the length of the song

  def length=(minutes)
    write_attribute(:length, minutes.to_i * 60)
  end

  def length
    read_attribute(:length) / 60
  end
end

You can alternatively use self[:attribute]=(value) and self[:attribute] instead of write_attribute(:attribute, value) and read_attribute(:attribute).

Attribute query methods

In addition to the basic accessors, query methods are also automatically available on the Active Record object. Query methods allow you to test whether an attribute value is present.

For example, an Active Record User with the name attribute has a name? method that you can call to determine whether the user has a name:

user = User.new(:name => "David")
user.name? # => true

anonymous = User.new(:name => "")
anonymous.name? # => false

Accessing attributes before they have been typecasted

Sometimes you want to be able to read the raw attribute data without having the column-determined typecast run its course first. That can be done by using the <attribute>_before_type_cast accessors that all attributes have. For example, if your Account model has a balance attribute, you can call account.balance_before_type_cast or account.id_before_type_cast.

This is especially useful in validation situations where the user might supply a string for an integer field and you want to display the original string back in an error message. Accessing the attribute normally would typecast the string to 0, which isn’t what you want.

Dynamic attribute-based finders

Dynamic attribute-based finders are a cleaner way of getting (and/or creating) objects by simple queries without turning to SQL. They work by appending the name of an attribute to find_by_, find_last_by_, or find_all_by_ and thus produces finders like Person.find_by_user_name, Person.find_all_by_last_name, and Payment.find_by_transaction_id. Instead of writing Person.where(:user_name => user_name).first, you just do Person.find_by_user_name(user_name). And instead of writing Person.where(:last_name => last_name).all, you just do Person.find_all_by_last_name(last_name).

It’s possible to add an exclamation point (!) on the end of the dynamic finders to get them to raise an ActiveRecord::RecordNotFound error if they do not return any records, like Person.find_by_last_name!.

It’s also possible to use multiple attributes in the same find by separating them with “and”.

Person.where(:user_name => user_name, :password => password).first
Person.find_by_user_name_and_password(user_name, password) # with dynamic finder

It’s even possible to call these dynamic finder methods on relations and named scopes.

Payment.order("created_on").find_all_by_amount(50)
Payment.pending.find_last_by_amount(100)

The same dynamic finder style can be used to create the object if it doesn’t already exist. This dynamic finder is called with find_or_create_by_ and will return the object if it already exists and otherwise creates it, then returns it. Protected attributes won’t be set unless they are given in a block.

# No 'Summer' tag exists
Tag.find_or_create_by_name("Summer") # equal to Tag.create(:name => "Summer")

# Now the 'Summer' tag does exist
Tag.find_or_create_by_name("Summer") # equal to Tag.find_by_name("Summer")

# Now 'Bob' exist and is an 'admin'
User.find_or_create_by_name('Bob', :age => 40) { |u| u.admin = true }

Adding an exclamation point (!) on to the end of find_or_create_by_ will raise an ActiveRecord::RecordInvalid error if the new record is invalid.

Use the find_or_initialize_by_ finder if you want to return a new record without saving it first. Protected attributes won’t be set unless they are given in a block.

# No 'Winter' tag exists
winter = Tag.find_or_initialize_by_name("Winter")
winter.persisted? # false

To find by a subset of the attributes to be used for instantiating a new object, pass a hash instead of a list of parameters.

Tag.find_or_create_by_name(:name => "rails", :creator => current_user)

That will either find an existing tag named “rails”, or create a new one while setting the user that created it.

Just like find_by_*, you can also use scoped_by_* to retrieve data. The good thing about using this feature is that the very first time result is returned using method_missing technique but after that the method is declared on the class. Henceforth method_missing will not be hit.

User.scoped_by_user_name('David')

Saving arrays, hashes, and other non-mappable objects in text columns

Active Record can serialize any object in text columns using YAML. To do so, you must specify this with a call to the class method serialize. This makes it possible to store arrays, hashes, and other non-mappable objects without doing any additional work.

class User < ActiveRecord::Base
  serialize :preferences
end

user = User.create(:preferences => { "background" => "black", "display" => large })
User.find(user.id).preferences # => { "background" => "black", "display" => large }

You can also specify a class option as the second parameter that’ll raise an exception if a serialized object is retrieved as a descendant of a class not in the hierarchy.

class User < ActiveRecord::Base
  serialize :preferences, Hash
end

user = User.create(:preferences => %w( one two three ))
User.find(user.id).preferences    # raises SerializationTypeMismatch

When you specify a class option, the default value for that attribute will be a new instance of that class.

class User < ActiveRecord::Base
  serialize :preferences, OpenStruct
end

user = User.new
user.preferences.theme_color = "red"

Single table inheritance

Active Record allows inheritance by storing the name of the class in a column that by default is named “type” (can be changed by overwriting Base.inheritance_column). This means that an inheritance looking like this:

class Company < ActiveRecord::Base; end
class Firm < Company; end
class Client < Company; end
class PriorityClient < Client; end

When you do Firm.create(:name => "37signals"), this record will be saved in the companies table with type = “Firm”. You can then fetch this row again using Company.where(:name => '37signals').first and it will return a Firm object.

If you don’t have a type column defined in your table, single-table inheritance won’t be triggered. In that case, it’ll work just like normal subclasses with no special magic for differentiating between them or reloading the right type with find.

Note, all the attributes for all the cases are kept in the same table. Read more: www.martinfowler.com/eaaCatalog/singleTableInheritance.html

Connection to multiple databases in different models

Connections are usually created through ActiveRecord::Base.establish_connection and retrieved by ActiveRecord::Base.connection. All classes inheriting from ActiveRecord::Base will use this connection. But you can also set a class-specific connection. For example, if Course is an ActiveRecord::Base, but resides in a different database, you can just say Course.establish_connection and Course and all of its subclasses will use this connection instead.

This feature is implemented by keeping a connection pool in ActiveRecord::Base that is a Hash indexed by the class. If a connection is requested, the retrieve_connection method will go up the class-hierarchy until a connection is found in the connection pool.

Exceptions

  • ActiveRecordError - Generic error class and superclass of all other errors raised by Active Record.

  • AdapterNotSpecified - The configuration hash used in establish_connection didn’t include an :adapter key.

  • AdapterNotFound - The :adapter key used in establish_connection specified a non-existent adapter (or a bad spelling of an existing one).

  • AssociationTypeMismatch - The object assigned to the association wasn’t of the type specified in the association definition.

  • SerializationTypeMismatch - The serialized object wasn’t of the class specified as the second parameter.

  • ConnectionNotEstablished+ - No connection has been established. Use establish_connection before querying.

  • RecordNotFound - No record responded to the find method. Either the row with the given ID doesn’t exist or the row didn’t meet the additional restrictions. Some find calls do not raise this exception to signal nothing was found, please check its documentation for further details.

  • StatementInvalid - The database server rejected the SQL statement. The precise error is added in the message.

  • MultiparameterAssignmentErrors - Collection of errors that occurred during a mass assignment using the attributes= method. The errors property of this exception contains an array of AttributeAssignmentError objects that should be inspected to determine which attributes triggered the errors.

  • AttributeAssignmentError - An error occurred while doing a mass assignment through the attributes= method. You can inspect the attribute property of the exception object to determine which attribute triggered the error.

Note: The attributes listed are class-level attributes (accessible from both the class and instance level). So it’s possible to assign a logger to the class through Base.logger= which will then be used by all instances in the current object space.

Direct Known Subclasses

SessionStore::Session

Defined Under Namespace

Classes: ConnectionSpecification

Constant Summary collapse

@@configurations = 
{}
@@default_timezone = 
:local
@@schema_format = 
:ruby
@@timestamped_migrations = 
true

Constants included from AutosaveAssociation

AutosaveAssociation::ASSOCIATION_TYPES

Constants included from Callbacks

Callbacks::CALLBACKS

Instance Attribute Summary

Attributes included from Associations

#association_cache

Class Method Summary collapse

Instance Method Summary collapse

Methods included from QueryCache::ClassMethods

cache, uncached

Methods included from Querying

count_by_sql, find_by_sql

Methods included from Translation

i18n_scope, lookup_ancestors

Methods included from DynamicMatchers

respond_to?

Methods included from CounterCache

decrement_counter, increment_counter, reset_counters, update_counters

Methods included from Explain

collecting_queries_for_explain, exec_explain, extended, logging_query_plan, silence_auto_explain

Methods included from Aggregations

#clear_aggregation_cache

Methods included from Transactions

#add_to_transaction, #committed!, #destroy, #rollback_active_record_state!, #rolledback!, #save, #save!, #transaction, #with_transaction_returning_status

Methods included from Serialization

#serializable_hash, #to_xml

Methods included from AutosaveAssociation

#changed_for_autosave?, #mark_for_destruction, #marked_for_destruction?, #reload

Methods included from NestedAttributes

#_destroy

Methods included from IdentityMap

add, clear, enabled, enabled=, get, #reinit_with, remove, remove_by_id, repository, use, without

Methods included from Associations

#association, #clear_association_cache

Methods included from Callbacks

#destroy, #touch

Methods included from AttributeMethods

#attribute_for_inspect, #attribute_missing, #attribute_names, #attribute_present?, #attributes, #column_for_attribute, #has_attribute?, #method_missing, #respond_to?

Methods included from Locking::Optimistic

#locking_enabled?

Methods included from Locking::Pessimistic

#lock!, #with_lock

Methods included from Validations

#save, #save!, #valid?

Methods included from Integration

#cache_key, #to_param

Methods included from AttributeAssignment

#assign_attributes, #attributes=

Methods included from Sanitization

#quoted_id

Methods included from Scoping

#populate_with_current_scope_attributes

Methods included from Persistence

#becomes, #decrement, #decrement!, #delete, #destroy, #destroyed?, #increment, #increment!, #new_record?, #persisted?, #reload, #save, #save!, #toggle, #toggle!, #touch, #update_attribute, #update_attributes, #update_attributes!, #update_column

Constructor Details

#initialize(attributes = nil, options = {}) {|_self| ... } ⇒ Base

New objects can be instantiated as either empty (pass no construction parameter) or pre-set with attributes but not yet saved (pass a hash with key names matching the associated table column names). In both instances, valid attribute keys are determined by the column names of the associated table – hence you can’t have attributes that aren’t part of the table columns.

initialize respects mass-assignment security and accepts either :as or :without_protection options in the options parameter.

Examples

# Instantiates a single new object
User.new(:first_name => 'Jamie')

# Instantiates a single new object using the :admin mass-assignment security role
User.new({ :first_name => 'Jamie', :is_admin => true }, :as => :admin)

# Instantiates a single new object bypassing mass-assignment security
User.new({ :first_name => 'Jamie', :is_admin => true }, :without_protection => true)

Yields:

  • (_self)

Yield Parameters:



481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
 
# File 'lib/active_record/base.rb', line 481

def initialize(attributes = nil, options = {})
  defaults = Hash[self.class.column_defaults.map { |k, v| [k, v.duplicable? ? v.dup : v] }]
  @attributes = self.class.initialize_attributes(defaults)
  @association_cache = {}
  @aggregation_cache = {}
  @attributes_cache = {}
  @new_record = true
  @readonly = false
  @destroyed = false
  @marked_for_destruction = false
  @previously_changed = {}
  @changed_attributes = {}

  ensure_proper_type

  populate_with_current_scope_attributes

  assign_attributes(attributes, options) if attributes

  yield self if block_given?
  run_callbacks :initialize
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method in the class ActiveRecord::AttributeMethods

Class Method Details

.===(object) ⇒ Object

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



432
433
434
 
# File 'lib/active_record/base.rb', line 432

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

.arel_engine ⇒ Object 



440
441
442
443
444
445
446
447
448
 
# File 'lib/active_record/base.rb', line 440

def arel_engine
  @arel_engine ||= begin
    if self == ActiveRecord::Base
      ActiveRecord::Base
    else
      connection_handler.retrieve_connection_pool(self) ? self : superclass.arel_engine
    end
  end
end

.arel_table ⇒ Object 



436
437
438
 
# File 'lib/active_record/base.rb', line 436

def arel_table
  @arel_table ||= Arel::Table.new(table_name, arel_engine)
end

.clear_active_connections! ⇒ Object 



183
184
185
 
# File 'lib/active_record/connection_adapters/abstract/connection_specification.rb', line 183

def clear_active_connections!
  connection_handler.clear_active_connections!
end

.connected? ⇒ Boolean

Returns true if Active Record is connected.

Returns:

  • (Boolean) 


175
176
177
 
# File 'lib/active_record/connection_adapters/abstract/connection_specification.rb', line 175

def connected?
  connection_handler.connected?(self)
end

.connection ⇒ Object

Returns the connection currently associated with the class. This can also be used to “borrow” the connection to do database work unrelated to any of the specific Active Records.



144
145
146
 
# File 'lib/active_record/connection_adapters/abstract/connection_specification.rb', line 144

def connection
  retrieve_connection
end

.connection_config ⇒ Object

Returns the configuration of the associated connection as a hash:

ActiveRecord::Base.connection_config
# => {:pool=>5, :timeout=>5000, :database=>"db/development.sqlite3", :adapter=>"sqlite3"}

Please use only for reading.



162
163
164
 
# File 'lib/active_record/connection_adapters/abstract/connection_specification.rb', line 162

def connection_config
  connection_pool.spec.config
end

.connection_id ⇒ Object 



148
149
150
 
# File 'lib/active_record/connection_adapters/abstract/connection_specification.rb', line 148

def connection_id
  Thread.current['ActiveRecord::Base.connection_id']
end

.connection_id=(connection_id) ⇒ Object 



152
153
154
 
# File 'lib/active_record/connection_adapters/abstract/connection_specification.rb', line 152

def connection_id=(connection_id)
  Thread.current['ActiveRecord::Base.connection_id'] = connection_id
end

.connection_pool ⇒ Object 



166
167
168
 
# File 'lib/active_record/connection_adapters/abstract/connection_specification.rb', line 166

def connection_pool
  connection_handler.retrieve_connection_pool(self) or raise ConnectionNotEstablished
end

.establish_connection(spec = ) ⇒ Object

Establishes the connection to the database. Accepts a hash as input where the :adapter key must be specified with the name of a database adapter (in lower-case) example for regular databases (MySQL, Postgresql, etc):

ActiveRecord::Base.establish_connection(
  :adapter  => "mysql",
  :host     => "localhost",
  :username => "myuser",
  :password => "mypass",
  :database => "somedatabase"
)

Example for SQLite database:

ActiveRecord::Base.establish_connection(
  :adapter => "sqlite",
  :database  => "path/to/dbfile"
)

Also accepts keys as strings (for parsing from YAML for example):

ActiveRecord::Base.establish_connection(
  "adapter" => "sqlite",
  "database"  => "path/to/dbfile"
)

Or a URL:

ActiveRecord::Base.establish_connection(
  "postgres://myuser:mypass@localhost/somedatabase"
)

The exceptions AdapterNotSpecified, AdapterNotFound and ArgumentError may be returned on an error.



128
129
130
131
132
133
134
135
136
137
138
 
# File 'lib/active_record/connection_adapters/abstract/connection_specification.rb', line 128

def self.establish_connection(spec = ENV["DATABASE_URL"])
  resolver = ConnectionSpecification::Resolver.new spec, configurations
  spec = resolver.spec

  unless respond_to?(spec.adapter_method)
    raise AdapterNotFound, "database configuration specifies nonexistent #{spec.config[:adapter]} adapter"
  end

  remove_connection
  connection_handler.establish_connection name, spec
end

.generated_feature_methods ⇒ Object 



409
410
411
412
413
414
415
 
# File 'lib/active_record/base.rb', line 409

def generated_feature_methods
  @generated_feature_methods ||= begin
    mod = const_set(:GeneratedFeatureMethods, Module.new)
    include mod
    mod
  end
end

.inherited(child_class) ⇒ Object

:nodoc:



396
397
398
399
 
# File 'lib/active_record/base.rb', line 396

def inherited(child_class) #:nodoc:
  child_class.initialize_generated_modules
  super
end

.initialize_generated_modules ⇒ Object

:nodoc:



401
402
403
404
405
406
407
 
# File 'lib/active_record/base.rb', line 401

def initialize_generated_modules #:nodoc:
  @attribute_methods_mutex = Mutex.new

  # force attribute methods to be higher in inheritance hierarchy than other generated methods
  generated_attribute_methods
  generated_feature_methods
end

.inspect ⇒ Object

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



418
419
420
421
422
423
424
425
426
427
428
429
 
# File 'lib/active_record/base.rb', line 418

def inspect
  if self == Base
    super
  elsif abstract_class?
    "#{super}(abstract)"
  elsif table_exists?
    attr_list = columns.map { |c| "#{c.name}: #{c.type}" } * ', '
    "#{super}(#{attr_list})"
  else
    "#{super}(Table doesn't exist)"
  end
end

.mysql2_connection(config) ⇒ Object

Establishes a connection to the database that’s used by all Active Record objects.



9
10
11
12
13
14
15
16
17
18
19
 
# File 'lib/active_record/connection_adapters/mysql2_adapter.rb', line 9

def self.mysql2_connection(config)
  config[:username] = 'root' if config[:username].nil?

  if Mysql2::Client.const_defined? :FOUND_ROWS
    config[:flags] = Mysql2::Client::FOUND_ROWS
  end

  client = Mysql2::Client.new(config.symbolize_keys)
  options = [config[:host], config[:username], config[:password], config[:database], config[:port], config[:socket], 0]
  ConnectionAdapters::Mysql2Adapter.new(client, logger, options, config)
end

.mysql_connection(config) ⇒ Object

Establishes a connection to the database that’s used by all Active Record objects.



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/active_record/connection_adapters/mysql_adapter.rb', line 23

def self.mysql_connection(config) # :nodoc:
  config = config.symbolize_keys
  host     = config[:host]
  port     = config[:port]
  socket   = config[:socket]
  username = config[:username] ? config[:username].to_s : 'root'
  password = config[:password].to_s
  database = config[:database]

  mysql = Mysql.init
  mysql.ssl_set(config[:sslkey], config[:sslcert], config[:sslca], config[:sslcapath], config[:sslcipher]) if config[:sslca] || config[:sslkey]

  default_flags = Mysql.const_defined?(:CLIENT_MULTI_RESULTS) ? Mysql::CLIENT_MULTI_RESULTS : 0
  default_flags |= Mysql::CLIENT_FOUND_ROWS if Mysql.const_defined?(:CLIENT_FOUND_ROWS)
  options = [host, username, password, database, port, socket, default_flags]
  ConnectionAdapters::MysqlAdapter.new(mysql, logger, options, config)
end

.postgresql_connection(config) ⇒ Object

Establishes a connection to the database that’s used by all Active Record objects



13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
# File 'lib/active_record/connection_adapters/postgresql_adapter.rb', line 13

def self.postgresql_connection(config) # :nodoc:
  config = config.symbolize_keys
  host     = config[:host]
  port     = config[:port] || 5432
  username = config[:username].to_s if config[:username]
  password = config[:password].to_s if config[:password]

  if config.key?(:database)
    database = config[:database]
  else
    raise ArgumentError, "No database specified. Missing argument: database."
  end

  # The postgres drivers don't allow the creation of an unconnected PGconn object,
  # so just pass a nil connection object for the time being.
  ConnectionAdapters::PostgreSQLAdapter.new(nil, logger, [host, port, nil, nil, database, username, password], config)
end

.remove_connection(klass = self) ⇒ Object 



179
180
181
 
# File 'lib/active_record/connection_adapters/abstract/connection_specification.rb', line 179

def remove_connection(klass = self)
  connection_handler.remove_connection(klass)
end

.retrieve_connection ⇒ Object 



170
171
172
 
# File 'lib/active_record/connection_adapters/abstract/connection_specification.rb', line 170

def retrieve_connection
  connection_handler.retrieve_connection(self)
end

.sqlite3_connection(config) ⇒ Object

sqlite3 adapter reuses sqlite_connection.



9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
# File 'lib/active_record/connection_adapters/sqlite3_adapter.rb', line 9

def self.sqlite3_connection(config) # :nodoc:
  # Require database.
  unless config[:database]
    raise ArgumentError, "No database file specified. Missing argument: database"
  end

  # Allow database path relative to Rails.root, but only if
  # the database path is not the special path that tells
  # Sqlite to build a database only in memory.
  if defined?(Rails.root) && ':memory:' != config[:database]
    config[:database] = File.expand_path(config[:database], Rails.root)
  end

  unless 'sqlite3' == config[:adapter]
    raise ArgumentError, 'adapter name should be "sqlite3"'
  end

  db = SQLite3::Database.new(
    config[:database],
    :results_as_hash => true
  )

  db.busy_timeout(config[:timeout]) if config[:timeout]

  ConnectionAdapters::SQLite3Adapter.new(db, logger, config)
end

Instance Method Details

#<=>(other_object) ⇒ Object

Allows sort on objects



618
619
620
621
622
623
624
 
# File 'lib/active_record/base.rb', line 618

def <=>(other_object)
  if other_object.is_a?(self.class)
    self.to_key <=> other_object.to_key
  else
    nil
  end
end

#==(comparison_object) ⇒ Object Also known as: eql?

Returns true if comparison_object is the same exact object, or comparison_object is of the same type and self has an ID and it is equal to comparison_object.id.

Note that new records are different from any other record by definition, unless the other record is the receiver itself. Besides, if you fetch existing records with select and leave the ID out, you’re on your own, this predicate will return false.

Note also that destroying a record preserves its ID in the model instance, so deleted models are still comparable.



593
594
595
596
597
598
 
# File 'lib/active_record/base.rb', line 593

def ==(comparison_object)
  super ||
    comparison_object.instance_of?(self.class) &&
    id.present? &&
    comparison_object.id == id
end

#configurations ⇒ Object

:singleton-method: Contains the database configuration - as is typically stored in config/database.yml - as a Hash.

For example, the following database.yml…

development:
  adapter: sqlite3
  database: db/development.sqlite3

production:
  adapter: sqlite3
  database: db/production.sqlite3

…would result in ActiveRecord::Base.configurations to look like this:

{
   'development' => {
      'adapter'  => 'sqlite3',
      'database' => 'db/development.sqlite3'
   },
   'production' => {
      'adapter'  => 'sqlite3',
      'database' => 'db/production.sqlite3'
   }
}



368
 
# File 'lib/active_record/base.rb', line 368

cattr_accessor :configurations, :instance_writer => false

#connection ⇒ Object

Returns the connection currently associated with the class. This can also be used to “borrow” the connection to do database work that isn’t easily done without going straight to SQL.



90
91
92
 
# File 'lib/active_record/connection_adapters/abstract/connection_specification.rb', line 90

def connection
  self.class.connection
end

#connection_handler ⇒ Object

:singleton-method: The connection handler



84
 
# File 'lib/active_record/connection_adapters/abstract/connection_specification.rb', line 84

class_attribute :connection_handler, :instance_writer => false

#default_timezone ⇒ Object

:singleton-method: Determines whether to use Time.local (using :local) or Time.utc (using :utc) when pulling dates and times from the database. This is set to :local by default.



375
 
# File 'lib/active_record/base.rb', line 375

cattr_accessor :default_timezone, :instance_writer => false

#dup ⇒ Object

:nodoc:



561
562
563
564
565
 
# File 'lib/active_record/base.rb', line 561

def dup # :nodoc:
  copy = super
  copy.initialize_dup(self)
  copy
end

#encode_with(coder) ⇒ Object

Populate coder with attributes about this record that should be serialized. The structure of coder defined in this method is guaranteed to match the structure of coder passed to the init_with method.

Example:

class Post < ActiveRecord::Base
end
coder = {}
Post.new.encode_with(coder)
coder # => { 'id' => nil, ... }



580
581
582
 
# File 'lib/active_record/base.rb', line 580

def encode_with(coder)
  coder['attributes'] = attributes
end

#freeze ⇒ Object

Freeze the attributes hash such that associations are still accessible, even on destroyed records.



608
609
610
 
# File 'lib/active_record/base.rb', line 608

def freeze
  @attributes.freeze; self
end

#frozen? ⇒ Boolean

Returns true if the attributes hash has been frozen.

Returns:

  • (Boolean) 


613
614
615
 
# File 'lib/active_record/base.rb', line 613

def frozen?
  @attributes.frozen?
end

#hash ⇒ Object

Delegates to id in order to allow two records of the same type and id to work with something like:

[ Person.find(1), Person.find(2), Person.find(3) ] & [ Person.find(1), Person.find(4) ] # => [ Person.find(1) ]



603
604
605
 
# File 'lib/active_record/base.rb', line 603

def hash
  id.hash
end

#init_with(coder) ⇒ Object

Initialize an empty model object from coder. coder must contain the attributes necessary for initializing an empty model object. For example:

class Post < ActiveRecord::Base
end

post = Post.allocate
post.init_with('attributes' => { 'title' => 'hello world' })
post.title # => 'hello world'



514
515
516
517
518
519
520
521
522
523
524
525
526
527
 
# File 'lib/active_record/base.rb', line 514

def init_with(coder)
  @attributes = self.class.initialize_attributes(coder['attributes'])
  @relation = nil

  @attributes_cache, @previously_changed, @changed_attributes = {}, {}, {}
  @association_cache = {}
  @aggregation_cache = {}
  @readonly = @destroyed = @marked_for_destruction = false
  @new_record = false
  run_callbacks :find
  run_callbacks :initialize

  self
end

#initialize_dup(other) ⇒ Object

Duped objects have no id assigned and are treated as new records. Note that this is a “shallow” copy as it copies the object’s attributes only, not its associations. The extent of a “deep” copy is application specific and is therefore left to the application to implement according to its need. The dup method does not preserve the timestamps (created|updated)_(at|on).



535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
 
# File 'lib/active_record/base.rb', line 535

def initialize_dup(other)
  cloned_attributes = other.clone_attributes(:read_attribute_before_type_cast)
  self.class.initialize_attributes(cloned_attributes, :serialized => false)

  cloned_attributes.delete(self.class.primary_key)

  @attributes = cloned_attributes

  _run_after_initialize_callbacks if respond_to?(:_run_after_initialize_callbacks)

  @changed_attributes = {}
  self.class.column_defaults.each do |attr, orig_value|
    @changed_attributes[attr] = orig_value if _field_changed?(attr, orig_value, @attributes[attr])
  end

  @aggregation_cache = {}
  @association_cache = {}
  @attributes_cache = {}
  @new_record  = true

  ensure_proper_type
  super
end

#inspect ⇒ Object

Returns the contents of the record as a nicely formatted string.



638
639
640
641
642
643
644
645
646
647
648
649
 
# File 'lib/active_record/base.rb', line 638

def inspect
  inspection = if @attributes
                 self.class.column_names.collect { |name|
                   if has_attribute?(name)
                     "#{name}: #{attribute_for_inspect(name)}"
                   end
                 }.compact.join(", ")
               else
                 "not initialized"
               end
  "#<#{self.class} #{inspection}>"
end

#logger ⇒ Object

:singleton-method: Accepts a logger conforming to the interface of Log4r or the default Ruby 1.8+ Logger class, which is then passed on to any new database connections made and which can be retrieved on both a class and instance level by calling logger.



339
 
# File 'lib/active_record/base.rb', line 339

cattr_accessor :logger, :instance_writer => false

#readonly! ⇒ Object

Marks this record as read only.



633
634
635
 
# File 'lib/active_record/base.rb', line 633

def readonly!
  @readonly = true
end

#readonly? ⇒ Boolean

Returns true if the record is read only. Records loaded through joins with piggy-back attributes will be marked as read only since they cannot be saved.

Returns:

  • (Boolean) 


628
629
630
 
# File 'lib/active_record/base.rb', line 628

def readonly?
  @readonly
end

#schema_format ⇒ Object

:singleton-method: Specifies the format to use when dumping the database schema with Rails’ Rakefile. If :sql, the schema is dumped as (potentially database- specific) SQL statements. If :ruby, the schema is dumped as an ActiveRecord::Schema file which can be loaded into any database that supports migrations. Use :ruby if you want to have different database adapters for, e.g., your development and test environments.



386
 
# File 'lib/active_record/base.rb', line 386

cattr_accessor :schema_format , :instance_writer => false

#timestamped_migrations ⇒ Object

:singleton-method: Specify whether or not to use timestamps for migration versions



392
 
# File 'lib/active_record/base.rb', line 392

cattr_accessor :timestamped_migrations , :instance_writer => false

#to_yaml(opts = {}) ⇒ Object

Hackery to accomodate Syck. Remove for 4.0.



652
653
654
655
656
657
658
659
660
661
662
663
664
 
# File 'lib/active_record/base.rb', line 652

def to_yaml(opts = {}) #:nodoc:
  if YAML.const_defined?(:ENGINE) && !YAML::ENGINE.syck?
    super
  else
    coder = {}
    encode_with(coder)
    YAML.quick_emit(self, opts) do |out|
      out.map(taguri, to_yaml_style) do |map|
        coder.each { |k, v| map.add(k, v) }
      end
    end
  end
end

#yaml_initialize(tag, coder) ⇒ Object

Hackery to accomodate Syck. Remove for 4.0.



667
668
669
 
# File 'lib/active_record/base.rb', line 667

def yaml_initialize(tag, coder) #:nodoc:
  init_with(coder)
end