class Clear::Reflection::Table::Collection
- Clear::Reflection::Table::Collection
- Clear::Model::CollectionBase(Clear::Reflection::Table)
- Reference
- Object
Overview
Addition of the method for eager loading and N+1 avoidance.
Defined in:
clear/model/reflection/table.cr:4clear/model/reflection/table.cr:16
clear/model/reflection/table.cr:18
clear/model/reflection/table.cr:19
Instance Method Summary
- #public
- #tables_only
- #views_only
-
#with_columns(fetch_columns = false, &block : Clear::Reflection::Column::Collection -> ) : self
Eager load the has many relation columns.
- #with_columns(fetch_columns = false)
Instance methods inherited from class Clear::Model::CollectionBase(Clear::Reflection::Table)
<<(item : T)
<<,
[](range : Range(Number, Number), fetch_columns = false) : Array(T)[](off, fetch_columns = false) : T [], []?(off, fetch_columns = false) : T | Nil []?, add(item : T) add, any? any?, build(x : NamedTuple, &block : T -> Nil) : T
build(**tuple, & : T -> Nil) : T
build(x : NamedTuple) : T
build(**tuple) : T build, count(type : X.class = Int64) forall X count, create(x : NamedTuple, &block : T -> Nil) : T
create(**tuple, & : T -> Nil) : T
create(x : NamedTuple) : T
create(**tuple) : T create, create!(x : NamedTuple, &block : T -> Nil) : T
create!(**tuple, & : T -> Nil) : T
create!(x : NamedTuple) : T
create!(**tuple) : T create!, delete_all : self delete_all, dup dup, each(fetch_columns = false, &block : T -> ) each, each_with_cursor(batch = 1000, fetch_columns = false, &block : T -> ) each_with_cursor, empty? empty?, find(fetch_columns = false, &) : T | Nil
find(tuple : NamedTuple, fetch_columns = false) : T | Nil
find(**tuple) : T | Nil find, find!(fetch_columns = false, &) : T
find!(tuple : NamedTuple, fetch_columns = false) : T
find!(**tuple) : T find!, find_or_build(x : NamedTuple, &block : T -> Nil) : T
find_or_build(**tuple, & : T -> Nil) : T
find_or_build(x : NamedTuple) : T
find_or_build(**tuple) : T find_or_build, find_or_create(x : NamedTuple, &block : T -> Nil) : T
find_or_create(**tuple, & : T -> Nil) : T
find_or_create(x : NamedTuple) : T
find_or_create(**tuple) : T find_or_create, first(fetch_columns = false) : T | Nil first, first!(fetch_columns = false) : T first!, item_class item_class, last(fetch_columns = false) : T | Nil last, last!(fetch_columns = false) : T last!, map(fetch_columns = false, &block : T -> X) : Array(X) forall X map, tags tags, to_a(fetch_columns = false) : Array(T) to_a, unlink(item : T) unlink
Instance methods inherited from module Clear::SQL::SelectBuilder
before_query(&block : -> Nil)
before_query,
columns : Array(SQL::Column)
columns,
default_wildcard_table
default_wildcard_table,
dup : self
dup,
havings : Array(Clear::Expression::Node)
havings,
is_distinct?
is_distinct?,
joins : Array(SQL::Join)
joins,
limit : Int64 | Nil
limit,
lock : String | Nil
lock,
offset : Int64 | Nil
offset,
order_bys : Array(Clear::SQL::Query::OrderBy::Record)
order_bys,
to_delete
to_delete,
to_sql : String
to_sql,
to_update
to_update,
total_entries : Int64 | Nil
total_entries,
total_entries=(total_entries : Int64 | Nil)
total_entries=,
wheres : Array(Clear::Expression::Node)
wheres
Constructor methods inherited from module Clear::SQL::SelectBuilder
new(distinct_value = nil, cte = {} of String => Clear::SQL::SelectBuilder | String, columns = [] of SQL::Column, froms = [] of SQL::From, joins = [] of SQL::Join, wheres = [] of Clear::Expression::Node, havings = [] of Clear::Expression::Node, windows = [] of ::Tuple(String, String), group_bys = [] of Symbolic, order_bys = [] of Clear::SQL::Query::OrderBy::Record, limit = nil, offset = nil, lock = nil, before_query_triggers = [] of (-> Nil))
new
Instance methods inherited from module Clear::SQL::Query::WithPagination
current_page
current_page,
first_page?
first_page?,
last_page?
last_page?,
next_page
next_page,
out_of_bounds?
out_of_bounds?,
paginate(page : Int32 = DEFAULT_PAGE, per_page : Int32 = DEFAULT_LIMIT)
paginate,
per_page
per_page,
previous_page
previous_page,
total_pages
total_pages
Instance methods inherited from module Clear::SQL::Query::Change
change! : self
change!
Instance methods inherited from module Clear::SQL::Query::Connection
connection_name : String
connection_name,
use_connection(connection_name : String)
use_connection
Instance methods inherited from module Clear::SQL::Query::Pluck
pluck(fields : Tuple(*T)) forall Tpluck(*fields)
pluck(**fields : **T) forall T pluck, pluck_col(field : Clear::SQL::Symbolic, type : T.class) forall T
pluck_col(field : Clear::SQL::Symbolic) pluck_col
Instance methods inherited from module Clear::SQL::Query::Fetch
fetch(fetch_all = false, & : Hash(String, Clear::SQL::Any) -> Nil)
fetch,
fetch_first
fetch_first,
fetch_first!
fetch_first!,
fetch_with_cursor(count = 1000, & : Hash(String, Clear::SQL::Any) -> Nil)
fetch_with_cursor,
first
first,
first!
first!,
scalar(type : T.class) forall T
scalar,
to_a : Array(Hash(String, Clear::SQL::Any))
to_a
Instance methods inherited from module Clear::SQL::Query::Execute
execute(connection_name : String | Nil = nil)
execute
Instance methods inherited from module Clear::SQL::Query::Lock
with_lock(str : String = "FOR UPDATE")
with_lock
Instance methods inherited from module Clear::SQL::Query::Window
clear_windows
clear_windows,
print_windows
print_windows,
window(name, value)window(windows : NamedTuple) window, windows : Array(WindowDeclaration) windows
Instance methods inherited from module Clear::SQL::Query::CTE
cte : Hash(String, CTEAuthorized)
cte,
with_cte(name, request : CTEAuthorized)with_cte(tuple : NamedTuple) with_cte
Instance methods inherited from module Clear::SQL::Query::Aggregate
agg(field, x : X.class) forall X
agg,
avg(field, x : X.class) forall X
avg,
count(type : X.class = Int64) forall X
count,
max(field, x : X.class) forall X
max,
min(field, x : X.class) forall X
min,
sum(field) : Float64
sum
Instance methods inherited from module Clear::SQL::Query::OffsetLimit
clear_limit
clear_limit,
clear_offset
clear_offset,
limit(x : Int | Nil)
limit,
offset(x : Int | Nil)
offset
Instance methods inherited from module Clear::SQL::Query::GroupBy
clear_group_bys
clear_group_bys,
group_by(column : Symbolic)
group_by,
group_bys : Array(Symbolic)
group_bys
Instance methods inherited from module Clear::SQL::Query::OrderBy
clear_order_bys
clear_order_bys,
order_by(tuple : NamedTuple)order_by(expression : Symbol, direction : Symbol = :asc, nulls : Symbol | Nil = nil)
order_by(expression : String, direction : Symbol = :asc, nulls : Symbol | Nil = nil)
order_by(**tuple) order_by, reverse_order_by reverse_order_by
Instance methods inherited from module Clear::SQL::Query::Having
clear_havings
clear_havings,
having(node : Clear::Expression::Node)having(&)
having(conditions : NamedTuple | Hash(String, Clear::SQL::Any))
having(template : String, *args)
having(template : String, **tuple)
having(**tuple) having, or_having(node : Clear::Expression::Node)
or_having(template : String, *args)
or_having(template : String, **named_tuple)
or_having(&) or_having
Instance methods inherited from module Clear::SQL::Query::Where
clear_wheres
clear_wheres,
or_where(node : Clear::Expression::Node)or_where(template : String, *args)
or_where(template : String, **tuple)
or_where(&) or_where, where(node : Clear::Expression::Node)
where(&)
where(conditions : NamedTuple | Hash(String, Clear::SQL::Any))
where(template : String)
where(template : String, *args)
where(template : String, **tuple)
where(**tuple) where
Instance methods inherited from module Clear::SQL::Query::Join
cross_join(name : Selectable, lateral = false)
cross_join,
full_outer_join(name : Selectable, lateral = false, &)full_outer_join(name : Selectable, condition : String = "true", lateral = false) full_outer_join, inner_join(name : Selectable, lateral = false, &)
inner_join(name : Selectable, condition : String = "true", lateral = false) inner_join, join(name : Selectable, type = :inner, lateral = false, &)
join(name : Selectable, type = :inner, condition : String = "true", lateral = false)
join(name : Selectable, type = :inner, lateral = false) join, left_join(name : Selectable, lateral = false, &)
left_join(name : Selectable, condition : String = "true", lateral = false) left_join, right_join(name : Selectable, lateral = false, &)
right_join(name : Selectable, condition : String = "true", lateral = false) right_join
Instance methods inherited from module Clear::SQL::Query::From
clear_from
clear_from,
from(*args)from(**tuple) from, froms : Array(SQL::From) froms
Instance methods inherited from module Clear::SQL::Query::Select
clear_distinct
clear_distinct,
clear_select
clear_select,
default_wildcard_table=(table : String | Nil = nil)
default_wildcard_table=,
distinct(on : String | Nil = "")
distinct,
distinct_value : String | Nil
distinct_value,
select(c : Column)select(*args) select
Instance Method Detail
def with_columns(fetch_columns = false, &block : Clear::Reflection::Column::Collection -> ) : self
#
Eager load the has many relation columns. Use it to avoid N+1 queries.