cake

Cake is an SQL query building library for RDBMS:

• 🐘PostgreSQL
• 🪶SQLite
• 🦭MariaDB
• 🐬MySQL

For examples see the tests.

Summary

Cake is a composable SQL query-building library for Gleam. It targets four major RDBMS dialects — 🐘 PostgreSQL, 🪶 SQLite, 🦭 MariaDB, and 🐬 MySQL — and produces prepared statements (parameterised SQL + typed parameter lists) that are safe from SQL injection. Cake does not execute queries or decode result rows; it hands a PreparedStatement to a dialect adapter library that does so.

Module Overview

Dialect helpers live under cake/dialect/:

Recommended Imports

import cake
import cake/select as s
import cake/insert as i
import cake/update as u
import cake/delete as d
import cake/combined as c
import cake/where as w
import cake/join as j
import cake/fragment as f
import cake/param as p

Query Flow

Every query is built using a pipeline of builder functions that accumulate clauses, then converted to a ReadQuery or WriteQuery for execution via your chosen adapter.

flowchart TD
    A[new] --> B[add clauses]
    B --> C[to_query]
    C --> D{query type}
    D -->|ReadQuery| E[adapter: run_read_query]
    D -->|WriteQuery| F[adapter: run_write_query]
    E --> G[decode results]
    F --> H[inspect returning / rows affected]

Quick Example

import cake/select as s
import cake/where as w

s.new()
|> s.from_table("users")
|> s.col("id")
|> s.col("name")
|> s.where(w.eq(w.col("active"), w.bool(True)))
|> s.order_by_asc("name")
|> s.limit(10)
|> s.to_query

Generates:

SELECT id, name FROM users WHERE active = $1 ORDER BY name ASC LIMIT 10

How It Works

Build query  →  call to_query()  →  call to_prepared_statement()  →  pass to adapter

1. Build – use one of the query-builder modules (select, insert, update, delete, combined) to assemble a typed query value.
2. Compile – call cake.to_prepared_statement(query, dialect) (or the dialect-specific helper) to get a PreparedStatement.
3. Execute – extract cake.get_sql(ps) and cake.get_params(ps) and pass them to the appropriate adapter.

cake — Core

Key types re-exported for adapter use:

Key functions:

cake/select — SELECT Queries

Build SELECT statements. All builder functions return a new Select, making them pipeable.

Constructors

Column selection

FROM clause

Filtering

Aggregation

Joins

Ordering, paging, extras

cake/insert — INSERT Queries

Constructors

Row / value helpers

Configuration

Conflict handling (upsert)

Returning / extras

cake/update — UPDATE Queries

Constructor

SET clause

FROM, JOIN, WHERE, RETURNING, extras

Same API shape as cake/select — from_table, from_sub_query, no_from, join, where, or_where, xor_where, not_where, replace_where, no_where, returning, no_returning, epilog, comment, etc.

Note: RETURNING is not supported on 🦭 MariaDB or 🐬 MySQL for UPDATE.

cake/delete — DELETE Queries

Constructor

Configuration

JOIN, WHERE, RETURNING, extras

Same API shape as cake/update — join, where, or_where, xor_where, not_where, replace_where, no_where, returning, no_returning, epilog, comment, etc.

Note: 🪶 SQLite does not support USING. RETURNING is not supported on 🦭 MariaDB or 🐬 MySQL for DELETE.

cake/combined — UNION / EXCEPT / INTERSECT

Combines two or more Select queries.

Supports limit, offset, order_by_*, epilog, and comment with the same API as cake/select.

cake/where — WHERE / HAVING Conditions

Used to build WHERE clauses (and HAVING clauses, which share the same type).

Value constructors

Logical combinators

Comparisons

eq, neq, lt, lte, gt, gte — compare two WhereValues.

eq_any_query, lt_any_query, lte_any_query, gt_any_query, gte_any_query, neq_any_query — compare against ANY result of a sub-query (not 🪶 SQLite).

eq_all_query, lt_all_query, lte_all_query, gt_all_query, gte_all_query, neq_all_query — compare against ALL results of a sub-query (not 🪶 SQLite).

Other predicates

cake/join — JOIN Clauses

Join target constructors

Join kind constructors

cake/fragment — Raw SQL Fragments

Fragments allow injecting custom SQL into a query while keeping parameter binding safe.

cake/param — Typed Parameters

Param is the boxed value type used in prepared statements.

Dialect Compatibility Summary

pub type CakeQuery(a) {
  CakeReadQuery(query: ReadQuery)
  CakeWriteQuery(query: WriteQuery(a))
}

pub type Dialect =
  @internal Dialect

pub type PreparedStatement =
  @internal PreparedStatement

pub type ReadQuery =
  @internal ReadQuery

pub type WriteQuery(a) =
  @internal WriteQuery(a)

pub fn get_params(
  prepared_statement prepared_statement: PreparedStatement,
) -> List(param.Param)

pub fn get_sql(
  prepared_statement prepared_statement: PreparedStatement,
) -> String

pub fn main() -> Nil

pub fn read_query_to_prepared_statement(
  query query: ReadQuery,
  dialect dialect: Dialect,
) -> PreparedStatement

pub fn to_prepared_statement(
  query query: CakeQuery(a),
  dialect dialect: Dialect,
) -> PreparedStatement

pub fn to_read_query(query query: ReadQuery) -> CakeQuery(a)

pub fn to_write_query(query query: WriteQuery(a)) -> CakeQuery(a)

pub fn write_query_to_prepared_statement(
  query query: WriteQuery(a),
  dialect dialect: Dialect,
) -> PreparedStatement