Query all records from the database. Doesn't actually issue any SQL query. See Cache#to_a to load all records from the database into an Array.

Calculates the average of a column. See #sum for details.

Counts how many records match the SQL query.

You can count all columns or a specific column::

User.count
User.count(:name)

You can specify a raw SQL query with a String:

User.count("LENGTH(name)")

Executes a DELETE SQL query.

User.where(group_id: 1).delete_all
# => DELETE FROM "users" WHERE "group_id" = 1;

Specify a DISTINCT statement for the query.

Returns true when a record identified by primary key exists in the database with the current conditions.

User.where(group_id: 1).exists?(2)
# => SELECT 1 AS one FROM "users" WHERE "group_id" = 1 AND "id" = 2 LIMIT 1;

Returns true if the SQL query has at least one result.

User.where(group_id: 1).exists?
# => SELECT 1 AS one FROM "users" WHERE "group_id" = 1 LIMIT 1;

Loads a record by id from the database. Raises a Error::RecordNotFound exception when the record doesn't exist.

user = User.find(1)
# => SELECT * FROM "users" WHERE "id" = 1 LIMIT 1;

Same as #find but returns nil when the record doesn't exist.

Loads a record by arguments from the database. Raises a RecordNotFound exception when the record doesn't exist. For example:

user = User.find_by(name: "user", group_id: 2)
# => SELECT * FROM "users" WHERE "name" = 'user' AND "group_id" = 2 LIMIT 1;

See #where for more details on conditions.

Same as #find_by but returns nil when no record could be found in the database.

Loads the first record from the database, ordering by the primary key in ascending order unless an order has been specified.

Merely takes the last entry in the cached result set if the relation was previously loaded.

Prefer #take if you don't need an ordering or already specified one.

user = User.first
# => SELECT * FROM "users" ORDER BY "id" ASC LIMIT 1;

user = User.order(name: :desc).last
# => SELECT * FROM "users" ORDER BY "name" DESC LIMIT 1;

user = User.order("name ASC, group_id DESC").last
# => SELECT * FROM "users" ORDER BY name ASC, group_id DESC LIMIT 1;

Same as #first? but returns nil when no record could be found in the database.

Loads all primary key values of rows matching the SQL query.

Loads the last record from the database, ordering by the primary key in ascending order unless an order has been specified.

Merely takes the last entry in the cached result set if the relation was previously loaded.

Prefer #take if you don't need an ordering or already specified one.

user = User.last
# => SELECT * FROM "users" ORDER BY "id" DESC LIMIT 1;

user = User.order(name: :desc).last
# => SELECT * FROM "users" ORDER BY "name" ASC LIMIT 1;

user = User.order("name ASC, group_id DESC").last
# => SELECT * FROM "users" ORDER BY name DESC, group_id ASC LIMIT 1;

Same as #last? but returns nil when no record could be found in the database.

Specify a LIMIT for the query.

Returns the maximum value for a column. See #sum for details.

Returns the minimum value for a column. See #sum for details.

Ensures that the query will never return anything from the database.

Specify an OFFSET for the query.

Specify an ORDER for the query. This is added to any previous order definition. For example:

User.order({name: :asc, group_id: :desc})
# => SELECT * FROM "users" ORDER BY "name" ASC, "group_id" DESC;

Specify an ORDER column for the query. This is added to any previous order definition. For example:

User.order(:name)
# => SELECT * FROM "users" ORDER BY "name" ASC;

Specify an ORDER for the query. This is added to any previous order definition. For example:

User.order(name: :asc, group_id: :desc)
# => SELECT * FROM "users" ORDER BY "name" ASC, "group_id" DESC;

Loads values of a single column as an Array.

names = User.pluck(:name)
# => SELECT "name" FROM "users";
# => ["user", "alice", ...]

Specify an ORDER for the query, replacing any previous ORDER definition. See #order for details.

Specify an ORDER column for the query, replacing any previous ORDER definition. See #order for details.

Specify an ORDER for the query, replacing any previous ORDER definition. See #order for details.

Specify a raw SELECT statement for the query.

Specify SELECT columns for the query.

Returns how many records match the SQL query. Uses the cached result set if the query was previously loaded, otherwise executes a COUNT SQL query.

Calculates the sum of a column.

You can specify a column name:

User.sum(:salary)

You can specify a raw SQL query with a String:

User.sum("LENGTH(name)")

Loads one record from the database, without any ordering. Raises a Error::RecordNotFound exception when no record could be found.

user = User.take
# => SELECT * FROM "users" LIMIT 1;

Same as #take but returns nil when no record could be found in the database.

Returns the generated SQL query. Useful for debugging.

Resets previously set SQL statement(s). For example:

users = User.where(group_id: 1).limit(10)
users.unscope(:limit)         # == User.where(group_id: 1)
users.unscope(:where)         # == User.limit(10)
users.unscope(:where, :limit) # == User.all

Available properties:

• :select
• :where
• :order
• :limit
• :offset

Executes an UPDATE SQL query.

User.where(id: 1).update_all({group_id: 2})
# => UPDATE "users" SET "group_id" = 2 WHERE "id" = 1;

Executes an UPDATE SQL query.

User.where(id: 1).update_all(group_id: 2)
# => UPDATE "users" SET "group_id" = 2 WHERE "id" = 1;

Specify WHERE conditions for the query. For example:

conditions = {
  :name     => "user",
  :group_id => 2,
}
User.where(conditions)
# => SELECT * FROM "users" WHERE "name" = 'user' AND "group_id" = 2;

The condition value may be nil:

User.where({:group_id => nil})
# => SELECT * FROM "users" WHERE "group_id" IS NULL;

The condition value may also be an Array of values:

User.where({:group_id => [1, 2, 3]})
# => SELECT * FROM "users" WHERE "group_id" IN (1, 2, 3);

Specify a raw WHERE condition for the query. You can specify arguments as ? and pass them to the method. For example:

User.where("LENGTH(name) > ?", 10)
# => SELECT * FROM "users" WHERE LENGTH(name) > 10;

Specify WHERE conditions for the query. For example:

User.where(name: "user", group_id: 2)
# => SELECT * FROM "users" WHERE "name" = 'user' AND "group_id" = 2;

The condition value may be nil:

User.where(group_id: nil)
# => SELECT * FROM "users" WHERE "group_id" IS NULL;

The condition value may also be an Array of values:

User.where(group_id: [1, 2, 3])
# => SELECT * FROM "users" WHERE "group_id" IN (1, 2, 3);