-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, 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"
).

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

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

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

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

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

        {delete_modifier, Mdfr} ->
            Mdfr
    end.

-file("src/cake/delete.gleam", 111).
?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(ENH), binary()) -> cake@internal@write_query:delete(ENH).
table(Dlt, Tbl_nm) ->
    {delete,
        erlang:element(2, Dlt),
        begin
            _pipe = Tbl_nm,
            {delete_table, _pipe}
        end,
        erlang:element(4, Dlt),
        erlang:element(5, Dlt),
        erlang:element(6, Dlt),
        erlang:element(7, Dlt),
        erlang:element(8, Dlt),
        erlang:element(9, Dlt)}.

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

-file("src/cake/delete.gleam", 123).
?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(Dlt) ->
    erlang:element(3, Dlt).

-file("src/cake/delete.gleam", 143).
?DOC(
    " Adds a `USING` clause to the `Delete` query specifing 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(ENP), binary()) -> cake@internal@write_query:delete(ENP).
using_table(Dlt, Tbl_nm) ->
    case erlang:element(4, Dlt) of
        no_delete_using ->
            {delete,
                erlang:element(2, Dlt),
                erlang:element(3, Dlt),
                begin
                    _pipe@1 = [begin
                            _pipe = Tbl_nm,
                            {from_table, _pipe}
                        end],
                    {delete_using, _pipe@1}
                end,
                erlang:element(5, Dlt),
                erlang:element(6, Dlt),
                erlang:element(7, Dlt),
                erlang:element(8, Dlt),
                erlang:element(9, Dlt)};

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

-file("src/cake/delete.gleam", 174).
?DOC(
    " Adds a `USING` clause to the `Delete` query specifing 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 may not support sub-queries in the `USING`\n"
    " clause.\n"
    " In such case you may use a sub-query in a `WHERE` clause,  or use a join\n"
    " instead.\n"
).
-spec using_sub_query(
    cake@internal@write_query:delete(ENS),
    cake@internal@read_query:read_query(),
    binary()
) -> cake@internal@write_query:delete(ENS).
using_sub_query(Dlt, Qry, Als) ->
    case erlang:element(4, Dlt) of
        no_delete_using ->
            {delete,
                erlang:element(2, Dlt),
                erlang:element(3, Dlt),
                begin
                    _pipe@1 = [begin
                            _pipe = Qry,
                            {from_sub_query, _pipe, Als}
                        end],
                    {delete_using, _pipe@1}
                end,
                erlang:element(5, Dlt),
                erlang:element(6, Dlt),
                erlang:element(7, Dlt),
                erlang:element(8, Dlt),
                erlang:element(9, Dlt)};

        {delete_using, Dlt_usngs} ->
            {delete,
                erlang:element(2, Dlt),
                erlang:element(3, Dlt),
                begin
                    _pipe@2 = Dlt_usngs,
                    _pipe@4 = lists:append(
                        _pipe@2,
                        [begin
                                _pipe@3 = Qry,
                                {from_sub_query, _pipe@3, Als}
                            end]
                    ),
                    {delete_using, _pipe@4}
                end,
                erlang:element(5, Dlt),
                erlang:element(6, Dlt),
                erlang:element(7, Dlt),
                erlang:element(8, Dlt),
                erlang:element(9, Dlt)}
    end.

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

        {delete_using, _} ->
            {delete,
                erlang:element(2, Dlt),
                erlang:element(3, Dlt),
                begin
                    _pipe@3 = [begin
                            _pipe@2 = Tbl_nm,
                            {from_table, _pipe@2}
                        end],
                    {delete_using, _pipe@3}
                end,
                erlang:element(5, Dlt),
                erlang:element(6, Dlt),
                erlang:element(7, Dlt),
                erlang:element(8, Dlt),
                erlang:element(9, Dlt)}
    end.

-file("src/cake/delete.gleam", 206).
?DOC(" Replaces the `USING` clause of the `Delete` query with a sub-query.\n").
-spec replace_using_sub_query(
    cake@internal@write_query:delete(ENY),
    cake@internal@read_query:read_query(),
    binary()
) -> cake@internal@write_query:delete(ENY).
replace_using_sub_query(Dlt, Qry, Als) ->
    case erlang:element(4, Dlt) of
        no_delete_using ->
            {delete,
                erlang:element(2, Dlt),
                erlang:element(3, Dlt),
                begin
                    _pipe@1 = [begin
                            _pipe = Qry,
                            {from_sub_query, _pipe, Als}
                        end],
                    {delete_using, _pipe@1}
                end,
                erlang:element(5, Dlt),
                erlang:element(6, Dlt),
                erlang:element(7, Dlt),
                erlang:element(8, Dlt),
                erlang:element(9, Dlt)};

        {delete_using, _} ->
            {delete,
                erlang:element(2, Dlt),
                erlang:element(3, Dlt),
                begin
                    _pipe@3 = [begin
                            _pipe@2 = Qry,
                            {from_sub_query, _pipe@2, Als}
                        end],
                    {delete_using, _pipe@3}
                end,
                erlang:element(5, Dlt),
                erlang:element(6, Dlt),
                erlang:element(7, Dlt),
                erlang:element(8, Dlt),
                erlang:element(9, Dlt)}
    end.

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

-file("src/cake/delete.gleam", 227).
?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(Dlt) ->
    case erlang:element(4, Dlt) of
        no_delete_using ->
            [];

        {delete_using, Usng} ->
            Usng
    end.

-file("src/cake/delete.gleam", 241).
?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(EOH),
    cake@internal@read_query:join()
) -> cake@internal@write_query:delete(EOH).
join(Dlt, Jn) ->
    case erlang:element(5, Dlt) of
        {joins, Jns} ->
            {delete,
                erlang:element(2, Dlt),
                erlang:element(3, Dlt),
                erlang:element(4, Dlt),
                begin
                    _pipe = Jns,
                    _pipe@1 = lists:append(_pipe, [Jn]),
                    {joins, _pipe@1}
                end,
                erlang:element(6, Dlt),
                erlang:element(7, Dlt),
                erlang:element(8, Dlt),
                erlang:element(9, Dlt)};

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

-file("src/cake/delete.gleam", 253).
?DOC(
    " Replaces any `Join`s of the `Delete` query with a signle `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(EOK),
    cake@internal@read_query:join()
) -> cake@internal@write_query:delete(EOK).
replace_join(Dlt, Jn) ->
    {delete,
        erlang:element(2, Dlt),
        erlang:element(3, Dlt),
        erlang:element(4, Dlt),
        begin
            _pipe = [Jn],
            {joins, _pipe}
        end,
        erlang:element(6, Dlt),
        erlang:element(7, Dlt),
        erlang:element(8, Dlt),
        erlang:element(9, Dlt)}.

-file("src/cake/delete.gleam", 262).
?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(EON),
    list(cake@internal@read_query:join())
) -> cake@internal@write_query:delete(EON).
joins(Dlt, Jns) ->
    case {Jns, erlang:element(5, Dlt)} of
        {[], _} ->
            {delete,
                erlang:element(2, Dlt),
                erlang:element(3, Dlt),
                erlang:element(4, Dlt),
                begin
                    _pipe = Jns,
                    {joins, _pipe}
                end,
                erlang:element(6, Dlt),
                erlang:element(7, Dlt),
                erlang:element(8, Dlt),
                erlang:element(9, Dlt)};

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

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

-file("src/cake/delete.gleam", 276).
?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(EOR),
    list(cake@internal@read_query:join())
) -> cake@internal@write_query:delete(EOR).
replace_joins(Dlt, Jns) ->
    {delete,
        erlang:element(2, Dlt),
        erlang:element(3, Dlt),
        erlang:element(4, Dlt),
        begin
            _pipe = Jns,
            {joins, _pipe}
        end,
        erlang:element(6, Dlt),
        erlang:element(7, Dlt),
        erlang:element(8, Dlt),
        erlang:element(9, Dlt)}.

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

-file("src/cake/delete.gleam", 288).
?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(Dlt) ->
    erlang:element(5, Dlt).

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

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

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

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

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

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

-file("src/cake/delete.gleam", 344).
?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: This operator does not exist in 🐘PostgreSQL or 🪶SQLite, and\n"
    " *Cake* generates equivalent SQL using `OR` and `AND` and `NOT`.\n"
    "\n"
    " NOTICE: This operator exists in 🦭MariaDB and 🐬MySQL, nativly.\n"
).
-spec xor_where(
    cake@internal@write_query:delete(EPG),
    cake@internal@read_query:where()
) -> cake@internal@write_query:delete(EPG).
xor_where(Dlt, Whr) ->
    case erlang:element(6, Dlt) of
        no_where ->
            {delete,
                erlang:element(2, Dlt),
                erlang:element(3, Dlt),
                erlang:element(4, Dlt),
                erlang:element(5, Dlt),
                Whr,
                erlang:element(7, Dlt),
                erlang:element(8, Dlt),
                erlang:element(9, Dlt)};

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

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

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

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

-file("src/cake/delete.gleam", 367).
?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(Dlt) ->
    erlang:element(6, Dlt).

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

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

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

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

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

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

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

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

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

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

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