cake

-module(cake@internal@write_query).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/cake/internal/write_query.gleam").
-export([to_prepared_statement/3]).
-export_type([write_query/1, returning/0, insert/1, insert_into_table/0, insert_columns/0, insert_modifier/0, insert_source/1, insert_row/0, insert_value/0, insert_conflict_strategy/1, insert_conflict_target/0, update/1, update_modifier/0, update_table/0, update_sets/0, update_set/0, delete/1, delete_modifier/0, delete_table/0, delete_using/0]).

-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(false).

-type write_query(EFI) :: {insert_query, insert(EFI)} |
    {update_query, update(EFI)} |
    {delete_query, delete(EFI)}.

-type returning() :: no_returning | {returning, list(binary())}.

-type insert(EFJ) :: {insert,
        insert_into_table(),
        insert_columns(),
        insert_modifier(),
        insert_source(EFJ),
        insert_conflict_strategy(EFJ),
        returning(),
        cake@internal@read_query:epilog(),
        cake@internal@read_query:comment()}.

-type insert_into_table() :: no_insert_into_table |
    {insert_into_table, binary()}.

-type insert_columns() :: no_insert_columns | {insert_columns, list(binary())}.

-type insert_modifier() :: no_insert_modifier | {insert_modifier, binary()}.

-type insert_source(EFK) :: no_insert_source |
    insert_source_default |
    {insert_source_records, list(EFK), fun((EFK) -> insert_row())} |
    {insert_source_rows, list(insert_row())} |
    {insert_source_query, cake@internal@read_query:read_query()}.

-type insert_row() :: {insert_row, list(insert_value())}.

-type insert_value() :: {insert_param, cake@param:param()} |
    insert_default |
    {insert_fragment, cake@internal@read_query:fragment()}.

-type insert_conflict_strategy(EFL) :: insert_conflict_error |
    {insert_conflict_ignore,
        insert_conflict_target(),
        cake@internal@read_query:where()} |
    {insert_conflict_update,
        insert_conflict_target(),
        cake@internal@read_query:where(),
        update(EFL)} |
    {insert_duplicate_key_update, update(EFL)}.

-type insert_conflict_target() :: {insert_conflict_target, list(binary())} |
    {insert_conflict_target_constraint, binary()}.

-type update(EFM) :: {update,
        update_table(),
        update_modifier(),
        update_sets(),
        cake@internal@read_query:from(),
        cake@internal@read_query:joins(),
        cake@internal@read_query:where(),
        returning(),
        cake@internal@read_query:epilog(),
        cake@internal@read_query:comment()} |
    {gleam_phantom, EFM}.

-type update_modifier() :: no_update_modifier | {update_modifier, binary()}.

-type update_table() :: no_update_table | {update_table, binary()}.

-type update_sets() :: no_update_sets | {update_sets, list(update_set())}.

-type update_set() :: {update_param_set, binary(), cake@param:param()} |
    {update_expression_set, list(binary()), binary()} |
    {update_sub_query_set,
        list(binary()),
        cake@internal@read_query:read_query()} |
    {update_fragment_set, binary(), cake@internal@read_query:fragment()}.

-type delete(EFN) :: {delete,
        delete_modifier(),
        delete_table(),
        delete_using(),
        cake@internal@read_query:joins(),
        cake@internal@read_query:where(),
        returning(),
        cake@internal@read_query:epilog(),
        cake@internal@read_query:comment()} |
    {gleam_phantom, EFN}.

-type delete_modifier() :: no_delete_modifier | {delete_modifier, binary()}.

-type delete_table() :: no_delete_table | {delete_table, binary()}.

-type delete_using() :: no_delete_using |
    {delete_using, list(cake@internal@read_query:from())}.

-file("src/cake/internal/write_query.gleam", 70).
?DOC(false).
-spec returning_apply(
    cake@internal@prepared_statement:prepared_statement(),
    returning()
) -> cake@internal@prepared_statement:prepared_statement().
returning_apply(Prepared_statement, Returning) ->
    case Returning of
        no_returning ->
            Prepared_statement;

        {returning, Columns} ->
            _pipe = Prepared_statement,
            _pipe@1 = cake@internal@prepared_statement:append_sql(
                _pipe,
                <<" RETURNING "/utf8>>
            ),
            cake@internal@prepared_statement:append_sql(
                _pipe@1,
                begin
                    _pipe@2 = Columns,
                    gleam@string:join(_pipe@2, <<", "/utf8>>)
                end
            )
    end.

-file("src/cake/internal/write_query.gleam", 935).
?DOC(false).
-spec using_apply(
    cake@internal@prepared_statement:prepared_statement(),
    delete_using()
) -> cake@internal@prepared_statement:prepared_statement().
using_apply(Prepared_statement, Using) ->
    case Using of
        no_delete_using ->
            Prepared_statement;

        {delete_using, Froms} ->
            Prepared_statement@1 = begin
                _pipe = Prepared_statement,
                cake@internal@prepared_statement:append_sql(
                    _pipe,
                    <<" USING "/utf8>>
                )
            end,
            _pipe@1 = Froms,
            gleam@list:fold(
                _pipe@1,
                Prepared_statement@1,
                fun(New_prepared_statement, From) ->
                    New_prepared_statement@1 = case {New_prepared_statement =:= Prepared_statement@1,
                        From} of
                        {true, _} ->
                            New_prepared_statement;

                        {_, no_from} ->
                            New_prepared_statement;

                        {false, _} ->
                            _pipe@2 = New_prepared_statement,
                            cake@internal@prepared_statement:append_sql(
                                _pipe@2,
                                <<", "/utf8>>
                            )
                    end,
                    case From of
                        no_from ->
                            New_prepared_statement@1;

                        {from_table, Table_name} ->
                            _pipe@3 = New_prepared_statement@1,
                            cake@internal@prepared_statement:append_sql(
                                _pipe@3,
                                Table_name
                            );

                        {from_sub_query, Query, Alias} ->
                            _pipe@4 = New_prepared_statement@1,
                            _pipe@5 = cake@internal@prepared_statement:append_sql(
                                _pipe@4,
                                <<" ("/utf8>>
                            ),
                            _pipe@6 = cake@internal@read_query:apply(
                                _pipe@5,
                                Query
                            ),
                            cake@internal@prepared_statement:append_sql(
                                _pipe@6,
                                <<") AS "/utf8, Alias/binary>>
                            )
                    end
                end
            )
    end.

-file("src/cake/internal/write_query.gleam", 924).
?DOC(false).
-spec delete_modifier_apply(
    cake@internal@prepared_statement:prepared_statement(),
    delete_modifier()
) -> cake@internal@prepared_statement:prepared_statement().
delete_modifier_apply(Prepared_statement, Delete_modifier) ->
    case Delete_modifier of
        no_delete_modifier ->
            Prepared_statement;

        {delete_modifier, Keyword} ->
            _pipe = Prepared_statement,
            cake@internal@prepared_statement:append_sql(
                _pipe,
                <<" "/utf8, Keyword/binary>>
            )
    end.

-file("src/cake/internal/write_query.gleam", 912).
?DOC(false).
-spec delete_table_apply(
    cake@internal@prepared_statement:prepared_statement(),
    delete_table()
) -> cake@internal@prepared_statement:prepared_statement().
delete_table_apply(Prepared_statement, Table_name) ->
    case Table_name of
        no_delete_table ->
            Prepared_statement;

        {delete_table, Name} ->
            _pipe = Prepared_statement,
            cake@internal@prepared_statement:append_sql(
                _pipe,
                <<" FROM "/utf8, Name/binary>>
            )
    end.

-file("src/cake/internal/write_query.gleam", 896).
?DOC(false).
-spec delete_apply(
    cake@internal@prepared_statement:prepared_statement(),
    delete(any())
) -> cake@internal@prepared_statement:prepared_statement().
delete_apply(Prepared_statement, Delete) ->
    _pipe = Prepared_statement,
    _pipe@1 = cake@internal@prepared_statement:append_sql(
        _pipe,
        <<"DELETE"/utf8>>
    ),
    _pipe@2 = delete_table_apply(_pipe@1, erlang:element(3, Delete)),
    _pipe@3 = delete_modifier_apply(_pipe@2, erlang:element(2, Delete)),
    _pipe@4 = using_apply(_pipe@3, erlang:element(4, Delete)),
    _pipe@5 = cake@internal@read_query:join_clause_apply(
        _pipe@4,
        erlang:element(5, Delete)
    ),
    _pipe@6 = cake@internal@read_query:where_clause_apply(
        _pipe@5,
        erlang:element(6, Delete)
    ),
    _pipe@7 = returning_apply(_pipe@6, erlang:element(7, Delete)),
    _pipe@8 = cake@internal@read_query:epilog_apply(
        _pipe@7,
        erlang:element(8, Delete)
    ),
    cake@internal@read_query:comment_apply(_pipe@8, erlang:element(9, Delete)).

-file("src/cake/internal/write_query.gleam", 785).
?DOC(false).
-spec update_sets_apply(
    cake@internal@prepared_statement:prepared_statement(),
    list(update_set())
) -> cake@internal@prepared_statement:prepared_statement().
update_sets_apply(Prepared_statement, Update_sets) ->
    Columns_apply = fun(New_prepared_statement, Columns) -> case Columns of
            [] ->
                New_prepared_statement;

            [Column] ->
                _pipe = New_prepared_statement,
                cake@internal@prepared_statement:append_sql(
                    _pipe,
                    <<<<" "/utf8, Column/binary>>/binary, " ="/utf8>>
                );

            [_ | _] ->
                _pipe@1 = New_prepared_statement,
                _pipe@3 = cake@internal@prepared_statement:append_sql(
                    _pipe@1,
                    <<<<" ("/utf8,
                            (begin
                                _pipe@2 = Columns,
                                gleam@string:join(_pipe@2, <<", "/utf8>>)
                            end)/binary>>/binary,
                        ")"/utf8>>
                ),
                cake@internal@prepared_statement:append_sql(
                    _pipe@3,
                    <<" ="/utf8>>
                )
        end end,
    _pipe@4 = Update_sets,
    gleam@list:fold(
        _pipe@4,
        Prepared_statement,
        fun(New_prepared_statement@1, Update_set) ->
            New_prepared_statement@2 = case New_prepared_statement@1 =:= Prepared_statement of
                true ->
                    New_prepared_statement@1;

                false ->
                    _pipe@5 = New_prepared_statement@1,
                    cake@internal@prepared_statement:append_sql(
                        _pipe@5,
                        <<","/utf8>>
                    )
            end,
            case Update_set of
                {update_param_set, Column@1, Param} ->
                    _pipe@6 = New_prepared_statement@2,
                    _pipe@7 = Columns_apply(_pipe@6, [Column@1]),
                    _pipe@8 = cake@internal@prepared_statement:append_sql(
                        _pipe@7,
                        <<" "/utf8>>
                    ),
                    cake@internal@prepared_statement:append_param(
                        _pipe@8,
                        Param
                    );

                {update_expression_set, Columns@1, Expression} ->
                    _pipe@9 = New_prepared_statement@2,
                    _pipe@10 = Columns_apply(_pipe@9, Columns@1),
                    cake@internal@prepared_statement:append_sql(
                        _pipe@10,
                        <<" "/utf8, Expression/binary>>
                    );

                {update_sub_query_set, Columns@2, Query} ->
                    _pipe@11 = New_prepared_statement@2,
                    _pipe@12 = Columns_apply(_pipe@11, Columns@2),
                    _pipe@13 = cake@internal@prepared_statement:append_sql(
                        _pipe@12,
                        <<" ("/utf8>>
                    ),
                    _pipe@14 = cake@internal@read_query:apply(_pipe@13, Query),
                    cake@internal@prepared_statement:append_sql(
                        _pipe@14,
                        <<")"/utf8>>
                    );

                {update_fragment_set, Column@2, Value} ->
                    _pipe@15 = New_prepared_statement@2,
                    _pipe@16 = Columns_apply(_pipe@15, [Column@2]),
                    _pipe@17 = cake@internal@prepared_statement:append_sql(
                        _pipe@16,
                        <<" "/utf8>>
                    ),
                    cake@internal@read_query:fragment_apply(_pipe@17, Value)
            end
        end
    ).

-file("src/cake/internal/write_query.gleam", 774).
?DOC(false).
-spec update_set_apply(
    cake@internal@prepared_statement:prepared_statement(),
    update_sets()
) -> cake@internal@prepared_statement:prepared_statement().
update_set_apply(Prepared_statement, Update_sets) ->
    case Update_sets of
        no_update_sets ->
            Prepared_statement;

        {update_sets, Items} ->
            _pipe = Prepared_statement,
            update_sets_apply(_pipe, Items)
    end.

-file("src/cake/internal/write_query.gleam", 763).
?DOC(false).
-spec update_modifier_apply(
    cake@internal@prepared_statement:prepared_statement(),
    update_modifier()
) -> cake@internal@prepared_statement:prepared_statement().
update_modifier_apply(Prepared_statement, Update_modifier) ->
    case Update_modifier of
        no_update_modifier ->
            Prepared_statement;

        {update_modifier, Keyword} ->
            _pipe = Prepared_statement,
            cake@internal@prepared_statement:append_sql(
                _pipe,
                <<" "/utf8, Keyword/binary>>
            )
    end.

-file("src/cake/internal/write_query.gleam", 751).
?DOC(false).
-spec update_table_apply(
    cake@internal@prepared_statement:prepared_statement(),
    update_table()
) -> cake@internal@prepared_statement:prepared_statement().
update_table_apply(Prepared_statement, Table_name) ->
    case Table_name of
        no_update_table ->
            Prepared_statement;

        {update_table, Name} ->
            _pipe = Prepared_statement,
            cake@internal@prepared_statement:append_sql(
                _pipe,
                <<" "/utf8, Name/binary>>
            )
    end.

-file("src/cake/internal/write_query.gleam", 733).
?DOC(false).
-spec update_apply(
    cake@internal@prepared_statement:prepared_statement(),
    update(any())
) -> cake@internal@prepared_statement:prepared_statement().
update_apply(Prepared_statement, Update) ->
    _pipe = Prepared_statement,
    _pipe@1 = cake@internal@prepared_statement:append_sql(
        _pipe,
        <<"UPDATE"/utf8>>
    ),
    _pipe@2 = update_table_apply(_pipe@1, erlang:element(2, Update)),
    _pipe@3 = update_modifier_apply(_pipe@2, erlang:element(3, Update)),
    _pipe@4 = cake@internal@prepared_statement:append_sql(
        _pipe@3,
        <<" SET"/utf8>>
    ),
    _pipe@5 = update_set_apply(_pipe@4, erlang:element(4, Update)),
    _pipe@6 = cake@internal@read_query:from_clause_apply(
        _pipe@5,
        erlang:element(5, Update)
    ),
    _pipe@7 = cake@internal@read_query:join_clause_apply(
        _pipe@6,
        erlang:element(6, Update)
    ),
    _pipe@8 = cake@internal@read_query:where_clause_apply(
        _pipe@7,
        erlang:element(7, Update)
    ),
    _pipe@9 = returning_apply(_pipe@8, erlang:element(8, Update)),
    _pipe@10 = cake@internal@read_query:epilog_apply(
        _pipe@9,
        erlang:element(9, Update)
    ),
    cake@internal@read_query:comment_apply(_pipe@10, erlang:element(10, Update)).

-file("src/cake/internal/write_query.gleam", 659).
?DOC(false).
-spec insert_on_conflict_target_apply(
    cake@internal@prepared_statement:prepared_statement(),
    insert_conflict_target()
) -> cake@internal@prepared_statement:prepared_statement().
insert_on_conflict_target_apply(Prepared_statement, Target) ->
    case Target of
        {insert_conflict_target, Columns} ->
            _pipe = Prepared_statement,
            _pipe@1 = cake@internal@prepared_statement:append_sql(
                _pipe,
                <<" ON CONFLICT ("/utf8>>
            ),
            _pipe@3 = cake@internal@prepared_statement:append_sql(
                _pipe@1,
                begin
                    _pipe@2 = Columns,
                    gleam@string:join(_pipe@2, <<", "/utf8>>)
                end
            ),
            cake@internal@prepared_statement:append_sql(_pipe@3, <<")"/utf8>>);

        {insert_conflict_target_constraint, Name} ->
            _pipe@4 = Prepared_statement,
            _pipe@5 = cake@internal@prepared_statement:append_sql(
                _pipe@4,
                <<" ON CONFLICT ON CONSTRAINT "/utf8>>
            ),
            cake@internal@prepared_statement:append_sql(_pipe@5, Name)
    end.

-file("src/cake/internal/write_query.gleam", 636).
?DOC(false).
-spec insert_on_conflict_apply(
    cake@internal@prepared_statement:prepared_statement(),
    insert_conflict_strategy(any())
) -> cake@internal@prepared_statement:prepared_statement().
insert_on_conflict_apply(Prepared_statement, On_conflict) ->
    case On_conflict of
        insert_conflict_error ->
            Prepared_statement;

        {insert_conflict_ignore, Target, Where} ->
            _pipe = Prepared_statement,
            _pipe@1 = insert_on_conflict_target_apply(_pipe, Target),
            _pipe@2 = cake@internal@read_query:where_clause_apply(
                _pipe@1,
                Where
            ),
            cake@internal@prepared_statement:append_sql(
                _pipe@2,
                <<" DO NOTHING"/utf8>>
            );

        {insert_conflict_update, Target@1, Where@1, Update} ->
            _pipe@3 = Prepared_statement,
            _pipe@4 = insert_on_conflict_target_apply(_pipe@3, Target@1),
            _pipe@5 = cake@internal@prepared_statement:append_sql(
                _pipe@4,
                <<" DO "/utf8>>
            ),
            _pipe@6 = update_apply(_pipe@5, Update),
            cake@internal@read_query:where_clause_apply(_pipe@6, Where@1);

        {insert_duplicate_key_update, _} ->
            Prepared_statement
    end.

-file("src/cake/internal/write_query.gleam", 587).
?DOC(false).
-spec row_apply(
    cake@internal@prepared_statement:prepared_statement(),
    list(insert_value())
) -> cake@internal@prepared_statement:prepared_statement().
row_apply(New_prepared_statement, Row) ->
    _pipe = Row,
    gleam@list:fold(
        _pipe,
        New_prepared_statement,
        fun(New_prepared_statement_inner, Insert_value) -> case Insert_value of
                {insert_param, Value} ->
                    case New_prepared_statement_inner =:= New_prepared_statement of
                        true ->
                            _pipe@1 = New_prepared_statement_inner,
                            cake@internal@prepared_statement:append_param(
                                _pipe@1,
                                Value
                            );

                        false ->
                            _pipe@2 = New_prepared_statement_inner,
                            _pipe@3 = cake@internal@prepared_statement:append_sql(
                                _pipe@2,
                                <<", "/utf8>>
                            ),
                            cake@internal@prepared_statement:append_param(
                                _pipe@3,
                                Value
                            )
                    end;

                insert_default ->
                    case New_prepared_statement_inner =:= New_prepared_statement of
                        true ->
                            _pipe@4 = New_prepared_statement_inner,
                            cake@internal@prepared_statement:append_sql(
                                _pipe@4,
                                <<"DEFAULT"/utf8>>
                            );

                        false ->
                            _pipe@5 = New_prepared_statement_inner,
                            cake@internal@prepared_statement:append_sql(
                                _pipe@5,
                                <<", DEFAULT"/utf8>>
                            )
                    end;

                {insert_fragment, Value@1} ->
                    case New_prepared_statement_inner =:= New_prepared_statement of
                        true ->
                            _pipe@6 = New_prepared_statement_inner,
                            cake@internal@read_query:fragment_apply(
                                _pipe@6,
                                Value@1
                            );

                        false ->
                            _pipe@7 = New_prepared_statement_inner,
                            _pipe@8 = cake@internal@prepared_statement:append_sql(
                                _pipe@7,
                                <<", "/utf8>>
                            ),
                            cake@internal@read_query:fragment_apply(
                                _pipe@8,
                                Value@1
                            )
                    end
            end end
    ).

-file("src/cake/internal/write_query.gleam", 560).
?DOC(false).
-spec insert_from_values_apply(
    cake@internal@prepared_statement:prepared_statement(),
    list(insert_row())
) -> cake@internal@prepared_statement:prepared_statement().
insert_from_values_apply(Prepared_statement, Source) ->
    Prepared_statement@1 = begin
        _pipe = Prepared_statement,
        cake@internal@prepared_statement:append_sql(_pipe, <<" ("/utf8>>)
    end,
    Prepared_statement@2 = begin
        _pipe@1 = Source,
        gleam@list:fold(
            _pipe@1,
            Prepared_statement@1,
            fun(New_prepared_statement, Row) ->
                {insert_row, Row@1} = Row,
                case New_prepared_statement =:= Prepared_statement@1 of
                    true ->
                        _pipe@2 = New_prepared_statement,
                        row_apply(_pipe@2, Row@1);

                    false ->
                        _pipe@3 = New_prepared_statement,
                        _pipe@4 = cake@internal@prepared_statement:append_sql(
                            _pipe@3,
                            <<"), ("/utf8>>
                        ),
                        row_apply(_pipe@4, Row@1)
                end
            end
        )
    end,
    Prepared_statement@3 = begin
        _pipe@5 = Prepared_statement@2,
        cake@internal@prepared_statement:append_sql(_pipe@5, <<")"/utf8>>)
    end,
    Prepared_statement@3.

-file("src/cake/internal/write_query.gleam", 532).
?DOC(false).
-spec insert_from_params_apply(
    cake@internal@prepared_statement:prepared_statement(),
    list(EGI),
    fun((EGI) -> insert_row())
) -> cake@internal@prepared_statement:prepared_statement().
insert_from_params_apply(Prepared_statement, Source, Row_encoder) ->
    Prepared_statement@1 = begin
        _pipe = Prepared_statement,
        cake@internal@prepared_statement:append_sql(_pipe, <<" ("/utf8>>)
    end,
    Prepared_statement@2 = begin
        _pipe@1 = Source,
        gleam@list:fold(
            _pipe@1,
            Prepared_statement@1,
            fun(New_prepared_statement, Record) ->
                {insert_row, Row} = begin
                    _pipe@2 = Record,
                    Row_encoder(_pipe@2)
                end,
                case New_prepared_statement =:= Prepared_statement@1 of
                    true ->
                        _pipe@3 = New_prepared_statement,
                        row_apply(_pipe@3, Row);

                    false ->
                        _pipe@4 = New_prepared_statement,
                        _pipe@5 = cake@internal@prepared_statement:append_sql(
                            _pipe@4,
                            <<"), ("/utf8>>
                        ),
                        row_apply(_pipe@5, Row)
                end
            end
        )
    end,
    Prepared_statement@3 = begin
        _pipe@6 = Prepared_statement@2,
        cake@internal@prepared_statement:append_sql(_pipe@6, <<")"/utf8>>)
    end,
    Prepared_statement@3.

-file("src/cake/internal/write_query.gleam", 508).
?DOC(false).
-spec insert_source_apply(
    cake@internal@prepared_statement:prepared_statement(),
    insert_source(any())
) -> cake@internal@prepared_statement:prepared_statement().
insert_source_apply(Prepared_statement, Source) ->
    case Source of
        no_insert_source ->
            Prepared_statement;

        {insert_source_records, Source@1, Row_encoder} ->
            _pipe = Prepared_statement,
            _pipe@1 = cake@internal@prepared_statement:append_sql(
                _pipe,
                <<" VALUES"/utf8>>
            ),
            insert_from_params_apply(_pipe@1, Source@1, Row_encoder);

        {insert_source_rows, Source@2} ->
            _pipe@2 = Prepared_statement,
            _pipe@3 = cake@internal@prepared_statement:append_sql(
                _pipe@2,
                <<" VALUES"/utf8>>
            ),
            insert_from_values_apply(_pipe@3, Source@2);

        {insert_source_query, Query} ->
            _pipe@4 = Prepared_statement,
            _pipe@5 = cake@internal@prepared_statement:append_sql(
                _pipe@4,
                <<" "/utf8>>
            ),
            cake@internal@read_query:apply(_pipe@5, Query);

        insert_source_default ->
            _pipe@6 = Prepared_statement,
            cake@internal@prepared_statement:append_sql(
                _pipe@6,
                <<" DEFAULT VALUES"/utf8>>
            )
    end.

-file("src/cake/internal/write_query.gleam", 289).
?DOC(false).
-spec insert_columns_apply(
    cake@internal@prepared_statement:prepared_statement(),
    insert_columns()
) -> cake@internal@prepared_statement:prepared_statement().
insert_columns_apply(Prepared_statement, Columns) ->
    case Columns of
        no_insert_columns ->
            Prepared_statement;

        {insert_columns, Names} ->
            _pipe = Prepared_statement,
            cake@internal@prepared_statement:append_sql(
                _pipe,
                <<<<" ("/utf8,
                        (begin
                            _pipe@1 = Names,
                            gleam@string:join(_pipe@1, <<", "/utf8>>)
                        end)/binary>>/binary,
                    ")"/utf8>>
            )
    end.

-file("src/cake/internal/write_query.gleam", 263).
?DOC(false).
-spec insert_into_table_apply(
    cake@internal@prepared_statement:prepared_statement(),
    insert_into_table()
) -> cake@internal@prepared_statement:prepared_statement().
insert_into_table_apply(Prepared_statement, Table_name) ->
    case Table_name of
        no_insert_into_table ->
            _pipe = Prepared_statement,
            cake@internal@prepared_statement:append_sql(_pipe, <<" INTO"/utf8>>);

        {insert_into_table, Table_name@1} ->
            _pipe@1 = Prepared_statement,
            cake@internal@prepared_statement:append_sql(
                _pipe@1,
                <<" INTO "/utf8, Table_name@1/binary>>
            )
    end.

-file("src/cake/internal/write_query.gleam", 497).
?DOC(false).
-spec insert_modifier_apply(
    cake@internal@prepared_statement:prepared_statement(),
    insert_modifier()
) -> cake@internal@prepared_statement:prepared_statement().
insert_modifier_apply(Prepared_statement, Insert_modifier) ->
    case Insert_modifier of
        no_insert_modifier ->
            Prepared_statement;

        {insert_modifier, Keyword} ->
            _pipe = Prepared_statement,
            cake@internal@prepared_statement:append_sql(
                _pipe,
                <<" "/utf8, Keyword/binary>>
            )
    end.

-file("src/cake/internal/write_query.gleam", 480).
?DOC(false).
-spec insert_duplicate_key_update_apply(
    cake@internal@prepared_statement:prepared_statement(),
    insert(any())
) -> cake@internal@prepared_statement:prepared_statement().
insert_duplicate_key_update_apply(Prepared_statement, Insert) ->
    Update@1 = case erlang:element(6, Insert) of
        {insert_duplicate_key_update, Update} -> Update;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"cake/internal/write_query"/utf8>>,
                        function => <<"insert_duplicate_key_update_apply"/utf8>>,
                        line => 485,
                        value => _assert_fail,
                        start => 18139,
                        'end' => 18204,
                        pattern_start => 18150,
                        pattern_end => 18183})
    end,
    _pipe = Prepared_statement,
    _pipe@1 = cake@internal@prepared_statement:append_sql(
        _pipe,
        <<"INSERT"/utf8>>
    ),
    _pipe@2 = insert_modifier_apply(_pipe@1, erlang:element(4, Insert)),
    _pipe@3 = insert_into_table_apply(_pipe@2, erlang:element(2, Insert)),
    _pipe@4 = insert_columns_apply(_pipe@3, erlang:element(3, Insert)),
    _pipe@5 = insert_source_apply(_pipe@4, erlang:element(5, Insert)),
    _pipe@6 = cake@internal@prepared_statement:append_sql(
        _pipe@5,
        <<" ON DUPLICATE KEY UPDATE"/utf8>>
    ),
    update_set_apply(_pipe@6, erlang:element(4, Update@1)).

-file("src/cake/internal/write_query.gleam", 276).
?DOC(false).
-spec insert_ignore_into_table_apply(
    cake@internal@prepared_statement:prepared_statement(),
    insert_into_table()
) -> cake@internal@prepared_statement:prepared_statement().
insert_ignore_into_table_apply(Prepared_statement, Table_name) ->
    case Table_name of
        no_insert_into_table ->
            _pipe = Prepared_statement,
            cake@internal@prepared_statement:append_sql(
                _pipe,
                <<" IGNORE INTO"/utf8>>
            );

        {insert_into_table, Table_name@1} ->
            _pipe@1 = Prepared_statement,
            cake@internal@prepared_statement:append_sql(
                _pipe@1,
                <<" IGNORE INTO "/utf8, Table_name@1/binary>>
            )
    end.

-file("src/cake/internal/write_query.gleam", 419).
?DOC(false).
-spec insert_not_exists_where_apply(
    cake@internal@prepared_statement:prepared_statement(),
    list(insert_value()),
    list(binary()),
    binary(),
    list(binary())
) -> cake@internal@prepared_statement:prepared_statement().
insert_not_exists_where_apply(
    Prepared_statement,
    Row_values,
    Col_names,
    Table_name,
    Target_cols
) ->
    Target_col_values = begin
        _pipe = gleam@list:zip(Col_names, Row_values),
        gleam@list:filter(
            _pipe,
            fun(Pair) ->
                gleam@list:contains(Target_cols, erlang:element(1, Pair))
            end
        )
    end,
    case Target_col_values of
        [] ->
            Prepared_statement;

        _ ->
            Prepared_statement@1 = begin
                _pipe@1 = Prepared_statement,
                _pipe@2 = cake@internal@prepared_statement:append_sql(
                    _pipe@1,
                    <<" WHERE NOT EXISTS ("/utf8>>
                ),
                cake@internal@prepared_statement:append_sql(
                    _pipe@2,
                    <<<<"SELECT 1 FROM "/utf8, Table_name/binary>>/binary,
                        " WHERE "/utf8>>
                )
            end,
            Prepared_statement@2 = begin
                _pipe@3 = Target_col_values,
                gleam@list:fold(
                    _pipe@3,
                    Prepared_statement@1,
                    fun(New_prepared_statement, Pair@1) ->
                        {Col_name, Insert_value} = Pair@1,
                        New_prepared_statement@1 = case New_prepared_statement
                        =:= Prepared_statement@1 of
                            true ->
                                New_prepared_statement;

                            false ->
                                _pipe@4 = New_prepared_statement,
                                cake@internal@prepared_statement:append_sql(
                                    _pipe@4,
                                    <<" AND "/utf8>>
                                )
                        end,
                        case Insert_value of
                            {insert_param, Value} ->
                                _pipe@5 = New_prepared_statement@1,
                                _pipe@6 = cake@internal@prepared_statement:append_sql(
                                    _pipe@5,
                                    <<Col_name/binary, " = "/utf8>>
                                ),
                                cake@internal@prepared_statement:append_param(
                                    _pipe@6,
                                    Value
                                );

                            insert_default ->
                                New_prepared_statement@1;

                            {insert_fragment, Value@1} ->
                                _pipe@7 = New_prepared_statement@1,
                                _pipe@8 = cake@internal@prepared_statement:append_sql(
                                    _pipe@7,
                                    <<Col_name/binary, " = "/utf8>>
                                ),
                                cake@internal@read_query:fragment_apply(
                                    _pipe@8,
                                    Value@1
                                )
                        end
                    end
                )
            end,
            _pipe@9 = Prepared_statement@2,
            _pipe@10 = cake@internal@prepared_statement:append_sql(
                _pipe@9,
                <<" FOR UPDATE"/utf8>>
            ),
            cake@internal@prepared_statement:append_sql(_pipe@10, <<")"/utf8>>)
    end.

-file("src/cake/internal/write_query.gleam", 382).
?DOC(false).
-spec insert_select_not_exists_rows_apply(
    cake@internal@prepared_statement:prepared_statement(),
    list(list(insert_value())),
    list(binary()),
    binary(),
    list(binary())
) -> cake@internal@prepared_statement:prepared_statement().
insert_select_not_exists_rows_apply(
    Prepared_statement,
    Rows,
    Col_names,
    Table_name,
    Target_cols
) ->
    _pipe = Rows,
    gleam@list:fold(
        _pipe,
        Prepared_statement,
        fun(New_prepared_statement, Values) ->
            New_prepared_statement@1 = case New_prepared_statement =:= Prepared_statement of
                true ->
                    _pipe@1 = New_prepared_statement,
                    cake@internal@prepared_statement:append_sql(
                        _pipe@1,
                        <<" SELECT "/utf8>>
                    );

                false ->
                    _pipe@2 = New_prepared_statement,
                    cake@internal@prepared_statement:append_sql(
                        _pipe@2,
                        <<" UNION ALL SELECT "/utf8>>
                    )
            end,
            _pipe@3 = New_prepared_statement@1,
            _pipe@4 = row_apply(_pipe@3, Values),
            insert_not_exists_where_apply(
                _pipe@4,
                Values,
                Col_names,
                Table_name,
                Target_cols
            )
        end
    ).

-file("src/cake/internal/write_query.gleam", 316).
?DOC(false).
-spec insert_conflict_ignore_maria_mysql_apply(
    cake@internal@prepared_statement:prepared_statement(),
    insert(any())
) -> cake@internal@prepared_statement:prepared_statement().
insert_conflict_ignore_maria_mysql_apply(Prepared_statement, Insert) ->
    case {erlang:element(2, Insert),
        erlang:element(3, Insert),
        erlang:element(6, Insert)} of
        {{insert_into_table, Table_name},
            {insert_columns, Col_names},
            {insert_conflict_ignore, {insert_conflict_target, Target_cols}, _}} ->
            Row_values = case erlang:element(5, Insert) of
                {insert_source_rows, Data} ->
                    _pipe = Data,
                    gleam@list:map(
                        _pipe,
                        fun(Row) ->
                            {insert_row, Values} = Row,
                            Values
                        end
                    );

                {insert_source_records, Data@1, Encoder} ->
                    _pipe@1 = Data@1,
                    gleam@list:map(
                        _pipe@1,
                        fun(Row@1) ->
                            {insert_row, Values@1} = begin
                                _pipe@2 = Row@1,
                                Encoder(_pipe@2)
                            end,
                            Values@1
                        end
                    );

                _ ->
                    []
            end,
            case Row_values of
                [] ->
                    _pipe@3 = Prepared_statement,
                    _pipe@4 = cake@internal@prepared_statement:append_sql(
                        _pipe@3,
                        <<"INSERT"/utf8>>
                    ),
                    _pipe@5 = insert_modifier_apply(
                        _pipe@4,
                        erlang:element(4, Insert)
                    ),
                    _pipe@6 = insert_ignore_into_table_apply(
                        _pipe@5,
                        erlang:element(2, Insert)
                    ),
                    _pipe@7 = insert_columns_apply(
                        _pipe@6,
                        erlang:element(3, Insert)
                    ),
                    insert_source_apply(_pipe@7, erlang:element(5, Insert));

                _ ->
                    _pipe@8 = Prepared_statement,
                    _pipe@9 = cake@internal@prepared_statement:append_sql(
                        _pipe@8,
                        <<"INSERT"/utf8>>
                    ),
                    _pipe@10 = insert_modifier_apply(
                        _pipe@9,
                        erlang:element(4, Insert)
                    ),
                    _pipe@11 = insert_into_table_apply(
                        _pipe@10,
                        erlang:element(2, Insert)
                    ),
                    _pipe@12 = insert_columns_apply(
                        _pipe@11,
                        erlang:element(3, Insert)
                    ),
                    _pipe@13 = insert_source_apply(
                        _pipe@12,
                        erlang:element(5, Insert)
                    ),
                    insert_select_not_exists_rows_apply(
                        _pipe@13,
                        Row_values,
                        Col_names,
                        Table_name,
                        Target_cols
                    )
            end;

        {_, _, _} ->
            _pipe@14 = Prepared_statement,
            _pipe@15 = cake@internal@prepared_statement:append_sql(
                _pipe@14,
                <<"INSERT"/utf8>>
            ),
            _pipe@16 = insert_modifier_apply(
                _pipe@15,
                erlang:element(4, Insert)
            ),
            _pipe@17 = insert_ignore_into_table_apply(
                _pipe@16,
                erlang:element(2, Insert)
            ),
            _pipe@18 = insert_columns_apply(_pipe@17, erlang:element(3, Insert)),
            insert_source_apply(_pipe@18, erlang:element(5, Insert))
    end.

-file("src/cake/internal/write_query.gleam", 217).
?DOC(false).
-spec insert_apply(
    cake@internal@prepared_statement:prepared_statement(),
    insert(any())
) -> cake@internal@prepared_statement:prepared_statement().
insert_apply(Prepared_statement, Insert) ->
    case {begin
            _pipe = Prepared_statement,
            cake@internal@prepared_statement:get_dialect(_pipe)
        end,
        erlang:element(6, Insert)} of
        {maria, {insert_conflict_ignore, _, _}} ->
            _pipe@1 = Prepared_statement,
            _pipe@2 = insert_conflict_ignore_maria_mysql_apply(_pipe@1, Insert),
            _pipe@3 = returning_apply(_pipe@2, erlang:element(7, Insert)),
            _pipe@4 = cake@internal@read_query:epilog_apply(
                _pipe@3,
                erlang:element(8, Insert)
            ),
            cake@internal@read_query:comment_apply(
                _pipe@4,
                erlang:element(9, Insert)
            );

        {mysql, {insert_conflict_ignore, _, _}} ->
            _pipe@1 = Prepared_statement,
            _pipe@2 = insert_conflict_ignore_maria_mysql_apply(_pipe@1, Insert),
            _pipe@3 = returning_apply(_pipe@2, erlang:element(7, Insert)),
            _pipe@4 = cake@internal@read_query:epilog_apply(
                _pipe@3,
                erlang:element(8, Insert)
            ),
            cake@internal@read_query:comment_apply(
                _pipe@4,
                erlang:element(9, Insert)
            );

        {_, {insert_duplicate_key_update, _}} ->
            _pipe@5 = Prepared_statement,
            _pipe@6 = insert_duplicate_key_update_apply(_pipe@5, Insert),
            _pipe@7 = returning_apply(_pipe@6, erlang:element(7, Insert)),
            _pipe@8 = cake@internal@read_query:epilog_apply(
                _pipe@7,
                erlang:element(8, Insert)
            ),
            cake@internal@read_query:comment_apply(
                _pipe@8,
                erlang:element(9, Insert)
            );

        {_, _} ->
            _pipe@9 = Prepared_statement,
            _pipe@10 = cake@internal@prepared_statement:append_sql(
                _pipe@9,
                <<"INSERT"/utf8>>
            ),
            _pipe@11 = insert_modifier_apply(
                _pipe@10,
                erlang:element(4, Insert)
            ),
            _pipe@12 = insert_into_table_apply(
                _pipe@11,
                erlang:element(2, Insert)
            ),
            _pipe@13 = insert_columns_apply(_pipe@12, erlang:element(3, Insert)),
            _pipe@14 = insert_source_apply(_pipe@13, erlang:element(5, Insert)),
            _pipe@15 = insert_on_conflict_apply(
                _pipe@14,
                erlang:element(6, Insert)
            ),
            _pipe@16 = returning_apply(_pipe@15, erlang:element(7, Insert)),
            _pipe@17 = cake@internal@read_query:epilog_apply(
                _pipe@16,
                erlang:element(8, Insert)
            ),
            cake@internal@read_query:comment_apply(
                _pipe@17,
                erlang:element(9, Insert)
            )
    end.

-file("src/cake/internal/write_query.gleam", 47).
?DOC(false).
-spec apply(
    cake@internal@prepared_statement:prepared_statement(),
    write_query(any())
) -> cake@internal@prepared_statement:prepared_statement().
apply(Prepared_statement, Query) ->
    case Query of
        {insert_query, Insert} ->
            _pipe = Prepared_statement,
            insert_apply(_pipe, Insert);

        {update_query, Update} ->
            _pipe@1 = Prepared_statement,
            update_apply(_pipe@1, Update);

        {delete_query, Delete} ->
            _pipe@2 = Prepared_statement,
            delete_apply(_pipe@2, Delete)
    end.

-file("src/cake/internal/write_query.gleam", 37).
?DOC(false).
-spec to_prepared_statement(
    write_query(any()),
    binary(),
    cake@internal@dialect:dialect()
) -> cake@internal@prepared_statement:prepared_statement().
to_prepared_statement(Query, Placeholder_base, Dialect) ->
    _pipe = Placeholder_base,
    _pipe@1 = cake@internal@prepared_statement:new(_pipe, Dialect),
    apply(_pipe@1, Query).