cake/query/select · cake

alias

pub fn alias(
  value vl: SelectValue,
  alias als: String,
) -> SelectValue

all

</>

pub fn all(query qry: Select) -> Select

bool

</>

pub fn bool(value vl: Bool) -> SelectValue

col

</>

pub fn col(name nm: String) -> SelectValue

comment

</>

pub fn comment(
  query qry: Select,
  comment cmmnt: String,
) -> Select

distinct

</>

pub fn distinct(query qry: Select) -> Select

epilog

</>

pub fn epilog(query qry: Select, epilog eplg: String) -> Select

float

</>

pub fn float(value vl: Float) -> SelectValue

fragment

</>

pub fn fragment(fragment frgmt: Fragment) -> SelectValue

from

</>

pub fn from(query qry: Select, from frm: From) -> Select

get_comment

</>

pub fn get_comment(query qry: Select) -> Comment

get_epilog

</>

pub fn get_epilog(query qry: Select) -> Epilog

get_from

</>

pub fn get_from(query qry: Select) -> From

get_having

</>

pub fn get_having(query qry: Select) -> Where

See having on details why returns a where

get_joins

</>

pub fn get_joins(query qry: Select) -> Joins

get_kind

</>

pub fn get_kind(
  query qry: Select,
  kind knd: SelectKind,
) -> Select

get_limit

</>

pub fn get_limit(query qry: Select) -> Limit

get_offset

</>

pub fn get_offset(query qry: Select) -> Offset

get_select

</>

pub fn get_select(query qry: Select) -> Selects

get_where

</>

pub fn get_where(query qry: Select) -> Where

group_by

</>

pub fn group_by(
  query qry: Select,
  group_by grpb: String,
) -> Select

group_by_replace

</>

pub fn group_by_replace(
  query qry: Select,
  group_by grpb: String,
) -> Select

group_bys_replace

</>

pub fn group_bys_replace(
  query qry: Select,
  group_bys grpbs: List(String),
) -> Select

groups_by

</>

pub fn groups_by(
  query qry: Select,
  group_bys grpbs: List(String),
) -> Select

having

</>

pub fn having(query qry: Select, having whr: Where) -> Select

HAVING allows to specify constraints much like WHERE, but filters the results after GROUP BY is applied instead of before.

Because it uses the same semantics as WHERE, it takes a Where

having_replace

</>

pub fn having_replace(
  query qry: Select,
  having whr: Where,
) -> Select

See having on details why this takes a where

int

</>

pub fn int(value vl: Int) -> SelectValue

join

</>

pub fn join(query qry: Select, join jn: Join) -> Select

join_replace

</>

pub fn join_replace(query qry: Select, join jn: Join) -> Select

joins

</>

pub fn joins(query qry: Select, joins jns: List(Join)) -> Select

joins_replace

</>

pub fn joins_replace(
  query qry: Select,
  joins jns: List(Join),
) -> Select

limit

</>

pub fn limit(query qry: Select, limit lmt: Int) -> Select

new

</>

pub fn new() -> Select

new_from

</>

pub fn new_from(from frm: From) -> Select

no_comment

</>

pub fn no_comment(query qry: Select) -> Select

no_epilog

</>

pub fn no_epilog(query qry: Select) -> Select

no_joins

</>

pub fn no_joins(query qry: Select) -> Select

offset

</>

pub fn offset(query qry: Select, offst offst: Int) -> Select

or_having

</>

pub fn or_having(query qry: Select, having whr: Where) -> Select

See having on details why this takes a where

or_where

</>

pub fn or_where(query qry: Select, where whr: Where) -> Select

order

</>

pub fn order(
  query qry: Select,
  by ordb: String,
  direction dir: Direction,
) -> Select

order_asc

</>

pub fn order_asc(query qry: Select, by ordb: String) -> Select

order_asc_nulls_first

</>

pub fn order_asc_nulls_first(
  query qry: Select,
  by ordb: String,
) -> Select

order_asc_nulls_first_replace

</>

pub fn order_asc_nulls_first_replace(
  query qry: Select,
  by ordb: String,
) -> Select

order_asc_replace

</>

pub fn order_asc_replace(
  query qry: Select,
  by ordb: String,
) -> Select

order_desc

</>

pub fn order_desc(query qry: Select, by ordb: String) -> Select

order_desc_nulls_first

</>

pub fn order_desc_nulls_first(
  query qry: Select,
  by ordb: String,
) -> Select

order_desc_nulls_first_replace

</>

pub fn order_desc_nulls_first_replace(
  query qry: Select,
  by ordb: String,
) -> Select

order_desc_replace

</>

pub fn order_desc_replace(
  query qry: Select,
  by ordb: String,
) -> Select

order_replace

</>

pub fn order_replace(
  query qry: Select,
  by ordb: String,
  direction dir: Direction,
) -> Select

selects

</>

pub fn selects(
  query qry: Select,
  select_values sv: List(SelectValue),
) -> Select

selects_replace

</>

pub fn selects_replace(
  query qry: Select,
  select_values sv: List(SelectValue),
) -> Select

string

</>

pub fn string(value vl: String) -> SelectValue

to_query

</>

pub fn to_query(query qry: Select) -> Query

where

</>

pub fn where(query qry: Select, where whr: Where) -> Select

where_replace

</>

pub fn where_replace(
  query qry: Select,
  where whr: Where,
) -> Select

xor_having

</>

pub fn xor_having(query qry: Select, having whr: Where) -> Select

See having on details why this takes a where

xor_where

</>

pub fn xor_where(query qry: Select, where whr: Where) -> Select

Constructors