-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(FLV)) -> cake@internal@write_query:write_query(FLV).
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(FMC),
    fun((FMC) -> cake@internal@write_query:insert_row())
) -> cake@internal@write_query:insert(FMC).
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(FMJ), binary()) -> cake@internal@write_query:insert(FMJ).
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(FMO), binary()) -> cake@internal@write_query:insert(FMO).
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(FMR)) -> cake@internal@write_query:insert(FMR).
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(FMW),
    list(FMW),
    fun((FMW) -> cake@internal@write_query:insert_row())
) -> cake@internal@write_query:insert(FMW).
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(FNA),
    list(cake@internal@write_query:insert_row())
) -> cake@internal@write_query:insert(FNA).
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(FNE)) -> cake@internal@write_query:insert_source(FNE).
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(FNH), list(binary())) -> cake@internal@write_query:insert(FNH).
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", 246).
?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", 256).
?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(FNN)) -> cake@internal@write_query:insert(FNN).
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", 265).
?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(FNQ),
    list(binary()),
    cake@internal@read_query:where()
) -> cake@internal@write_query:insert(FNQ).
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", 284).
?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(FNU),
    binary(),
    cake@internal@read_query:where()
) -> cake@internal@write_query:insert(FNU).
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", 302).
?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(FNX),
    list(binary()),
    cake@internal@read_query:where(),
    cake@internal@write_query:update(FNX)
) -> cake@internal@write_query:insert(FNX).
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", 322).
?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(FOC),
    binary(),
    cake@internal@read_query:where(),
    cake@internal@write_query:update(FOC)
) -> cake@internal@write_query:insert(FOC).
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", 340).
?DOC(" Get the conflict strategy from an `Insert` query.\n").
-spec get_on_conflict(cake@internal@write_query:insert(FOG)) -> cake@internal@write_query:insert_conflict_strategy(FOG).
get_on_conflict(Isrt) ->
    erlang:element(6, Isrt).

-file("src/cake/insert.gleam", 348).
?DOC(" Specify the columns to return after the `INSERT` query.\n").
-spec returning(cake@internal@write_query:insert(FOJ), list(binary())) -> cake@internal@write_query:insert(FOJ).
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", 360).
?DOC(" Specify that no columns should be returned after the `INSERT` query.\n").
-spec no_returning(cake@internal@write_query:insert(FON)) -> cake@internal@write_query:insert(FON).
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", 368).
?DOC(" Specify an epilog for the `INSERT` query.\n").
-spec epilog(cake@internal@write_query:insert(FOQ), binary()) -> cake@internal@write_query:insert(FOQ).
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", 378).
?DOC(" Specify that no epilog should be added to the `INSERT` query.\n").
-spec no_epilog(cake@internal@write_query:insert(FOT)) -> cake@internal@write_query:insert(FOT).
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", 384).
?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", 392).
?DOC(" Specify a comment for the `INSERT` query.\n").
-spec comment(cake@internal@write_query:insert(FOY), binary()) -> cake@internal@write_query:insert(FOY).
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", 402).
?DOC(" Specify that no comment should be added to the `INSERT` query.\n").
-spec no_comment(cake@internal@write_query:insert(FPB)) -> cake@internal@write_query:insert(FPB).
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", 408).
?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).