-module(cake@delete).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/cake/delete.gleam").
-export([to_query/1, new/0, modifier/2, no_modifier/1, get_modifier/1, table/2, no_table/1, get_table/1, using_table/2, using_sub_query/3, replace_using_table/2, replace_using_sub_query/3, no_using/1, get_using/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, returning/2, no_returning/1, epilog/2, no_epilog/1, get_epilog/1, comment/2, no_comment/1, get_comment/1]).

-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 `DELETE` queries.\n"
    "\n"
    " ## Aliases\n"
    "\n"
    " ```gleam\n"
    " import cake/delete as d\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[d.new] --> B[d.table]\n"
    "     B --> C[d.using_table / d.join]\n"
    "     C --> D[d.where]\n"
    "     D --> E[d.returning]\n"
    "     E --> F[d.to_query]\n"
    " ```\n"
    "\n"
    " ---\n"
    "\n"
    " ## Constructor\n"
    "\n"
    " ### `new() -> Delete(a)`\n"
    "\n"
    " Creates an empty `Delete` query.\n"
    "\n"
    " ### `to_query(delete: Delete(a)) -> WriteQuery(a)`\n"
    "\n"
    " Converts a `Delete` into a `WriteQuery` for execution.\n"
    "\n"
    " ---\n"
    "\n"
    " ## Table\n"
    "\n"
    " ### `table(delete, table_name) -> Delete(a)`\n"
    "\n"
    " Sets the table from which rows will be deleted.\n"
    "\n"
    " ```gleam\n"
    " d.new()\n"
    " |> d.table(\"sessions\")\n"
    " |> d.where(w.lt(w.col(\"expires_at\"), w.date(today)))\n"
    " |> d.to_query\n"
    " // DELETE FROM sessions WHERE expires_at < $1\n"
    " ```\n"
    "\n"
    " | Function             | Effect                     |\n"
    " | ------               | ------                     |\n"
    " | `table(delete, name)` | Set the target table      |\n"
    " | `no_table(delete)`    | Remove the target table   |\n"
    "\n"
    " ---\n"
    "\n"
    " ## USING clause\n"
    "\n"
    " `USING` allows referencing additional tables to filter which rows are deleted.\n"
    " It is the `DELETE` equivalent of a `FROM` join-helper on 🐘 PostgreSQL.\n"
    "\n"
    " ```mermaid\n"
    " flowchart TD\n"
    "     A[DELETE FROM a] --> B{USING}\n"
    "     B -->|table| C[USING b]\n"
    "     B -->|sub-query| D[USING sub AS alias]\n"
    "     C --> E[WHERE a.b_id = b.id]\n"
    "     D --> E\n"
    " ```\n"
    "\n"
    " ### `using_table(delete, table_name) -> Delete(a)`\n"
    "\n"
    " Appends a table reference to the `USING` clause.\n"
    "\n"
    " ```gleam\n"
    " d.new()\n"
    " |> d.table(\"order_items\")\n"
    " |> d.using_table(\"orders\")\n"
    " |> d.where(w.and([\n"
    "   w.eq(w.col(\"order_items.order_id\"), w.col(\"orders.id\")),\n"
    "   w.eq(w.col(\"orders.status\"), w.string(\"cancelled\")),\n"
    " ]))\n"
    " // DELETE FROM order_items USING orders\n"
    " // WHERE order_items.order_id = orders.id AND orders.status = $1\n"
    " ```\n"
    "\n"
    " ### `using_sub_query(delete, query, alias) -> Delete(a)`\n"
    "\n"
    " Appends an aliased sub-query to the `USING` clause.\n"
    "\n"
    " > 🦭 MariaDB and 🐬 MySQL do not support sub-queries in `USING` — use a `JOIN`\n"
    " > or a `WHERE` sub-query instead.\n"
    "\n"
    " ### Database compatibility for USING\n"
    "\n"
    " | Database      | Table | Sub-query |\n"
    " | ------------- | ----- | --------- |\n"
    " | 🐘 PostgreSQL | ✅    | ✅        |\n"
    " | 🦭 MariaDB    | ✅    | ❌        |\n"
    " | 🐬 MySQL      | ✅    | ❌        |\n"
    " | 🪶 SQLite     | ❌    | ❌        |\n"
    "\n"
    " > For 🦭 MariaDB and 🐬 MySQL the primary table used in `FROM` must also be\n"
    " > listed in `USING`. For example:\n"
    " >\n"
    " > ```sql\n"
    " > DELETE a FROM a USING a, b WHERE a.b_id = b.id\n"
    " > ```\n"
    "\n"
    " ### Replace / remove variants\n"
    "\n"
    " | Function                                              | Effect                         |\n"
    " | ------                                                | ------ |\n"
    " | `replace_using_table(delete, name)`         | Replace USING with one table     |\n"
    " | `replace_using_sub_query(delete, query, alias)` | Replace USING with one sub-query |\n"
    " | `no_using(delete)`                          | Remove USING clause              |\n"
    "\n"
    " ---\n"
    "\n"
    " ## JOIN\n"
    "\n"
    " For 🦭 MariaDB and 🐬 MySQL, `JOIN` is the standard way to filter a `DELETE`\n"
    " against another table.\n"
    "\n"
    " > On 🐘 PostgreSQL and 🪶 SQLite, `JOIN` on a `DELETE` requires a `USING`\n"
    " > clause to be set.\n"
    "\n"
    " ```gleam\n"
    " d.new()\n"
    " |> d.table(\"order_items\")\n"
    " |> d.join(j.inner(\n"
    "   with: j.table(\"orders\"),\n"
    "   on: w.eq(w.col(\"order_items.order_id\"), w.col(\"orders.id\")),\n"
    "   alias: \"orders\",\n"
    " ))\n"
    " |> d.where(w.eq(w.col(\"orders.status\"), w.string(\"cancelled\")))\n"
    " ```\n"
    "\n"
    " | Function                   | Effect                     |\n"
    " | ------                     | ------                     |\n"
    " | `join(delete, join)`            | Append one join            |\n"
    " | `replace_join(delete, join)`    | Replace all joins with one |\n"
    " | `joins(delete, joins)`          | Append many joins          |\n"
    " | `replace_joins(delete, joins)`  | Replace all joins          |\n"
    " | `no_join(delete)`               | Remove all joins           |\n"
    "\n"
    " ---\n"
    "\n"
    " ## WHERE clause\n"
    "\n"
    " See [`cake/where`](where.md) for building `Where` values.\n"
    "\n"
    " ### `where(delete, where) -> Delete(a)`\n"
    "\n"
    " Adds a condition with `AND` semantics.\n"
    "\n"
    " ```gleam\n"
    " d.new()\n"
    " |> d.table(\"users\")\n"
    " |> d.where(w.eq(w.col(\"active\"), w.bool(False)))\n"
    " |> d.where(w.lt(w.col(\"created_at\"), w.date(cutoff)))\n"
    " // DELETE FROM users WHERE active = $1 AND created_at < $2\n"
    " ```\n"
    "\n"
    " ### `or_where(delete, where) -> Delete(a)`\n"
    "\n"
    " Combines with `OR` semantics.\n"
    "\n"
    " ### `xor_where(delete, where) -> Delete(a)`\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(delete, where) -> Delete(a)`\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"
    " | Function                 | Effect                   |\n"
    " | ------                   | ------                   |\n"
    " | `replace_where(delete, where)` | Replace the entire WHERE |\n"
    " | `no_where(delete)`             | Remove WHERE clause      |\n"
    "\n"
    " ---\n"
    "\n"
    " ## RETURNING\n"
    "\n"
    " Fetch column values from the deleted rows.\n"
    "\n"
    " > Only supported by 🐘 PostgreSQL and 🪶 SQLite.\n"
    "\n"
    " ```gleam\n"
    " d.new()\n"
    " |> d.table(\"sessions\")\n"
    " |> d.where(w.eq(w.col(\"user_id\"), w.int(42)))\n"
    " |> d.returning([\"id\", \"token\"])\n"
    " // DELETE FROM sessions WHERE user_id = $1 RETURNING id, token\n"
    " ```\n"
    "\n"
    " | Function             | Effect                   |\n"
    " | ------               | ------                   |\n"
    " | `returning(delete, cols)` | Return the listed columns |\n"
    " | `no_returning(delete)`    | Remove RETURNING clause   |\n"
    "\n"
    " ---\n"
    "\n"
    " ## Modifier\n"
    "\n"
    " A raw string modifier inserted after `DELETE`\n"
    " (e.g. `LOW_PRIORITY` or `QUICK` for MySQL).\n"
    "\n"
    " ```gleam\n"
    " d.new() |> d.modifier(\"LOW_PRIORITY\")\n"
    " // DELETE LOW_PRIORITY FROM ...\n"
    " ```\n"
    "\n"
    " ---\n"
    "\n"
    " ## Epilog and Comment\n"
    "\n"
    " ```gleam\n"
    " d.new()\n"
    " |> d.table(\"audit_log\")\n"
    " |> d.where(w.lt(w.col(\"created_at\"), w.date(cutoff)))\n"
    " |> d.epilog(\"RETURNING id\")\n"
    " |> d.comment(\"purge old audit records\")\n"
    " ```\n"
    "\n"
    " ---\n"
    "\n"
    " ## Full Example\n"
    "\n"
    " ```gleam\n"
    " import cake/delete as d\n"
    " import cake/where as w\n"
    "\n"
    " d.new()\n"
    " |> d.table(\"messages\")\n"
    " |> d.where(w.and([\n"
    "   w.eq(w.col(\"read\"), w.bool(True)),\n"
    "   w.lt(w.col(\"created_at\"), w.date(thirty_days_ago)),\n"
    " ]))\n"
    " |> d.returning([\"id\"])\n"
    " |> d.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"
).

-file("src/cake/delete.gleam", 337).
?DOC(" Creates a `WriteQuery` from a `Delete` query.\n").
-spec to_query(cake@internal@write_query:delete(ERG)) -> cake@internal@write_query:write_query(ERG).
to_query(Delete) ->
    _pipe = Delete,
    {delete_query, _pipe}.

-file("src/cake/delete.gleam", 345).
?DOC(" Creates an empty `Delete` query.\n").
-spec new() -> cake@internal@write_query:delete(any()).
new() ->
    {delete,
        no_delete_modifier,
        no_delete_table,
        no_delete_using,
        no_joins,
        no_where,
        no_returning,
        no_epilog,
        no_comment}.

-file("src/cake/delete.gleam", 362).
?DOC(" Sets the `DELETE` modifier.\n").
-spec modifier(cake@internal@write_query:delete(ERL), binary()) -> cake@internal@write_query:delete(ERL).
modifier(Delete, Modifier) ->
    Modifier@1 = begin
        _pipe = Modifier,
        gleam@string:trim(_pipe)
    end,
    case Modifier@1 of
        <<""/utf8>> ->
            {delete,
                no_delete_modifier,
                erlang:element(3, Delete),
                erlang:element(4, Delete),
                erlang:element(5, Delete),
                erlang:element(6, Delete),
                erlang:element(7, Delete),
                erlang:element(8, Delete),
                erlang:element(9, Delete)};

        _ ->
            {delete,
                begin
                    _pipe@1 = Modifier@1,
                    {delete_modifier, _pipe@1}
                end,
                erlang:element(3, Delete),
                erlang:element(4, Delete),
                erlang:element(5, Delete),
                erlang:element(6, Delete),
                erlang:element(7, Delete),
                erlang:element(8, Delete),
                erlang:element(9, Delete)}
    end.

-file("src/cake/delete.gleam", 375).
?DOC(" Removes the `DELETE` modifier.\n").
-spec no_modifier(cake@internal@write_query:delete(ERO)) -> cake@internal@write_query:delete(ERO).
no_modifier(Delete) ->
    {delete,
        no_delete_modifier,
        erlang:element(3, Delete),
        erlang:element(4, Delete),
        erlang:element(5, Delete),
        erlang:element(6, Delete),
        erlang:element(7, Delete),
        erlang:element(8, Delete),
        erlang:element(9, Delete)}.

-file("src/cake/delete.gleam", 381).
?DOC(" Gets the `DELETE` modifier.\n").
-spec get_modifier(cake@internal@write_query:delete(any())) -> binary().
get_modifier(Delete) ->
    case erlang:element(2, Delete) of
        no_delete_modifier ->
            <<""/utf8>>;

        {delete_modifier, Keyword} ->
            Keyword
    end.

-file("src/cake/delete.gleam", 393).
?DOC(
    " Sets the table name of the `Delete` query, aka the table where\n"
    " the rows will be deleted from.\n"
).
-spec table(cake@internal@write_query:delete(ERT), binary()) -> cake@internal@write_query:delete(ERT).
table(Delete, Table_name) ->
    {delete,
        erlang:element(2, Delete),
        begin
            _pipe = Table_name,
            {delete_table, _pipe}
        end,
        erlang:element(4, Delete),
        erlang:element(5, Delete),
        erlang:element(6, Delete),
        erlang:element(7, Delete),
        erlang:element(8, Delete),
        erlang:element(9, Delete)}.

-file("src/cake/delete.gleam", 402).
?DOC(" Removes the table name from the `Delete` query.\n").
-spec no_table(cake@internal@write_query:delete(ERW)) -> cake@internal@write_query:delete(ERW).
no_table(Delete) ->
    {delete,
        erlang:element(2, Delete),
        no_delete_table,
        erlang:element(4, Delete),
        erlang:element(5, Delete),
        erlang:element(6, Delete),
        erlang:element(7, Delete),
        erlang:element(8, Delete),
        erlang:element(9, Delete)}.

-file("src/cake/delete.gleam", 408).
?DOC(" Gets the table name of the `Delete` query.\n").
-spec get_table(cake@internal@write_query:delete(any())) -> cake@internal@write_query:delete_table().
get_table(Delete) ->
    erlang:element(3, Delete).

-file("src/cake/delete.gleam", 428).
?DOC(
    " Adds a `USING` clause to the `Delete` query specifying a table.\n"
    "\n"
    " If the query already has a `USING` clause, the new `USING` clause\n"
    " will be appended to the existing one.\n"
    "\n"
    " The `USING` clause is used to specify additional tables that are used\n"
    " to filter the rows to be deleted.\n"
    "\n"
    " NOTICE: 🪶SQLite does not support `USING`.\n"
    "\n"
    " NOTICE: For 🦭MariaDB and 🐬MySQL it is mandatory to specify the table set\n"
    " within the `FROM` clause in the `USING` clause, again - e.g. in raw SQL:\n"
    " `DELETE * FROM a USING a, b, WHERE a.b_id = b.id;`\n"
).
-spec using_table(cake@internal@write_query:delete(ESB), binary()) -> cake@internal@write_query:delete(ESB).
using_table(Delete, Table_name) ->
    case erlang:element(4, Delete) of
        no_delete_using ->
            {delete,
                erlang:element(2, Delete),
                erlang:element(3, Delete),
                begin
                    _pipe@1 = [begin
                            _pipe = Table_name,
                            {from_table, _pipe}
                        end],
                    {delete_using, _pipe@1}
                end,
                erlang:element(5, Delete),
                erlang:element(6, Delete),
                erlang:element(7, Delete),
                erlang:element(8, Delete),
                erlang:element(9, Delete)};

        {delete_using, Delete_usings} ->
            {delete,
                erlang:element(2, Delete),
                erlang:element(3, Delete),
                begin
                    _pipe@2 = Delete_usings,
                    _pipe@4 = lists:append(
                        _pipe@2,
                        [begin
                                _pipe@3 = Table_name,
                                {from_table, _pipe@3}
                            end]
                    ),
                    {delete_using, _pipe@4}
                end,
                erlang:element(5, Delete),
                erlang:element(6, Delete),
                erlang:element(7, Delete),
                erlang:element(8, Delete),
                erlang:element(9, Delete)}
    end.

-file("src/cake/delete.gleam", 463).
?DOC(
    " Adds a `USING` clause to the `Delete` query specifying a sub-query.\n"
    "\n"
    " The sub-query must be aliased.\n"
    "\n"
    " If the query already has a `USING` clause, the new `USING` clause\n"
    " will be appended to the existing one.\n"
    "\n"
    " The `USING` clause is used to specify additional tables that are used\n"
    " to filter the rows to be deleted.\n"
    "\n"
    " NOTICE: 🪶SQLite does not support `USING`.\n"
    "\n"
    " NOTICE: 🦭MariaDB and 🐬MySQL do not support derived tables (sub-queries)\n"
    " in the `USING` clause of a multi-table `DELETE` - only literal table names\n"
    " are accepted there. Use a sub-query in a `WHERE` clause or a `JOIN` instead.\n"
    "\n"
    " NOTICE: 🪶SQLite does not support `USING` at all.\n"
).
-spec using_sub_query(
    cake@internal@write_query:delete(ESE),
    cake@internal@read_query:read_query(),
    binary()
) -> cake@internal@write_query:delete(ESE).
using_sub_query(Delete, Query, Alias) ->
    case erlang:element(4, Delete) of
        no_delete_using ->
            {delete,
                erlang:element(2, Delete),
                erlang:element(3, Delete),
                begin
                    _pipe = [{from_sub_query, Query, Alias}],
                    {delete_using, _pipe}
                end,
                erlang:element(5, Delete),
                erlang:element(6, Delete),
                erlang:element(7, Delete),
                erlang:element(8, Delete),
                erlang:element(9, Delete)};

        {delete_using, Delete_usings} ->
            {delete,
                erlang:element(2, Delete),
                erlang:element(3, Delete),
                begin
                    _pipe@1 = Delete_usings,
                    _pipe@2 = lists:append(
                        _pipe@1,
                        [{from_sub_query, Query, Alias}]
                    ),
                    {delete_using, _pipe@2}
                end,
                erlang:element(5, Delete),
                erlang:element(6, Delete),
                erlang:element(7, Delete),
                erlang:element(8, Delete),
                erlang:element(9, Delete)}
    end.

-file("src/cake/delete.gleam", 483).
?DOC(" Replaces the `USING` clause of the `Delete` query with a table.\n").
-spec replace_using_table(cake@internal@write_query:delete(ESH), binary()) -> cake@internal@write_query:delete(ESH).
replace_using_table(Delete, Table_name) ->
    {delete,
        erlang:element(2, Delete),
        erlang:element(3, Delete),
        begin
            _pipe@1 = [begin
                    _pipe = Table_name,
                    {from_table, _pipe}
                end],
            {delete_using, _pipe@1}
        end,
        erlang:element(5, Delete),
        erlang:element(6, Delete),
        erlang:element(7, Delete),
        erlang:element(8, Delete),
        erlang:element(9, Delete)}.

-file("src/cake/delete.gleam", 492).
?DOC(" Replaces the `USING` clause of the `Delete` query with a sub-query.\n").
-spec replace_using_sub_query(
    cake@internal@write_query:delete(ESK),
    cake@internal@read_query:read_query(),
    binary()
) -> cake@internal@write_query:delete(ESK).
replace_using_sub_query(Delete, Query, Alias) ->
    {delete,
        erlang:element(2, Delete),
        erlang:element(3, Delete),
        begin
            _pipe = [{from_sub_query, Query, Alias}],
            {delete_using, _pipe}
        end,
        erlang:element(5, Delete),
        erlang:element(6, Delete),
        erlang:element(7, Delete),
        erlang:element(8, Delete),
        erlang:element(9, Delete)}.

-file("src/cake/delete.gleam", 502).
?DOC(" Removes the `USING` clause from the `Delete` query.\n").
-spec no_using(cake@internal@write_query:delete(ESN)) -> cake@internal@write_query:delete(ESN).
no_using(Delete) ->
    {delete,
        erlang:element(2, Delete),
        erlang:element(3, Delete),
        no_delete_using,
        erlang:element(5, Delete),
        erlang:element(6, Delete),
        erlang:element(7, Delete),
        erlang:element(8, Delete),
        erlang:element(9, Delete)}.

-file("src/cake/delete.gleam", 508).
?DOC(" Gets the `USING` clause of the `Delete` query.\n").
-spec get_using(cake@internal@write_query:delete(any())) -> list(cake@internal@read_query:from()).
get_using(Delete) ->
    case erlang:element(4, Delete) of
        no_delete_using ->
            [];

        {delete_using, Using} ->
            Using
    end.

-file("src/cake/delete.gleam", 522).
?DOC(
    " Adds a `Join` to the `Delete` query.\n"
    "\n"
    " NOTICE: On 🐘PostgreSQL and 🪶SQLite `Joins` are only allowed if the `FROM`\n"
    " clause is set as well.\n"
).
-spec join(
    cake@internal@write_query:delete(EST),
    cake@internal@read_query:join()
) -> cake@internal@write_query:delete(EST).
join(Delete, Join) ->
    case erlang:element(5, Delete) of
        {joins, Existing_joins} ->
            {delete,
                erlang:element(2, Delete),
                erlang:element(3, Delete),
                erlang:element(4, Delete),
                begin
                    _pipe = Existing_joins,
                    _pipe@1 = lists:append(_pipe, [Join]),
                    {joins, _pipe@1}
                end,
                erlang:element(6, Delete),
                erlang:element(7, Delete),
                erlang:element(8, Delete),
                erlang:element(9, Delete)};

        no_joins ->
            {delete,
                erlang:element(2, Delete),
                erlang:element(3, Delete),
                erlang:element(4, Delete),
                begin
                    _pipe@2 = [Join],
                    {joins, _pipe@2}
                end,
                erlang:element(6, Delete),
                erlang:element(7, Delete),
                erlang:element(8, Delete),
                erlang:element(9, Delete)}
    end.

-file("src/cake/delete.gleam", 535).
?DOC(
    " Replaces any `Join`s of the `Delete` query with a single `Join`.\n"
    "\n"
    " NOTICE: On 🐘PostgreSQL and 🪶SQLite `Joins` are only allowed if the `FROM`\n"
    " clause is set as well.\n"
).
-spec replace_join(
    cake@internal@write_query:delete(ESW),
    cake@internal@read_query:join()
) -> cake@internal@write_query:delete(ESW).
replace_join(Delete, Join) ->
    {delete,
        erlang:element(2, Delete),
        erlang:element(3, Delete),
        erlang:element(4, Delete),
        begin
            _pipe = [Join],
            {joins, _pipe}
        end,
        erlang:element(6, Delete),
        erlang:element(7, Delete),
        erlang:element(8, Delete),
        erlang:element(9, Delete)}.

-file("src/cake/delete.gleam", 544).
?DOC(
    " Adds `Join`s to the `Delete` query.\n"
    "\n"
    " NOTICE: On 🐘PostgreSQL and 🪶SQLite `Joins` are only allowed if the `FROM`\n"
    " clause is set as well.\n"
).
-spec joins(
    cake@internal@write_query:delete(ESZ),
    list(cake@internal@read_query:join())
) -> cake@internal@write_query:delete(ESZ).
joins(Delete, Joins) ->
    case {Joins, erlang:element(5, Delete)} of
        {[], _} ->
            Delete;

        {_, {joins, Existing_joins}} ->
            {delete,
                erlang:element(2, Delete),
                erlang:element(3, Delete),
                erlang:element(4, Delete),
                begin
                    _pipe = Existing_joins,
                    _pipe@1 = lists:append(_pipe, Joins),
                    {joins, _pipe@1}
                end,
                erlang:element(6, Delete),
                erlang:element(7, Delete),
                erlang:element(8, Delete),
                erlang:element(9, Delete)};

        {_, no_joins} ->
            {delete,
                erlang:element(2, Delete),
                erlang:element(3, Delete),
                erlang:element(4, Delete),
                begin
                    _pipe@2 = Joins,
                    {joins, _pipe@2}
                end,
                erlang:element(6, Delete),
                erlang:element(7, Delete),
                erlang:element(8, Delete),
                erlang:element(9, Delete)}
    end.

-file("src/cake/delete.gleam", 558).
?DOC(
    " Replaces any `Join`s of the `Delete` query with the given `Join`s.\n"
    "\n"
    " NOTICE: On 🐘PostgreSQL and 🪶SQLite `Joins` are only allowed if the `FROM`\n"
    " clause is set as well.\n"
).
-spec replace_joins(
    cake@internal@write_query:delete(ETD),
    list(cake@internal@read_query:join())
) -> cake@internal@write_query:delete(ETD).
replace_joins(Delete, Joins) ->
    {delete,
        erlang:element(2, Delete),
        erlang:element(3, Delete),
        erlang:element(4, Delete),
        begin
            _pipe = Joins,
            {joins, _pipe}
        end,
        erlang:element(6, Delete),
        erlang:element(7, Delete),
        erlang:element(8, Delete),
        erlang:element(9, Delete)}.

-file("src/cake/delete.gleam", 567).
?DOC(" Removes any `Joins` from the `Delete` query.\n").
-spec no_join(cake@internal@write_query:delete(ETH)) -> cake@internal@write_query:delete(ETH).
no_join(Delete) ->
    {delete,
        erlang:element(2, Delete),
        erlang:element(3, Delete),
        erlang:element(4, Delete),
        no_joins,
        erlang:element(6, Delete),
        erlang:element(7, Delete),
        erlang:element(8, Delete),
        erlang:element(9, Delete)}.

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

-file("src/cake/delete.gleam", 588).
?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@write_query:delete(ETM),
    cake@internal@read_query:where()
) -> cake@internal@write_query:delete(ETM).
where(Delete, Where) ->
    case erlang:element(6, Delete) of
        no_where ->
            {delete,
                erlang:element(2, Delete),
                erlang:element(3, Delete),
                erlang:element(4, Delete),
                erlang:element(5, Delete),
                Where,
                erlang:element(7, Delete),
                erlang:element(8, Delete),
                erlang:element(9, Delete)};

        {and_where, Conditions} ->
            {delete,
                erlang:element(2, Delete),
                erlang:element(3, Delete),
                erlang:element(4, Delete),
                erlang:element(5, Delete),
                begin
                    _pipe = Conditions,
                    _pipe@1 = lists:append(_pipe, [Where]),
                    {and_where, _pipe@1}
                end,
                erlang:element(7, Delete),
                erlang:element(8, Delete),
                erlang:element(9, Delete)};

        _ ->
            {delete,
                erlang:element(2, Delete),
                erlang:element(3, Delete),
                erlang:element(4, Delete),
                erlang:element(5, Delete),
                begin
                    _pipe@2 = [erlang:element(6, Delete), Where],
                    {and_where, _pipe@2}
                end,
                erlang:element(7, Delete),
                erlang:element(8, Delete),
                erlang:element(9, Delete)}
    end.

-file("src/cake/delete.gleam", 606).
?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@write_query:delete(ETP),
    cake@internal@read_query:where()
) -> cake@internal@write_query:delete(ETP).
or_where(Delete, Where) ->
    case erlang:element(6, Delete) of
        no_where ->
            {delete,
                erlang:element(2, Delete),
                erlang:element(3, Delete),
                erlang:element(4, Delete),
                erlang:element(5, Delete),
                Where,
                erlang:element(7, Delete),
                erlang:element(8, Delete),
                erlang:element(9, Delete)};

        {or_where, Conditions} ->
            {delete,
                erlang:element(2, Delete),
                erlang:element(3, Delete),
                erlang:element(4, Delete),
                erlang:element(5, Delete),
                begin
                    _pipe = Conditions,
                    _pipe@1 = lists:append(_pipe, [Where]),
                    {or_where, _pipe@1}
                end,
                erlang:element(7, Delete),
                erlang:element(8, Delete),
                erlang:element(9, Delete)};

        _ ->
            {delete,
                erlang:element(2, Delete),
                erlang:element(3, Delete),
                erlang:element(4, Delete),
                erlang:element(5, Delete),
                begin
                    _pipe@2 = [erlang:element(6, Delete), Where],
                    {or_where, _pipe@2}
                end,
                erlang:element(7, Delete),
                erlang:element(8, Delete),
                erlang:element(9, Delete)}
    end.

-file("src/cake/delete.gleam", 631).
?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"
    "\n"
    " For odd-parity XOR (which on 🦭MariaDB / 🐬MySQL delegates to its native\n"
    " `XOR`) use `where.xor_parity` instead.\n"
).
-spec xor_where(
    cake@internal@write_query:delete(ETS),
    cake@internal@read_query:where()
) -> cake@internal@write_query:delete(ETS).
xor_where(Delete, Where) ->
    case erlang:element(6, Delete) of
        no_where ->
            {delete,
                erlang:element(2, Delete),
                erlang:element(3, Delete),
                erlang:element(4, Delete),
                erlang:element(5, Delete),
                Where,
                erlang:element(7, Delete),
                erlang:element(8, Delete),
                erlang:element(9, Delete)};

        {xor_where, Conditions} ->
            {delete,
                erlang:element(2, Delete),
                erlang:element(3, Delete),
                erlang:element(4, Delete),
                erlang:element(5, Delete),
                begin
                    _pipe = Conditions,
                    _pipe@1 = lists:append(_pipe, [Where]),
                    {xor_where, _pipe@1}
                end,
                erlang:element(7, Delete),
                erlang:element(8, Delete),
                erlang:element(9, Delete)};

        _ ->
            {delete,
                erlang:element(2, Delete),
                erlang:element(3, Delete),
                erlang:element(4, Delete),
                erlang:element(5, Delete),
                begin
                    _pipe@2 = [erlang:element(6, Delete), Where],
                    {xor_where, _pipe@2}
                end,
                erlang:element(7, Delete),
                erlang:element(8, Delete),
                erlang:element(9, Delete)}
    end.

-file("src/cake/delete.gleam", 651).
?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"
    " - 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@write_query:delete(ETV),
    cake@internal@read_query:where()
) -> cake@internal@write_query:delete(ETV).
not_where(Delete, Where) ->
    case erlang:element(6, Delete) of
        no_where ->
            {delete,
                erlang:element(2, Delete),
                erlang:element(3, Delete),
                erlang:element(4, Delete),
                erlang:element(5, Delete),
                {not_where, Where},
                erlang:element(7, Delete),
                erlang:element(8, Delete),
                erlang:element(9, Delete)};

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

        _ ->
            {delete,
                erlang:element(2, Delete),
                erlang:element(3, Delete),
                erlang:element(4, Delete),
                erlang:element(5, Delete),
                begin
                    _pipe@2 = [erlang:element(6, Delete), {not_where, Where}],
                    {and_where, _pipe@2}
                end,
                erlang:element(7, Delete),
                erlang:element(8, Delete),
                erlang:element(9, Delete)}
    end.

-file("src/cake/delete.gleam", 671).
?DOC(" Replaces the `Where` in the `Delete` query.\n").
-spec replace_where(
    cake@internal@write_query:delete(ETY),
    cake@internal@read_query:where()
) -> cake@internal@write_query:delete(ETY).
replace_where(Delete, Where) ->
    {delete,
        erlang:element(2, Delete),
        erlang:element(3, Delete),
        erlang:element(4, Delete),
        erlang:element(5, Delete),
        Where,
        erlang:element(7, Delete),
        erlang:element(8, Delete),
        erlang:element(9, Delete)}.

-file("src/cake/delete.gleam", 680).
?DOC(" Removes the `Where` from the `Delete` query.\n").
-spec no_where(cake@internal@write_query:delete(EUB)) -> cake@internal@write_query:delete(EUB).
no_where(Delete) ->
    {delete,
        erlang:element(2, Delete),
        erlang:element(3, Delete),
        erlang:element(4, Delete),
        erlang:element(5, Delete),
        no_where,
        erlang:element(7, Delete),
        erlang:element(8, Delete),
        erlang:element(9, Delete)}.

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

-file("src/cake/delete.gleam", 694).
?DOC(" Specify the columns to return after the `Delete` query.\n").
-spec returning(cake@internal@write_query:delete(EUG), list(binary())) -> cake@internal@write_query:delete(EUG).
returning(Delete, Returning) ->
    case Returning of
        [] ->
            {delete,
                erlang:element(2, Delete),
                erlang:element(3, Delete),
                erlang:element(4, Delete),
                erlang:element(5, Delete),
                erlang:element(6, Delete),
                no_returning,
                erlang:element(8, Delete),
                erlang:element(9, Delete)};

        _ ->
            {delete,
                erlang:element(2, Delete),
                erlang:element(3, Delete),
                erlang:element(4, Delete),
                erlang:element(5, Delete),
                erlang:element(6, Delete),
                begin
                    _pipe = Returning,
                    {returning, _pipe}
                end,
                erlang:element(8, Delete),
                erlang:element(9, Delete)}
    end.

-file("src/cake/delete.gleam", 706).
?DOC(" Specify that no columns should be returned after the `Delete` query.\n").
-spec no_returning(cake@internal@write_query:delete(EUK)) -> cake@internal@write_query:delete(EUK).
no_returning(Delete) ->
    {delete,
        erlang:element(2, Delete),
        erlang:element(3, Delete),
        erlang:element(4, Delete),
        erlang:element(5, Delete),
        erlang:element(6, Delete),
        no_returning,
        erlang:element(8, Delete),
        erlang:element(9, Delete)}.

-file("src/cake/delete.gleam", 714).
?DOC(" Specify an epilog for the `Delete` query.\n").
-spec epilog(cake@internal@write_query:delete(EUN), binary()) -> cake@internal@write_query:delete(EUN).
epilog(Delete, Epilog) ->
    Epilog@1 = begin
        _pipe = Epilog,
        gleam@string:trim(_pipe)
    end,
    case Epilog@1 of
        <<""/utf8>> ->
            {delete,
                erlang:element(2, Delete),
                erlang:element(3, Delete),
                erlang:element(4, Delete),
                erlang:element(5, Delete),
                erlang:element(6, Delete),
                erlang:element(7, Delete),
                no_epilog,
                erlang:element(9, Delete)};

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

-file("src/cake/delete.gleam", 724).
?DOC(" Specify that no epilog should be added to the `Delete` query.\n").
-spec no_epilog(cake@internal@write_query:delete(EUQ)) -> cake@internal@write_query:delete(EUQ).
no_epilog(Delete) ->
    {delete,
        erlang:element(2, Delete),
        erlang:element(3, Delete),
        erlang:element(4, Delete),
        erlang:element(5, Delete),
        erlang:element(6, Delete),
        erlang:element(7, Delete),
        no_epilog,
        erlang:element(9, Delete)}.

-file("src/cake/delete.gleam", 730).
?DOC(" Get the epilog from a `Delete` query.\n").
-spec get_epilog(cake@internal@write_query:delete(any())) -> cake@internal@read_query:epilog().
get_epilog(Delete) ->
    erlang:element(8, Delete).

-file("src/cake/delete.gleam", 738).
?DOC(" Specify a comment for the `Delete` query.\n").
-spec comment(cake@internal@write_query:delete(EUV), binary()) -> cake@internal@write_query:delete(EUV).
comment(Delete, Comment) ->
    Comment@1 = begin
        _pipe = Comment,
        gleam@string:trim(_pipe)
    end,
    case Comment@1 of
        <<""/utf8>> ->
            {delete,
                erlang:element(2, Delete),
                erlang:element(3, Delete),
                erlang:element(4, Delete),
                erlang:element(5, Delete),
                erlang:element(6, Delete),
                erlang:element(7, Delete),
                erlang:element(8, Delete),
                no_comment};

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

-file("src/cake/delete.gleam", 748).
?DOC(" Specify that no comment should be added to the `Delete` query.\n").
-spec no_comment(cake@internal@write_query:delete(EUY)) -> cake@internal@write_query:delete(EUY).
no_comment(Delete) ->
    {delete,
        erlang:element(2, Delete),
        erlang:element(3, Delete),
        erlang:element(4, Delete),
        erlang:element(5, Delete),
        erlang:element(6, Delete),
        erlang:element(7, Delete),
        erlang:element(8, Delete),
        no_comment}.

-file("src/cake/delete.gleam", 754).
?DOC(" Get the comment from a `Delete` query.\n").
-spec get_comment(cake@internal@write_query:delete(any())) -> cake@internal@read_query:comment().
get_comment(Delete) ->
    erlang:element(9, Delete).