cake

-module(cake@insert).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/cake/insert.gleam").
-export([to_query/1, row/1, bool/1, float/1, int/1, string/1, null/0, new/0, from_records/4, from_values/3, table/2, get_table/1, modifier/2, no_modifier/1, get_modifier/1, source_records/3, source_values/2, get_source/1, columns/2, get_columns/1, on_conflict_error/1, on_columns_conflict_ignore/3, on_constraint_conflict_ignore/3, on_columns_conflict_update/4, on_constraint_conflict_update/4, get_on_conflict/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 `INSERT` queries.\n"
    "\n"
).

-file("src/cake/insert.gleam", 61).
?DOC(" Creates a `WriteQuery` from an `Insert` query.\n").
-spec to_query(cake@internal@write_query:insert(FLS)) -> cake@internal@write_query:write_query(FLS).
to_query(Isrt) ->
    _pipe = Isrt,
    {insert_query, _pipe}.

-file("src/cake/insert.gleam", 69).
?DOC(" Create an `InsertRow` from a list of `InsertValue`s.\n").
-spec row(list(cake@internal@write_query:insert_value())) -> cake@internal@write_query:insert_row().
row(Vls) ->
    _pipe = Vls,
    {insert_row, _pipe}.

-file("src/cake/insert.gleam", 75).
?DOC(" Create an `InsertValue` from a column `String` and a `Bool` value.\n").
-spec bool(boolean()) -> cake@internal@write_query:insert_value().
bool(Vl) ->
    _pipe = Vl,
    _pipe@1 = {bool_param, _pipe},
    {insert_param, _pipe@1}.

-file("src/cake/insert.gleam", 81).
?DOC(" Create an `InsertValue` from a column `String` and a `Float` value.\n").
-spec float(float()) -> cake@internal@write_query:insert_value().
float(Vl) ->
    _pipe = Vl,
    _pipe@1 = {float_param, _pipe},
    {insert_param, _pipe@1}.

-file("src/cake/insert.gleam", 87).
?DOC(" Create an `InsertValue` from a column `String` and an `Int` value.\n").
-spec int(integer()) -> cake@internal@write_query:insert_value().
int(Vl) ->
    _pipe = Vl,
    _pipe@1 = {int_param, _pipe},
    {insert_param, _pipe@1}.

-file("src/cake/insert.gleam", 93).
?DOC(" Create an `InsertValue` from a column `String` and a `String` value.\n").
-spec string(binary()) -> cake@internal@write_query:insert_value().
string(Vl) ->
    _pipe = Vl,
    _pipe@1 = {string_param, _pipe},
    {insert_param, _pipe@1}.

-file("src/cake/insert.gleam", 99).
?DOC(" Create a NULL `InsertValue`.\n").
-spec null() -> cake@internal@write_query:insert_value().
null() ->
    _pipe = null_param,
    {insert_param, _pipe}.

-file("src/cake/insert.gleam", 107).
?DOC(" Create an empty `INSERT` query.\n").
-spec new() -> cake@internal@write_query:insert(any()).
new() ->
    {insert,
        no_insert_into_table,
        no_insert_columns,
        no_insert_modifier,
        no_insert_source,
        insert_conflict_error,
        no_returning,
        no_epilog,
        no_comment}.

-file("src/cake/insert.gleam", 124).
?DOC(
    " Create an `INSERT` query from a list of gleam records.\n"
    "\n"
    " The `encoder` function is used to convert each record into an `InsertRow`.\n"
).
-spec from_records(
    binary(),
    list(binary()),
    list(FLZ),
    fun((FLZ) -> cake@internal@write_query:insert_row())
) -> cake@internal@write_query:insert(FLZ).
from_records(Tbl_nm, Cols, Rcrds, Encdr) ->
    {insert,
        begin
            _pipe = Tbl_nm,
            {insert_into_table, _pipe}
        end,
        begin
            _pipe@1 = Cols,
            {insert_columns, _pipe@1}
        end,
        no_insert_modifier,
        begin
            _pipe@2 = Rcrds,
            {insert_source_records, _pipe@2, Encdr}
        end,
        insert_conflict_error,
        no_returning,
        no_epilog,
        no_comment}.

-file("src/cake/insert.gleam", 144).
?DOC(" Create an `INSERT` query from a list of `InsertRow`s.\n").
-spec from_values(
    binary(),
    list(binary()),
    list(cake@internal@write_query:insert_row())
) -> cake@internal@write_query:insert(any()).
from_values(Tbl_nm, Cols, Vls) ->
    {insert,
        begin
            _pipe = Tbl_nm,
            {insert_into_table, _pipe}
        end,
        begin
            _pipe@1 = Cols,
            {insert_columns, _pipe@1}
        end,
        no_insert_modifier,
        begin
            _pipe@2 = Vls,
            {insert_source_rows, _pipe@2}
        end,
        insert_conflict_error,
        no_returning,
        no_epilog,
        no_comment}.

-file("src/cake/insert.gleam", 165).
?DOC(" Specify the table to insert into.\n").
-spec table(cake@internal@write_query:insert(FMG), binary()) -> cake@internal@write_query:insert(FMG).
table(Isrt, Tbl_nm) ->
    {insert,
        begin
            _pipe = Tbl_nm,
            {insert_into_table, _pipe}
        end,
        erlang:element(3, Isrt),
        erlang:element(4, Isrt),
        erlang:element(5, Isrt),
        erlang:element(6, Isrt),
        erlang:element(7, Isrt),
        erlang:element(8, Isrt),
        erlang:element(9, Isrt)}.

-file("src/cake/insert.gleam", 171).
?DOC(" Get the table name to insert into from an `Insert` query.\n").
-spec get_table(cake@internal@write_query:insert(any())) -> cake@internal@write_query:insert_into_table().
get_table(Isrt) ->
    erlang:element(2, Isrt).

-file("src/cake/insert.gleam", 179).
?DOC(" Specify a modifier for the `INSERT` query.\n").
-spec modifier(cake@internal@write_query:insert(FML), binary()) -> cake@internal@write_query:insert(FML).
modifier(Isrt, Mdfr) ->
    Mdfr@1 = begin
        _pipe = Mdfr,
        gleam@string:trim(_pipe)
    end,
    case Mdfr@1 of
        <<""/utf8>> ->
            {insert,
                erlang:element(2, Isrt),
                erlang:element(3, Isrt),
                no_insert_modifier,
                erlang:element(5, Isrt),
                erlang:element(6, Isrt),
                erlang:element(7, Isrt),
                erlang:element(8, Isrt),
                erlang:element(9, Isrt)};

        _ ->
            {insert,
                erlang:element(2, Isrt),
                erlang:element(3, Isrt),
                begin
                    _pipe@1 = Mdfr@1,
                    {insert_modifier, _pipe@1}
                end,
                erlang:element(5, Isrt),
                erlang:element(6, Isrt),
                erlang:element(7, Isrt),
                erlang:element(8, Isrt),
                erlang:element(9, Isrt)}
    end.

-file("src/cake/insert.gleam", 189).
?DOC(" Specify that no modifier should be used for the given `INSERT` query.\n").
-spec no_modifier(cake@internal@write_query:insert(FMO)) -> cake@internal@write_query:insert(FMO).
no_modifier(Isrt) ->
    {insert,
        erlang:element(2, Isrt),
        erlang:element(3, Isrt),
        no_insert_modifier,
        erlang:element(5, Isrt),
        erlang:element(6, Isrt),
        erlang:element(7, Isrt),
        erlang:element(8, Isrt),
        erlang:element(9, Isrt)}.

-file("src/cake/insert.gleam", 195).
?DOC(" Get the modifier from an `Insert` query.\n").
-spec get_modifier(cake@internal@write_query:insert(any())) -> binary().
get_modifier(Isrt) ->
    case erlang:element(4, Isrt) of
        no_insert_modifier ->
            <<""/utf8>>;

        {insert_modifier, Mdfr} ->
            Mdfr
    end.

-file("src/cake/insert.gleam", 206).
?DOC(" Specify the source records to insert.\n").
-spec source_records(
    cake@internal@write_query:insert(FMT),
    list(FMT),
    fun((FMT) -> cake@internal@write_query:insert_row())
) -> cake@internal@write_query:insert(FMT).
source_records(Isrt, Rcrds, Encdr) ->
    {insert,
        erlang:element(2, Isrt),
        erlang:element(3, Isrt),
        erlang:element(4, Isrt),
        begin
            _pipe = Rcrds,
            {insert_source_records, _pipe, Encdr}
        end,
        erlang:element(6, Isrt),
        erlang:element(7, Isrt),
        erlang:element(8, Isrt),
        erlang:element(9, Isrt)}.

-file("src/cake/insert.gleam", 216).
?DOC(" Specify the source values to insert.\n").
-spec source_values(
    cake@internal@write_query:insert(FMX),
    list(cake@internal@write_query:insert_row())
) -> cake@internal@write_query:insert(FMX).
source_values(Isrt, Rws) ->
    {insert,
        erlang:element(2, Isrt),
        erlang:element(3, Isrt),
        erlang:element(4, Isrt),
        begin
            _pipe = Rws,
            {insert_source_rows, _pipe}
        end,
        erlang:element(6, Isrt),
        erlang:element(7, Isrt),
        erlang:element(8, Isrt),
        erlang:element(9, Isrt)}.

-file("src/cake/insert.gleam", 226).
?DOC(
    " Get the source from an `Insert` query which is either a list of records,\n"
    " accompanied by a encoder function or a list of `InsertRow`s.\n"
).
-spec get_source(cake@internal@write_query:insert(FNB)) -> cake@internal@write_query:insert_source(FNB).
get_source(Isrt) ->
    erlang:element(5, Isrt).

-file("src/cake/insert.gleam", 237).
?DOC(
    " Specify the columns to insert into.\n"
    "\n"
    " NOTICE: You have to specify the columns and keep track if their names are\n"
    " correct, as well as their count which must be equal to the count of\n"
    " `InsertRows` the encoder function returns or is given as source\n"
    "          values.\n"
).
-spec columns(cake@internal@write_query:insert(FNE), list(binary())) -> cake@internal@write_query:insert(FNE).
columns(Isrt, Cols) ->
    {insert,
        erlang:element(2, Isrt),
        begin
            _pipe = Cols,
            {insert_columns, _pipe}
        end,
        erlang:element(4, Isrt),
        erlang:element(5, Isrt),
        erlang:element(6, Isrt),
        erlang:element(7, Isrt),
        erlang:element(8, Isrt),
        erlang:element(9, Isrt)}.

-file("src/cake/insert.gleam", 243).
?DOC(" Get the columns to insert into from an `Insert` query.\n").
-spec get_columns(cake@internal@write_query:insert(any())) -> cake@internal@write_query:insert_columns().
get_columns(Isrt) ->
    erlang:element(3, Isrt).

-file("src/cake/insert.gleam", 253).
?DOC(
    " This specifies that any conflicts result in the query to fail\n"
    "\n"
    " This is the default behaviour.\n"
).
-spec on_conflict_error(cake@internal@write_query:insert(FNK)) -> cake@internal@write_query:insert(FNK).
on_conflict_error(Isrt) ->
    {insert,
        erlang:element(2, Isrt),
        erlang:element(3, Isrt),
        erlang:element(4, Isrt),
        erlang:element(5, Isrt),
        insert_conflict_error,
        erlang:element(7, Isrt),
        erlang:element(8, Isrt),
        erlang:element(9, Isrt)}.

-file("src/cake/insert.gleam", 262).
?DOC(
    " This specifies that specific conflicts do not result in an error but instead\n"
    " are just ignored and not inserted.\n"
    "\n"
    " Conflict Target: Columns\n"
).
-spec on_columns_conflict_ignore(
    cake@internal@write_query:insert(FNN),
    list(binary()),
    cake@internal@read_query:where()
) -> cake@internal@write_query:insert(FNN).
on_columns_conflict_ignore(Isrt, Cols, Whr) ->
    {insert,
        erlang:element(2, Isrt),
        erlang:element(3, Isrt),
        erlang:element(4, Isrt),
        erlang:element(5, Isrt),
        {insert_conflict_ignore,
            begin
                _pipe = Cols,
                {insert_conflict_target, _pipe}
            end,
            Whr},
        erlang:element(7, Isrt),
        erlang:element(8, Isrt),
        erlang:element(9, Isrt)}.

-file("src/cake/insert.gleam", 281).
?DOC(
    " This specifies that specific conflicts do not result in an error but instead\n"
    " are just ignored and not inserted.\n"
    "\n"
    " Conflict Target: Constraint\n"
).
-spec on_constraint_conflict_ignore(
    cake@internal@write_query:insert(FNR),
    binary(),
    cake@internal@read_query:where()
) -> cake@internal@write_query:insert(FNR).
on_constraint_conflict_ignore(Isrt, Cnstrt, Whr) ->
    {insert,
        erlang:element(2, Isrt),
        erlang:element(3, Isrt),
        erlang:element(4, Isrt),
        erlang:element(5, Isrt),
        {insert_conflict_ignore,
            begin
                _pipe = Cnstrt,
                {insert_conflict_target_constraint, _pipe}
            end,
            Whr},
        erlang:element(7, Isrt),
        erlang:element(8, Isrt),
        erlang:element(9, Isrt)}.

-file("src/cake/insert.gleam", 299).
?DOC(
    " Inserts or updates on conflict, also called ´UPSERT´.\n"
    "\n"
    " Conflict Target: Columns\n"
).
-spec on_columns_conflict_update(
    cake@internal@write_query:insert(FNU),
    list(binary()),
    cake@internal@read_query:where(),
    cake@internal@write_query:update(FNU)
) -> cake@internal@write_query:insert(FNU).
on_columns_conflict_update(Isrt, Cols, Whr, Updt) ->
    {insert,
        erlang:element(2, Isrt),
        erlang:element(3, Isrt),
        erlang:element(4, Isrt),
        erlang:element(5, Isrt),
        {insert_conflict_update,
            begin
                _pipe = Cols,
                {insert_conflict_target, _pipe}
            end,
            Whr,
            Updt},
        erlang:element(7, Isrt),
        erlang:element(8, Isrt),
        erlang:element(9, Isrt)}.

-file("src/cake/insert.gleam", 319).
?DOC(
    " Inserts or updates on conflict, also called ´UPSERT´.\n"
    "\n"
    " Conflict Target: Constraint\n"
).
-spec on_constraint_conflict_update(
    cake@internal@write_query:insert(FNZ),
    binary(),
    cake@internal@read_query:where(),
    cake@internal@write_query:update(FNZ)
) -> cake@internal@write_query:insert(FNZ).
on_constraint_conflict_update(Isrt, Cnstrt, Whr, Updt) ->
    {insert,
        erlang:element(2, Isrt),
        erlang:element(3, Isrt),
        erlang:element(4, Isrt),
        erlang:element(5, Isrt),
        {insert_conflict_update,
            begin
                _pipe = Cnstrt,
                {insert_conflict_target_constraint, _pipe}
            end,
            Whr,
            Updt},
        erlang:element(7, Isrt),
        erlang:element(8, Isrt),
        erlang:element(9, Isrt)}.

-file("src/cake/insert.gleam", 337).
?DOC(" Get the conflict strategy from an `Insert` query.\n").
-spec get_on_conflict(cake@internal@write_query:insert(FOD)) -> cake@internal@write_query:insert_conflict_strategy(FOD).
get_on_conflict(Isrt) ->
    erlang:element(6, Isrt).

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

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

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

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

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

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

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

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

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

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

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