cake/select

A DSL to build SELECT queries.

Types

Comment

pub type Comment =
  read_query.Comment

Epilog

</>

pub type Epilog =
  read_query.Epilog

Fragment

</>

pub type Fragment =
  read_query.Fragment

From

</>

pub type From =
  read_query.From

GroupBy

</>

pub type GroupBy =
  read_query.GroupBy

Join

</>

pub type Join =
  read_query.Join

Joins

</>

pub type Joins =
  read_query.Joins

Limit

</>

pub type Limit =
  read_query.Limit

Offset

</>

pub type Offset =
  read_query.Offset

OrderBy

</>

pub type OrderBy =
  read_query.OrderBy

OrderByDirection

</>

pub type OrderByDirection =
  read_query.OrderByDirection

ReadQuery

</>

pub type ReadQuery =
  read_query.ReadQuery

Select

</>

pub type Select =
  read_query.Select

SelectKind

</>

pub type SelectKind =
  read_query.SelectKind

SelectValue

</>

pub type SelectValue =
  read_query.SelectValue

Selects

</>

pub type Selects =
  read_query.Selects

Where

</>

pub type Where =
  read_query.Where

Functions

all

</>

pub fn all(select slct: Select) -> Select

Sets the kind of the Select query to return duplicates which is the default.

col

</>

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

Creates a column identifier off a String.

comment

</>

pub fn comment(
  select slct: Select,
  comment cmmnt: String,
) -> Select

Appends a Comment to the Select query.

distinct

</>

pub fn distinct(select slct: Select) -> Select

Sets the kind of the Select query to return distinct rows only.

epilog

</>

pub fn epilog(select slct: Select, epilog eplg: String) -> Select

Appends an Epilog to the Select query.

fragment

</>

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

Creates a SelectFragment off a Fragment.

from_query

</>

pub fn from_query(
  select slct: Select,
  sub_query sb_qry: ReadQuery,
  alias als: String,
) -> Select

Sets the FROM clause of the Select query to an aliased sub-query.

from_table

</>

pub fn from_table(
  select slct: Select,
  name tbl_nm: String,
) -> Select

Sets the FROM clause of the Select query to a table name.

get_comment

</>

pub fn get_comment(select slct: Select) -> Comment

Gets the Comment from the Select query.

get_epilog

</>

pub fn get_epilog(select slct: Select) -> Epilog

Gets the Epilog from the Select query.

get_from

</>

pub fn get_from(select slct: Select) -> From

Gets the FROM clause of the Select query.

get_having

</>

pub fn get_having(select slct: Select) -> Where

GetsHAVING in the Select query.

See function having on details why this returns a Where.

get_order_by

</>

pub fn get_order_by(select slct: Select) -> OrderBy

Gets the OrderBy from the Select query.

get_select

</>

pub fn get_select(select slct: Select) -> Selects

Gets the SelectValues of the Select query.

group_by

</>

pub fn group_by(
  select slct: Select,
  group_by grpb: String,
) -> Select

Sets or appends GroupBy a single into an existing GroupBy.

group_bys

</>

pub fn group_bys(
  select slct: Select,
  group_bys grpbs: List(String),
) -> Select

Sets or appends a list of GroupBy into an existing GroupBy.

having

</>

pub fn having(select slct: Select, having whr: Where) -> Select

Sets an AndWhere or appends into an existing AndWhere.

If the outermost Where is an AndWhere, the new Where is appended to the list within AndWhere.
If the query does not have a Where clause, the given Where is set instead.
If the outermost Where is any other kind of Where, this and the current outermost Where are wrapped in an AndWhere.

NOTICE: HAVING allows to specify constraints much like WHERE, but filters the results after GROUP BY is applied instead of before. Because HAVING uses the same semantics as WHERE, it takes a Where.

int

</>

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

Creates an integer Param off an Int.

join

</>

pub fn join(select slct: Select, join jn: Join) -> Select

Adds a Join to the Select query.

joins

</>

pub fn joins(
  select slct: Select,
  joins jns: List(Join),
) -> Select

Adds Joins to the Select query.

limit

</>

pub fn limit(select slct: Select, limit lmt: Int) -> Select

Sets a Limit in the Select query.

new

</>

pub fn new() -> Select

Creates an empty Select query.

no_comment

</>

pub fn no_comment(select slct: Select) -> Select

Removes the Comment from the Select query.

no_epilog

</>

pub fn no_epilog(select slct: Select) -> Select

Removes the Epilog from the Select query.

no_from

</>

pub fn no_from(select slct: Select) -> Select

Removes the FROM clause of the Select query.

no_group_by

</>

pub fn no_group_by(select slct: Select) -> Select

Removes GroupBy from the Select query.

no_having

</>

pub fn no_having(select slct: Select) -> Select

Removes HAVING from the Select query.

no_join

</>

pub fn no_join(select slct: Select) -> Select

Removes any Joins from the Select query.

no_limit

</>

pub fn no_limit(select slct: Select) -> Select

Removes Limit from the Select query.

no_offset

</>

pub fn no_offset(select slct: Select) -> Select

Removes Offset from the Select query.

no_order_by

</>

pub fn no_order_by(select slct: Select) -> Select

Removes the OrderBy from the Select query.

no_where

</>

pub fn no_where(select slct: Select) -> Select

Removes the Where from the Select query.

null

</>

pub fn null() -> SelectValue

Creates an SQL NULL Param.

offset

</>

pub fn offset(select slct: Select, offst offst: Int) -> Select

Sets an Offset in the Select query.

or_having

</>

pub fn or_having(
  select slct: Select,
  having whr: Where,
) -> Select

Sets an OrWhere or appends into an existing OrWhere.

If the outermost Where is an OrWhere, the new Where is appended to the list within OrWhere.
If the query does not have a Where clause, the given Where is set instead.
If the outermost Where is any other kind of Where, this and the current outermost Where are wrapped in an OrWhere.

See function having on details why this takes a Where.

or_where

</>

pub fn or_where(select slct: Select, where whr: Where) -> Select

Sets an OrWhere or appends into an existing OrWhere.

If the outermost Where is an OrWhere, the new Where is appended to the list within OrWhere.
If the query does not have a Where clause, the given Where is set instead.
If the outermost Where is any other kind of Where, this and the current outermost Where are wrapped in an OrWhere.

order_by

</>

pub fn order_by(
  select slct: Select,
  by ordb: String,
  direction dir: Direction,
) -> Select

Creates or appends an OrderBy a column with a direction.

The direction can either ASC or DESC.

order_by_asc

</>

pub fn order_by_asc(
  select slct: Select,
  by ordb: String,
) -> Select

Creates or appends an ascending OrderBy.

order_by_asc_nulls_first

</>

pub fn order_by_asc_nulls_first(
  select slct: Select,
  by ordb: String,
) -> Select

Creates or appends an ascending OrderBy with NULLS FIRST.

NOTICE: 🦭MariaDB and 🐬MySQL do not support NULLS FIRST out of the box.

order_by_asc_nulls_last

</>

pub fn order_by_asc_nulls_last(
  select slct: Select,
  by ordb: String,
) -> Select

Creates or appends an ascending OrderBy with NULLS LAST.

NOTICE: 🦭MariaDB and 🐬MySQL do not support NULLS LAST out of the box.

order_by_desc

</>

pub fn order_by_desc(
  select slct: Select,
  by ordb: String,
) -> Select

Creates or appends a descending OrderBy.

order_by_desc_nulls_first

</>

pub fn order_by_desc_nulls_first(
  select slct: Select,
  by ordb: String,
) -> Select

Creates or appends a descending order with NULLS FIRST.

NOTICE: 🦭MariaDB and 🐬MySQL do not support NULLS FIRST out of the box.

order_by_desc_nulls_last

</>

pub fn order_by_desc_nulls_last(
  select slct: Select,
  by ordb: String,
) -> Select

Creates or appends a descending OrderBy with NULLS LAST.

NOTICE: 🦭MariaDB and 🐬MySQL do not support NULLS LAST out of the box.

replace_group_by

</>

pub fn replace_group_by(
  select slct: Select,
  group_by grpb: String,
) -> Select

Replaces GroupBy with a single GroupBy.

replace_group_bys

</>

pub fn replace_group_bys(
  select slct: Select,
  group_bys grpbs: List(String),
) -> Select

Replaces GroupBy with a list of GroupBys.

replace_having

</>

pub fn replace_having(
  select slct: Select,
  having whr: Where,
) -> Select

Replaces HAVING in the Select query.

See function having on details why this takes a Where.

replace_join

</>

pub fn replace_join(select slct: Select, join jn: Join) -> Select

Replaces any Joins of the Select query with a signle Join.

replace_joins

</>

pub fn replace_joins(
  select slct: Select,
  joins jns: List(Join),
) -> Select

Replaces any Joins of the Select query with the given Joins.

replace_order_by

</>

pub fn replace_order_by(
  select slct: Select,
  by ordb: String,
  direction dir: Direction,
) -> Select

Replaces the OrderBy a column with a direction.

replace_order_by_asc

</>

pub fn replace_order_by_asc(
  select slct: Select,
  by ordb: String,
) -> Select

Replaces the OrderBy a single ascending OrderBy.

replace_order_by_asc_nulls_first

</>

pub fn replace_order_by_asc_nulls_first(
  select slct: Select,
  by ordb: String,
) -> Select

Replaces the OrderBy a single ascending OrderBy with NULLS FIRST.

NOTICE: 🦭MariaDB and 🐬MySQL do not support NULLS FIRST out of the box.

replace_order_by_asc_nulls_last

</>

pub fn replace_order_by_asc_nulls_last(
  select slct: Select,
  by ordb: String,
) -> Select

Replaces the OrderBy a single ascending OrderBy with NULLS LAST.

NOTICE: 🦭MariaDB and 🐬MySQL do not support NULLS LAST out of the box.

replace_order_by_desc

</>

pub fn replace_order_by_desc(
  select slct: Select,
  by ordb: String,
) -> Select

Replaces the OrderBy a single descending order.

replace_order_by_desc_nulls_first

</>

pub fn replace_order_by_desc_nulls_first(
  select slct: Select,
  by ordb: String,
) -> Select

Replaces the OrderBy a single descending order with NULLS FIRST.

NOTICE: 🦭MariaDB and 🐬MySQL do not support NULLS FIRST out of the box.

replace_order_by_desc_nulls_last

</>

pub fn replace_order_by_desc_nulls_last(
  select slct: Select,
  by ordb: String,
) -> Select

Replaces the OrderBy a single descending OrderBy with NULLS LAST.

NOTICE: 🦭MariaDB and 🐬MySQL do not support NULLS LAST out of the box.

replace_select

</>

pub fn replace_select(
  select slct: Select,
  select_value sv: SelectValue,
) -> Select

Add a SelectValues to the Select query.

If the query already has any SelectValues, they are replaced.

replace_selects

</>

pub fn replace_selects(
  select slct: Select,
  select_values svs: List(SelectValue),
) -> Select

Adds many SelectValues to the Select query.

If the query already has any SelectValues, they are replaced.

replace_where

</>

pub fn replace_where(
  select slct: Select,
  where whr: Where,
) -> Select

Replaces the Where in the Select query.

select

</>

pub fn select(
  select slct: Select,
  select_value sv: SelectValue,
) -> Select

Add a SelectValue to the Select query.

If the query already has any SelectValues, the new one is appended.

selects

</>

pub fn selects(
  select slct: Select,
  select_values svs: List(SelectValue),
) -> Select

Adds many SelectValues to the Select query.

If the query already has any SelectValues, the new ones are appended.

string

</>

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

Creates a string Param off a String.

to_query

</>

pub fn to_query(select slct: Select) -> ReadQuery

Creates a ReadQuery from a Select query.

where

</>

pub fn where(select slct: Select, where whr: Where) -> Select

Sets an AndWhere or appends into an existing AndWhere.

If the outermost Where is an AndWhere, the new Where is appended to the list within AndWhere.
If the query does not have a Where clause, the given Where is set instead.
If the outermost Where is any other kind of Where, this and the current outermost Where are wrapped in an AndWhere.

xor_having

</>

pub fn xor_having(
  select slct: Select,
  having whr: Where,
) -> Select

Sets an XorWhere or appends into an existing XorWhere.

If the outermost Where is an XorWhere, the new Where is appended to the list within XorWhere.
If the query does not have a Where clause, the given Where is set instead.
If the outermost Where is any other kind of Where, this and the current outermost Where are wrapped in an XorWhere.

See function having on details why this takes a Where.

NOTICE: This operator does not exist in 🐘PostgreSQL or 🪶SQLite, and Cake generates equivalent SQL using OR and AND and NOT. This operator exists in 🦭MariaDB and 🐬MySQL.

xor_where

</>

pub fn xor_where(select slct: Select, where whr: Where) -> Select

Sets an XorWhere or appends into an existing XorWhere.

If the outermost Where is an XorWhere, the new Where is appended to the list within XorWhere.
If the query does not have a Where clause, the given Where is set instead.
If the outermost Where is any other kind of Where, this and the current outermost Where are wrapped in an XorWhere.

NOTICE: This operator does not exist in 🐘PostgreSQL or 🪶SQLite, and Cake generates equivalent SQL using OR and AND and NOT. This operator exists in 🦭MariaDB and 🐬MySQL.

Constructors