class Rome::Collection(T)

Overview

Build Database Queries.

A Collection is immutable: all methods will return a copy of the previous Collection with the added constraint(s). For example:

users = User.select(:id, :name).where(group_id: 2)

Termination methods such as #find_by, or #take will explicitely execute a SQL request against the database and load one record.

first_user = users.order(:name).take
# => SELECT "id", "name"
#    FROM "users"
#    WHERE "group_id" = 2
#    ORDER BY "name" ASC
#    LIMIT 1;

Termination methods such as #to_a or #each will execute a SQL request then cache loaded records into the Collection, so further accesses won't re-execute the SQL request. Some methods such as #first or #size will leverage this cache when it's available.

users.to_a
# => SELECT "id", "name" FROM "users" WHERE "group_id" = 2;

When specifying column names you should always use a Symbol, so they'll be properly quoted for the database server. In many cases you can specify raw SQL statements using a String. For example:

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

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

count = User.count("LENGTH(name)", distinct: true)
# => SELECT COUNT(DISTINCT LENGTH(name)) FROM "users";

Included Modules

Defined in:

collection.cr

Instance methods inherited from module Rome::Query::Cache(T)

cached? cached?, each(&block : T -> ) : Nil
each
each
, reload reload, to_a : Array(T) to_a

Instance methods inherited from module Rome::Query::Methods(T)

all : self all, average(column_name : Symbol | String) : Float64 average, count(column_name : Symbol | String = "*", distinct = builder.distinct?) : Int64 count, delete_all : Nil delete_all, distinct(value = true) : self distinct, dup(builder : Builder) dup, exists?(id : T::PrimaryKeyType) : Bool
exists? : Bool
exists?
, find(id : T::PrimaryKeyType) : T find, find?(id : T::PrimaryKeyType) : T | Nil find?, find_by(**args) : T find_by, find_by?(**args) : T | Nil find_by?, first : T first, first? : T | Nil first?, ids : Array(T::PrimaryKeyType) ids, last : T last, last? : T | Nil last?, limit(value : Int32) : self limit, maximum(column_name : Symbol | String) maximum, minimum(column_name : Symbol | String) minimum, none : self none, offset(value : Int32) : self offset, order(columns : Hash(Symbol, Symbol)) : self
order(*columns : Symbol | String) : self
order(**columns) : self
order
, pluck(column_name : Symbol | String) : Array(Value) pluck, reorder(columns : Hash(Symbol, Symbol)) : self
reorder(*columns : Symbol | String) : self
reorder(**columns) : self
reorder
, select(sql : String) : self
select(*columns : Symbol) : self
select
, size : Int64 size, sum(column_name : Symbol | String) : Int64 | Float64 sum, take : T take, take? : T | Nil take?, to_sql : String to_sql, unscope(*args) : self unscope, update_all(attributes : Hash | NamedTuple) : Nil
update_all(**attributes) : Nil
update_all
, where(conditions : Hash(Symbol, Value | Array(Value)) | NamedTuple) : self
where(sql : String, *args : Value) : self
where(**conditions) : self
where
, where_not(conditions : Hash(Symbol, Value | Array(Value)) | NamedTuple) : self
where_not(**conditions) : self
where_not