Cake

https://hexdocs.pm/cake/2.1.3/
Admin
Cake is a SQL query builder library written in Gleam designed to compose SQL queries targeting...
Tokens:43,487
Snippets:201
Trust Score:9.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Installation

Source: https://hexdocs.pm/cake/2.1.3/index

Install the Cake library using the gleam add command. This command fetches and adds the specified version of the Cake package to your Gleam project.

```gleam
gleam add cake@2
```

--------------------------------

### Run Test Suite Locally

Source: https://hexdocs.pm/cake/2.1.3/index

Instructions for running the project's test suite locally using Docker. It involves starting the Docker environment and then executing the Gleam test command.

```bash
bin/docker/attached
# wait a few seconds until everything is ready
# if you run gleam test too early, it will crash
gleam test
```

--------------------------------

### Get SQL from PreparedStatement

Source: https://hexdocs.pm/cake/2.1.3/cake

Retrieves the SQL string representation of a prepared statement. This function takes an internal PreparedStatement object as input and returns its corresponding SQL query as a string.

```gleam
pub fn get_sql(
  prepared_statement prp_stm: @internal PreparedStatement,
) -> String
```

--------------------------------

### Initial Preview and Demo

Source: https://hexdocs.pm/cake/2.1.3/changelog

This snippet marks the first preview release of the library, including a demo.

```gleam
First preview / demo.
```

--------------------------------

### Combined Query Offset Management

Source: https://hexdocs.pm/cake/2.1.3/cake/combined

Functions for getting, setting, and removing the offset from a Combined ReadQuery. `get_offset` retrieves the current offset, `offset` sets a new offset value, and `no_offset` removes any existing offset.

```APIDOC
get_offset:
  pub fn get_offset(query qry: @internal Combined) -> @internal Offset
  Gets `Offset` in the `Combined` `ReadQuery`.

offset:
  pub fn offset(query qry: @internal Combined, offest offst: Int) -> @internal Combined
  Sets an `Offset` in the `Combined` `ReadQuery`.

no_offset:
  pub fn no_offset(query qry: @internal Combined) -> @internal Combined
  Removes `Offset` from the `Combined` `ReadQuery`.
```

--------------------------------

### Helper Commands

Source: https://hexdocs.pm/cake/2.1.3/index

A collection of helper commands for managing the Docker environment and performing various development tasks, including test execution and code review automation.

```bash
bin/docker/attached
bin/docker/detached
bin/docker/down

bin/test

bin/birdie/interactive-review
bin/birdie/accept-all
bin/birdie/reject-all
```

--------------------------------

### Cake Dependency Updates

Source: https://hexdocs.pm/cake/2.1.3/changelog

Details updates to project dependencies, including the `pog` library and the replacement of `gleam_pgo` with `pgo` for development and testing environments.

```gleam
Utilize `pog ~> 4.0.0` dependency in tests.
Replaced dev/test and adapter target `gleam_pgo` with `pgo` dependency.
```

--------------------------------

### Cake SQL Builder API Documentation

Source: https://hexdocs.pm/cake/2.1.3/cake/select

This section provides comprehensive API documentation for the Cake library, covering its modules for constructing SQL queries. It details functions for SELECT, INSERT, UPDATE, DELETE operations, joins, where clauses, and dialect-specific configurations.

```APIDOC
cake:
  __module__
    Provides core SQL building functionality.

  combined:
    Functions for combining multiple SQL statements or fragments.

  delete:
    Functions for constructing DELETE SQL statements.
    - delete(from: table, where: condition)
      - Constructs a DELETE statement.
      - Parameters:
        - from: The table to delete from.
        - where: The condition for deletion.
      - Returns: A DELETE statement representation.

  dialect:
    Contains modules for different SQL dialects.
    - maria_dialect:
      - Provides MariaDB/MySQL specific SQL dialect functions.
    - mysql_dialect:
      - Provides MySQL specific SQL dialect functions.
    - postgres_dialect:
      - Provides PostgreSQL specific SQL dialect functions.
    - sqlite_dialect:
      - Provides SQLite specific SQL dialect functions.

  fragment:
    Utilities for creating SQL fragments.

  having:
    Functions for constructing HAVING clauses in SQL queries.
    - having(condition)
      - Adds a HAVING clause to a query.
      - Parameters:
        - condition: The condition for the HAVING clause.
      - Returns: A query with the HAVING clause.

  insert:
    Functions for constructing INSERT SQL statements.
    - insert(into: table, values: list)
      - Constructs an INSERT statement.
      - Parameters:
        - into: The table to insert into.
        - values: A list of values to insert.
      - Returns: An INSERT statement representation.

  join:
    Functions for constructing JOIN clauses in SQL queries.
    - join(type, table, on: condition)
      - Adds a JOIN clause to a query.
      - Parameters:
        - type: The type of join (e.g., :inner, :left).
        - table: The table to join.
        - on: The join condition.
      - Returns: A query with the JOIN clause.

  param:
    Utilities for handling SQL parameters.

  select:
    Functions for constructing SELECT SQL statements.
    - select(fields: list, from: table, where: condition, order_by: list, limit: integer, offset: integer)
      - Constructs a SELECT statement.
      - Parameters:
        - fields: List of fields to select.
        - from: The table to select from.
        - where: The condition for filtering.
        - order_by: List of fields to order by.
        - limit: Maximum number of records to return.
        - offset: Number of records to skip.
      - Returns: A SELECT statement representation.
    - Types:
      - Comment: Represents a SQL comment.
      - Direction: Represents ordering direction (:asc, :desc).
      - Epilog: Represents SQL fragments appended at the end.
      - Fragment: Represents a reusable SQL fragment.
      - From: Represents the FROM clause.
      - GroupBy: Represents the GROUP BY clause.
      - Join: Represents a JOIN clause.
      - Joins: A list of JOIN clauses.
      - Limit: Represents the LIMIT clause.
      - Offset: Represents the OFFSET clause.
      - OrderBy: Represents the ORDER BY clause.
      - OrderByDirection: Represents the direction of ordering.
      - ReadQuery: Represents a read query structure.
      - Select: Represents the SELECT clause.
      - SelectKind: The type of selection (e.g., :all, :fields).
      - SelectValue: A value within the SELECT clause.
      - Selects: A list of selected fields or expressions.
      - Where: Represents the WHERE clause.

  update:
    Functions for constructing UPDATE SQL statements.
    - update(table: table, set: list, where: condition)
      - Constructs an UPDATE statement.
      - Parameters:
        - table: The table to update.
        - set: A list of field-value pairs to set.
        - where: The condition for updating.
      - Returns: An UPDATE statement representation.

  where:
    Functions for constructing WHERE clauses in SQL queries.
    - where(condition)
      - Adds a WHERE clause to a query.
      - Parameters:
        - condition: The condition for the WHERE clause.
      - Returns: A query with the WHERE clause.
```

--------------------------------

### Gleam Cake Insert API Documentation

Source: https://hexdocs.pm/cake/2.1.3/cake/insert

Comprehensive API documentation for the Gleam Cake insert module. This section covers various functions for building SQL INSERT statements, including creating new queries, specifying data sources, handling conflicts, and applying modifiers.

```APIDOC
get_on_conflict(insert isrt: @internal Insert(a)) -> @internal InsertConflictStrategy(a)
  Get the conflict strategy from an `Insert` query.

get_source(insert isrt: @internal Insert(a)) -> @internal InsertSource(a)
  Get the source from an `Insert` query which is either a list of records, accompanied by a encoder function or a list of `InsertRow`s.

get_table(insert isrt: @internal Insert(a)) -> @internal InsertIntoTable
  Get the table name to insert into from an `Insert` query.

int(value vl: Int) -> @internal InsertValue
  Create an `InsertValue` from a column `String` and an `Int` value.

modifier(insert isrt: @internal Insert(a), modifier mdfr: String) -> @internal Insert(a)
  Specify a modifier for the `INSERT` query.

new() -> @internal Insert(a)
  Create an empty `INSERT` query.

no_comment(insert isrt: @internal Insert(a)) -> @internal Insert(a)
  Specify that no comment should be added to the `INSERT` query.

no_epilog(insert isrt: @internal Insert(a)) -> @internal Insert(a)
  Specify that no epilog should be added to the `INSERT` query.

no_modifier(insert isrt: @internal Insert(a)) -> @internal Insert(a)
  Specify that no modifier should be used for the given `INSERT` query.

no_returning(insert isrt: @internal Insert(a)) -> @internal Insert(a)
  Specify that no columns should be returned after the `INSERT` query.

null() -> @internal InsertValue
  Create a NULL `InsertValue`.

on_columns_conflict_ignore(insert isrt: @internal Insert(a), columns cols: List(String), where whr: @internal Where) -> @internal Insert(a)
  This specifies that specific conflicts do not result in an error but instead are just ignored and not inserted.
  Conflict Target: Columns

on_columns_conflict_update(insert isrt: @internal Insert(a), columns cols: List(String), where whr: @internal Where, update updt: @internal Update(a)) -> @internal Insert(a)
  Inserts or updates on conflict, also called ´UPSERT´.
  Conflict Target: Columns

on_conflict_error(insert isrt: @internal Insert(a)) -> @internal Insert(a)
  This specifies that any conflicts result in the query to fail
  This is the default behaviour.
```

--------------------------------

### Support for Deletes and New Database Adapters

Source: https://hexdocs.pm/cake/2.1.3/changelog

This entry covers the addition of support for deletes and interface modules for `insert`, `update`, `delete`, along with support for MariaDB and MySQL. It also notes the removal of hard dependencies on RDBMS specific libraries, listing available adapters.

```gleam
Added support for deletes and interface modules for `insert`, `update`, `delete` ontop of the existing `select` and `combined` interface modules.
Added support for 🦭MariaDB and 🐬MySQL.
Removed the hard dependency on any RDMBS specific library. These are now only required when developing and testing this library, but when running you can chose any of the following adapters: 
    * `pog`
    * `sqlight`
    * `gmysql`
```

--------------------------------

### Create PreparedStatement from Write Query

Source: https://hexdocs.pm/cake/2.1.3/cake

Generates a prepared statement from a write query. This function takes a write query and a dialect, returning an internal PreparedStatement. For dialect-specific details, refer to the implementations in `cake/dialect/*`.

```gleam
pub fn write_query_to_prepared_statement(
  query qry: @internal WriteQuery(a),
  dialect dlct: @internal Dialect,
) -> @internal PreparedStatement
```

--------------------------------

### Cake SQL Query Building Modules

Source: https://hexdocs.pm/cake/2.1.3/cake/insert

This section outlines the core modules within the Cake library used for constructing SQL queries. It covers functionalities like selecting data, inserting, updating, deleting records, joining tables, and applying WHERE and HAVING clauses. Each module provides specific functions to build different parts of a SQL query.

```elixir
cake/select.ex
cake/insert.ex
cake/update.ex
cake/delete.ex
cake/join.ex
cake/where.ex
cake/having.ex
```

--------------------------------

### Create Prepared SQL Fragment

Source: https://hexdocs.pm/cake/2.1.3/cake/fragment

Creates a new SQL fragment from a string and a list of parameters. It handles mismatches between placeholders and parameters by printing errors to stderr and repeating or ignoring excess parameters.

```gleam
pub fn prepared(
  string str: String,
  params prms: List([param.Param](https://hexdocs.pm/cake/2.1.3/cake/param.html#Param "cake/param.{type Param}")),
) -> @internal Fragment
```

--------------------------------

### Builder Flexibility and Documentation for CRUD Operations

Source: https://hexdocs.pm/cake/2.1.3/changelog

This snippet details improvements to builder flexibility for inserts and updates, along with documentation for the `insert`, `update`, and `delete` interface modules. It also covers fixes for updating with sub-queries and a rename for `select.groups_by`.

```gleam
Improved builder flexibility for inserts and updates.
Added documentation for the `insert`, `update` and `delete` interface modules.
Improved tests for `UPDATE`.
Renamed `select.groups_by` to `select.group_bys`.
Fixed bugs when updating with sub-queries, where specifying a sub_query while setting update columns to vales would remove all other settings.
```

--------------------------------

### Gleam Select Query Construction

Source: https://hexdocs.pm/cake/2.1.3/cake/select

Demonstrates how to construct parts of a SQL SELECT query using the Gleam Cake library. This includes defining the FROM clause, GROUP BY conditions, HAVING filters, JOINs, LIMIT, OFFSET, ORDER BY, WHERE clauses, and the specific columns to select.

```gleam
pub fn get_from(select slct: @internal Select) -> @internal From
pub fn get_group_by(select slct: @internal Select) -> @internal GroupBy
pub fn get_having(select slct: @internal Select) -> @internal Where
pub fn get_joins(select slct: @internal Select) -> @internal Joins
pub fn get_kind(select slct: @internal Select, kind knd: @internal SelectKind) -> @internal Select
pub fn get_limit(select slct: @internal Select) -> @internal Limit
pub fn get_offset(select slct: @internal Select) -> @internal Offset
pub fn get_order_by(select slct: @internal Select) -> @internal OrderBy
pub fn get_select(select slct: @internal Select) -> @internal Selects
pub fn get_where(select slct: @internal Select) -> @internal Where
pub fn group_by(select slct: @internal Select, group_by grpb: String) -> @internal Select
pub fn group_bys(select slct: @internal Select, group_bys grpbs: List(String)) -> @internal Select
pub fn having(select slct: @internal Select, having whr: @internal Where) -> @internal Select
pub fn int(value vl: Int) -> @internal SelectValue
```

--------------------------------

### Public API for Query Generation

Source: https://hexdocs.pm/cake/2.1.3/changelog

This entry details the provision of public APIs to access generated SQL and prepared statement parameters from the base `cake` and `dialect` modules.

```gleam
Provide public API to access the generated SQL and prepared statement parameters in the base `cake` and new `dialect` modules.
```

--------------------------------

### Cake SQL Query Building Modules

Source: https://hexdocs.pm/cake/2.1.3/cake/update

This section outlines the core modules within the Cake library used for constructing SQL queries. It covers functionalities for selecting, inserting, updating, deleting, joining, and filtering data.

```elixir
cake
cake/combined
cake/delete
cake/fragment
cake/having
cake/insert
cake/join
cake/param
cake/select
cake/update
cake/where
```

--------------------------------

### Cake SQL Dialect Implementations

Source: https://hexdocs.pm/cake/2.1.3/cake/update

This section details the modules that provide specific implementations for different SQL database dialects. These modules handle the nuances of SQL syntax for MariaDB, MySQL, PostgreSQL, and SQLite.

```elixir
cake/dialect/maria_dialect
cake/dialect/mysql_dialect
cake/dialect/postgres_dialect
cake/dialect/sqlite_dialect
```

--------------------------------

### Cake SQL Query Building

Source: https://hexdocs.pm/cake/2.1.3/cake/where

This snippet demonstrates the core functionality of the Cake library for constructing SQL queries. It showcases how to build SELECT statements with WHERE clauses and other common query components.

```elixir
iex> Cake.select([:id, :name], "users")
"SELECT id, name FROM users"

iex> Cake.where("age > ?", [30])
"age > 30"

iex> Cake.select([:id, :name], "users") |> Cake.where("age > ?", [30]) |> Cake.order_by([:name])
"SELECT id, name FROM users WHERE age > 30 ORDER BY name"

iex> Cake.insert("users", [name: "Alice", age: 25])
"INSERT INTO users (name, age) VALUES ('Alice', 25)"

iex> Cake.update("users", [age: 31], fn w -> w.id == 1 end)
"UPDATE users SET age = 31 WHERE id = 1"

iex> Cake.delete("users", fn w -> w.age < 18 end)
"DELETE FROM users WHERE age < 18"
```

--------------------------------

### Cake Delete: Convert to WriteQuery

Source: https://hexdocs.pm/cake/2.1.3/cake/delete

Converts a Delete query builder instance into a WriteQuery, preparing it for execution.

```APIDOC
to_query(dlt: Delete(a)) -> WriteQuery(a)

  Creates a `WriteQuery` from a `Delete` query.

  Parameters:
    dlt: The Delete query builder instance to convert.
```

--------------------------------

### Support for MySQL and MariaDB

Source: https://hexdocs.pm/cake/2.1.3/changelog

This entry highlights the addition of MySQL as a first-class supported database, independent of MariaDB.

```gleam
Added 🐬MySQL independent of 🦭MariaDB as first class supported.
```

--------------------------------

### Cake SQL Query Building Modules

Source: https://hexdocs.pm/cake/2.1.3/cake/combined

This section lists the core modules within the Cake library used for constructing SQL queries. Each module focuses on a specific aspect of query building, such as SELECT statements, INSERT operations, UPDATEs, DELETEs, JOINs, and WHERE clauses. It also includes modules for handling combined queries and dialect-specific SQL generation.

```elixir
cake
cake/combined
cake/delete
cake/dialect/maria_dialect
cake/dialect/mysql_dialect
cake/dialect/postgres_dialect
cake/dialect/sqlite_dialect
cake/fragment
cake/having
cake/insert
cake/join
cake/param
cake/select
cake/update
cake/where
```

--------------------------------

### CI/Docker Compose Fixes and License Change

Source: https://hexdocs.pm/cake/2.1.3/changelog

This snippet details fixes for GitHub CI and Docker Compose testing against PostgreSQL and MariaDB, provides instructions for local testing, and announces a license change from AGPL 3.0 to MPL-2.0.

```gleam
Fixed github CI and docker compose testing against 🐘PostgreSQL and 🦭MariaDB.
Locally you should be able to install docker and then just run: `bin/docker/detached/` and then `gleam test`.
Relaxed licence from AGPL 3.0 to Mozilla Public License 2.0 (MPL-2.0).
```

--------------------------------

### Create PreparedStatement from Cake Query

Source: https://hexdocs.pm/cake/2.1.3/cake

Converts a Cake query into a prepared statement. This function takes a Cake query and a dialect, returning an internal PreparedStatement. It is recommended to consult dialect-specific implementations in `cake/dialect/*` for more details.

```gleam
pub fn to_prepared_statement(
  query qry: [CakeQuery](https://hexdocs.pm/cake/2.1.3/cake.html#CakeQuery)(a),
  dialect dlct: @internal Dialect,
) -> @internal PreparedStatement
```

--------------------------------

### Gleam Cake INSERT Query Construction

Source: https://hexdocs.pm/cake/2.1.3/cake/insert

Functions for building `INSERT` queries. This includes specifying columns, adding comments, setting epilogs, and creating queries from records or raw values.

```gleam
pub fn columns(
  insert isrt: @internal Insert(a),
  columns cols: List(String),
) -> @internal Insert(a)

pub fn comment(
  insert isrt: @internal Insert(a),
  comment cmmnt: String,
) -> @internal Insert(a)

pub fn epilog(
  insert isrt: @internal Insert(a),
  epilog eplg: String,
) -> @internal Insert(a)

pub fn from_records(
  table_name tbl_nm: String,
  columns cols: List(String),
  records rcrds: List(a),
  encoder encdr: fn(a) -> @internal InsertRow,
) -> @internal Insert(a)

pub fn from_values(
  table_name tbl_nm: String,
  columns cols: List(String),
  values vls: List(@internal InsertRow),
) -> @internal Insert(a)
```

--------------------------------

### Cake Where Module API Documentation

Source: https://hexdocs.pm/cake/2.1.3/cake/where

This section details the functions available in the Cake Where module for constructing SQL WHERE clauses. It covers type definitions, value creation, logical operations, and comparisons.

```APIDOC
Fragment:
  Represents a SQL fragment.

ReadQuery:
  Represents a query that can be used in subqueries.

Where:
  Represents a WHERE clause.

WhereValue:
  Represents a value that can be used in a WHERE clause.

and(wheres: List(Where)) -> Where
  Logical AND of multiple Where clauses.

between(value_a: WhereValue, value_b: WhereValue, value_c: WhereValue) -> Where
  Creates a WHERE clause that checks if a WhereValue A is between two WhereValues B and C.

col(name: String) -> WhereValue
  Creates a WhereValue from a column name String.

eq(value_a: WhereValue, value_b: WhereValue) -> Where
  Creates a WHERE clause that checks if a WhereValue equals another WhereValue.

eq_all_query(value: WhereValue, sub_query: ReadQuery) -> Where
  Creates a WHERE clause that checks if a WhereValue matches all in a sub-query.
  NOTICE: Not supported by 🪶SQLite.

eq_any_query(value: WhereValue, sub_query: ReadQuery) -> Where
  Creates a WHERE clause that checks if a WhereValue matches any in a sub-query.
  NOTICE: Not supported by 🪶SQLite.

exists_in_query(sub_query: ReadQuery) -> Where
  Creates a WHERE clause that checks if it exists in a sub-query.

false() -> WhereValue
  Creates a FALSE WhereValue. You probably want to use `where.is_false()` instead.

float(vl: Float) -> WhereValue
  Creates a WhereValue from a Float.

fragment(fragment: Fragment) -> Where
  Creates a WhereFragment from a Fragment.
```

--------------------------------

### Create JOIN target from sub-query

Source: https://hexdocs.pm/cake/2.1.3/cake/join

Creates a JOIN target from a sub-query.

```gleam
pub fn sub_query(
  sub_query sq: @internal ReadQuery,
) -> @internal JoinTarget
```

--------------------------------

### SQLite Query Conversion Functions

Source: https://hexdocs.pm/cake/2.1.3/cake/dialect/sqlite_dialect

Provides functions to convert Cake query types into SQLite-specific prepared statements. These are essential for executing queries with the sqlight library.

```APIDOC
cake_query_to_prepared_statement(query qry: CakeQuery(a)) -> PreparedStatement:
  Converts a generic Cake query to a SQLite prepared statement.

read_query_to_prepared_statement(query qry: ReadQuery) -> PreparedStatement:
  Converts a read query to a SQLite prepared statement.
```

--------------------------------

### Cake Param Constructors

Source: https://hexdocs.pm/cake/2.1.3/cake/param

Provides functions to create `Param` types for various data types. These functions wrap literal values into `Param` types suitable for SQL queries.

```gleam
pub fn bool(value vl: Bool) -> Param

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

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

pub fn null() -> Param

pub fn string(value vl: String) -> Param
```

--------------------------------

### Cake Update API Documentation

Source: https://hexdocs.pm/cake/2.1.3/cake/update

This section provides comprehensive documentation for the functions within the Cake update module, detailing their purpose, parameters, and usage within the context of building SQL UPDATE queries.

```APIDOC
sets_expression(columns: List(String), expression: String) -> UpdateSet
  Sets many columns to an expression value.
  NOTICE: the expression must return an equal count of columns.

sets_replace(update: Update(a), sets: List(UpdateSet)) -> Update(a)
  Sets or replaces many column sets in an `Update` query.

sets_sub_query(columns: List(String), query: ReadQuery) -> UpdateSet
  Sets many columns to a sub-query value.
  NOTICE: the sub-query must return an equal count of columns.

table(update: Update(a), table_name: String) -> Update(a)
  Sets the table of the `Update` query.

to_query(update: Update(a)) -> WriteQuery(a)
  Creates a `WriteQuery` from an `Update` query.

where(update: Update(a), where: Where) -> Update(a)
  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_where(update: Update(a), where: Where) -> Update(a)
  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`.
NOTICE: This operator exists in 🦭MariaDB and 🐬MySQL with native support.
```

--------------------------------

### Create JOIN target from table name

Source: https://hexdocs.pm/cake/2.1.3/cake/join

Creates a JOIN target from a table name.

```gleam
pub fn table(table_name tbl_nm: String) -> @internal JoinTarget
```

--------------------------------

### Create PreparedStatement from Read Query

Source: https://hexdocs.pm/cake/2.1.3/cake

Generates a prepared statement from a read query. This function requires a read query and a dialect to correctly format the SQL. It is part of the query preparation utilities in the Cake library.

```gleam
pub fn read_query_to_prepared_statement(
  query qry: @internal ReadQuery,
  dialect dlct: @internal Dialect,
) -> @internal PreparedStatement
```

--------------------------------

### Flattened Query Interface and Internal Module Movement

Source: https://hexdocs.pm/cake/2.1.3/changelog

This entry describes the flattening of query interface/DSL modules into the base `cake/` namespace and the relocation of some internal modules to `cake/internal/`. It also mentions improvements to the test suite for `DELETE` statements and general documentation.

```gleam
Flattened the query interface/DSL modules into the base namespace of `cake/`.
Moved some modules only used internally into `cake/internal/` namespace.
Fixed and improved test suite for `DELETE` statements.
Improved general documentation.
```

--------------------------------

### Cake SQL Query Building

Source: https://hexdocs.pm/cake/2.1.3/cake/delete

This section provides an overview of the Cake library's capabilities for building SQL queries. It covers modules for SELECT, INSERT, UPDATE, DELETE statements, along with clauses like WHERE, HAVING, and JOIN. It also includes dialect-specific implementations for various database systems.

```elixir
cake/select.html
cake/insert.html
cake/update.html
cake/delete.html
cake/join.html
cake/where.html
cake/having.html
cake/dialect/maria_dialect.html
cake/dialect/mysql_dialect.html
cake/dialect/postgres_dialect.html
cake/dialect/sqlite_dialect.html
```

--------------------------------

### Cake Select Module Functions

Source: https://hexdocs.pm/cake/2.1.3/cake/select

This section provides an overview of the functions available in the Cake Select module for building SQL queries. It covers operations such as aliasing, selecting columns, filtering, joining, grouping, ordering, and limiting results.

```APIDOC
alias(field, alias)
  - Sets an alias for a field.
  - Parameters:
    - field: The field to alias.
    - alias: The alias name.

all()
  - Selects all columns.

bool(field)
  - Casts a field to boolean.
  - Parameters:
    - field: The field to cast.

col(field)
  - Selects a specific column.
  - Parameters:
    - field: The column name.

comment(sql)
  - Adds a SQL comment.
  - Parameters:
    - sql: The SQL string to comment.

distinct(field)
  - Applies the DISTINCT keyword to a field.
  - Parameters:
    - field: The field to apply DISTINCT to.

epilog(sql)
  - Adds an epilog to the query.
  - Parameters:
    - sql: The SQL string for the epilog.

float(field)
  - Casts a field to float.
  - Parameters:
    - field: The field to cast.

fragment(sql)
  - Inserts a SQL fragment.
  - Parameters:
    - sql: The SQL fragment.

from_query(query)
  - Specifies the source of data as a subquery.
  - Parameters:
    - query: The subquery.

from_table(table)
  - Specifies the source table for the query.
  - Parameters:
    - table: The table name.

get_comment()
  - Retrieves the SQL comment.

get_epilog()
  - Retrieves the query epilog.

get_from()
  - Retrieves the source table or subquery.

get_group_by()
  - Retrieves the grouping columns.

get_having()
  - Retrieves the HAVING conditions.

get_joins()
  - Retrieves the JOIN clauses.

get_kind()
  - Retrieves the type of query (e.g., SELECT).

get_limit()
  - Retrieves the limit for the query.

get_offset()
  - Retrieves the offset for the query.

get_order_by()
  - Retrieves the ordering columns.

get_select()
  - Retrieves the selected columns and expressions.

get_where()
  - Retrieves the WHERE conditions.

group_by(field)
  - Adds a field to the GROUP BY clause.
  - Parameters:
    - field: The field to group by.

group_bys(fields)
  - Adds multiple fields to the GROUP BY clause.
  - Parameters:
    - fields: An array of fields to group by.

having(condition)
  - Adds a HAVING condition to the query.
  - Parameters:
    - condition: The HAVING condition.

int(field)
  - Casts a field to integer.
  - Parameters:
    - field: The field to cast.

join(table, condition)
  - Adds a JOIN clause to the query.
  - Parameters:
    - table: The table to join.
    - condition: The join condition.

joins(joins)
  - Adds multiple JOIN clauses to the query.
  - Parameters:
    - joins: An array of join definitions.

limit(count)
  - Sets the limit for the query.
  - Parameters:
    - count: The maximum number of rows to return.

new()
  - Creates a new Select query builder.

no_comment()
  - Removes any SQL comment.

no_epilog()
  - Removes the query epilog.

no_from()
  - Removes the source table or subquery.

no_group_by()
  - Removes all GROUP BY clauses.

no_having()
  - Removes all HAVING conditions.

no_join()
  - Removes all JOIN clauses.

no_limit()
  - Removes the query limit.

no_offset()
  - Removes the query offset.

no_order_by()
  - Removes all ORDER BY clauses.

no_where()
  - Removes all WHERE conditions.

null(field)
  - Casts a field to NULL.
  - Parameters:
    - field: The field to cast.

offset(count)
  - Sets the offset for the query.
  - Parameters:
    - count: The number of rows to skip.

or_having(condition)
  - Adds an OR condition to the HAVING clause.
  - Parameters:
    - condition: The OR HAVING condition.

or_where(condition)
  - Adds an OR condition to the WHERE clause.
  - Parameters:
    - condition: The OR WHERE condition.

order_by(field, direction)
  - Adds a field to the ORDER BY clause.
  - Parameters:
    - field: The field to order by.
    - direction: The ordering direction ('ASC' or 'DESC').

order_by_asc(field)
  - Adds a field to the ORDER BY clause in ascending order.
  - Parameters:
    - field: The field to order by.

order_by_asc_nulls_first(field)
  - Adds a field to the ORDER BY clause in ascending order with NULLs first.
  - Parameters:
    - field: The field to order by.

order_by_asc_nulls_last(field)
  - Adds a field to the ORDER BY clause in ascending order with NULLs last.
  - Parameters:
    - field: The field to order by.

order_by_desc(field)
  - Adds a field to the ORDER BY clause in descending order.
  - Parameters:
    - field: The field to order by.

order_by_desc_nulls_first(field)
  - Adds a field to the ORDER BY clause in descending order with NULLs first.
  - Parameters:
    - field: The field to order by.

order_by_desc_nulls_last(field)
  - Adds a field to the ORDER BY clause in descending order with NULLs last.
  - Parameters:
    - field: The field to order by.

replace_group_by(field, new_field)
  - Replaces a field in the GROUP BY clause.
  - Parameters:
    - field: The field to replace.
    - new_field: The new field.

replace_group_bys(fields)
  - Replaces all fields in the GROUP BY clause.
  - Parameters:
    - fields: An array of new fields.

replace_having(condition, new_condition)
  - Replaces a HAVING condition.
  - Parameters:
    - condition: The condition to replace.
    - new_condition: The new condition.

replace_join(table, condition, new_table, new_condition)
  - Replaces a JOIN clause.
  - Parameters:
    - table: The table to replace.
    - condition: The condition to replace.
    - new_table: The new table.
    - new_condition: The new condition.

replace_joins(joins)
  - Replaces all JOIN clauses.
  - Parameters:
    - joins: An array of new join definitions.

replace_order_by(field, direction, new_field, new_direction)
  - Replaces a field in the ORDER BY clause.
  - Parameters:
    - field: The field to replace.
    - direction: The direction to replace.
    - new_field: The new field.
    - new_direction: The new direction.

replace_order_by_asc(field, new_field)
  - Replaces a field in the ORDER BY clause with ascending order.
  - Parameters:
    - field: The field to replace.
    - new_field: The new field.

replace_order_by_asc_nulls_first(field, new_field)
  - Replaces a field in the ORDER BY clause with ascending order and NULLs first.
  - Parameters:
    - field: The field to replace.
    - new_field: The new field.

replace_order_by_asc_nulls_last(field, new_field)
  - Replaces a field in the ORDER BY clause with ascending order and NULLs last.
  - Parameters:
    - field: The field to replace.
    - new_field: The new field.

replace_order_by_desc(field, new_field)
  - Replaces a field in the ORDER BY clause with descending order.
  - Parameters:
    - field: The field to replace.
    - new_field: The new field.

replace_order_by_desc_nulls_first(field, new_field)
  - Replaces a field in the ORDER BY clause with descending order and NULLs first.
  - Parameters:
    - field: The field to replace.
    - new_field: The new field.

replace_order_by_desc_nulls_last(field, new_field)
  - Replaces a field in the ORDER BY clause with descending order and NULLs last.
  - Parameters:
    - field: The field to replace.
    - new_field: The new field.

where(condition)
  - Adds a WHERE condition to the query.
  - Parameters:
    - condition: The WHERE condition.

```

--------------------------------

### Cake Select Value Creation Functions

Source: https://hexdocs.pm/cake/2.1.3/cake/select

Provides functions to create `SelectValue` instances from various data types. These functions are essential for building the selection list in a SQL query.

```APIDOC
alias(value: SelectValue, alias: String) -> SelectValue
  Creates an alias off a String.

bool(value: Bool) -> SelectValue
  Creates a boolean `Param` off a `Bool`.

col(name: String) -> SelectValue
  Creates a column identifier off a `String`.

fragment(fragment: Fragment) -> SelectValue
  Creates a `SelectFragment` off a `Fragment`.

float(value: Float) -> SelectValue
  Creates a float `Param` off a `Float`.
```

--------------------------------

### PostgreSQL Dialect Value Conversions

Source: https://hexdocs.pm/cake/2.1.3/cake/dialect/postgres_dialect

Provides functions to convert Cake query types into PostgreSQL-specific prepared statements. These functions are crucial for executing queries against a PostgreSQL database.

```APIDOC
cake_query_to_prepared_statement(query qry: CakeQuery(a)) -> PreparedStatement
  Converts a cake query to a 🐘PostgreSQL prepared statement.

read_query_to_prepared_statement(query qry: ReadQuery) -> PreparedStatement
  Converts read query to a 🐘PostgreSQL prepared statement.
```

--------------------------------

### MariaDB Dialect Value Conversions

Source: https://hexdocs.pm/cake/2.1.3/cake/dialect/maria_dialect

Provides functions to convert Cake query structures into MariaDB-specific prepared statements. These functions are crucial for preparing queries for execution against a MariaDB database, ensuring proper formatting and parameter handling.

```APIDOC
cake_query_to_prepared_statement(query qry: [cake.CakeQuery](https://hexdocs.pm/cake/2.1.3/cake.html#CakeQuery "cake.{type CakeQuery}")(a)) -> @internal PreparedStatement
  Converts a cake query to a 🦭MariaDB prepared statement.

read_query_to_prepared_statement(query qry: @internal ReadQuery) -> @internal PreparedStatement
  Converts read query to a 🦭MariaDB prepared statement.
```

--------------------------------

### Convert Insert to Write Query

Source: https://hexdocs.pm/cake/2.1.3/cake/insert

Transforms an `Insert` query builder into a `WriteQuery` object, preparing it for execution against the database. This is typically the final step before executing the insert operation.

```gleam
pub fn to_query(
  insert isrt: @internal Insert(a),
) -> @internal WriteQuery(a)
```

--------------------------------

### Write Query to Prepared Statement (PostgreSQL)

Source: https://hexdocs.pm/cake/2.1.3/cake/dialect/postgres_dialect

Converts a write query into a PostgreSQL prepared statement. This function is part of the PostgreSQL dialect in the Cake library.

```gleam
pub fn write_query_to_prepared_statement(
  query qry: @internal WriteQuery(a),
) -> @internal PreparedStatement
```

--------------------------------

### Write Query to MariaDB Prepared Statement

Source: https://hexdocs.pm/cake/2.1.3/cake/dialect/maria_dialect

Converts a write query into a MariaDB prepared statement. This function is part of the MariaDB dialect in the Cake library.

```gleam
pub fn write_query_to_prepared_statement(
  query qry: @internal WriteQuery(a),
) -> @internal PreparedStatement
```

--------------------------------

### Comparison and Pattern Matching

Source: https://hexdocs.pm/cake/2.1.3/cake/where

Functions for creating WHERE clauses based on comparisons and pattern matching. `is_true` checks if a value is True, `like` matches a value against a pattern (supporting '%' and '_'), `lt` checks for less than, `lte` checks for less than or equal to.

```APIDOC
is_true(value: WhereValue) -> Where
  Creates a WHERE clause that checks if a WhereValue is True.

like(value: WhereValue, pattern: String) -> Where
  Creates a WHERE clause that checks if a WhereValue matches a pattern. The pattern can contain for example the following wildcards:
    * % matches any sequence of characters.
    * _ matches any single character.

lt(value_a: WhereValue, value_b: WhereValue) -> Where
  Creates a WHERE clause that checks if a WhereValue lower than another WhereValue.

lt_all_query(value: WhereValue, sub_query: ReadQuery) -> Where
  Creates a WHERE clause that checks if a WhereValue is lower than all in a sub-query.
  NOTICE: Not supported by 🪶SQLite.

lt_any_query(value: WhereValue, sub_query: ReadQuery) -> Where
  Creates a WHERE clause that checks if a WhereValue is lower than an any in a sub-query.
  NOTICE: Not supported by 🪶SQLite.


lte(value_a: WhereValue, value_b: WhereValue) -> Where
  Creates a WHERE clause that checks if a WhereValue lower or equal to another WhereValue.

lte_all_query(value: WhereValue, sub_query: ReadQuery) -> Where
  Creates a WHERE clause that checks if a WhereValue is lower or equal to all in a sub-query.
  NOTICE: Not supported by 🪶SQLite.

lte_any_query(value: WhereValue, sub_query: ReadQuery) -> Where
  Creates a WHERE clause that checks if a WhereValue is lower or equal to any in a sub-query.
  NOTICE: Not supported by 🪶SQLite.
```

--------------------------------

### Cake SQL Dialect Implementations

Source: https://hexdocs.pm/cake/2.1.3/cake/insert

Cake provides specific implementations for different SQL dialects to ensure compatibility and proper query generation. This includes support for MariaDB, MySQL, PostgreSQL, and SQLite. These modules handle dialect-specific syntax and features.

```elixir
cake/dialect/maria_dialect.ex
cake/dialect/mysql_dialect.ex
cake/dialect/postgres_dialect.ex
cake/dialect/sqlite_dialect.ex
```
Tokens:
Raw