module Clear::SQL::SelectBuilder

Included Modules

Direct including types

Defined in:

clear/sql/select_builder.cr

Constructors

Instance Method Summary

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 T
pluck(*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

Constructor Detail

def self.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)) #

[View source]

Instance Method Detail

def before_query(&block : -> Nil) #

A hook to apply some operation just before the query is executed.

call = 0
req = Clear::SQL.select("1").before_query { call += 1 }
10.times { req.execute }
pp call # 10

[View source]
def columns : Array(SQL::Column) #

def default_wildcard_table #

def dup : self #

Duplicate the query


[View source]
def havings : Array(Clear::Expression::Node) #

def is_distinct? #

[View source]
def joins : Array(SQL::Join) #

def limit : Int64 | Nil #

def lock : String | Nil #

def offset : Int64 | Nil #

def order_bys : Array(Clear::SQL::Query::OrderBy::Record) #

def to_delete #

Construct a delete query from this select query. It uses only the from and the where clause fo the current select request. Can be useful in some case, but use at your own risk !


[View source]
def to_sql : String #

[View source]
def to_update #

[View source]
def total_entries : Int64 | Nil #

def total_entries=(total_entries : Int64 | Nil) #

def wheres : Array(Clear::Expression::Node) #

Return the list of where clause; each where clause are transformed into Clear::Expression::Node