-module(cake@update).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([to_query/1, new/0, table/2, get_table/1, set_bool/2, set_true/1, set_false/1, set_float/2, set_int/2, set_string/2, set_null/1, set_expression/2, set_sub_query/2, sets_expression/2, sets_sub_query/2, get_set/1, set/2, set_replace/2, sets/2, sets_replace/2, from_table/2, from_sub_query/3, no_from/1, get_from/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 `UPDATE` queries.\n"
    "\n"
).

-file("src/cake/update.gleam", 63).
?DOC(" Creates a `WriteQuery` from an `Update` query.\n").
-spec to_query(cake@internal@write_query:update(PXF)) -> cake@internal@write_query:write_query(PXF).
to_query(Updt) ->
    _pipe = Updt,
    {update_query, _pipe}.

-file("src/cake/update.gleam", 71).
?DOC(" Creates an empty `Update` query.\n").
-spec new() -> cake@internal@write_query:update(any()).
new() ->
    {update,
        no_update_table,
        no_update_modifier,
        no_update_sets,
        no_from,
        no_joins,
        no_where,
        no_returning,
        no_epilog,
        no_comment}.

-file("src/cake/update.gleam", 89).
?DOC(" Sets the table of the `Update` query.\n").
-spec table(cake@internal@write_query:update(PXK), binary()) -> cake@internal@write_query:update(PXK).
table(Updt, Tbl_nm) ->
    _record = Updt,
    {update,
        begin
            _pipe = Tbl_nm,
            {update_table, _pipe}
        end,
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record)}.

-file("src/cake/update.gleam", 95).
?DOC(" Get the table of the `Update` query.\n").
-spec get_table(cake@internal@write_query:update(any())) -> cake@internal@write_query:update_table().
get_table(Updt) ->
    erlang:element(2, Updt).

-file("src/cake/update.gleam", 103).
?DOC(" Sets a column to a `Bool` `UpdateParamSet`.\n").
-spec set_bool(binary(), boolean()) -> cake@internal@write_query:update_set().
set_bool(Col, V) ->
    _pipe = V,
    _pipe@1 = {bool_param, _pipe},
    {update_param_set, Col, _pipe@1}.

-file("src/cake/update.gleam", 109).
?DOC(" Sets a column to a `True` `UpdateParamSet`.\n").
-spec set_true(binary()) -> cake@internal@write_query:update_set().
set_true(Col) ->
    _pipe = true,
    _pipe@1 = {bool_param, _pipe},
    {update_param_set, Col, _pipe@1}.

-file("src/cake/update.gleam", 115).
?DOC(" Sets a column to a `False` `UpdateParamSet`.\n").
-spec set_false(binary()) -> cake@internal@write_query:update_set().
set_false(Col) ->
    _pipe = false,
    _pipe@1 = {bool_param, _pipe},
    {update_param_set, Col, _pipe@1}.

-file("src/cake/update.gleam", 121).
?DOC(" Sets a column to a `Float` `UpdateParamSet`.\n").
-spec set_float(binary(), float()) -> cake@internal@write_query:update_set().
set_float(Col, V) ->
    _pipe = V,
    _pipe@1 = {float_param, _pipe},
    {update_param_set, Col, _pipe@1}.

-file("src/cake/update.gleam", 127).
?DOC(" Sets a column to a `Int` `UpdateParamSet`.\n").
-spec set_int(binary(), integer()) -> cake@internal@write_query:update_set().
set_int(Col, V) ->
    _pipe = V,
    _pipe@1 = {int_param, _pipe},
    {update_param_set, Col, _pipe@1}.

-file("src/cake/update.gleam", 133).
?DOC(" Sets a column to a string `UpdateParamSet`.\n").
-spec set_string(binary(), binary()) -> cake@internal@write_query:update_set().
set_string(Col, V) ->
    _pipe = V,
    _pipe@1 = {string_param, _pipe},
    {update_param_set, Col, _pipe@1}.

-file("src/cake/update.gleam", 139).
?DOC(" Sets a column to an SQL `NULL` `UpdateParamSet`.\n").
-spec set_null(binary()) -> cake@internal@write_query:update_set().
set_null(Col) ->
    _pipe = null_param,
    {update_param_set, Col, _pipe}.

-file("src/cake/update.gleam", 145).
?DOC(" Sets a column to an expression value.\n").
-spec set_expression(binary(), binary()) -> cake@internal@write_query:update_set().
set_expression(Col, Exp) ->
    _pipe = [Col],
    {update_expression_set, _pipe, Exp}.

-file("src/cake/update.gleam", 151).
?DOC(" Sets a column to a sub-query value.\n").
-spec set_sub_query(binary(), cake@internal@read_query:read_query()) -> cake@internal@write_query:update_set().
set_sub_query(Col, Qry) ->
    _pipe = [Col],
    {update_sub_query_set, _pipe, Qry}.

-file("src/cake/update.gleam", 159).
?DOC(
    " Sets many columns to an expression value.\n"
    "\n"
    " NOTICE: the expression must return an equal count of columns.\n"
).
-spec sets_expression(list(binary()), binary()) -> cake@internal@write_query:update_set().
sets_expression(Cols, Exp) ->
    _pipe = Cols,
    {update_expression_set, _pipe, Exp}.

-file("src/cake/update.gleam", 170).
?DOC(
    " Sets many columns to a sub-query value.\n"
    "\n"
    " NOTICE: the sub-query must return an equal count of columns.\n"
).
-spec sets_sub_query(list(binary()), cake@internal@read_query:read_query()) -> cake@internal@write_query:update_set().
sets_sub_query(Cols, Qry) ->
    _pipe = Cols,
    {update_sub_query_set, _pipe, Qry}.

-file("src/cake/update.gleam", 179).
?DOC(" Get the `SET`s of the `Update` query.\n").
-spec get_set(cake@internal@write_query:update(any())) -> list(cake@internal@write_query:update_set()).
get_set(Updt) ->
    case erlang:element(4, Updt) of
        no_update_sets ->
            [];

        {update_sets, Sets} ->
            Sets
    end.

-file("src/cake/update.gleam", 188).
?DOC(" Sets or appends one column set in an `Update` query.\n").
-spec set(
    cake@internal@write_query:update(PXU),
    cake@internal@write_query:update_set()
) -> cake@internal@write_query:update(PXU).
set(Updt, St) ->
    case erlang:element(4, Updt) of
        no_update_sets ->
            _record = Updt,
            {update,
                erlang:element(2, _record),
                erlang:element(3, _record),
                begin
                    _pipe = [St],
                    {update_sets, _pipe}
                end,
                erlang:element(5, _record),
                erlang:element(6, _record),
                erlang:element(7, _record),
                erlang:element(8, _record),
                erlang:element(9, _record),
                erlang:element(10, _record)};

        {update_sets, Sets} ->
            _record@1 = Updt,
            {update,
                erlang:element(2, _record@1),
                erlang:element(3, _record@1),
                begin
                    _pipe@1 = Sets,
                    _pipe@2 = lists:append(_pipe@1, [St]),
                    {update_sets, _pipe@2}
                end,
                erlang:element(5, _record@1),
                erlang:element(6, _record@1),
                erlang:element(7, _record@1),
                erlang:element(8, _record@1),
                erlang:element(9, _record@1),
                erlang:element(10, _record@1)}
    end.

-file("src/cake/update.gleam", 198).
?DOC(" Sets or replaces one column set in an `Update` query.\n").
-spec set_replace(
    cake@internal@write_query:update(PXX),
    cake@internal@write_query:update_set()
) -> cake@internal@write_query:update(PXX).
set_replace(Updt, St) ->
    _record = Updt,
    {update,
        erlang:element(2, _record),
        erlang:element(3, _record),
        begin
            _pipe = [St],
            {update_sets, _pipe}
        end,
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record)}.

-file("src/cake/update.gleam", 204).
?DOC(" Sets or appends many column sets n an `Update` query.\n").
-spec sets(
    cake@internal@write_query:update(PYA),
    list(cake@internal@write_query:update_set())
) -> cake@internal@write_query:update(PYA).
sets(Updt, Sts) ->
    case erlang:element(4, Updt) of
        no_update_sets ->
            _record = Updt,
            {update,
                erlang:element(2, _record),
                erlang:element(3, _record),
                begin
                    _pipe = Sts,
                    {update_sets, _pipe}
                end,
                erlang:element(5, _record),
                erlang:element(6, _record),
                erlang:element(7, _record),
                erlang:element(8, _record),
                erlang:element(9, _record),
                erlang:element(10, _record)};

        {update_sets, Sets} ->
            _record@1 = Updt,
            {update,
                erlang:element(2, _record@1),
                erlang:element(3, _record@1),
                begin
                    _pipe@1 = Sets,
                    _pipe@2 = lists:append(_pipe@1, Sts),
                    {update_sets, _pipe@2}
                end,
                erlang:element(5, _record@1),
                erlang:element(6, _record@1),
                erlang:element(7, _record@1),
                erlang:element(8, _record@1),
                erlang:element(9, _record@1),
                erlang:element(10, _record@1)}
    end.

-file("src/cake/update.gleam", 214).
?DOC(" Sets or replaces many column sets in an `Update` query.\n").
-spec sets_replace(
    cake@internal@write_query:update(PYE),
    list(cake@internal@write_query:update_set())
) -> cake@internal@write_query:update(PYE).
sets_replace(Updt, Sts) ->
    _record = Updt,
    {update,
        erlang:element(2, _record),
        erlang:element(3, _record),
        begin
            _pipe = Sts,
            {update_sets, _pipe}
        end,
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record)}.

-file("src/cake/update.gleam", 225).
?DOC(" Sets the `FROM` clause of the `Update` query to a table name.\n").
-spec from_table(cake@internal@write_query:update(PYI), binary()) -> cake@internal@write_query:update(PYI).
from_table(Updt, Tbl_nm) ->
    _record = Updt,
    {update,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        begin
            _pipe = Tbl_nm,
            {from_table, _pipe}
        end,
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record)}.

-file("src/cake/update.gleam", 231).
?DOC(" Sets the `FROM` clause of the `Update` query to an aliased sub-query.\n").
-spec from_sub_query(
    cake@internal@write_query:update(PYL),
    cake@internal@read_query:read_query(),
    binary()
) -> cake@internal@write_query:update(PYL).
from_sub_query(Updt, Qry, Als) ->
    _record = Updt,
    {update,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        begin
            _pipe = Qry,
            {from_sub_query, _pipe, Als}
        end,
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record)}.

-file("src/cake/update.gleam", 241).
?DOC(" Removes the `FROM` clause of the `Update` query.\n").
-spec no_from(cake@internal@write_query:update(PYO)) -> cake@internal@write_query:update(PYO).
no_from(Updt) ->
    _record = Updt,
    {update,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        no_from,
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record)}.

-file("src/cake/update.gleam", 247).
?DOC(" Gets the `FROM` clause of the `Update` query.\n").
-spec get_from(cake@internal@write_query:update(any())) -> cake@internal@read_query:from().
get_from(Updt) ->
    erlang:element(5, Updt).

-file("src/cake/update.gleam", 258).
?DOC(
    " Adds a `Join` to the `Update` 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:update(PYT),
    cake@internal@read_query:join()
) -> cake@internal@write_query:update(PYT).
join(Updt, Jn) ->
    case erlang:element(6, Updt) of
        {joins, Jns} ->
            _record = Updt,
            {update,
                erlang:element(2, _record),
                erlang:element(3, _record),
                erlang:element(4, _record),
                erlang:element(5, _record),
                begin
                    _pipe = Jns,
                    _pipe@1 = lists:append(_pipe, [Jn]),
                    {joins, _pipe@1}
                end,
                erlang:element(7, _record),
                erlang:element(8, _record),
                erlang:element(9, _record),
                erlang:element(10, _record)};

        no_joins ->
            _record@1 = Updt,
            {update,
                erlang:element(2, _record@1),
                erlang:element(3, _record@1),
                erlang:element(4, _record@1),
                erlang:element(5, _record@1),
                begin
                    _pipe@2 = [Jn],
                    {joins, _pipe@2}
                end,
                erlang:element(7, _record@1),
                erlang:element(8, _record@1),
                erlang:element(9, _record@1),
                erlang:element(10, _record@1)}
    end.

-file("src/cake/update.gleam", 270).
?DOC(
    " Replaces any `Join`s of the `Update` 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:update(PYW),
    cake@internal@read_query:join()
) -> cake@internal@write_query:update(PYW).
replace_join(Updt, Jn) ->
    _record = Updt,
    {update,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        begin
            _pipe = [Jn],
            {joins, _pipe}
        end,
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record)}.

-file("src/cake/update.gleam", 279).
?DOC(
    " Adds `Join`s to the `Update` 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:update(PYZ),
    list(cake@internal@read_query:join())
) -> cake@internal@write_query:update(PYZ).
joins(Updt, Jns) ->
    case {Jns, erlang:element(6, Updt)} of
        {[], _} ->
            _record = Updt,
            {update,
                erlang:element(2, _record),
                erlang:element(3, _record),
                erlang:element(4, _record),
                erlang:element(5, _record),
                begin
                    _pipe = Jns,
                    {joins, _pipe}
                end,
                erlang:element(7, _record),
                erlang:element(8, _record),
                erlang:element(9, _record),
                erlang:element(10, _record)};

        {Jns@1, {joins, Updt_joins}} ->
            _record@1 = Updt,
            {update,
                erlang:element(2, _record@1),
                erlang:element(3, _record@1),
                erlang:element(4, _record@1),
                erlang:element(5, _record@1),
                begin
                    _pipe@1 = Updt_joins,
                    _pipe@2 = lists:append(_pipe@1, Jns@1),
                    {joins, _pipe@2}
                end,
                erlang:element(7, _record@1),
                erlang:element(8, _record@1),
                erlang:element(9, _record@1),
                erlang:element(10, _record@1)};

        {Jns@2, no_joins} ->
            _record@2 = Updt,
            {update,
                erlang:element(2, _record@2),
                erlang:element(3, _record@2),
                erlang:element(4, _record@2),
                erlang:element(5, _record@2),
                begin
                    _pipe@3 = Jns@2,
                    {joins, _pipe@3}
                end,
                erlang:element(7, _record@2),
                erlang:element(8, _record@2),
                erlang:element(9, _record@2),
                erlang:element(10, _record@2)}
    end.

-file("src/cake/update.gleam", 293).
?DOC(
    " Replaces any `Join`s of the `Update` 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:update(PZD),
    list(cake@internal@read_query:join())
) -> cake@internal@write_query:update(PZD).
replace_joins(Updt, Jns) ->
    _record = Updt,
    {update,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        begin
            _pipe = Jns,
            {joins, _pipe}
        end,
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record)}.

-file("src/cake/update.gleam", 299).
?DOC(" Removes any `Joins` from the `Update` query.\n").
-spec no_join(cake@internal@write_query:update(PZH)) -> cake@internal@write_query:update(PZH).
no_join(Updt) ->
    _record = Updt,
    {update,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        no_joins,
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record)}.

-file("src/cake/update.gleam", 305).
?DOC(" Gets the `Joins` of the `Update` query.\n").
-spec get_joins(cake@internal@write_query:update(any())) -> cake@internal@read_query:joins().
get_joins(Updt) ->
    erlang:element(6, Updt).

-file("src/cake/update.gleam", 320).
?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:update(PZM),
    cake@internal@read_query:where()
) -> cake@internal@write_query:update(PZM).
where(Updt, Whr) ->
    case erlang:element(7, Updt) of
        no_where ->
            _record = Updt,
            {update,
                erlang:element(2, _record),
                erlang:element(3, _record),
                erlang:element(4, _record),
                erlang:element(5, _record),
                erlang:element(6, _record),
                Whr,
                erlang:element(8, _record),
                erlang:element(9, _record),
                erlang:element(10, _record)};

        {and_where, Wheres} ->
            _record@1 = Updt,
            {update,
                erlang:element(2, _record@1),
                erlang:element(3, _record@1),
                erlang:element(4, _record@1),
                erlang:element(5, _record@1),
                erlang:element(6, _record@1),
                begin
                    _pipe = Wheres,
                    _pipe@1 = lists:append(_pipe, [Whr]),
                    {and_where, _pipe@1}
                end,
                erlang:element(8, _record@1),
                erlang:element(9, _record@1),
                erlang:element(10, _record@1)};

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

-file("src/cake/update.gleam", 338).
?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:update(PZP),
    cake@internal@read_query:where()
) -> cake@internal@write_query:update(PZP).
or_where(Updt, Whr) ->
    case erlang:element(7, Updt) of
        no_where ->
            _record = Updt,
            {update,
                erlang:element(2, _record),
                erlang:element(3, _record),
                erlang:element(4, _record),
                erlang:element(5, _record),
                erlang:element(6, _record),
                Whr,
                erlang:element(8, _record),
                erlang:element(9, _record),
                erlang:element(10, _record)};

        {or_where, Wheres} ->
            _record@1 = Updt,
            {update,
                erlang:element(2, _record@1),
                erlang:element(3, _record@1),
                erlang:element(4, _record@1),
                erlang:element(5, _record@1),
                erlang:element(6, _record@1),
                begin
                    _pipe = Wheres,
                    _pipe@1 = lists:append(_pipe, [Whr]),
                    {or_where, _pipe@1}
                end,
                erlang:element(8, _record@1),
                erlang:element(9, _record@1),
                erlang:element(10, _record@1)};

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

-file("src/cake/update.gleam", 361).
?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,\n"
    " and *Cake* generates equivalent SQL using `OR` and `AND` and `NOT`.\n"
    "\n"
    " NOTICE: This operator exists in 🦭MariaDB and 🐬MySQL with native support.\n"
).
-spec xor_where(
    cake@internal@write_query:update(PZS),
    cake@internal@read_query:where()
) -> cake@internal@write_query:update(PZS).
xor_where(Updt, Whr) ->
    case erlang:element(7, Updt) of
        no_where ->
            _record = Updt,
            {update,
                erlang:element(2, _record),
                erlang:element(3, _record),
                erlang:element(4, _record),
                erlang:element(5, _record),
                erlang:element(6, _record),
                Whr,
                erlang:element(8, _record),
                erlang:element(9, _record),
                erlang:element(10, _record)};

        {xor_where, Wheres} ->
            _record@1 = Updt,
            {update,
                erlang:element(2, _record@1),
                erlang:element(3, _record@1),
                erlang:element(4, _record@1),
                erlang:element(5, _record@1),
                erlang:element(6, _record@1),
                begin
                    _pipe = Wheres,
                    _pipe@1 = lists:append(_pipe, [Whr]),
                    {xor_where, _pipe@1}
                end,
                erlang:element(8, _record@1),
                erlang:element(9, _record@1),
                erlang:element(10, _record@1)};

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

-file("src/cake/update.gleam", 372).
?DOC(" Replaces the `Where` in the `Update` query.\n").
-spec replace_where(
    cake@internal@write_query:update(PZV),
    cake@internal@read_query:where()
) -> cake@internal@write_query:update(PZV).
replace_where(Updt, Whr) ->
    _record = Updt,
    {update,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        Whr,
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record)}.

-file("src/cake/update.gleam", 378).
?DOC(" Removes the `Where` from the `Update` query.\n").
-spec no_where(cake@internal@write_query:update(PZY)) -> cake@internal@write_query:update(PZY).
no_where(Updt) ->
    _record = Updt,
    {update,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        no_where,
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record)}.

-file("src/cake/update.gleam", 384).
?DOC(" Gets the `Where` of the `Update` query.\n").
-spec get_where(cake@internal@write_query:update(any())) -> cake@internal@read_query:where().
get_where(Updt) ->
    erlang:element(7, Updt).

-file("src/cake/update.gleam", 393).
?DOC(
    " NOTICE: 🦭MariaDB and 🐬MySQL do not support `RETURNING` in `UPDATE`\n"
    " queries; they do support it in `INSERT` (and `REPLACE`) queries, however.\n"
).
-spec returning(cake@internal@write_query:update(QAD), list(binary())) -> cake@internal@write_query:update(QAD).
returning(Updt, Rtrn) ->
    case Rtrn of
        [] ->
            _record = Updt,
            {update,
                erlang:element(2, _record),
                erlang:element(3, _record),
                erlang:element(4, _record),
                erlang:element(5, _record),
                erlang:element(6, _record),
                erlang:element(7, _record),
                no_returning,
                erlang:element(9, _record),
                erlang:element(10, _record)};

        _ ->
            _record@1 = Updt,
            {update,
                erlang:element(2, _record@1),
                erlang:element(3, _record@1),
                erlang:element(4, _record@1),
                erlang:element(5, _record@1),
                erlang:element(6, _record@1),
                erlang:element(7, _record@1),
                begin
                    _pipe = Rtrn,
                    {returning, _pipe}
                end,
                erlang:element(9, _record@1),
                erlang:element(10, _record@1)}
    end.

-file("src/cake/update.gleam", 406).
?DOC(
    " NOTICE: 🦭MariaDB and 🐬MySQL do not support `RETURNING` in `UPDATE`\n"
    " queries; they do support it in `INSERT` (and `REPLACE`) queries, however.\n"
).
-spec no_returning(cake@internal@write_query:update(QAH)) -> cake@internal@write_query:update(QAH).
no_returning(Updt) ->
    _record = Updt,
    {update,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        no_returning,
        erlang:element(9, _record),
        erlang:element(10, _record)}.

-file("src/cake/update.gleam", 414).
?DOC(" Sets an `Epilog` or appends into an existing `Epilog`.\n").
-spec epilog(cake@internal@write_query:update(QAK), binary()) -> cake@internal@write_query:update(QAK).
epilog(Updt, Eplg) ->
    Eplg@1 = begin
        _pipe = Eplg,
        gleam@string:trim(_pipe)
    end,
    case Eplg@1 of
        <<""/utf8>> ->
            _record = Updt,
            {update,
                erlang:element(2, _record),
                erlang:element(3, _record),
                erlang:element(4, _record),
                erlang:element(5, _record),
                erlang:element(6, _record),
                erlang:element(7, _record),
                erlang:element(8, _record),
                no_epilog,
                erlang:element(10, _record)};

        _ ->
            _record@1 = Updt,
            {update,
                erlang:element(2, _record@1),
                erlang:element(3, _record@1),
                erlang:element(4, _record@1),
                erlang:element(5, _record@1),
                erlang:element(6, _record@1),
                erlang:element(7, _record@1),
                erlang:element(8, _record@1),
                begin
                    _pipe@1 = (<<" "/utf8, Eplg@1/binary>>),
                    {epilog, _pipe@1}
                end,
                erlang:element(10, _record@1)}
    end.

-file("src/cake/update.gleam", 424).
?DOC(" Removes the `Epilog` from the `Update` query.\n").
-spec no_epilog(cake@internal@write_query:update(QAN)) -> cake@internal@write_query:update(QAN).
no_epilog(Updt) ->
    _record = Updt,
    {update,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        no_epilog,
        erlang:element(10, _record)}.

-file("src/cake/update.gleam", 430).
?DOC(" Gets the `Epilog` of the `Update` query.\n").
-spec get_epilog(cake@internal@write_query:update(any())) -> cake@internal@read_query:epilog().
get_epilog(Updt) ->
    erlang:element(9, Updt).

-file("src/cake/update.gleam", 438).
?DOC(" Sets a `Comment` or appends into an existing `Comment`.\n").
-spec comment(cake@internal@write_query:update(QAS), binary()) -> cake@internal@write_query:update(QAS).
comment(Updt, Cmmnt) ->
    Cmmnt@1 = begin
        _pipe = Cmmnt,
        gleam@string:trim(_pipe)
    end,
    case Cmmnt@1 of
        <<""/utf8>> ->
            _record = Updt,
            {update,
                erlang:element(2, _record),
                erlang:element(3, _record),
                erlang:element(4, _record),
                erlang:element(5, _record),
                erlang:element(6, _record),
                erlang:element(7, _record),
                erlang:element(8, _record),
                erlang:element(9, _record),
                no_comment};

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

-file("src/cake/update.gleam", 448).
?DOC(" Removes the `Comment` from the `Update` query.\n").
-spec no_comment(cake@internal@write_query:update(QAV)) -> cake@internal@write_query:update(QAV).
no_comment(Updt) ->
    _record = Updt,
    {update,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        no_comment}.

-file("src/cake/update.gleam", 454).
?DOC(" Gets the `Comment` of the `Update` query.\n").
-spec get_comment(cake@internal@write_query:update(any())) -> cake@internal@read_query:comment().
get_comment(Updt) ->
    erlang:element(10, Updt).