-module(cake@select).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/cake/select.gleam").
-export([to_query/1, col/1, alias/2, bool/1, float/1, int/1, string/1, date/1, null/0, fragment/1, new/0, all/1, distinct/1, get_kind/1, from_table/2, from_query/3, no_from/1, get_from/1, select_col/2, select/2, replace_select/2, replace_select_col/2, selects/2, select_cols/2, replace_selects/2, replace_select_cols/2, get_select/1, join/2, replace_join/2, joins/2, replace_joins/2, no_join/1, get_joins/1, where/2, or_where/2, xor_where/2, not_where/2, replace_where/2, no_where/1, get_where/1, having/2, or_having/2, xor_having/2, not_having/2, replace_having/2, no_having/1, get_having/1, group_by/2, replace_group_by/2, group_bys/2, replace_group_bys/2, no_group_by/1, get_group_by/1, limit/2, no_limit/1, get_limit/1, offset/2, no_offset/1, get_offset/1, order_by_asc/2, order_by_asc_nulls_first/2, order_by_asc_nulls_last/2, replace_order_by_asc/2, replace_order_by_asc_nulls_first/2, replace_order_by_asc_nulls_last/2, order_by_desc/2, order_by_desc_nulls_first/2, order_by_desc_nulls_last/2, replace_order_by_desc/2, replace_order_by_desc_nulls_first/2, replace_order_by_desc_nulls_last/2, order_by/3, replace_order_by/3, no_order_by/1, get_order_by/1, epilog/2, no_epilog/1, get_epilog/1, comment/2, no_comment/1, get_comment/1]).
-export_type([direction/0]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC(
    " A DSL to build `SELECT` queries.\n"
    "\n"
    " ## Aliases\n"
    "\n"
    " ```gleam\n"
    " import cake/select as s\n"
    " import cake/where as w\n"
    " import cake/join as j\n"
    " ```\n"
    "\n"
    " ---\n"
    "\n"
    " ## Query Lifecycle\n"
    "\n"
    " ```mermaid\n"
    " flowchart LR\n"
    "     A[s.new] --> B[s.from_table / s.from_query]\n"
    "     B --> C[s.col / s.select]\n"
    "     C --> D[s.join]\n"
    "     D --> E[s.where]\n"
    "     E --> F[s.group_by / s.having]\n"
    "     F --> G[s.order_by_asc / s.order_by_desc]\n"
    "     G --> H[s.limit / s.offset]\n"
    "     H --> I[s.to_query]\n"
    " ```\n"
    "\n"
    " ---\n"
    "\n"
    " ## Constructor\n"
    "\n"
    " ### `new() -> Select`\n"
    "\n"
    " Creates an empty `Select` query. All clauses are unset by default\n"
    " (`SELECT ALL`, no `FROM`, no `WHERE`, etc.).\n"
    "\n"
    " ```gleam\n"
    " s.new()\n"
    " ```\n"
    "\n"
    " ### `to_query(select: Select) -> ReadQuery`\n"
    "\n"
    " Converts a `Select` into a `ReadQuery` suitable for passing to an adapter.\n"
    "\n"
    " ```gleam\n"
    " s.new()\n"
    " |> s.from_table(\"users\")\n"
    " |> s.to_query\n"
    " ```\n"
    "\n"
    " ---\n"
    "\n"
    " ## SELECT values\n"
    "\n"
    " These functions create `SelectValue`s — the individual expressions that appear\n"
    " between `SELECT` and `FROM`.\n"
    "\n"
    " | Function          | SQL equivalent        |\n"
    " | ----------        | ----------            |\n"
    " | `col(\"table.column\")`   | `table.column`        |\n"
    " | `alias(value, \"alias\")` | `expression AS alias` |\n"
    " | `bool(True)`            | `TRUE` (as param)     |\n"
    " | `float(3.14)`           | `3.14` (as param)     |\n"
    " | `int(42)`               | `42` (as param)       |\n"
    " | `string(\"hi\")`          | `'hi'` (as param)     |\n"
    " | `date(d)`               | date param            |\n"
    " | `null()`                | `NULL`                |\n"
    " | `fragment(f)`           | raw SQL fragment      |\n"
    "\n"
    " ### Examples\n"
    "\n"
    " ```gleam\n"
    " // Simple column\n"
    " s.col(\"users.name\")\n"
    "\n"
    " // Column with alias\n"
    " s.col(\"users.name\") |> s.alias(\"full_name\")\n"
    "\n"
    " // Literal integer\n"
    " s.int(1)\n"
    "\n"
    " // Fragment-based expression (e.g. database function)\n"
    " import cake/fragment as f\n"
    " s.fragment(f.literal(\"NOW()\"))\n"
    " ```\n"
    "\n"
    " ---\n"
    "\n"
    " ## Adding columns to the SELECT list\n"
    "\n"
    " ### `select_col(select, name) -> Select`\n"
    "\n"
    " Appends a bare column name to the projection list.\n"
    "\n"
    " ```gleam\n"
    " s.new()\n"
    " |> s.col(\"id\")\n"
    " |> s.col(\"name\")\n"
    " ```\n"
    "\n"
    " ### `select(select, select_value) -> Select`\n"
    "\n"
    " Appends any `SelectValue` (including aliases and fragments).\n"
    "\n"
    " ```gleam\n"
    " s.new()\n"
    " |> s.select(s.col(\"id\") |> s.alias(\"user_id\"))\n"
    " |> s.select(s.fragment(f.literal(\"COUNT(*)\")))\n"
    " ```\n"
    "\n"
    " ### `select_cols(select, names) -> Select`\n"
    "\n"
    " ### `selects(select, select_values) -> Select`\n"
    "\n"
    " Append multiple columns or values at once.\n"
    "\n"
    " ```gleam\n"
    " s.new()\n"
    " |> s.select_cols([\"id\", \"name\", \"email\"])\n"
    " ```\n"
    "\n"
    " ### Replace variants\n"
    "\n"
    " Use the `replace_*` variants to discard any previously added values:\n"
    "\n"
    " | Function                             | Effect                             |\n"
    " | ----------                           | ----------                         |\n"
    " | `replace_select_col(select, name)`   | Replace all with one column        |\n"
    " | `replace_select(select, value)`      | Replace all with one value         |\n"
    " | `replace_select_cols(select, names)` | Replace all with a list of columns |\n"
    " | `replace_selects(select, values)`    | Replace all with a list of values  |\n"
    "\n"
    " ---\n"
    "\n"
    " ## FROM clause\n"
    "\n"
    " ### `from_table(select, name) -> Select`\n"
    "\n"
    " ```gleam\n"
    " s.new() |> s.from_table(\"users\")\n"
    " // FROM users\n"
    " ```\n"
    "\n"
    " ### `from_query(select, sub_query, alias) -> Select`\n"
    "\n"
    " Use an aliased sub-query as the source.\n"
    "\n"
    " ```gleam\n"
    " let sub =\n"
    "   s.new()\n"
    "   |> s.from_table(\"orders\")\n"
    "   |> s.col(\"user_id\")\n"
    "   |> s.to_query\n"
    "\n"
    " s.new()\n"
    " |> s.from_query(sub, \"recent_orders\")\n"
    " |> s.col(\"user_id\")\n"
    " // FROM (SELECT user_id FROM orders) AS recent_orders\n"
    " ```\n"
    "\n"
    " ### `no_from(select) -> Select`\n"
    "\n"
    " Removes the `FROM` clause (useful for `SELECT 1` style queries).\n"
    "\n"
    " ---\n"
    "\n"
    " ## SELECT DISTINCT\n"
    "\n"
    " ```gleam\n"
    " s.new() |> s.distinct   // SELECT DISTINCT ...\n"
    " s.new() |> s.all        // SELECT ALL ... (default)\n"
    " ```\n"
    "\n"
    " ---\n"
    "\n"
    " ## JOIN\n"
    "\n"
    " See the [`cake/join`](join.md) module for building `Join` values.\n"
    "\n"
    " ```mermaid\n"
    " flowchart LR\n"
    "     A[j.table / j.sub_query] --> B[j.inner / j.left / j.right / j.full / j.cross]\n"
    "     B --> C[s.join]\n"
    " ```\n"
    "\n"
    " ### `join(select, join) -> Select`\n"
    "\n"
    " Appends a single `Join`.\n"
    "\n"
    " ```gleam\n"
    " import cake/join as j\n"
    "\n"
    " s.new()\n"
    " |> s.from_table(\"orders\")\n"
    " |> s.join(j.inner(\n"
    "   with: j.table(\"users\"),\n"
    "   on: w.eq(w.col(\"orders.user_id\"), w.col(\"users.id\")),\n"
    "   alias: \"users\",\n"
    " ))\n"
    " ```\n"
    "\n"
    " ### `joins(select, joins) -> Select`\n"
    "\n"
    " Appends multiple `Join`s.\n"
    "\n"
    " ### Replace / remove variants\n"
    "\n"
    " | Function             | Effect                     |\n"
    " | ----------           | ------                     |\n"
    " | `replace_join(select, join)`   | Replace all joins with one |\n"
    " | `replace_joins(select, joins)` | Replace all joins          |\n"
    " | `no_join(select)`              | Remove all joins           |\n"
    "\n"
    " ---\n"
    "\n"
    " ## WHERE clause\n"
    "\n"
    " See [`cake/where`](where.md) for building `Where` values.\n"
    "\n"
    " ### `where(select, where) -> Select`\n"
    "\n"
    " Adds a condition with `AND` semantics. If the current outermost clause is\n"
    " already an `AndWhere`, the new condition is appended to it.\n"
    "\n"
    " ```gleam\n"
    " s.new()\n"
    " |> s.from_table(\"users\")\n"
    " |> s.where(w.eq(w.col(\"active\"), w.bool(True)))\n"
    " |> s.where(w.gt(w.col(\"age\"), w.int(18)))\n"
    " // WHERE active = $1 AND age > $2\n"
    " ```\n"
    "\n"
    " ### `or_where(select, where) -> Select`\n"
    "\n"
    " Combines with `OR` semantics.\n"
    "\n"
    " ```gleam\n"
    " s.new()\n"
    " |> s.from_table(\"users\")\n"
    " |> s.or_where(w.eq(w.col(\"role\"), w.string(\"admin\")))\n"
    " |> s.or_where(w.eq(w.col(\"role\"), w.string(\"mod\")))\n"
    " // WHERE role = $1 OR role = $2\n"
    " ```\n"
    "\n"
    " ### `xor_where(select, where) -> Select`\n"
    "\n"
    " Combines with exactly-one-true `XOR` semantics. Implemented via a custom\n"
    " `OR / AND / NOT` expansion on all adapters — native `XOR` is not used on any\n"
    " adapter, including 🦭 MariaDB / 🐬 MySQL.\n"
    "\n"
    " > For odd-parity XOR (matching 🦭 MariaDB / 🐬 MySQL native `XOR`), use\n"
    " > `w.xor_parity` instead.\n"
    "\n"
    " ### `not_where(select, where) -> Select`\n"
    "\n"
    " Negates the given condition with `NOT` and combines with `AND` semantics.\n"
    "\n"
    " - If there is no current WHERE, the condition is set as a standalone `NOT`.\n"
    " - If the outermost WHERE is an `AndWhere`, the negated condition is appended to it.\n"
    " - Otherwise, the existing WHERE and the new `NOT` condition are wrapped in an `AndWhere`.\n"
    "\n"
    " ```gleam\n"
    " s.new()\n"
    " |> s.from_table(\"users\")\n"
    " |> s.where(w.eq(w.col(\"active\"), w.bool(True)))\n"
    " |> s.not_where(w.eq(w.col(\"role\"), w.string(\"banned\")))\n"
    " // WHERE active = $1 AND NOT role = $2\n"
    " ```\n"
    "\n"
    " ### Replace / remove variants\n"
    "\n"
    " | Function             | Effect                      |\n"
    " | ----------           | ------                      |\n"
    " | `replace_where(select, where)` | Replace entire WHERE clause |\n"
    " | `no_where(select)`             | Remove WHERE clause         |\n"
    "\n"
    " ---\n"
    "\n"
    " ## GROUP BY / HAVING\n"
    "\n"
    " ### `group_by(select, column) -> Select`\n"
    "\n"
    " ### `group_bys(select, columns) -> Select`\n"
    "\n"
    " ```gleam\n"
    " s.new()\n"
    " |> s.from_table(\"orders\")\n"
    " |> s.col(\"user_id\")\n"
    " |> s.select(s.fragment(f.literal(\"SUM(amount)\")) |> s.alias(\"total\"))\n"
    " |> s.group_by(\"user_id\")\n"
    " // GROUP BY user_id\n"
    " ```\n"
    "\n"
    " ### `having(select, where) -> Select`\n"
    "\n"
    " ### `or_having(select, where) -> Select`\n"
    "\n"
    " ### `xor_having(select, where) -> Select`\n"
    "\n"
    " `HAVING` works identically to `WHERE` but filters _after_ aggregation.\n"
    " Build the condition with the same `cake/where` functions.\n"
    "\n"
    " ```gleam\n"
    " s.new()\n"
    " |> s.from_table(\"orders\")\n"
    " |> s.group_by(\"user_id\")\n"
    " |> s.having(w.gt(\n"
    "   w.fragment_value(f.literal(\"SUM(amount)\")),\n"
    "   w.int(100),\n"
    " ))\n"
    " // HAVING SUM(amount) > $1\n"
    " ```\n"
    "\n"
    " > **Note:** `cake/having` is a thin placeholder module. Use `cake/where` to\n"
    " > build `Having` conditions — the types are identical.\n"
    "\n"
    " ### Replace / remove variants\n"
    "\n"
    " | Function                          | Effect                           |\n"
    " | --------------------------------- | -------------------------------- |\n"
    " | `replace_group_by(select, col)`   | Replace GROUP BY with one column |\n"
    " | `replace_group_bys(select, cols)` | Replace GROUP BY with list       |\n"
    " | `no_group_by(select)`             | Remove GROUP BY                  |\n"
    " | `replace_having(select, where)`   | Replace HAVING clause            |\n"
    " | `no_having(select)`               | Remove HAVING clause             |\n"
    "\n"
    " ---\n"
    "\n"
    " ## ORDER BY\n"
    "\n"
    " ```mermaid\n"
    " flowchart LR\n"
    "     A[order_by_asc] --> B[ASC]\n"
    "     C[order_by_asc_nulls_first] --> D[ASC NULLS FIRST]\n"
    "     E[order_by_asc_nulls_last] --> F[ASC NULLS LAST]\n"
    "     G[order_by_desc] --> H[DESC]\n"
    "     I[order_by_desc_nulls_first] --> J[DESC NULLS FIRST]\n"
    "     K[order_by_desc_nulls_last] --> L[DESC NULLS LAST]\n"
    " ```\n"
    "\n"
    " | Function                                 | Notes                                  |\n"
    " | ---------------------------------------- | -------------------------------------- |\n"
    " | `order_by_asc(select, col)`              | Append ASC order                       |\n"
    " | `order_by_asc_nulls_first(select, col)`  | Not supported by 🦭 MariaDB / 🐬 MySQL |\n"
    " | `order_by_asc_nulls_last(select, col)`   | Not supported by 🦭 MariaDB / 🐬 MySQL |\n"
    " | `order_by_desc(select, col)`             | Append DESC order                      |\n"
    " | `order_by_desc_nulls_first(select, col)` | Not supported by 🦭 MariaDB / 🐬 MySQL |\n"
    " | `order_by_desc_nulls_last(select, col)`  | Not supported by 🦭 MariaDB / 🐬 MySQL |\n"
    " | `replace_order_by_asc(select, col)`      | Replace all order-bys                  |\n"
    " | `no_order_by(select)`                    | Remove ORDER BY                        |\n"
    "\n"
    " ### Custom direction\n"
    "\n"
    " ```gleam\n"
    " s.order_by(select, order_by: \"name\", direction: s.Asc)\n"
    " s.order_by(select, order_by: \"created_at\", direction: s.Desc)\n"
    " ```\n"
    "\n"
    " ---\n"
    "\n"
    " ## LIMIT and OFFSET\n"
    "\n"
    " ```gleam\n"
    " s.new()\n"
    " |> s.from_table(\"users\")\n"
    " |> s.limit(20)\n"
    " |> s.offset(40)\n"
    " // LIMIT 20 OFFSET 40\n"
    " ```\n"
    "\n"
    " | Function            | Effect        |\n"
    " | ------------------- | ------------- |\n"
    " | `limit(select, n)`  | Set LIMIT     |\n"
    " | `no_limit(select)`  | Remove LIMIT  |\n"
    " | `offset(select, n)` | Set OFFSET    |\n"
    " | `no_offset(select)` | Remove OFFSET |\n"
    "\n"
    " ---\n"
    "\n"
    " ## Epilog and Comment\n"
    "\n"
    " An **epilog** is appended verbatim to the end of the generated SQL.\n"
    " A **comment** is placed at the very end, typically rendered as a SQL comment.\n"
    "\n"
    " ```gleam\n"
    " s.new()\n"
    " |> s.from_table(\"users\")\n"
    " |> s.epilog(\"FOR UPDATE\")\n"
    " |> s.comment(\"fetching locked rows\")\n"
    " // SELECT ... FROM users FOR UPDATE -- fetching locked rows\n"
    " ```\n"
    "\n"
    " ---\n"
    "\n"
    " ## Full Example\n"
    "\n"
    " ```gleam\n"
    " import cake/select as s\n"
    " import cake/where as w\n"
    " import cake/join as j\n"
    " import cake/fragment as f\n"
    "\n"
    " s.new()\n"
    " |> s.from_table(\"orders\")\n"
    " |> s.select_cols([\"orders.id\", \"users.name\"])\n"
    " |> s.select(\n"
    "   s.fragment(f.literal(\"SUM(orders.amount)\")) |> s.alias(\"total\"),\n"
    " )\n"
    " |> s.join(j.inner(\n"
    "   with: j.table(\"users\"),\n"
    "   on: w.eq(w.col(\"orders.user_id\"), w.col(\"users.id\")),\n"
    "   alias: \"users\",\n"
    " ))\n"
    " |> s.where(w.eq(w.col(\"orders.status\"), w.string(\"paid\")))\n"
    " |> s.group_by(\"orders.id\")\n"
    " |> s.group_by(\"users.name\")\n"
    " |> s.having(w.gt(\n"
    "   w.fragment_value(f.literal(\"SUM(orders.amount)\")),\n"
    "   w.int(0),\n"
    " ))\n"
    " |> s.order_by_desc(\"total\")\n"
    " |> s.limit(5)\n"
    " |> s.to_query\n"
    " ```\n"
    "\n"
    "\n"
    " <!-- html assets for docs gen -->\n"
    " <style>\n"
    "  .page {\n"
    "    display: block;\n"
    "  }\n"
    "  .content {\n"
    "    width: auto;\n"
    "    max-width: none;\n"
    "  }\n"
    " </style>\n"
    " <!--<script src=\"https://cdn.jsdelivr.net/npm/@mermaid-js/tiny@11/dist/mermaid.tiny.js\"></script>-->\n"
    " <script\n"
    "   src=\"https://cdn.jsdelivr.net/npm/mermaid/dist/mermaid.min.js\"\n"
    "   integrity=\"sha256-cBN+d7snO7LvlyuG6LBADMqL5TyyW/xFkRoYbcmGZd4=\"\n"
    "   crossorigin=\"anonymous\"\n"
    " ></script>\n"
    " <script>\n"
    " (callback => document.readyState !== 'loading' ? callback() : document.addEventListener('DOMContentLoaded', callback, { once: true }))(() => {\n"
    "   mermaid.initialize({ startOnLoad: false })\n"
    "   mermaid.run({\n"
    "     querySelector: \".language-mermaid\",\n"
    "   })\n"
    " })\n"
    " </script>\n"
    "\n"
).

-type direction() :: asc | desc.

-file("src/cake/select.gleam", 523).
?DOC(" Creates a `ReadQuery` from a `Select` query.\n").
-spec to_query(cake@internal@read_query:select()) -> cake@internal@read_query:read_query().
to_query(Select) ->
    _pipe = Select,
    {select_query, _pipe}.

-file("src/cake/select.gleam", 529).
?DOC(" Creates a column `SelectValue` from a `String`.\n").
-spec col(binary()) -> cake@internal@read_query:select_value().
col(Name) ->
    _pipe = Name,
    {select_column, _pipe}.

-file("src/cake/select.gleam", 535).
?DOC(" Creates an alias `SelectValue` from `String`.\n").
-spec alias(cake@internal@read_query:select_value(), binary()) -> cake@internal@read_query:select_value().
alias(Value, Alias) ->
    _pipe = Value,
    {select_alias, _pipe, Alias}.

-file("src/cake/select.gleam", 541).
?DOC(" Creates a `SelectValue` from a `Bool`.\n").
-spec bool(boolean()) -> cake@internal@read_query:select_value().
bool(Value) ->
    _pipe = Value,
    _pipe@1 = {bool_param, _pipe},
    {select_param, _pipe@1}.

-file("src/cake/select.gleam", 547).
?DOC(" Creates a `SelectValue` from a `Float`.\n").
-spec float(float()) -> cake@internal@read_query:select_value().
float(Value) ->
    _pipe = Value,
    _pipe@1 = {float_param, _pipe},
    {select_param, _pipe@1}.

-file("src/cake/select.gleam", 553).
?DOC(" Creates a `SelectValue` from an `Int`.\n").
-spec int(integer()) -> cake@internal@read_query:select_value().
int(Value) ->
    _pipe = Value,
    _pipe@1 = {int_param, _pipe},
    {select_param, _pipe@1}.

-file("src/cake/select.gleam", 559).
?DOC(" Creates a `SelectValue` from a `String`.\n").
-spec string(binary()) -> cake@internal@read_query:select_value().
string(Value) ->
    _pipe = Value,
    _pipe@1 = {string_param, _pipe},
    {select_param, _pipe@1}.

-file("src/cake/select.gleam", 565).
?DOC(" Creates a `SelectValue` from a `calendar.Date`.\n").
-spec date(gleam@time@calendar:date()) -> cake@internal@read_query:select_value().
date(Value) ->
    _pipe = Value,
    _pipe@1 = {date_param, _pipe},
    {select_param, _pipe@1}.

-file("src/cake/select.gleam", 571).
?DOC(" Creates an SQL `NULL` `Param`.\n").
-spec null() -> cake@internal@read_query:select_value().
null() ->
    _pipe = null_param,
    {select_param, _pipe}.

-file("src/cake/select.gleam", 576).
?DOC(" Creates a `SelectFragment` off a `Fragment`.\n").
-spec fragment(cake@internal@read_query:fragment()) -> cake@internal@read_query:select_value().
fragment(Fragment) ->
    _pipe = Fragment,
    {select_fragment, _pipe}.

-file("src/cake/select.gleam", 584).
?DOC(" Creates an empty `Select` query.\n").
-spec new() -> cake@internal@read_query:select().
new() ->
    {select,
        select_all,
        no_selects,
        no_from,
        no_joins,
        no_where,
        no_group_by,
        no_where,
        no_order_by,
        no_limit,
        no_offset,
        no_epilog,
        no_comment}.

-file("src/cake/select.gleam", 606).
?DOC(
    " Sets the kind of the `Select` query to\n"
    " return duplicates which is the default.\n"
).
-spec all(cake@internal@read_query:select()) -> cake@internal@read_query:select().
all(Select) ->
    {select,
        select_all,
        erlang:element(3, Select),
        erlang:element(4, Select),
        erlang:element(5, Select),
        erlang:element(6, Select),
        erlang:element(7, Select),
        erlang:element(8, Select),
        erlang:element(9, Select),
        erlang:element(10, Select),
        erlang:element(11, Select),
        erlang:element(12, Select),
        erlang:element(13, Select)}.

-file("src/cake/select.gleam", 613).
?DOC(
    " Sets the kind of the `Select` query to\n"
    " return distinct rows only.\n"
).
-spec distinct(cake@internal@read_query:select()) -> cake@internal@read_query:select().
distinct(Select) ->
    {select,
        select_distinct,
        erlang:element(3, Select),
        erlang:element(4, Select),
        erlang:element(5, Select),
        erlang:element(6, Select),
        erlang:element(7, Select),
        erlang:element(8, Select),
        erlang:element(9, Select),
        erlang:element(10, Select),
        erlang:element(11, Select),
        erlang:element(12, Select),
        erlang:element(13, Select)}.

-file("src/cake/select.gleam", 619).
?DOC(" Gets the kind of the `Select` query.\n").
-spec get_kind(cake@internal@read_query:select()) -> cake@internal@read_query:select_kind().
get_kind(Select) ->
    erlang:element(2, Select).

-file("src/cake/select.gleam", 627).
?DOC(" Sets the `FROM` clause of the `Select` query to a table name.\n").
-spec from_table(cake@internal@read_query:select(), binary()) -> cake@internal@read_query:select().
from_table(Select, Table_name) ->
    {select,
        erlang:element(2, Select),
        erlang:element(3, Select),
        begin
            _pipe = Table_name,
            {from_table, _pipe}
        end,
        erlang:element(5, Select),
        erlang:element(6, Select),
        erlang:element(7, Select),
        erlang:element(8, Select),
        erlang:element(9, Select),
        erlang:element(10, Select),
        erlang:element(11, Select),
        erlang:element(12, Select),
        erlang:element(13, Select)}.

-file("src/cake/select.gleam", 633).
?DOC(" Sets the `FROM` clause of the `Select` query to an aliased sub-query.\n").
-spec from_query(
    cake@internal@read_query:select(),
    cake@internal@read_query:read_query(),
    binary()
) -> cake@internal@read_query:select().
from_query(Select, Sub_query, Alias) ->
    {select,
        erlang:element(2, Select),
        erlang:element(3, Select),
        begin
            _pipe = Sub_query,
            {from_sub_query, _pipe, Alias}
        end,
        erlang:element(5, Select),
        erlang:element(6, Select),
        erlang:element(7, Select),
        erlang:element(8, Select),
        erlang:element(9, Select),
        erlang:element(10, Select),
        erlang:element(11, Select),
        erlang:element(12, Select),
        erlang:element(13, Select)}.

-file("src/cake/select.gleam", 643).
?DOC(" Removes the `FROM` clause of the `Select` query.\n").
-spec no_from(cake@internal@read_query:select()) -> cake@internal@read_query:select().
no_from(Select) ->
    {select,
        erlang:element(2, Select),
        erlang:element(3, Select),
        no_from,
        erlang:element(5, Select),
        erlang:element(6, Select),
        erlang:element(7, Select),
        erlang:element(8, Select),
        erlang:element(9, Select),
        erlang:element(10, Select),
        erlang:element(11, Select),
        erlang:element(12, Select),
        erlang:element(13, Select)}.

-file("src/cake/select.gleam", 649).
?DOC(" Gets the `FROM` clause of the `Select` query.\n").
-spec get_from(cake@internal@read_query:select()) -> cake@internal@read_query:from().
get_from(Select) ->
    erlang:element(4, Select).

-file("src/cake/select.gleam", 659).
?DOC(
    " Add a column name to the `Select` query as a `SelectValue`.\n"
    "\n"
    " If the query already has any `SelectValue`s, the new one is appended.\n"
).
-spec select_col(cake@internal@read_query:select(), binary()) -> cake@internal@read_query:select().
select_col(Select, Name) ->
    Select_value = begin
        _pipe = Name,
        col(_pipe)
    end,
    case erlang:element(3, Select) of
        no_selects ->
            {select,
                erlang:element(2, Select),
                begin
                    _pipe@1 = [Select_value],
                    {selects, _pipe@1}
                end,
                erlang:element(4, Select),
                erlang:element(5, Select),
                erlang:element(6, Select),
                erlang:element(7, Select),
                erlang:element(8, Select),
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)};

        {selects, Values} ->
            {select,
                erlang:element(2, Select),
                begin
                    _pipe@2 = Values,
                    _pipe@3 = lists:append(_pipe@2, [Select_value]),
                    {selects, _pipe@3}
                end,
                erlang:element(4, Select),
                erlang:element(5, Select),
                erlang:element(6, Select),
                erlang:element(7, Select),
                erlang:element(8, Select),
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)}
    end.

-file("src/cake/select.gleam", 677).
?DOC(
    " Add a `SelectValue` to the `Select` query.\n"
    "\n"
    " If the query already has any `SelectValue`s, the new one is appended.\n"
).
-spec select(
    cake@internal@read_query:select(),
    cake@internal@read_query:select_value()
) -> cake@internal@read_query:select().
select(Select, Select_value) ->
    case erlang:element(3, Select) of
        no_selects ->
            {select,
                erlang:element(2, Select),
                begin
                    _pipe = [Select_value],
                    {selects, _pipe}
                end,
                erlang:element(4, Select),
                erlang:element(5, Select),
                erlang:element(6, Select),
                erlang:element(7, Select),
                erlang:element(8, Select),
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)};

        {selects, Values} ->
            {select,
                erlang:element(2, Select),
                begin
                    _pipe@1 = Values,
                    _pipe@2 = lists:append(_pipe@1, [Select_value]),
                    {selects, _pipe@2}
                end,
                erlang:element(4, Select),
                erlang:element(5, Select),
                erlang:element(6, Select),
                erlang:element(7, Select),
                erlang:element(8, Select),
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)}
    end.

-file("src/cake/select.gleam", 705).
?DOC(
    " Add a `SelectValue` to the `Select` query.\n"
    "\n"
    " If the query already has any `SelectValue`s, they are replaced.\n"
).
-spec replace_select(
    cake@internal@read_query:select(),
    cake@internal@read_query:select_value()
) -> cake@internal@read_query:select().
replace_select(Select, Select_value) ->
    {select,
        erlang:element(2, Select),
        begin
            _pipe = [Select_value],
            {selects, _pipe}
        end,
        erlang:element(4, Select),
        erlang:element(5, Select),
        erlang:element(6, Select),
        erlang:element(7, Select),
        erlang:element(8, Select),
        erlang:element(9, Select),
        erlang:element(10, Select),
        erlang:element(11, Select),
        erlang:element(12, Select),
        erlang:element(13, Select)}.

-file("src/cake/select.gleam", 697).
?DOC(
    " Add a column name to the `Select` query as a `SelectValue`.\n"
    "\n"
    " If the query already has any `SelectValue`s, they are replaced.\n"
).
-spec replace_select_col(cake@internal@read_query:select(), binary()) -> cake@internal@read_query:select().
replace_select_col(Select, Name) ->
    _pipe = Name,
    _pipe@1 = col(_pipe),
    replace_select(Select, _pipe@1).

-file("src/cake/select.gleam", 727).
?DOC(
    " Adds many `SelectValue`s to the `Select` query.\n"
    "\n"
    " If the query already has any `SelectValue`s, the new ones are appended.\n"
).
-spec selects(
    cake@internal@read_query:select(),
    list(cake@internal@read_query:select_value())
) -> cake@internal@read_query:select().
selects(Select, Select_values) ->
    case {Select_values, erlang:element(3, Select)} of
        {[], _} ->
            Select;

        {Select_values@1, no_selects} ->
            {select,
                erlang:element(2, Select),
                begin
                    _pipe = Select_values@1,
                    {selects, _pipe}
                end,
                erlang:element(4, Select),
                erlang:element(5, Select),
                erlang:element(6, Select),
                erlang:element(7, Select),
                erlang:element(8, Select),
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)};

        {Select_values@2, {selects, Existing_selects}} ->
            {select,
                erlang:element(2, Select),
                begin
                    _pipe@1 = Existing_selects,
                    _pipe@2 = lists:append(_pipe@1, Select_values@2),
                    {selects, _pipe@2}
                end,
                erlang:element(4, Select),
                erlang:element(5, Select),
                erlang:element(6, Select),
                erlang:element(7, Select),
                erlang:element(8, Select),
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)}
    end.

-file("src/cake/select.gleam", 716).
?DOC(
    " Adds many column names as `SelectValue`s to the `Select` query.\n"
    "\n"
    " If the query already has any `SelectValue`s, the new ones are appended.\n"
).
-spec select_cols(cake@internal@read_query:select(), list(binary())) -> cake@internal@read_query:select().
select_cols(Select, Columns) ->
    _pipe = Columns,
    _pipe@1 = gleam@list:map(_pipe, fun col/1),
    selects(Select, _pipe@1).

-file("src/cake/select.gleam", 762).
?DOC(
    " Adds many `SelectValue`s to the `Select` query.\n"
    "\n"
    " If the query already has any `SelectValue`s, they are replaced.\n"
    "\n"
    " If no `SelectValue`s are provided, the query is returned as-is.\n"
).
-spec replace_selects(
    cake@internal@read_query:select(),
    list(cake@internal@read_query:select_value())
) -> cake@internal@read_query:select().
replace_selects(Select, Select_values) ->
    case Select_values of
        [] ->
            Select;

        _ ->
            {select,
                erlang:element(2, Select),
                begin
                    _pipe = Select_values,
                    {selects, _pipe}
                end,
                erlang:element(4, Select),
                erlang:element(5, Select),
                erlang:element(6, Select),
                erlang:element(7, Select),
                erlang:element(8, Select),
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)}
    end.

-file("src/cake/select.gleam", 749).
?DOC(
    " Adds many column names as `SelectValue`s to the `Select` query.\n"
    "\n"
    " If the query already has any `SelectValue`s, the new ones are replaced.\n"
).
-spec replace_select_cols(cake@internal@read_query:select(), list(binary())) -> cake@internal@read_query:select().
replace_select_cols(Select, Columns) ->
    _pipe = Columns,
    _pipe@1 = gleam@list:map(_pipe, fun col/1),
    replace_selects(Select, _pipe@1).

-file("src/cake/select.gleam", 774).
?DOC(" Gets the `SelectValue`s of the `Select` query.\n").
-spec get_select(cake@internal@read_query:select()) -> cake@internal@read_query:selects().
get_select(Select) ->
    erlang:element(3, Select).

-file("src/cake/select.gleam", 782).
?DOC(" Adds a `Join` to the `Select` query.\n").
-spec join(cake@internal@read_query:select(), cake@internal@read_query:join()) -> cake@internal@read_query:select().
join(Select, Join) ->
    case erlang:element(5, Select) of
        {joins, Existing_joins} ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                begin
                    _pipe = Existing_joins,
                    _pipe@1 = lists:append(_pipe, [Join]),
                    {joins, _pipe@1}
                end,
                erlang:element(6, Select),
                erlang:element(7, Select),
                erlang:element(8, Select),
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)};

        no_joins ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                begin
                    _pipe@2 = [Join],
                    {joins, _pipe@2}
                end,
                erlang:element(6, Select),
                erlang:element(7, Select),
                erlang:element(8, Select),
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)}
    end.

-file("src/cake/select.gleam", 792).
?DOC(" Replaces any `Join`s of the `Select` query with a single `Join`.\n").
-spec replace_join(
    cake@internal@read_query:select(),
    cake@internal@read_query:join()
) -> cake@internal@read_query:select().
replace_join(Select, Join) ->
    {select,
        erlang:element(2, Select),
        erlang:element(3, Select),
        erlang:element(4, Select),
        begin
            _pipe = [Join],
            {joins, _pipe}
        end,
        erlang:element(6, Select),
        erlang:element(7, Select),
        erlang:element(8, Select),
        erlang:element(9, Select),
        erlang:element(10, Select),
        erlang:element(11, Select),
        erlang:element(12, Select),
        erlang:element(13, Select)}.

-file("src/cake/select.gleam", 798).
?DOC(" Adds `Join`s to the `Select` query.\n").
-spec joins(
    cake@internal@read_query:select(),
    list(cake@internal@read_query:join())
) -> cake@internal@read_query:select().
joins(Select, Joins) ->
    case {Joins, erlang:element(5, Select)} of
        {[], _} ->
            Select;

        {_, {joins, Existing_joins}} ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                begin
                    _pipe = Existing_joins,
                    _pipe@1 = lists:append(_pipe, Joins),
                    {joins, _pipe@1}
                end,
                erlang:element(6, Select),
                erlang:element(7, Select),
                erlang:element(8, Select),
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)};

        {_, no_joins} ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                begin
                    _pipe@2 = Joins,
                    {joins, _pipe@2}
                end,
                erlang:element(6, Select),
                erlang:element(7, Select),
                erlang:element(8, Select),
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)}
    end.

-file("src/cake/select.gleam", 809).
?DOC(" Replaces any `Join`s of the `Select` query with the given `Join`s.\n").
-spec replace_joins(
    cake@internal@read_query:select(),
    list(cake@internal@read_query:join())
) -> cake@internal@read_query:select().
replace_joins(Select, Joins) ->
    {select,
        erlang:element(2, Select),
        erlang:element(3, Select),
        erlang:element(4, Select),
        begin
            _pipe = Joins,
            {joins, _pipe}
        end,
        erlang:element(6, Select),
        erlang:element(7, Select),
        erlang:element(8, Select),
        erlang:element(9, Select),
        erlang:element(10, Select),
        erlang:element(11, Select),
        erlang:element(12, Select),
        erlang:element(13, Select)}.

-file("src/cake/select.gleam", 815).
?DOC(" Removes any `Joins` from the `Select` query.\n").
-spec no_join(cake@internal@read_query:select()) -> cake@internal@read_query:select().
no_join(Select) ->
    {select,
        erlang:element(2, Select),
        erlang:element(3, Select),
        erlang:element(4, Select),
        no_joins,
        erlang:element(6, Select),
        erlang:element(7, Select),
        erlang:element(8, Select),
        erlang:element(9, Select),
        erlang:element(10, Select),
        erlang:element(11, Select),
        erlang:element(12, Select),
        erlang:element(13, Select)}.

-file("src/cake/select.gleam", 821).
?DOC(" Gets the `Joins` of the `Select` query.\n").
-spec get_joins(cake@internal@read_query:select()) -> cake@internal@read_query:joins().
get_joins(Select) ->
    erlang:element(5, Select).

-file("src/cake/select.gleam", 836).
?DOC(
    " Sets an `AndWhere` or appends into an existing `AndWhere`.\n"
    "\n"
    " - If the outermost `Where` is an `AndWhere`, the new `Where` is appended\n"
    "   to the list within `AndWhere`.\n"
    " - If the query does not have a `Where` clause, the given `Where` is set\n"
    "   instead.\n"
    " - If the outermost `Where` is any other kind of `Where`, this and the\n"
    "   current outermost `Where` are wrapped in an `AndWhere`.\n"
).
-spec where(cake@internal@read_query:select(), cake@internal@read_query:where()) -> cake@internal@read_query:select().
where(Select, Where) ->
    case erlang:element(6, Select) of
        no_where ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                Where,
                erlang:element(7, Select),
                erlang:element(8, Select),
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)};

        {and_where, Conditions} ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                begin
                    _pipe = Conditions,
                    _pipe@1 = lists:append(_pipe, [Where]),
                    {and_where, _pipe@1}
                end,
                erlang:element(7, Select),
                erlang:element(8, Select),
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)};

        _ ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                begin
                    _pipe@2 = [erlang:element(6, Select), Where],
                    {and_where, _pipe@2}
                end,
                erlang:element(7, Select),
                erlang:element(8, Select),
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)}
    end.

-file("src/cake/select.gleam", 854).
?DOC(
    " Sets an `OrWhere` or appends into an existing `OrWhere`.\n"
    "\n"
    " - If the outermost `Where` is an `OrWhere`, the new `Where` is appended\n"
    "   to the list within `OrWhere`.\n"
    " - If the query does not have a `Where` clause, the given `Where` is set\n"
    "   instead.\n"
    " - If the outermost `Where` is any other kind of `Where`, this and the\n"
    "   current outermost `Where` are wrapped in an `OrWhere`.\n"
).
-spec or_where(
    cake@internal@read_query:select(),
    cake@internal@read_query:where()
) -> cake@internal@read_query:select().
or_where(Select, Where) ->
    case erlang:element(6, Select) of
        no_where ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                Where,
                erlang:element(7, Select),
                erlang:element(8, Select),
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)};

        {or_where, Conditions} ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                begin
                    _pipe = Conditions,
                    _pipe@1 = lists:append(_pipe, [Where]),
                    {or_where, _pipe@1}
                end,
                erlang:element(7, Select),
                erlang:element(8, Select),
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)};

        _ ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                begin
                    _pipe@2 = [erlang:element(6, Select), Where],
                    {or_where, _pipe@2}
                end,
                erlang:element(7, Select),
                erlang:element(8, Select),
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)}
    end.

-file("src/cake/select.gleam", 878).
?DOC(
    " Sets an `XorWhere` or appends into an existing `XorWhere`.\n"
    "\n"
    " - If the outermost `Where` is an `XorWhere`, the new `Where` is appended\n"
    "   to the list within `XorWhere`.\n"
    " - If the query does not have a `Where` clause, the given `Where` is set\n"
    "   instead.\n"
    " - If the outermost `Where` is any other kind of `Where`, this and the\n"
    "   current outermost `Where` are wrapped in an `XorWhere`.\n"
    "\n"
    " NOTICE: *Cake* implements this using a custom `OR / AND / NOT` expansion\n"
    " on all four adapters (🐘PostgreSQL, 🪶SQLite, 🦭MariaDB, 🐬MySQL) —\n"
    " native `XOR` is **not** used on any adapter.\n"
    " For odd-parity XOR that delegates to 🦭MariaDB / 🐬MySQL native `XOR`,\n"
    " use `where.xor_parity` instead.\n"
).
-spec xor_where(
    cake@internal@read_query:select(),
    cake@internal@read_query:where()
) -> cake@internal@read_query:select().
xor_where(Select, Where) ->
    case erlang:element(6, Select) of
        no_where ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                Where,
                erlang:element(7, Select),
                erlang:element(8, Select),
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)};

        {xor_where, Conditions} ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                begin
                    _pipe = Conditions,
                    _pipe@1 = lists:append(_pipe, [Where]),
                    {xor_where, _pipe@1}
                end,
                erlang:element(7, Select),
                erlang:element(8, Select),
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)};

        _ ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                begin
                    _pipe@2 = [erlang:element(6, Select), Where],
                    {xor_where, _pipe@2}
                end,
                erlang:element(7, Select),
                erlang:element(8, Select),
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)}
    end.

-file("src/cake/select.gleam", 899).
?DOC(
    " Sets a `NotWhere` or appends into an existing `AndWhere`.\n"
    "\n"
    " Wraps the given `Where` in a `NotWhere`, then applies it with `AND`\n"
    " semantics:\n"
    "\n"
    " - If the query does not have a `Where` clause, the given `Where` is set\n"
    "   as a `NotWhere`.\n"
    " - If the outermost `Where` is an `AndWhere`, the new `NotWhere` is appended\n"
    "   to the list within `AndWhere`.\n"
    " - If the outermost `Where` is any other kind of `Where`, this and the\n"
    "   current outermost `Where` are wrapped in an `AndWhere`.\n"
).
-spec not_where(
    cake@internal@read_query:select(),
    cake@internal@read_query:where()
) -> cake@internal@read_query:select().
not_where(Select, Where) ->
    case erlang:element(6, Select) of
        no_where ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                {not_where, Where},
                erlang:element(7, Select),
                erlang:element(8, Select),
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)};

        {and_where, Conditions} ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                begin
                    _pipe = Conditions,
                    _pipe@1 = lists:append(_pipe, [{not_where, Where}]),
                    {and_where, _pipe@1}
                end,
                erlang:element(7, Select),
                erlang:element(8, Select),
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)};

        _ ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                begin
                    _pipe@2 = [erlang:element(6, Select), {not_where, Where}],
                    {and_where, _pipe@2}
                end,
                erlang:element(7, Select),
                erlang:element(8, Select),
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)}
    end.

-file("src/cake/select.gleam", 919).
?DOC(" Replaces the `Where` in the `Select` query.\n").
-spec replace_where(
    cake@internal@read_query:select(),
    cake@internal@read_query:where()
) -> cake@internal@read_query:select().
replace_where(Select, Where) ->
    {select,
        erlang:element(2, Select),
        erlang:element(3, Select),
        erlang:element(4, Select),
        erlang:element(5, Select),
        Where,
        erlang:element(7, Select),
        erlang:element(8, Select),
        erlang:element(9, Select),
        erlang:element(10, Select),
        erlang:element(11, Select),
        erlang:element(12, Select),
        erlang:element(13, Select)}.

-file("src/cake/select.gleam", 925).
?DOC(" Removes the `Where` from the `Select` query.\n").
-spec no_where(cake@internal@read_query:select()) -> cake@internal@read_query:select().
no_where(Select) ->
    {select,
        erlang:element(2, Select),
        erlang:element(3, Select),
        erlang:element(4, Select),
        erlang:element(5, Select),
        no_where,
        erlang:element(7, Select),
        erlang:element(8, Select),
        erlang:element(9, Select),
        erlang:element(10, Select),
        erlang:element(11, Select),
        erlang:element(12, Select),
        erlang:element(13, Select)}.

-file("src/cake/select.gleam", 931).
?DOC(" Gets the `Where` of the `Select` query.\n").
-spec get_where(cake@internal@read_query:select()) -> cake@internal@read_query:where().
get_where(Select) ->
    erlang:element(6, Select).

-file("src/cake/select.gleam", 951).
?DOC(
    " Sets an `AndWhere` or appends into an existing `AndWhere`.\n"
    "\n"
    " - If the outermost `Where` is an `AndWhere`, the new `Where` is appended\n"
    "   to the list within `AndWhere`.\n"
    " - If the query does not have a `Where` clause, the given `Where` is set\n"
    "   instead.\n"
    " - If the outermost `Where` is any other kind of `Where`, this and the\n"
    "   current outermost `Where` are wrapped in an `AndWhere`.\n"
    "\n"
    " NOTICE: `HAVING` allows to specify constraints much like `WHERE`, but\n"
    " filters the results after `GROUP BY` is applied instead of before. Because\n"
    " `HAVING` uses the same semantics as `WHERE`, it\n"
    "         takes a `Where`.\n"
).
-spec having(
    cake@internal@read_query:select(),
    cake@internal@read_query:where()
) -> cake@internal@read_query:select().
having(Select, Where) ->
    case erlang:element(8, Select) of
        no_where ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                erlang:element(6, Select),
                erlang:element(7, Select),
                Where,
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)};

        {and_where, Conditions} ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                erlang:element(6, Select),
                erlang:element(7, Select),
                begin
                    _pipe = Conditions,
                    _pipe@1 = lists:append(_pipe, [Where]),
                    {and_where, _pipe@1}
                end,
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)};

        _ ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                erlang:element(6, Select),
                erlang:element(7, Select),
                begin
                    _pipe@2 = [erlang:element(8, Select), Where],
                    {and_where, _pipe@2}
                end,
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)}
    end.

-file("src/cake/select.gleam", 971).
?DOC(
    " Sets an `OrWhere` or appends into an existing `OrWhere`.\n"
    "\n"
    " - If the outermost `Where` is an `OrWhere`, the new `Where` is appended\n"
    "   to the list within `OrWhere`.\n"
    " - If the query does not have a `Where` clause, the given `Where` is set\n"
    "   instead.\n"
    " - If the outermost `Where` is any other kind of `Where`, this and the\n"
    "   current outermost `Where` are wrapped in an `OrWhere`.\n"
    "\n"
    " See function `having` on details why this takes a `Where`.\n"
).
-spec or_having(
    cake@internal@read_query:select(),
    cake@internal@read_query:where()
) -> cake@internal@read_query:select().
or_having(Select, Where) ->
    case erlang:element(8, Select) of
        no_where ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                erlang:element(6, Select),
                erlang:element(7, Select),
                Where,
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)};

        {or_where, Conditions} ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                erlang:element(6, Select),
                erlang:element(7, Select),
                begin
                    _pipe = Conditions,
                    _pipe@1 = lists:append(_pipe, [Where]),
                    {or_where, _pipe@1}
                end,
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)};

        _ ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                erlang:element(6, Select),
                erlang:element(7, Select),
                begin
                    _pipe@2 = [erlang:element(8, Select), Where],
                    {or_where, _pipe@2}
                end,
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)}
    end.

-file("src/cake/select.gleam", 998).
?DOC(
    " Sets an `XorWhere` or appends into an existing `XorWhere`.\n"
    "\n"
    " - If the outermost `Where` is an `XorWhere`, the new `Where` is appended\n"
    "   to the list within `XorWhere`.\n"
    " - If the query does not have a `Where` clause, the given `Where` is set\n"
    "   instead.\n"
    " - If the outermost `Where` is any other kind of `Where`, this and the\n"
    "   current outermost `Where` are wrapped in an `XorWhere`.\n"
    "\n"
    " See function `having` on details why this takes a `Where`.\n"
    "\n"
    " NOTICE: *Cake* implements this using a custom `OR / AND / NOT` expansion\n"
    " on all four adapters (🐘PostgreSQL, 🪶SQLite, 🦭MariaDB, 🐬MySQL) —\n"
    " native `XOR` is **not** used on any adapter.\n"
    "\n"
    " For odd-parity XOR (which on 🦭MariaDB / 🐬MySQL delegates to its native\n"
    " `XOR`) use `where.xor_parity` instead.\n"
).
-spec xor_having(
    cake@internal@read_query:select(),
    cake@internal@read_query:where()
) -> cake@internal@read_query:select().
xor_having(Select, Where) ->
    case erlang:element(8, Select) of
        no_where ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                erlang:element(6, Select),
                erlang:element(7, Select),
                Where,
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)};

        {xor_where, Conditions} ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                erlang:element(6, Select),
                erlang:element(7, Select),
                begin
                    _pipe = Conditions,
                    _pipe@1 = lists:append(_pipe, [Where]),
                    {xor_where, _pipe@1}
                end,
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)};

        _ ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                erlang:element(6, Select),
                erlang:element(7, Select),
                begin
                    _pipe@2 = [erlang:element(8, Select), Where],
                    {xor_where, _pipe@2}
                end,
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)}
    end.

-file("src/cake/select.gleam", 1020).
?DOC(
    " Sets a `NotWhere` or appends into an existing `AndWhere` for `HAVING`.\n"
    "\n"
    " - Wraps the given `Where` in a `NotWhere`, then applies it with `AND`\n"
    "   semantics:\n"
    " - If the query does not have a `HAVING` clause, the given `Where` is set\n"
    "   as a `NotWhere`.\n"
    " - If the outermost `Where` is an `AndWhere`, the new `NotWhere` is appended\n"
    "   to the list within `AndWhere`.\n"
    " - If the outermost `Where` is any other kind of `Where`, this and the\n"
    "   current outermost `Where` are wrapped in an `AndWhere`.\n"
    "\n"
    " See function `having` on details why this takes a `Where`.\n"
).
-spec not_having(
    cake@internal@read_query:select(),
    cake@internal@read_query:where()
) -> cake@internal@read_query:select().
not_having(Select, Where) ->
    case erlang:element(8, Select) of
        no_where ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                erlang:element(6, Select),
                erlang:element(7, Select),
                {not_where, Where},
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)};

        {and_where, Conditions} ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                erlang:element(6, Select),
                erlang:element(7, Select),
                begin
                    _pipe = Conditions,
                    _pipe@1 = lists:append(_pipe, [{not_where, Where}]),
                    {and_where, _pipe@1}
                end,
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)};

        _ ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                erlang:element(6, Select),
                erlang:element(7, Select),
                begin
                    _pipe@2 = [erlang:element(8, Select), {not_where, Where}],
                    {and_where, _pipe@2}
                end,
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)}
    end.

-file("src/cake/select.gleam", 1042).
?DOC(
    " Replaces `HAVING` in the `Select` query.\n"
    "\n"
    " See function `having` on details why this takes a `Where`.\n"
).
-spec replace_having(
    cake@internal@read_query:select(),
    cake@internal@read_query:where()
) -> cake@internal@read_query:select().
replace_having(Select, Where) ->
    {select,
        erlang:element(2, Select),
        erlang:element(3, Select),
        erlang:element(4, Select),
        erlang:element(5, Select),
        erlang:element(6, Select),
        erlang:element(7, Select),
        Where,
        erlang:element(9, Select),
        erlang:element(10, Select),
        erlang:element(11, Select),
        erlang:element(12, Select),
        erlang:element(13, Select)}.

-file("src/cake/select.gleam", 1048).
?DOC(" Removes `HAVING` from the `Select` query.\n").
-spec no_having(cake@internal@read_query:select()) -> cake@internal@read_query:select().
no_having(Select) ->
    {select,
        erlang:element(2, Select),
        erlang:element(3, Select),
        erlang:element(4, Select),
        erlang:element(5, Select),
        erlang:element(6, Select),
        erlang:element(7, Select),
        no_where,
        erlang:element(9, Select),
        erlang:element(10, Select),
        erlang:element(11, Select),
        erlang:element(12, Select),
        erlang:element(13, Select)}.

-file("src/cake/select.gleam", 1056).
?DOC(
    " Gets `HAVING` in the `Select` query.\n"
    "\n"
    " See function `having` on details why this returns a `Where`.\n"
).
-spec get_having(cake@internal@read_query:select()) -> cake@internal@read_query:where().
get_having(Select) ->
    erlang:element(8, Select).

-file("src/cake/select.gleam", 1064).
?DOC(" Sets or appends `GroupBy` a single into an existing `GroupBy`.\n").
-spec group_by(cake@internal@read_query:select(), binary()) -> cake@internal@read_query:select().
group_by(Select, Group_by) ->
    case erlang:element(7, Select) of
        no_group_by ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                erlang:element(6, Select),
                begin
                    _pipe = [Group_by],
                    {group_by, _pipe}
                end,
                erlang:element(8, Select),
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)};

        {group_by, Columns} ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                erlang:element(6, Select),
                begin
                    _pipe@1 = Columns,
                    _pipe@2 = lists:append(_pipe@1, [Group_by]),
                    {group_by, _pipe@2}
                end,
                erlang:element(8, Select),
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)}
    end.

-file("src/cake/select.gleam", 1074).
?DOC(" Replaces `GroupBy` with a single `GroupBy`.\n").
-spec replace_group_by(cake@internal@read_query:select(), binary()) -> cake@internal@read_query:select().
replace_group_by(Select, Group_by) ->
    {select,
        erlang:element(2, Select),
        erlang:element(3, Select),
        erlang:element(4, Select),
        erlang:element(5, Select),
        erlang:element(6, Select),
        begin
            _pipe = [Group_by],
            {group_by, _pipe}
        end,
        erlang:element(8, Select),
        erlang:element(9, Select),
        erlang:element(10, Select),
        erlang:element(11, Select),
        erlang:element(12, Select),
        erlang:element(13, Select)}.

-file("src/cake/select.gleam", 1083).
?DOC(" Sets or appends a list of `GroupBy` into an existing `GroupBy`.\n").
-spec group_bys(cake@internal@read_query:select(), list(binary())) -> cake@internal@read_query:select().
group_bys(Select, Group_bys) ->
    case erlang:element(7, Select) of
        no_group_by ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                erlang:element(6, Select),
                begin
                    _pipe = Group_bys,
                    {group_by, _pipe}
                end,
                erlang:element(8, Select),
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)};

        {group_by, Columns} ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                erlang:element(6, Select),
                begin
                    _pipe@1 = Columns,
                    _pipe@2 = lists:append(_pipe@1, Group_bys),
                    {group_by, _pipe@2}
                end,
                erlang:element(8, Select),
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                erlang:element(13, Select)}
    end.

-file("src/cake/select.gleam", 1101).
?DOC(" Replaces `GroupBy` with a list of `GroupBy`s.\n").
-spec replace_group_bys(cake@internal@read_query:select(), list(binary())) -> cake@internal@read_query:select().
replace_group_bys(Select, Group_bys) ->
    {select,
        erlang:element(2, Select),
        erlang:element(3, Select),
        erlang:element(4, Select),
        erlang:element(5, Select),
        erlang:element(6, Select),
        begin
            _pipe = Group_bys,
            {group_by, _pipe}
        end,
        erlang:element(8, Select),
        erlang:element(9, Select),
        erlang:element(10, Select),
        erlang:element(11, Select),
        erlang:element(12, Select),
        erlang:element(13, Select)}.

-file("src/cake/select.gleam", 1110).
?DOC(" Removes `GroupBy` from the `Select` query.\n").
-spec no_group_by(cake@internal@read_query:select()) -> cake@internal@read_query:select().
no_group_by(Select) ->
    {select,
        erlang:element(2, Select),
        erlang:element(3, Select),
        erlang:element(4, Select),
        erlang:element(5, Select),
        erlang:element(6, Select),
        no_group_by,
        erlang:element(8, Select),
        erlang:element(9, Select),
        erlang:element(10, Select),
        erlang:element(11, Select),
        erlang:element(12, Select),
        erlang:element(13, Select)}.

-file("src/cake/select.gleam", 1116).
?DOC(" Gets `GroupBy` in the `Select` query.\n").
-spec get_group_by(cake@internal@read_query:select()) -> cake@internal@read_query:group_by().
get_group_by(Select) ->
    erlang:element(7, Select).

-file("src/cake/select.gleam", 1124).
?DOC(" Sets a `Limit` in the `Select` query.\n").
-spec limit(cake@internal@read_query:select(), integer()) -> cake@internal@read_query:select().
limit(Select, Limit) ->
    Limit@1 = begin
        _pipe = Limit,
        cake@internal@read_query:limit_new(_pipe)
    end,
    {select,
        erlang:element(2, Select),
        erlang:element(3, Select),
        erlang:element(4, Select),
        erlang:element(5, Select),
        erlang:element(6, Select),
        erlang:element(7, Select),
        erlang:element(8, Select),
        erlang:element(9, Select),
        Limit@1,
        erlang:element(11, Select),
        erlang:element(12, Select),
        erlang:element(13, Select)}.

-file("src/cake/select.gleam", 1131).
?DOC(" Removes `Limit` from the `Select` query.\n").
-spec no_limit(cake@internal@read_query:select()) -> cake@internal@read_query:select().
no_limit(Select) ->
    {select,
        erlang:element(2, Select),
        erlang:element(3, Select),
        erlang:element(4, Select),
        erlang:element(5, Select),
        erlang:element(6, Select),
        erlang:element(7, Select),
        erlang:element(8, Select),
        erlang:element(9, Select),
        no_limit,
        erlang:element(11, Select),
        erlang:element(12, Select),
        erlang:element(13, Select)}.

-file("src/cake/select.gleam", 1137).
?DOC(" Gets `Limit` in the `Select` query.\n").
-spec get_limit(cake@internal@read_query:select()) -> cake@internal@read_query:limit().
get_limit(Select) ->
    erlang:element(10, Select).

-file("src/cake/select.gleam", 1143).
?DOC(" Sets an `Offset` in the `Select` query.\n").
-spec offset(cake@internal@read_query:select(), integer()) -> cake@internal@read_query:select().
offset(Select, Offset) ->
    Offset@1 = begin
        _pipe = Offset,
        cake@internal@read_query:offset_new(_pipe)
    end,
    {select,
        erlang:element(2, Select),
        erlang:element(3, Select),
        erlang:element(4, Select),
        erlang:element(5, Select),
        erlang:element(6, Select),
        erlang:element(7, Select),
        erlang:element(8, Select),
        erlang:element(9, Select),
        erlang:element(10, Select),
        Offset@1,
        erlang:element(12, Select),
        erlang:element(13, Select)}.

-file("src/cake/select.gleam", 1150).
?DOC(" Removes `Offset` from the `Select` query.\n").
-spec no_offset(cake@internal@read_query:select()) -> cake@internal@read_query:select().
no_offset(Select) ->
    {select,
        erlang:element(2, Select),
        erlang:element(3, Select),
        erlang:element(4, Select),
        erlang:element(5, Select),
        erlang:element(6, Select),
        erlang:element(7, Select),
        erlang:element(8, Select),
        erlang:element(9, Select),
        erlang:element(10, Select),
        no_offset,
        erlang:element(12, Select),
        erlang:element(13, Select)}.

-file("src/cake/select.gleam", 1156).
?DOC(" Gets `Offset` in the `Select` query.\n").
-spec get_offset(cake@internal@read_query:select()) -> cake@internal@read_query:offset().
get_offset(Select) ->
    erlang:element(11, Select).

-file("src/cake/select.gleam", 1171).
-spec map_order_by_direction_constructor(direction()) -> cake@internal@read_query:order_by_direction().
map_order_by_direction_constructor(In) ->
    case In of
        asc ->
            asc;

        desc ->
            desc
    end.

-file("src/cake/select.gleam", 1180).
?DOC(" Creates or appends an ascending `OrderBy`.\n").
-spec order_by_asc(cake@internal@read_query:select(), binary()) -> cake@internal@read_query:select().
order_by_asc(Select, Order_by) ->
    _pipe = Select,
    cake@internal@read_query:select_order_by(
        _pipe,
        begin
            _pipe@2 = [begin
                    _pipe@1 = Order_by,
                    {order_by_column, _pipe@1, asc}
                end],
            {order_by, _pipe@2}
        end,
        true
    ).

-file("src/cake/select.gleam", 1196).
?DOC(
    " Creates or appends an ascending `OrderBy` with `NULLS FIRST`.\n"
    "\n"
    " NOTICE: 🦭MariaDB and 🐬MySQL do not support `NULLS FIRST` out of the box.\n"
).
-spec order_by_asc_nulls_first(cake@internal@read_query:select(), binary()) -> cake@internal@read_query:select().
order_by_asc_nulls_first(Select, Order_by) ->
    _pipe = Select,
    cake@internal@read_query:select_order_by(
        _pipe,
        begin
            _pipe@2 = [begin
                    _pipe@1 = Order_by,
                    {order_by_column, _pipe@1, asc_nulls_first}
                end],
            {order_by, _pipe@2}
        end,
        true
    ).

-file("src/cake/select.gleam", 1214).
?DOC(
    " Creates or appends an ascending `OrderBy` with `NULLS LAST`.\n"
    "\n"
    " NOTICE: 🦭MariaDB and 🐬MySQL do not support `NULLS LAST` out of the box.\n"
).
-spec order_by_asc_nulls_last(cake@internal@read_query:select(), binary()) -> cake@internal@read_query:select().
order_by_asc_nulls_last(Select, Order_by) ->
    _pipe = Select,
    cake@internal@read_query:select_order_by(
        _pipe,
        begin
            _pipe@2 = [begin
                    _pipe@1 = Order_by,
                    {order_by_column, _pipe@1, asc_nulls_last}
                end],
            {order_by, _pipe@2}
        end,
        true
    ).

-file("src/cake/select.gleam", 1228).
?DOC(" Replaces the `OrderBy` a single ascending `OrderBy`.\n").
-spec replace_order_by_asc(cake@internal@read_query:select(), binary()) -> cake@internal@read_query:select().
replace_order_by_asc(Select, Order_by) ->
    _pipe = Select,
    cake@internal@read_query:select_order_by(
        _pipe,
        begin
            _pipe@2 = [begin
                    _pipe@1 = Order_by,
                    {order_by_column, _pipe@1, asc}
                end],
            {order_by, _pipe@2}
        end,
        false
    ).

-file("src/cake/select.gleam", 1243).
?DOC(
    " Replaces the `OrderBy` a single ascending `OrderBy` with `NULLS FIRST`.\n"
    "\n"
    " NOTICE: 🦭MariaDB and 🐬MySQL do not support `NULLS FIRST` out of the box.\n"
).
-spec replace_order_by_asc_nulls_first(
    cake@internal@read_query:select(),
    binary()
) -> cake@internal@read_query:select().
replace_order_by_asc_nulls_first(Select, Order_by) ->
    _pipe = Select,
    cake@internal@read_query:select_order_by(
        _pipe,
        begin
            _pipe@2 = [begin
                    _pipe@1 = Order_by,
                    {order_by_column, _pipe@1, asc_nulls_first}
                end],
            {order_by, _pipe@2}
        end,
        false
    ).

-file("src/cake/select.gleam", 1259).
?DOC(
    " Replaces the `OrderBy` a single ascending `OrderBy` with `NULLS LAST`.\n"
    "\n"
    " NOTICE: 🦭MariaDB and 🐬MySQL do not support `NULLS LAST` out of the box.\n"
).
-spec replace_order_by_asc_nulls_last(
    cake@internal@read_query:select(),
    binary()
) -> cake@internal@read_query:select().
replace_order_by_asc_nulls_last(Select, Order_by) ->
    _pipe = Select,
    cake@internal@read_query:select_order_by(
        _pipe,
        begin
            _pipe@2 = [begin
                    _pipe@1 = Order_by,
                    {order_by_column, _pipe@1, asc_nulls_last}
                end],
            {order_by, _pipe@2}
        end,
        false
    ).

-file("src/cake/select.gleam", 1273).
?DOC(" Creates or appends a descending `OrderBy`.\n").
-spec order_by_desc(cake@internal@read_query:select(), binary()) -> cake@internal@read_query:select().
order_by_desc(Select, Order_by) ->
    _pipe = Select,
    cake@internal@read_query:select_order_by(
        _pipe,
        begin
            _pipe@2 = [begin
                    _pipe@1 = Order_by,
                    {order_by_column, _pipe@1, desc}
                end],
            {order_by, _pipe@2}
        end,
        true
    ).

-file("src/cake/select.gleam", 1288).
?DOC(
    " Creates or appends a descending order with `NULLS FIRST`.\n"
    "\n"
    " NOTICE: 🦭MariaDB and 🐬MySQL do not support `NULLS FIRST` out of the box.\n"
).
-spec order_by_desc_nulls_first(cake@internal@read_query:select(), binary()) -> cake@internal@read_query:select().
order_by_desc_nulls_first(Select, Order_by) ->
    _pipe = Select,
    cake@internal@read_query:select_order_by(
        _pipe,
        begin
            _pipe@2 = [begin
                    _pipe@1 = Order_by,
                    {order_by_column, _pipe@1, desc_nulls_first}
                end],
            {order_by, _pipe@2}
        end,
        true
    ).

-file("src/cake/select.gleam", 1304).
?DOC(
    " Creates or appends a descending `OrderBy` with `NULLS LAST`.\n"
    "\n"
    " NOTICE: 🦭MariaDB and 🐬MySQL do not support `NULLS LAST` out of the box.\n"
).
-spec order_by_desc_nulls_last(cake@internal@read_query:select(), binary()) -> cake@internal@read_query:select().
order_by_desc_nulls_last(Select, Order_by) ->
    _pipe = Select,
    cake@internal@read_query:select_order_by(
        _pipe,
        begin
            _pipe@2 = [begin
                    _pipe@1 = Order_by,
                    {order_by_column, _pipe@1, desc_nulls_last}
                end],
            {order_by, _pipe@2}
        end,
        true
    ).

-file("src/cake/select.gleam", 1318).
?DOC(" Replaces the `OrderBy` a single descending order.\n").
-spec replace_order_by_desc(cake@internal@read_query:select(), binary()) -> cake@internal@read_query:select().
replace_order_by_desc(Select, Order_by) ->
    _pipe = Select,
    cake@internal@read_query:select_order_by(
        _pipe,
        begin
            _pipe@2 = [begin
                    _pipe@1 = Order_by,
                    {order_by_column, _pipe@1, desc}
                end],
            {order_by, _pipe@2}
        end,
        false
    ).

-file("src/cake/select.gleam", 1333).
?DOC(
    " Replaces the `OrderBy` a single descending order with `NULLS FIRST`.\n"
    "\n"
    " NOTICE: 🦭MariaDB and 🐬MySQL do not support `NULLS FIRST` out of the box.\n"
).
-spec replace_order_by_desc_nulls_first(
    cake@internal@read_query:select(),
    binary()
) -> cake@internal@read_query:select().
replace_order_by_desc_nulls_first(Select, Order_by) ->
    _pipe = Select,
    cake@internal@read_query:select_order_by(
        _pipe,
        begin
            _pipe@2 = [begin
                    _pipe@1 = Order_by,
                    {order_by_column, _pipe@1, desc_nulls_first}
                end],
            {order_by, _pipe@2}
        end,
        false
    ).

-file("src/cake/select.gleam", 1349).
?DOC(
    " Replaces the `OrderBy` a single descending `OrderBy` with `NULLS LAST`.\n"
    "\n"
    " NOTICE: 🦭MariaDB and 🐬MySQL do not support `NULLS LAST` out of the box.\n"
).
-spec replace_order_by_desc_nulls_last(
    cake@internal@read_query:select(),
    binary()
) -> cake@internal@read_query:select().
replace_order_by_desc_nulls_last(Select, Order_by) ->
    _pipe = Select,
    cake@internal@read_query:select_order_by(
        _pipe,
        begin
            _pipe@2 = [begin
                    _pipe@1 = Order_by,
                    {order_by_column, _pipe@1, desc_nulls_last}
                end],
            {order_by, _pipe@2}
        end,
        false
    ).

-file("src/cake/select.gleam", 1365).
?DOC(
    " Creates or appends an `OrderBy` a column with a direction.\n"
    "\n"
    " The direction can either `ASC` or `DESC`.\n"
).
-spec order_by(cake@internal@read_query:select(), binary(), direction()) -> cake@internal@read_query:select().
order_by(Select, Order_by, Direction) ->
    Direction@1 = begin
        _pipe = Direction,
        map_order_by_direction_constructor(_pipe)
    end,
    _pipe@1 = Select,
    cake@internal@read_query:select_order_by(
        _pipe@1,
        begin
            _pipe@3 = [begin
                    _pipe@2 = Order_by,
                    {order_by_column, _pipe@2, Direction@1}
                end],
            {order_by, _pipe@3}
        end,
        true
    ).

-file("src/cake/select.gleam", 1380).
?DOC(" Replaces the `OrderBy` a column with a direction.\n").
-spec replace_order_by(cake@internal@read_query:select(), binary(), direction()) -> cake@internal@read_query:select().
replace_order_by(Select, Order_by, Direction) ->
    Direction@1 = begin
        _pipe = Direction,
        map_order_by_direction_constructor(_pipe)
    end,
    _pipe@1 = Select,
    cake@internal@read_query:select_order_by(
        _pipe@1,
        begin
            _pipe@3 = [begin
                    _pipe@2 = Order_by,
                    {order_by_column, _pipe@2, Direction@1}
                end],
            {order_by, _pipe@3}
        end,
        false
    ).

-file("src/cake/select.gleam", 1395).
?DOC(" Removes the `OrderBy` from the `Select` query.\n").
-spec no_order_by(cake@internal@read_query:select()) -> cake@internal@read_query:select().
no_order_by(Select) ->
    {select,
        erlang:element(2, Select),
        erlang:element(3, Select),
        erlang:element(4, Select),
        erlang:element(5, Select),
        erlang:element(6, Select),
        erlang:element(7, Select),
        erlang:element(8, Select),
        no_order_by,
        erlang:element(10, Select),
        erlang:element(11, Select),
        erlang:element(12, Select),
        erlang:element(13, Select)}.

-file("src/cake/select.gleam", 1401).
?DOC(" Gets the `OrderBy` from the `Select` query.\n").
-spec get_order_by(cake@internal@read_query:select()) -> cake@internal@read_query:order_by().
get_order_by(Select) ->
    erlang:element(9, Select).

-file("src/cake/select.gleam", 1409).
?DOC(" Appends an `Epilog` to the `Select` query.\n").
-spec epilog(cake@internal@read_query:select(), binary()) -> cake@internal@read_query:select().
epilog(Select, Epilog) ->
    Epilog@1 = begin
        _pipe = Epilog,
        gleam@string:trim(_pipe)
    end,
    case Epilog@1 of
        <<""/utf8>> ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                erlang:element(6, Select),
                erlang:element(7, Select),
                erlang:element(8, Select),
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                no_epilog,
                erlang:element(13, Select)};

        _ ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                erlang:element(6, Select),
                erlang:element(7, Select),
                erlang:element(8, Select),
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                begin
                    _pipe@1 = (<<" "/utf8, Epilog@1/binary>>),
                    {epilog, _pipe@1}
                end,
                erlang:element(13, Select)}
    end.

-file("src/cake/select.gleam", 1419).
?DOC(" Removes the `Epilog` from the `Select` query.\n").
-spec no_epilog(cake@internal@read_query:select()) -> cake@internal@read_query:select().
no_epilog(Select) ->
    {select,
        erlang:element(2, Select),
        erlang:element(3, Select),
        erlang:element(4, Select),
        erlang:element(5, Select),
        erlang:element(6, Select),
        erlang:element(7, Select),
        erlang:element(8, Select),
        erlang:element(9, Select),
        erlang:element(10, Select),
        erlang:element(11, Select),
        no_epilog,
        erlang:element(13, Select)}.

-file("src/cake/select.gleam", 1425).
?DOC(" Gets the `Epilog` from the `Select` query.\n").
-spec get_epilog(cake@internal@read_query:select()) -> cake@internal@read_query:epilog().
get_epilog(Select) ->
    erlang:element(12, Select).

-file("src/cake/select.gleam", 1433).
?DOC(" Appends a `Comment` to the `Select` query.\n").
-spec comment(cake@internal@read_query:select(), binary()) -> cake@internal@read_query:select().
comment(Select, Comment) ->
    Comment@1 = begin
        _pipe = Comment,
        gleam@string:trim(_pipe)
    end,
    case Comment@1 of
        <<""/utf8>> ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                erlang:element(6, Select),
                erlang:element(7, Select),
                erlang:element(8, Select),
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                no_comment};

        _ ->
            {select,
                erlang:element(2, Select),
                erlang:element(3, Select),
                erlang:element(4, Select),
                erlang:element(5, Select),
                erlang:element(6, Select),
                erlang:element(7, Select),
                erlang:element(8, Select),
                erlang:element(9, Select),
                erlang:element(10, Select),
                erlang:element(11, Select),
                erlang:element(12, Select),
                begin
                    _pipe@1 = (<<" "/utf8, Comment@1/binary>>),
                    {comment, _pipe@1}
                end}
    end.

-file("src/cake/select.gleam", 1443).
?DOC(" Removes the `Comment` from the `Select` query.\n").
-spec no_comment(cake@internal@read_query:select()) -> cake@internal@read_query:select().
no_comment(Select) ->
    {select,
        erlang:element(2, Select),
        erlang:element(3, Select),
        erlang:element(4, Select),
        erlang:element(5, Select),
        erlang:element(6, Select),
        erlang:element(7, Select),
        erlang:element(8, Select),
        erlang:element(9, Select),
        erlang:element(10, Select),
        erlang:element(11, Select),
        erlang:element(12, Select),
        no_comment}.

-file("src/cake/select.gleam", 1449).
?DOC(" Gets the `Comment` from the `Select` query.\n").
-spec get_comment(cake@internal@read_query:select()) -> cake@internal@read_query:comment().
get_comment(Select) ->
    erlang:element(13, Select).