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 => { :type => 'public' })
Student.joins(:schools).where('schools.type' => '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 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 #with dynamic finder
Person.where(:user_name => user_name, :password => password, :gender => 'male').first
Payment.find_by_user_name_and_password_and_gender
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 }
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
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.
===(object)
click to toggle source
Overwrite the default class equality method to provide support for
association proxies.
813: def ===(object)
814: object.is_a?(self)
815: end
abstract_class?()
click to toggle source
Returns whether this class is an abstract class or not.
831: def abstract_class?
832: defined?(@abstract_class) && @abstract_class == true
833: end
arel_engine()
click to toggle source
853: def arel_engine
854: @arel_engine ||= begin
855: if self == ActiveRecord::Base
856: Arel::Table.engine
857: else
858: connection_handler.connection_pools[name] ? self : superclass.arel_engine
859: end
860: end
861: end
arel_table()
click to toggle source
849: def arel_table
850: @arel_table ||= Arel::Table.new(table_name, arel_engine)
851: end
attr_readonly(*attributes)
click to toggle source
Attributes listed as readonly will be used to create a new record but
update operations will ignore these fields.
521: def attr_readonly(*attributes)
522: write_inheritable_attribute(:attr_readonly, Set.new(attributes.map { |a| a.to_s }) + (readonly_attributes || []))
523: end
attribute_method?(attribute)
click to toggle source
751: def attribute_method?(attribute)
752: super || (table_exists? && column_names.include?(attribute.to_s.sub(/=$/, '')))
753: end
base_class()
click to toggle source
Returns the base AR subclass that this class descends from. If A extends
AR::Base, A.base_class will return A. If B descends from A through some
arbitrarily deep hierarchy, B.base_class will return A.
If B < A and C < B and if A is an abstract_class then both B.base_class
and C.base_class would return B as the answer since A is an abstract_class.
823: def base_class
824: class_of_active_record_descendant(self)
825: end
colorize_logging(*args)
click to toggle source
432: def colorize_logging(*args)
433: ActiveSupport::Deprecation.warn "ActiveRecord::Base.colorize_logging and " <<
434: "config.active_record.colorize_logging are deprecated. Please use " <<
435: "Rails::LogSubscriber.colorize_logging or config.colorize_logging instead", caller
436: end
column_names()
click to toggle source
Returns an array of column names as strings.
691: def column_names
692: @column_names ||= columns.map { |column| column.name }
693: end
columns()
click to toggle source
Returns an array of column objects for the table associated with this
class.
677: def columns
678: unless defined?(@columns) && @columns
679: @columns = connection.columns(table_name, "#{name} Columns")
680: @columns.each { |column| column.primary = column.name == primary_key }
681: end
682: @columns
683: end
columns_hash()
click to toggle source
Returns a hash of column objects for the table associated with this class.
686: def columns_hash
687: @columns_hash ||= Hash[columns.map { |column| [column.name, column] }]
688: end
configurations
click to toggle source
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'
}
}
358: cattr_accessor :configurations, :instance_writer => false
connected?()
click to toggle source
Returns true if Active Record is connected.
101: def connected?
102: connection_handler.connected?(self)
103: end
connection()
click to toggle source
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.
88: def connection
89: retrieve_connection
90: end
connection_handler
click to toggle source
The connection handler
13: class_attribute :connection_handler, :instance_writer => false
connection_pool()
click to toggle source
92: def connection_pool
93: connection_handler.retrieve_connection_pool(self)
94: end
content_columns()
click to toggle source
Returns an array of column objects where the primary id, all columns ending
in “_id” or “_count”, and columns used for single
table inheritance have been removed.
697: def content_columns
698: @content_columns ||= columns.reject { |c| c.primary || c.name =~ /(_id|_count)$/ || c.name == inheritance_column }
699: end
count_by_sql(sql)
click to toggle source
Returns the result of an SQL statement that should only include a COUNT(*)
in the SELECT part. The use of this method should be restricted to
complicated SQL queries that can’t be executed using the ActiveRecord::Calculations class methods.
Look into those before using this.
Parameters
Examples
Product.count_by_sql "SELECT COUNT(*) FROM sales s, customers c WHERE s.customer_id = c.id"
514: def count_by_sql(sql)
515: sql = sanitize_conditions(sql)
516: connection.select_value(sql, "#{name} Count").to_i
517: end
create(attributes = nil, &block)
click to toggle source
Creates 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.
The attributes parameter can be either be a Hash or an Array of
Hashes. These Hashes describe the attributes on the objects that are to be
created.
Examples
# Create a single new object
User.create(:first_name => 'Jamie')
# Create an Array of new objects
User.create([{ :first_name => 'Jamie' }, { :first_name => 'Jeremy' }])
# Create a single object and pass it into a block to set other attributes.
User.create(:first_name => 'Jamie') do |u|
u.is_admin = false
end
# Creating an Array of new objects using a block, where the block is executed for each object:
User.create([{ :first_name => 'Jamie' }, { :first_name => 'Jeremy' }]) do |u|
u.is_admin = false
end
492: def create(attributes = nil, &block)
493: if attributes.is_a?(Array)
494: attributes.collect { |attr| create(attr, &block) }
495: else
496: object = new(attributes)
497: yield(object) if block_given?
498: object.save
499: object
500: end
501: end
default_timezone
click to toggle source
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.
403: cattr_accessor :default_timezone, :instance_writer => false
descends_from_active_record?()
click to toggle source
True if this isn’t a concrete subclass needing a STI type condition.
776: def descends_from_active_record?
777: if superclass.abstract_class?
778: superclass.descends_from_active_record?
779: else
780: superclass == Base || !columns_hash.include?(inheritance_column)
781: end
782: end
establish_connection(spec = nil)
click to toggle source
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"
)
The exceptions AdapterNotSpecified,
AdapterNotFound and ArgumentError may be
returned on an error.
51: def self.establish_connection(spec = nil)
52: case spec
53: when nil
54: raise AdapterNotSpecified unless defined?(Rails.env)
55: establish_connection(Rails.env)
56: when ConnectionSpecification
57: self.connection_handler.establish_connection(name, spec)
58: when Symbol, String
59: if configuration = configurations[spec.to_s]
60: establish_connection(configuration)
61: else
62: raise AdapterNotSpecified, "#{spec} database is not configured"
63: end
64: else
65: spec = spec.symbolize_keys
66: unless spec.key?(:adapter) then raise AdapterNotSpecified, "database configuration does not specify adapter" end
67:
68: begin
69: require "active_record/connection_adapters/#{spec[:adapter]}_adapter"
70: rescue LoadError => e
71: raise "Please install the #{spec[:adapter]} adapter: `gem install activerecord-#{spec[:adapter]}-adapter` (#{e})"
72: end
73:
74: adapter_method = "#{spec[:adapter]}_connection"
75: if !respond_to?(adapter_method)
76: raise AdapterNotFound, "database configuration specifies nonexistent #{spec[:adapter]} adapter"
77: end
78:
79: remove_connection
80: establish_connection(ConnectionSpecification.new(spec, adapter_method))
81: end
82: end
find_by_sql(sql)
click to toggle source
Executes a custom SQL query against your database and returns all the
results. The results will be returned as an array with columns requested
encapsulated as attributes of the model you call this method from. If you
call Product.find_by_sql then the results will be returned in a
Product object with the attributes you specified in the SQL query.
If you call a complicated SQL query which spans multiple tables the columns
specified by the SELECT will be attributes of the model, whether or not
they are columns of the corresponding table.
The sql parameter is a full SQL query as a string. It will be
called as is, there will be no database agnostic conversions performed.
This should be a last resort because using, for example, MySQL specific
terms will lock you to using that particular database engine or require you
to change your call if you switch engines.
Examples
# A simple SQL query spanning multiple tables
Post.find_by_sql "SELECT p.title, c.author FROM posts p, comments c WHERE p.id = c.post_id"
> [#<Post:0x36bff9c @attributes={"title"=>"Ruby Meetup", "first_name"=>"Quentin"}>, ...]
# You can use the same string replacement techniques as you can with ActiveRecord#find
Post.find_by_sql ["SELECT title FROM posts WHERE author = ? AND created > ?", author_id, start_date]
> [#<Post:0x36bff9c @attributes={"first_name"=>"The Cheap Man Buys Twice"}>, ...]
466: def find_by_sql(sql)
467: connection.select_all(sanitize_sql(sql), "#{name} Load").collect! { |record| instantiate(record) }
468: end
inheritance_column()
click to toggle source
Defines the column name for use with single table inheritance. Use set_inheritance_column
to set a different value.
610: def inheritance_column
611: @inheritance_column ||= "type"
612: end
inspect()
click to toggle source
Returns a string like ‘Post id:integer, title:string,
body:text’
790: def inspect
791: if self == Base
792: super
793: elsif abstract_class?
794: "#{super}(abstract)"
795: elsif table_exists?
796: attr_list = columns.map { |c| "#{c.name}: #{c.type}" } * ', '
797: "#{super}(#{attr_list})"
798: else
799: "#{super}(Table doesn't exist)"
800: end
801: end
logger
click to toggle source
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.
317: cattr_accessor :logger, :instance_writer => false
new(attributes = nil)
click to toggle source
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.
1393: def initialize(attributes = nil)
1394: @attributes = attributes_from_column_definition
1395: @attributes_cache = {}
1396: @persisted = false
1397: @readonly = false
1398: @destroyed = false
1399: @marked_for_destruction = false
1400: @previously_changed = {}
1401: @changed_attributes = {}
1402:
1403: ensure_proper_type
1404:
1405: populate_with_current_scope_attributes
1406: self.attributes = attributes unless attributes.nil?
1407:
1408: result = yield self if block_given?
1409: _run_initialize_callbacks
1410: result
1411: end
pluralize_table_names
click to toggle source
Indicates whether table names should be the pluralized versions of the
corresponding class names. If true, the default table name for a Product
class will be products. If false, it would just be
product. See table_name for the full rules on
table/class naming. This is true, by default.
396: cattr_accessor :pluralize_table_names, :instance_writer => false
primary_key_prefix_type
click to toggle source
Accessor for the prefix type that will be prepended to every primary key
column name. The options are :table_name and
:table_name_with_underscore. If the first is specified, the Product class
will look for “productid” instead of “id” as the
primary column. If the latter is specified, the Product class will look for
“product_id“ instead of “id”. Remember that this is
a global setting for all Active Records.
368: cattr_accessor :primary_key_prefix_type, :instance_writer => false
quoted_table_name()
click to toggle source
Returns a quoted version of the table name, used to construct SQL
statements.
595: def quoted_table_name
596: @quoted_table_name ||= connection.quote_table_name(table_name)
597: end
readonly_attributes()
click to toggle source
Returns an array of all the attributes that have been specified as
readonly.
526: def readonly_attributes
527: read_inheritable_attribute(:attr_readonly) || []
528: end
remove_connection(klass = self)
click to toggle source
105: def remove_connection(klass = self)
106: connection_handler.remove_connection(klass)
107: end
respond_to?(method_id, include_private = false)
click to toggle source
835: def respond_to?(method_id, include_private = false)
836: if match = DynamicFinderMatch.match(method_id)
837: return true if all_attributes_exists?(match.attribute_names)
838: elsif match = DynamicScopeMatch.match(method_id)
839: return true if all_attributes_exists?(match.attribute_names)
840: end
841:
842: super
843: end
retrieve_connection()
click to toggle source
96: def retrieve_connection
97: connection_handler.retrieve_connection(self)
98: end
serialize(attr_name, class_name = Object)
click to toggle source
If you have an attribute that needs to be saved to the database as an
object, and retrieved as the same object, then specify the name of that
attribute using this method and it will be handled automatically. The
serialization is done through YAML. If class_name is specified,
the serialized object must be of that class on retrieval or SerializationTypeMismatch will be
raised.
Parameters
attr_name - The field name that should be serialized.
class_name - Optional, class name that the object type should be
equal to.
Example
# Serialize a preferences attribute
class User
serialize :preferences
end
545: def serialize(attr_name, class_name = Object)
546: serialized_attributes[attr_name.to_s] = class_name
547: end
serialized_attributes()
click to toggle source
Returns a hash of all the attributes that have been specified for
serialization as keys and their class restriction as values.
551: def serialized_attributes
552: read_inheritable_attribute(:attr_serialized) or write_inheritable_attribute(:attr_serialized, {})
553: end
set_inheritance_column(value = nil, &block)
click to toggle source
Sets the name of the inheritance column to use to the given value, or (if
the value # is nil or false) to the value returned by the given block.
class Project < ActiveRecord::Base
set_inheritance_column do
original_inheritance_column + "_id"
end
end
647: def set_inheritance_column(value = nil, &block)
648: define_attr_method :inheritance_column, value, &block
649: end
set_sequence_name(value = nil, &block)
click to toggle source
Sets the name of the sequence to use when generating ids to the given
value, or (if the value is nil or false) to the value returned by the given
block. This is required for Oracle and is useful for any database which
relies on sequences for primary key generation.
If a sequence name is not explicitly set when using Oracle or Firebird, it
will default to the commonly used pattern of: #{table_name}_seq
If a sequence name is not explicitly set when using PostgreSQL, it will
discover the sequence corresponding to your primary key for you.
class Project < ActiveRecord::Base
set_sequence_name "projectseq" # default would have been "project_seq"
end
666: def set_sequence_name(value = nil, &block)
667: define_attr_method :sequence_name, value, &block
668: end
set_table_name(value = nil, &block)
click to toggle source
Sets the table name. If the value is nil or false then the value returned
by the given block is used.
class Project < ActiveRecord::Base
set_table_name "project"
end
632: def set_table_name(value = nil, &block)
633: @quoted_table_name = nil
634: define_attr_method :table_name, value, &block
635: end
sti_name()
click to toggle source
845: def sti_name
846: store_full_sti_class ? name : name.demodulize
847: end
subclasses()
click to toggle source
324: def subclasses
325: descendants
326: end
table_exists?()
click to toggle source
Indicates whether the table associated with this class exists
672: def table_exists?
673: connection.table_exists?(table_name)
674: end
table_name()
click to toggle source
Guesses the table name (in forced lower-case) based on the name of the
class in the inheritance hierarchy descending directly from ActiveRecord::Base. So if the hierarchy looks like:
Reply < Message < ActiveRecord::Base, then Message
is used to guess the table name even when called on Reply. The rules used
to do the guess are handled by the Inflector class in Active Support, which
knows almost all common English inflections. You can add new inflections in
config/initializers/inflections.rb.
Nested classes are given table names prefixed by the singular form of the
parent’s table name. Enclosing modules are not considered.
Examples
class Invoice < ActiveRecord::Base; end;
file class table_name
invoice.rb Invoice invoices
class Invoice < ActiveRecord::Base; class Lineitem < ActiveRecord::Base; end; end;
file class table_name
invoice.rb Invoice::Lineitem invoice_lineitems
module Invoice; class Lineitem < ActiveRecord::Base; end; end;
file class table_name
invoice/lineitem.rb Invoice::Lineitem lineitems
Additionally, the class-level table_name_prefix is
prepended and the table_name_suffix is
appended. So if you have “myapp_” as a prefix, the table name
guess for an Invoice class becomes “myapp_invoices“.
Invoice::Lineitem becomes “myapp_invoice_lineitems“.
You can also overwrite this class method to allow for unguessable links,
such as a Mouse class with a link to a “mice” table. Example:
class Mouse < ActiveRecord::Base
set_table_name "mice"
end
590: def table_name
591: reset_table_name
592: end
table_name_prefix
click to toggle source
Accessor for the name of the prefix string to prepend to every table name.
So if set to “basecamp_”, all table names will be named like
“basecamp_projects“, “basecamp_people“, etc. This
is a convenient way of creating a namespace for tables in a shared
database. By default, the prefix is the empty string.
If you are organising your models within modules you can add a prefix to
the models within a namespace by defining a singleton method in the parent
module called table_name_prefix which
returns your chosen prefix.
381: class_attribute :table_name_prefix, :instance_writer => false
table_name_suffix
click to toggle source
Works like table_name_prefix, but
appends instead of prepends (set to “_basecamp” gives
“projects_basecamp“, “people_basecamp“). By
default, the suffix is the empty string.
388: class_attribute :table_name_suffix, :instance_writer => false
timestamped_migrations
click to toggle source
Specify whether or not to use timestamps for migration versions
420: cattr_accessor :timestamped_migrations , :instance_writer => false