class ActiveRecord::Base

instances in the current object space.
So it’s possible to assign a logger to the class through Base.logger= which will then be used by all
Note: The attributes listed are class-level attributes (accessible from both the class and instance level).
* StatementInvalid - The database server rejected the SQL statement. The precise error is added in the message.
* SerializationTypeMismatch - The serialized object wasn’t of the class specified as the second parameter.
nothing was found, please check its documentation for further details.
Some ActiveRecord::Base.find calls do not raise this exception to signal
Either the row with the given ID doesn’t exist or the row didn’t meet the additional restrictions.
* RecordNotFound - No record responded to the ActiveRecord::Base.find method.
when the record is invalid.
* RecordInvalid - raised by ActiveRecord::Base#save! and
objects that should be inspected to determine which attributes triggered the errors.
AttributeAssignmentError
The errors property of this exception contains an array of
method.
* MultiparameterAssignmentErrors - Collection of errors that occurred during a mass assignment using the
Use ActiveRecord::Base.establish_connection before querying.
* ConnectionNotEstablished - No connection has been established.
triggered the error.
You can inspect the attribute property of the exception object to determine which attribute
method.
* AttributeAssignmentError - An error occurred while doing a mass assignment through the
specified in the association definition.
* AssociationTypeMismatch - The object assigned to the association wasn’t of the type
(or a bad spelling of an existing one).
specified a non-existent adapter
* AdapterNotFound - The :adapter key used in
didn’t include an :adapter key.
* AdapterNotSpecified - The configuration hash used in
* ActiveRecordError - Generic error class and superclass of all other errors raised by Active Record.
== Exceptions
will go up the class-hierarchy until a connection is found in the connection pool.
method
a hash indexed by the class. If a connection is requested, the
This feature is implemented by keeping a connection pool in ActiveRecord::Base that is
and Course and all of its subclasses will use this connection instead.
ActiveRecord::Base, but resides in a different database, you can just say Course.establish_connection
connection. But you can also set a class-specific connection. For example, if Course is an
by ActiveRecord::Base.connection. All classes inheriting from ActiveRecord::Base will use this
and retrieved
Connections are usually created through
== Connection to multiple databases in different models
more details.
column that is named “type” by default. See ActiveRecord::Inheritance for
Active Record allows inheritance by storing the name of the class in a
== Single table inheritance
user.preferences.theme_color = “red”
user = User.new
end
serialize :preferences, OpenStruct
class User < ActiveRecord::Base
instance of that class.
When you specify a class option, the default value for that attribute will be a new
User.find(user.id).preferences # raises SerializationTypeMismatch
user = User.create(preferences: %w( one two three ))
end
serialize :preferences, Hash
class User < ActiveRecord::Base
if a serialized object is retrieved as a descendant of a class not in the hierarchy.
You can also specify a class option as the second parameter that’ll raise an exception
User.find(user.id).preferences # => { “background” => “black”, “display” => large }
user = User.create(preferences: { “background” => “black”, “display” => large })
end
serialize :preferences
class User < ActiveRecord::Base
any additional work.
This makes it possible to store arrays, hashes, and other non-mappable objects without doing
.
specify this with a call to the class method
Active Record can serialize any object in text columns using YAML. To do so, you must
== Saving arrays, hashes, and other non-mappable objects in text columns
Payment.order(“created_on”).find_by_amount(50)
It’s even possible to call these dynamic finder methods on relations and named scopes.
Person.find_by_user_name_and_password(user_name, password) # with dynamic finder
Person.find_by(user_name: user_name, password: password)
“and”.
It’s also possible to use multiple attributes in the same find_by_ by separating them with
like Person.find_by_last_name!.
ActiveRecord::RecordNotFound error if they do not return any records,
It’s possible to add an exclamation point (!) on the end of the dynamic finders to get them to raise an
Person.find_by_user_name(user_name).
Instead of writing Person.find_by(user_name: user_name), you can use
to find_by_ like Person.find_by_user_name.
by simple queries without turning to SQL. They work by appending the name of an attribute
Dynamic attribute-based finders are a mildly deprecated way of getting (and/or creating) objects
== Dynamic attribute-based finders
attribute normally would typecast the string to 0, which isn’t what you want.
integer field and you want to display the original string back in an error message. Accessing the
This is especially useful in validation situations where the user might supply a string for an
you can call account.balance_before_type_cast or account.id_before_type_cast.
accessors that all attributes have. For example, if your Account model has a balance attribute,
typecast run its course first. That can be done by using the <attribute>_before_type_cast
Sometimes you want to be able to read the raw attribute data without having the column-determined
== Accessing attributes before they have been typecasted
user.admin? # => false, due to the getter override
user.admin # => false, due to the getter override<br><br>user # => true, also gets the column value
user.read_attribute(:admin) # => true, gets the column value
user.update(admin: true)
end
end
false
def admin
# Has admin boolean column
class User
Query methods will also respect any overrides of default accessors:
anonymous.name? # => false
anonymous = User.new(name: “”)
user.name? # => true
user = User.new(name: “David”)
to determine whether the user has a name:
For example, an Active Record User with the name attribute has a name? method that you can call
Additionally, when dealing with numeric values, a query method will return false if the value is zero.
Query methods allow you to test whether an attribute value is present.
In addition to the basic accessors, query methods are also automatically available on the Active Record object.
== Attribute query methods
end
end
super / 60
def length
end
super(minutes.to_i * 60)
def length=(minutes)
# Uses an integer of seconds to hold the length of the song
class Song < ActiveRecord::Base
super to actually change things.
the default accessors (using the same name as the attribute) and calling
object, but sometimes you want to specialize this behavior. This can be done by overwriting
All column values are automatically available through basic accessors on the Active Record
== Overwriting default accessors
Student.joins(:schools).where(‘schools.category’ => ‘public’ )
Student.joins(:schools).where(schools: { category: ‘public’ })
can be used to qualify the table name of a particular condition. For instance:
When joining tables, nested hashes or keys written in the form ‘table_name.column_name’
Student.where(grade: [9,11,12])
An array may be used in the hash to use the SQL IN operator:
Student.where(grade: 9..12)
A range may be used in the hash to use the SQL BETWEEN operator:<br><br>Student.where(params)
Student.where(first_name: “Harvey”, status: 1)
operator. For instance:
Similarly, a simple hash without a statement will generate conditions based on equality with the SQL AND
).first
{ id: 3, name: “37signals”, division: “First”, accounting_date: ‘2005-01-01’ }
“id = :id AND name = :name AND division = :division AND created_at > :accounting_date”,
Company.where(
symbols and supplying a hash with values for the matching symbol keys:
resort to named bind variables instead. That’s done by replacing the question marks with
what the fourth or fifth question mark is supposed to represent. In those cases, you can
When using multiple parameters in the conditions, it can easily become hard to read exactly
query and fake the login (or worse).
before inserting them in the query, which will ensure that an attacker can’t escape the
authenticate_safely_simply both will sanitize the user_name and password
parameters come directly from an HTTP request. The authenticate_safely and
and is thus susceptible to SQL-injection attacks if the user_name and password
The authenticate_unsafely method inserts the parameters directly into the query
end
end
where(user_name: user_name, password: password).first
def self.authenticate_safely_simply(user_name, password)
end
where(“user_name = ? AND password = ?”, user_name, password).first
def self.authenticate_safely(user_name, password)
end
where(“user_name = ‘#{user_name}’ AND password = ‘#{password}’”).first
def self.authenticate_unsafely(user_name, password)
class User < ActiveRecord::Base
only equality and range is possible. Examples:
be used for statements that don’t involve tainted data. The hash form works much like the array form, except
The array form is to be used when the condition input is tainted and requires sanitization. The string form can
Conditions can either be specified as a string, array, or hash representing the WHERE-part of an SQL statement.
== Conditions
user.occupation = “Code Artist”
user.name = “David”
user = User.new
And of course you can just create a bare object and specify the attributes after the fact:
end
u.occupation = “Code Artist”
u.name = “David”
user = User.new do |u|
You can also use block initialization:
user.name # => “David”
user = User.new(name: “David”, occupation: “Code Artist”)
HTTP request. It works like this:
method is especially useful when you’re receiving the data from somewhere else, like an
Active Records accept constructor parameters either in a hash or as a block. The hash
== Creation
See the mapping rules in table_name and the full example in files/activerecord/README_rdoc.html for more insight.
database table will happen automatically in most common cases, but can be overwritten for the uncommon ones.
Active Record objects. The mapping that binds a given Active Record class to a certain
and their type is done directly in the database. Any change is instantly reflected in the
the table definition with which they’re linked. Adding, removing, and changing attributes
Active Record objects don’t specify their attributes directly, but rather infer them from
= Active Record
:nodoc: