-module(cake@internal@read_query).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/cake/internal/read_query.gleam").
-export([comment_apply/2, epilog_apply/2, fragment_count_placeholders/1, fragment_prepared_split_string/1, fragment_apply/2, group_by_clause_apply/2, where_clause_apply/2, join_apply/2, join_clause_apply/2, from_clause_apply/2, combined_clause_apply/2, apply/2, to_prepared_statement/3, combined_query_new/2, combined_order_by/3, select_order_by/3, limit_new/1, offset_new/1]).
-export_type([read_query/0, combined/0, combined_query_kind/0, select_kind/0, select/0, selects/0, select_value/0, from/0, where/0, where_comparison_operator/0, where_value/0, group_by/0, joins/0, join_target/0, join/0, order_by/0, order_by_value/0, order_by_direction/0, limit/0, offset/0, epilog/0, comment/0, fragment/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 read_query() :: {select_query, select()} | {combined_query, combined()}.

-type combined() :: {combined,
        combined_query_kind(),
        list(select()),
        limit(),
        offset(),
        order_by(),
        epilog(),
        comment()}.

-type combined_query_kind() :: union_distinct |
    union_all |
    except_distinct |
    except_all |
    intersect_distinct |
    intersect_all.

-type select_kind() :: select_all | select_distinct.

-type select() :: {select,
        select_kind(),
        selects(),
        from(),
        joins(),
        where(),
        group_by(),
        where(),
        order_by(),
        limit(),
        offset(),
        epilog(),
        comment()}.

-type selects() :: no_selects | {selects, list(select_value())}.

-type select_value() :: {select_column, binary()} |
    {select_param, cake@param:param()} |
    {select_fragment, fragment()} |
    {select_alias, select_value(), binary()}.

-type from() :: no_from |
    {from_table, binary()} |
    {from_sub_query, read_query(), binary()}.

-type where() :: no_where |
    {not_where, where()} |
    {and_where, list(where())} |
    {or_where, list(where())} |
    {xor_where, list(where())} |
    {xor_parity_where, list(where())} |
    {where_is_bool, where_value(), boolean()} |
    {where_is_not_bool, where_value(), boolean()} |
    {where_is_null, where_value()} |
    {where_is_not_null, where_value()} |
    {where_comparison,
        where_value(),
        where_comparison_operator(),
        where_value()} |
    {where_any_of_sub_query,
        where_value(),
        where_comparison_operator(),
        read_query()} |
    {where_all_of_sub_query,
        where_value(),
        where_comparison_operator(),
        read_query()} |
    {where_in, where_value(), list(where_value())} |
    {where_exists_in_sub_query, read_query()} |
    {where_between, where_value(), where_value(), where_value()} |
    {where_like, where_value(), binary()} |
    {where_i_like, where_value(), binary()} |
    {where_similar_to, where_value(), binary(), binary()} |
    {where_fragment, fragment()}.

-type where_comparison_operator() :: equal |
    greater |
    greater_or_equal |
    lower |
    lower_or_equal |
    unequal.

-type where_value() :: {where_column_value, binary()} |
    {where_param_value, cake@param:param()} |
    {where_fragment_value, fragment()} |
    {where_sub_query_value, read_query()}.

-type group_by() :: no_group_by | {group_by, list(binary())}.

-type joins() :: no_joins | {joins, list(join())}.

-type join_target() :: {join_table, binary()} | {join_sub_query, read_query()}.

-type join() :: {inner_join, join_target(), binary(), where()} |
    {inner_join_lateral_on_true, join_target(), binary()} |
    {left_join, join_target(), binary(), where()} |
    {left_join_lateral_on_true, join_target(), binary()} |
    {right_join, join_target(), binary(), where()} |
    {full_join, join_target(), binary(), where()} |
    {cross_join, join_target(), binary()} |
    {cross_join_lateral, join_target(), binary()}.

-type order_by() :: no_order_by | {order_by, list(order_by_value())}.

-type order_by_value() :: {order_by_column, binary(), order_by_direction()} |
    {order_by_fragment, fragment(), order_by_direction()}.

-type order_by_direction() :: asc |
    asc_nulls_first |
    asc_nulls_last |
    desc |
    desc_nulls_first |
    desc_nulls_last.

-type limit() :: no_limit | {limit, integer()}.

-type offset() :: no_offset | {offset, integer()}.

-type epilog() :: no_epilog | {epilog, binary()}.

-type comment() :: no_comment | {comment, binary()}.

-type fragment() :: {fragment_literal, binary()} |
    {fragment_prepared, binary(), list(cake@param:param())}.

-file("src/cake/internal/read_query.gleam", 1571).
?DOC(false).
-spec comment_apply(
    cake@internal@prepared_statement:prepared_statement(),
    comment()
) -> cake@internal@prepared_statement:prepared_statement().
comment_apply(Prepared_statement, Comment) ->
    case Comment of
        no_comment ->
            Prepared_statement;

        {comment, String} ->
            case begin
                _pipe = String,
                gleam_stdlib:contains_string(_pipe, <<"\n"/utf8>>)
            end
            orelse begin
                _pipe@1 = String,
                gleam_stdlib:contains_string(_pipe@1, <<"\r"/utf8>>)
            end of
                true ->
                    _pipe@2 = Prepared_statement,
                    cake@internal@prepared_statement:append_sql(
                        _pipe@2,
                        <<<<" /* "/utf8,
                                (begin
                                    _pipe@3 = String,
                                    _pipe@4 = gleam@string:trim(_pipe@3),
                                    _pipe@5 = gleam@string:replace(
                                        _pipe@4,
                                        <<"*/"/utf8>>,
                                        <<"* /"/utf8>>
                                    ),
                                    gleam@string:replace(
                                        _pipe@5,
                                        <<"/*"/utf8>>,
                                        <<"/ *"/utf8>>
                                    )
                                end)/binary>>/binary,
                            " */"/utf8>>
                    );

                false ->
                    _pipe@6 = Prepared_statement,
                    cake@internal@prepared_statement:append_sql(
                        _pipe@6,
                        <<" -- "/utf8,
                            (begin
                                _pipe@7 = String,
                                gleam@string:trim(_pipe@7)
                            end)/binary>>
                    )
            end
    end.

-file("src/cake/internal/read_query.gleam", 1546).
?DOC(false).
-spec epilog_apply(
    cake@internal@prepared_statement:prepared_statement(),
    epilog()
) -> cake@internal@prepared_statement:prepared_statement().
epilog_apply(Prepared_statement, Epilog) ->
    case Epilog of
        no_epilog ->
            Prepared_statement;

        {epilog, String} ->
            _pipe = Prepared_statement,
            cake@internal@prepared_statement:append_sql(_pipe, String)
    end.

-file("src/cake/internal/read_query.gleam", 1517).
?DOC(false).
-spec offset_clause_apply(
    cake@internal@prepared_statement:prepared_statement(),
    offset()
) -> cake@internal@prepared_statement:prepared_statement().
offset_clause_apply(Prepared_statement, Offset) ->
    _pipe@1 = case Offset of
        no_offset ->
            <<""/utf8>>;

        {offset, Offset@1} ->
            <<" OFFSET "/utf8,
                (begin
                    _pipe = Offset@1,
                    erlang:integer_to_binary(_pipe)
                end)/binary>>
    end,
    cake@internal@prepared_statement:append_sql(Prepared_statement, _pipe@1).

-file("src/cake/internal/read_query.gleam", 1486).
?DOC(false).
-spec limit_clause_apply(
    cake@internal@prepared_statement:prepared_statement(),
    limit()
) -> cake@internal@prepared_statement:prepared_statement().
limit_clause_apply(Prepared_statement, Limit) ->
    _pipe@1 = case Limit of
        no_limit ->
            <<""/utf8>>;

        {limit, Limit@1} ->
            <<" LIMIT "/utf8,
                (begin
                    _pipe = Limit@1,
                    erlang:integer_to_binary(_pipe)
                end)/binary>>
    end,
    cake@internal@prepared_statement:append_sql(Prepared_statement, _pipe@1).

-file("src/cake/internal/read_query.gleam", 1453).
?DOC(false).
-spec order_by_direction_to_sql(order_by_direction()) -> binary().
order_by_direction_to_sql(Order_by_direction) ->
    case Order_by_direction of
        asc ->
            <<"ASC"/utf8>>;

        asc_nulls_first ->
            <<"ASC NULLS FIRST"/utf8>>;

        asc_nulls_last ->
            <<"ASC NULLS LAST"/utf8>>;

        desc ->
            <<"DESC"/utf8>>;

        desc_nulls_first ->
            <<"DESC NULLS FIRST"/utf8>>;

        desc_nulls_last ->
            <<"DESC NULLS LAST"/utf8>>
    end.

-file("src/cake/internal/read_query.gleam", 1763).
?DOC(false).
-spec fragment_count_placeholders(list(binary())) -> integer().
fragment_count_placeholders(String_fragments) ->
    _pipe = String_fragments,
    gleam@list:fold(
        _pipe,
        0,
        fun(Count, String_fragment) -> case String_fragment =:= <<"$"/utf8>> of
                true ->
                    Count + 1;

                false ->
                    Count
            end end
    ).

-file("src/cake/internal/read_query.gleam", 1637).
?DOC(false).
-spec fragment_prepared_split_string(binary()) -> list(binary()).
fragment_prepared_split_string(String_fragment) ->
    _pipe = String_fragment,
    _pipe@1 = gleam@string:to_graphemes(_pipe),
    _pipe@2 = gleam@list:fold(
        _pipe@1,
        [],
        fun(Accumulator, Grapheme) ->
            case {Grapheme =:= <<"$"/utf8>>, Accumulator} of
                {true, _} ->
                    [<<"$"/utf8>> | Accumulator];

                {false, []} ->
                    [Grapheme];

                {false, [X | _]} when X =:= <<"$"/utf8>> ->
                    [Grapheme | Accumulator];

                {false, [X@1 | Xs]} ->
                    [<<X@1/binary, Grapheme/binary>> | Xs]
            end
        end
    ),
    lists:reverse(_pipe@2).

-file("src/cake/internal/read_query.gleam", 1665).
?DOC(false).
-spec fragment_apply(
    cake@internal@prepared_statement:prepared_statement(),
    fragment()
) -> cake@internal@prepared_statement:prepared_statement().
fragment_apply(Prepared_statement, Fragment) ->
    case Fragment of
        {fragment_literal, Value} ->
            _pipe = Prepared_statement,
            cake@internal@prepared_statement:append_sql(_pipe, Value);

        {fragment_prepared, Value@1, []} ->
            _pipe@1 = Prepared_statement,
            cake@internal@prepared_statement:append_sql(_pipe@1, Value@1);

        {fragment_prepared, Value@2, Params} ->
            Fragments = begin
                _pipe@2 = Value@2,
                fragment_prepared_split_string(_pipe@2)
            end,
            Fragment_placeholder_count = begin
                _pipe@3 = Fragments,
                fragment_count_placeholders(_pipe@3)
            end,
            Params_count = begin
                _pipe@4 = Params,
                erlang:length(_pipe@4)
            end,
            Params@1 = case begin
                _pipe@5 = Fragment_placeholder_count,
                gleam@int:compare(_pipe@5, Params_count)
            end of
                eq ->
                    Params;

                lt ->
                    _pipe@6 = Params,
                    gleam@list:take(_pipe@6, Fragment_placeholder_count);

                gt ->
                    case begin
                        _pipe@7 = Params,
                        gleam@list:last(_pipe@7)
                    end of
                        {ok, Last_item} ->
                            Missing_params_count = Fragment_placeholder_count - Params_count,
                            Repeated_last_item = begin
                                _pipe@8 = Last_item,
                                gleam@list:repeat(_pipe@8, Missing_params_count)
                            end,
                            _pipe@9 = Params,
                            lists:append(_pipe@9, Repeated_last_item);

                        {error, nil} ->
                            Params
                    end
            end,
            case Fragments of
                [] ->
                    Prepared_statement;

                Fragments@1 ->
                    {New_prepared_statement@1, _} = begin
                        _pipe@10 = Fragments@1,
                        gleam@list:fold(
                            _pipe@10,
                            {Prepared_statement, Params@1},
                            fun(Accumulator, Fragment@1) ->
                                {New_prepared_statement, Params@2} = Accumulator,
                                case {Fragment@1 =:= <<"$"/utf8>>, Params@2} of
                                    {false, _} ->
                                        {begin
                                                _pipe@11 = New_prepared_statement,
                                                cake@internal@prepared_statement:append_sql(
                                                    _pipe@11,
                                                    Fragment@1
                                                )
                                            end,
                                            Params@2};

                                    {true, [Param | Rest_params]} ->
                                        {begin
                                                _pipe@12 = New_prepared_statement,
                                                cake@internal@prepared_statement:append_param(
                                                    _pipe@12,
                                                    Param
                                                )
                                            end,
                                            Rest_params};

                                    {true, []} ->
                                        {begin
                                                _pipe@13 = New_prepared_statement,
                                                cake@internal@prepared_statement:append_sql(
                                                    _pipe@13,
                                                    Fragment@1
                                                )
                                            end,
                                            []}
                                end
                            end
                        )
                    end,
                    New_prepared_statement@1
            end
    end.

-file("src/cake/internal/read_query.gleam", 1427).
?DOC(false).
-spec order_by_value_apply(
    cake@internal@prepared_statement:prepared_statement(),
    order_by_value()
) -> cake@internal@prepared_statement:prepared_statement().
order_by_value_apply(Prepared_statement, Value) ->
    case Value of
        {order_by_column, Column, Direction} ->
            _pipe = Prepared_statement,
            _pipe@1 = cake@internal@prepared_statement:append_sql(_pipe, Column),
            cake@internal@prepared_statement:append_sql(
                _pipe@1,
                <<" "/utf8,
                    (begin
                        _pipe@2 = Direction,
                        order_by_direction_to_sql(_pipe@2)
                    end)/binary>>
            );

        {order_by_fragment, Fragment, Direction@1} ->
            _pipe@3 = Prepared_statement,
            _pipe@4 = fragment_apply(_pipe@3, Fragment),
            cake@internal@prepared_statement:append_sql(
                _pipe@4,
                <<" "/utf8,
                    (begin
                        _pipe@5 = Direction@1,
                        order_by_direction_to_sql(_pipe@5)
                    end)/binary>>
            )
    end.

-file("src/cake/internal/read_query.gleam", 1391).
?DOC(false).
-spec order_by_clause_apply(
    cake@internal@prepared_statement:prepared_statement(),
    order_by()
) -> cake@internal@prepared_statement:prepared_statement().
order_by_clause_apply(Prepared_statement, Order_by) ->
    case Order_by of
        no_order_by ->
            Prepared_statement;

        {order_by, Order_bys} ->
            case Order_bys of
                [] ->
                    Prepared_statement;

                Vs ->
                    Prepared_statement@1 = begin
                        _pipe = Prepared_statement,
                        cake@internal@prepared_statement:append_sql(
                            _pipe,
                            <<" ORDER BY "/utf8>>
                        )
                    end,
                    _pipe@1 = Vs,
                    gleam@list:fold(
                        _pipe@1,
                        Prepared_statement@1,
                        fun(New_prepared_statement, Value) ->
                            case New_prepared_statement =:= Prepared_statement@1 of
                                true ->
                                    _pipe@2 = New_prepared_statement,
                                    order_by_value_apply(_pipe@2, Value);

                                false ->
                                    _pipe@3 = New_prepared_statement,
                                    _pipe@4 = cake@internal@prepared_statement:append_sql(
                                        _pipe@3,
                                        <<", "/utf8>>
                                    ),
                                    order_by_value_apply(_pipe@4, Value)
                            end
                        end
                    )
            end
    end.

-file("src/cake/internal/read_query.gleam", 795).
?DOC(false).
-spec where_sql_apply(
    cake@internal@prepared_statement:prepared_statement(),
    binary()
) -> cake@internal@prepared_statement:prepared_statement().
where_sql_apply(Prepared_statement, Sql) ->
    _pipe = Prepared_statement,
    cake@internal@prepared_statement:append_sql(_pipe, Sql).

-file("src/cake/internal/read_query.gleam", 802).
?DOC(false).
-spec where_param_apply(
    cake@internal@prepared_statement:prepared_statement(),
    cake@param:param()
) -> cake@internal@prepared_statement:prepared_statement().
where_param_apply(Prepared_statement, Param) ->
    _pipe = Prepared_statement,
    cake@internal@prepared_statement:append_param(_pipe, Param).

-file("src/cake/internal/read_query.gleam", 1171).
?DOC(false).
-spec group_by_apply(
    cake@internal@prepared_statement:prepared_statement(),
    list(binary())
) -> cake@internal@prepared_statement:prepared_statement().
group_by_apply(Prepared_statement, Group_bys) ->
    case Group_bys of
        [] ->
            Prepared_statement;

        _ ->
            _pipe = Group_bys,
            gleam@list:fold(
                _pipe,
                Prepared_statement,
                fun(New_prepared_statement, Sql) ->
                    case New_prepared_statement =:= Prepared_statement of
                        true ->
                            _pipe@1 = New_prepared_statement,
                            cake@internal@prepared_statement:append_sql(
                                _pipe@1,
                                Sql
                            );

                        false ->
                            _pipe@2 = New_prepared_statement,
                            cake@internal@prepared_statement:append_sql(
                                _pipe@2,
                                <<", "/utf8, Sql/binary>>
                            )
                    end
                end
            )
    end.

-file("src/cake/internal/read_query.gleam", 1158).
?DOC(false).
-spec group_by_clause_apply(
    cake@internal@prepared_statement:prepared_statement(),
    group_by()
) -> cake@internal@prepared_statement:prepared_statement().
group_by_clause_apply(Prepared_statement, Group_by) ->
    case Group_by of
        no_group_by ->
            Prepared_statement;

        {group_by, Columns} ->
            _pipe = Prepared_statement,
            _pipe@1 = cake@internal@prepared_statement:append_sql(
                _pipe,
                <<" GROUP BY "/utf8>>
            ),
            group_by_apply(_pipe@1, Columns)
    end.

-file("src/cake/internal/read_query.gleam", 380).
?DOC(false).
-spec select_value_apply(
    cake@internal@prepared_statement:prepared_statement(),
    select_value()
) -> cake@internal@prepared_statement:prepared_statement().
select_value_apply(Prepared_statement, Value) ->
    case Value of
        {select_column, Name} ->
            _pipe = Prepared_statement,
            cake@internal@prepared_statement:append_sql(_pipe, Name);

        {select_param, Value@1} ->
            _pipe@1 = Prepared_statement,
            cake@internal@prepared_statement:append_param(_pipe@1, Value@1);

        {select_fragment, Value@2} ->
            _pipe@2 = Prepared_statement,
            fragment_apply(_pipe@2, Value@2);

        {select_alias, Value@3, Name@1} ->
            _pipe@3 = Prepared_statement,
            _pipe@4 = select_value_apply(_pipe@3, Value@3),
            cake@internal@prepared_statement:append_sql(
                _pipe@4,
                <<" AS "/utf8, Name@1/binary>>
            )
    end.

-file("src/cake/internal/read_query.gleam", 338).
?DOC(false).
-spec select_clause_apply(
    cake@internal@prepared_statement:prepared_statement(),
    select_kind(),
    selects()
) -> cake@internal@prepared_statement:prepared_statement().
select_clause_apply(Prepared_statement, Kind, Selects) ->
    Select_command = case Kind of
        select_all ->
            <<"SELECT"/utf8>>;

        select_distinct ->
            <<"SELECT DISTINCT"/utf8>>
    end,
    case Selects of
        no_selects ->
            _pipe = Prepared_statement,
            cake@internal@prepared_statement:append_sql(
                _pipe,
                <<Select_command/binary, " *"/utf8>>
            );

        {selects, Values} ->
            case Values of
                [] ->
                    Prepared_statement;

                Vs ->
                    Prepared_statement@1 = begin
                        _pipe@1 = Prepared_statement,
                        cake@internal@prepared_statement:append_sql(
                            _pipe@1,
                            <<Select_command/binary, " "/utf8>>
                        )
                    end,
                    _pipe@2 = Vs,
                    gleam@list:fold(
                        _pipe@2,
                        Prepared_statement@1,
                        fun(New_prepared_statement, Value) ->
                            case New_prepared_statement =:= Prepared_statement@1 of
                                true ->
                                    _pipe@3 = New_prepared_statement,
                                    select_value_apply(_pipe@3, Value);

                                false ->
                                    _pipe@4 = New_prepared_statement,
                                    _pipe@5 = cake@internal@prepared_statement:append_sql(
                                        _pipe@4,
                                        <<", "/utf8>>
                                    ),
                                    select_value_apply(_pipe@5, Value)
                            end
                        end
                    )
            end
    end.

-file("src/cake/internal/read_query.gleam", 809).
?DOC(false).
-spec where_sub_query_apply(
    cake@internal@prepared_statement:prepared_statement(),
    read_query()
) -> cake@internal@prepared_statement:prepared_statement().
where_sub_query_apply(Prepared_statement, Query) ->
    _pipe = Prepared_statement,
    _pipe@1 = cake@internal@prepared_statement:append_sql(_pipe, <<"("/utf8>>),
    _pipe@2 = apply(_pipe@1, Query),
    cake@internal@prepared_statement:append_sql(_pipe@2, <<")"/utf8>>).

-file("src/cake/internal/read_query.gleam", 713).
?DOC(false).
-spec where_comparison_apply(
    cake@internal@prepared_statement:prepared_statement(),
    where_value(),
    binary(),
    where_value()
) -> cake@internal@prepared_statement:prepared_statement().
where_comparison_apply(Prepared_statement, Value_a, Operator, Value_b) ->
    case {Value_a, Value_b} of
        {{where_column_value, Column_a}, {where_column_value, Column_b}} ->
            _pipe = Prepared_statement,
            where_sql_apply(
                _pipe,
                <<<<<<<<Column_a/binary, " "/utf8>>/binary, Operator/binary>>/binary,
                        " "/utf8>>/binary,
                    Column_b/binary>>
            );

        {{where_column_value, Column}, {where_param_value, Param}} ->
            _pipe@1 = Prepared_statement,
            _pipe@2 = where_sql_apply(
                _pipe@1,
                <<<<<<Column/binary, " "/utf8>>/binary, Operator/binary>>/binary,
                    " "/utf8>>
            ),
            where_param_apply(_pipe@2, Param);

        {{where_param_value, Param@1}, {where_column_value, Column@1}} ->
            _pipe@3 = Prepared_statement,
            _pipe@4 = where_param_apply(_pipe@3, Param@1),
            where_sql_apply(
                _pipe@4,
                <<<<<<" "/utf8, Operator/binary>>/binary, " "/utf8>>/binary,
                    Column@1/binary>>
            );

        {{where_param_value, Param_a}, {where_param_value, Param_b}} ->
            _pipe@5 = Prepared_statement,
            _pipe@6 = where_param_apply(_pipe@5, Param_a),
            _pipe@7 = where_sql_apply(
                _pipe@6,
                <<<<" "/utf8, Operator/binary>>/binary, " "/utf8>>
            ),
            where_param_apply(_pipe@7, Param_b);

        {{where_fragment_value, Value}, {where_column_value, Column@2}} ->
            _pipe@8 = Prepared_statement,
            _pipe@9 = fragment_apply(_pipe@8, Value),
            where_sql_apply(
                _pipe@9,
                <<<<<<" "/utf8, Operator/binary>>/binary, " "/utf8>>/binary,
                    Column@2/binary>>
            );

        {{where_column_value, Column@3}, {where_fragment_value, Value@1}} ->
            _pipe@10 = Prepared_statement,
            _pipe@11 = where_sql_apply(
                _pipe@10,
                <<<<<<Column@3/binary, " "/utf8>>/binary, Operator/binary>>/binary,
                    " "/utf8>>
            ),
            fragment_apply(_pipe@11, Value@1);

        {{where_fragment_value, Value@2}, {where_param_value, Param@2}} ->
            _pipe@12 = Prepared_statement,
            _pipe@13 = fragment_apply(_pipe@12, Value@2),
            _pipe@14 = where_sql_apply(
                _pipe@13,
                <<<<" "/utf8, Operator/binary>>/binary, " "/utf8>>
            ),
            where_param_apply(_pipe@14, Param@2);

        {{where_param_value, Param@3}, {where_fragment_value, Value@3}} ->
            _pipe@15 = Prepared_statement,
            _pipe@16 = where_param_apply(_pipe@15, Param@3),
            _pipe@17 = where_sql_apply(
                _pipe@16,
                <<<<" "/utf8, Operator/binary>>/binary, " "/utf8>>
            ),
            fragment_apply(_pipe@17, Value@3);

        {{where_fragment_value, Value_a@1}, {where_fragment_value, Value_b@1}} ->
            _pipe@18 = Prepared_statement,
            _pipe@19 = fragment_apply(_pipe@18, Value_a@1),
            _pipe@20 = where_sql_apply(
                _pipe@19,
                <<<<" "/utf8, Operator/binary>>/binary, " "/utf8>>
            ),
            fragment_apply(_pipe@20, Value_b@1);

        {{where_sub_query_value, Query_a}, {where_sub_query_value, Query_b}} ->
            _pipe@21 = Prepared_statement,
            _pipe@22 = where_sub_query_apply(_pipe@21, Query_a),
            _pipe@23 = where_sql_apply(
                _pipe@22,
                <<<<" "/utf8, Operator/binary>>/binary, " "/utf8>>
            ),
            where_sub_query_apply(_pipe@23, Query_b);

        {{where_column_value, Column@4}, {where_sub_query_value, Query}} ->
            _pipe@24 = Prepared_statement,
            _pipe@25 = where_sql_apply(
                _pipe@24,
                <<<<<<Column@4/binary, " "/utf8>>/binary, Operator/binary>>/binary,
                    " "/utf8>>
            ),
            where_sub_query_apply(_pipe@25, Query);

        {{where_sub_query_value, Query@1}, {where_column_value, Column@5}} ->
            _pipe@26 = Prepared_statement,
            _pipe@27 = where_sub_query_apply(_pipe@26, Query@1),
            where_sql_apply(
                _pipe@27,
                <<<<<<" "/utf8, Operator/binary>>/binary, " "/utf8>>/binary,
                    Column@5/binary>>
            );

        {{where_param_value, Param@4}, {where_sub_query_value, Query@2}} ->
            _pipe@28 = Prepared_statement,
            _pipe@29 = where_param_apply(_pipe@28, Param@4),
            _pipe@30 = where_sql_apply(
                _pipe@29,
                <<<<" "/utf8, Operator/binary>>/binary, " "/utf8>>
            ),
            where_sub_query_apply(_pipe@30, Query@2);

        {{where_sub_query_value, Query@3}, {where_param_value, Param@5}} ->
            _pipe@31 = Prepared_statement,
            _pipe@32 = where_sub_query_apply(_pipe@31, Query@3),
            _pipe@33 = where_sql_apply(
                _pipe@32,
                <<<<" "/utf8, Operator/binary>>/binary, " "/utf8>>
            ),
            where_param_apply(_pipe@33, Param@5);

        {{where_fragment_value, Value@4}, {where_sub_query_value, Query@4}} ->
            _pipe@34 = Prepared_statement,
            _pipe@35 = fragment_apply(_pipe@34, Value@4),
            _pipe@36 = where_sql_apply(
                _pipe@35,
                <<<<" "/utf8, Operator/binary>>/binary, " "/utf8>>
            ),
            where_sub_query_apply(_pipe@36, Query@4);

        {{where_sub_query_value, Query@5}, {where_fragment_value, Value@5}} ->
            _pipe@37 = Prepared_statement,
            _pipe@38 = where_sub_query_apply(_pipe@37, Query@5),
            _pipe@39 = where_sql_apply(
                _pipe@38,
                <<<<" "/utf8, Operator/binary>>/binary, " "/utf8>>
            ),
            fragment_apply(_pipe@39, Value@5)
    end.

-file("src/cake/internal/read_query.gleam", 1035).
?DOC(false).
-spec where_value_in_values_apply(
    cake@internal@prepared_statement:prepared_statement(),
    where_value(),
    list(where_value())
) -> cake@internal@prepared_statement:prepared_statement().
where_value_in_values_apply(Prepared_statement, Value, Values) ->
    Prepared_statement@1 = begin
        _pipe@4 = case Value of
            {where_column_value, Name} ->
                _pipe = Prepared_statement,
                cake@internal@prepared_statement:append_sql(_pipe, Name);

            {where_param_value, Value@1} ->
                _pipe@1 = Prepared_statement,
                cake@internal@prepared_statement:append_param(_pipe@1, Value@1);

            {where_fragment_value, Value@2} ->
                _pipe@2 = Prepared_statement,
                fragment_apply(_pipe@2, Value@2);

            {where_sub_query_value, Query} ->
                _pipe@3 = Prepared_statement,
                where_sub_query_apply(_pipe@3, Query)
        end,
        cake@internal@prepared_statement:append_sql(_pipe@4, <<" IN ("/utf8>>)
    end,
    _pipe@5 = Values,
    _pipe@14 = gleam@list:fold(
        _pipe@5,
        Prepared_statement@1,
        fun(New_prepared_statement, Value@3) -> case Value@3 of
                {where_column_value, Name@1} ->
                    case New_prepared_statement =:= Prepared_statement@1 of
                        true ->
                            _pipe@6 = New_prepared_statement,
                            cake@internal@prepared_statement:append_sql(
                                _pipe@6,
                                Name@1
                            );

                        false ->
                            _pipe@7 = New_prepared_statement,
                            cake@internal@prepared_statement:append_sql(
                                _pipe@7,
                                <<", "/utf8, Name@1/binary>>
                            )
                    end;

                {where_param_value, Value@4} ->
                    _pipe@8 = case New_prepared_statement =:= Prepared_statement@1 of
                        true ->
                            <<""/utf8>>;

                        false ->
                            <<", "/utf8>>
                    end,
                    _pipe@9 = cake@internal@prepared_statement:append_sql(
                        New_prepared_statement,
                        _pipe@8
                    ),
                    cake@internal@prepared_statement:append_param(
                        _pipe@9,
                        Value@4
                    );

                {where_fragment_value, Value@5} ->
                    _pipe@11 = case New_prepared_statement =:= Prepared_statement@1 of
                        true ->
                            New_prepared_statement;

                        false ->
                            _pipe@10 = New_prepared_statement,
                            cake@internal@prepared_statement:append_sql(
                                _pipe@10,
                                <<", "/utf8>>
                            )
                    end,
                    fragment_apply(_pipe@11, Value@5);

                {where_sub_query_value, Query@1} ->
                    _pipe@13 = case New_prepared_statement =:= Prepared_statement@1 of
                        true ->
                            New_prepared_statement;

                        false ->
                            _pipe@12 = New_prepared_statement,
                            cake@internal@prepared_statement:append_sql(
                                _pipe@12,
                                <<", "/utf8>>
                            )
                    end,
                    where_sub_query_apply(_pipe@13, Query@1)
            end end
    ),
    cake@internal@prepared_statement:append_sql(_pipe@14, <<")"/utf8>>).

-file("src/cake/internal/read_query.gleam", 1097).
?DOC(false).
-spec where_between_apply(
    cake@internal@prepared_statement:prepared_statement(),
    where_value(),
    where_value(),
    where_value()
) -> cake@internal@prepared_statement:prepared_statement().
where_between_apply(Prepared_statement, Value_a, Value_b, Value_c) ->
    Prepared_statement@1 = case Value_a of
        {where_column_value, Name} ->
            _pipe = Prepared_statement,
            cake@internal@prepared_statement:append_sql(_pipe, Name);

        {where_param_value, Value} ->
            _pipe@1 = Prepared_statement,
            cake@internal@prepared_statement:append_param(_pipe@1, Value);

        {where_fragment_value, Value@1} ->
            _pipe@2 = Prepared_statement,
            fragment_apply(_pipe@2, Value@1);

        {where_sub_query_value, Query} ->
            _pipe@3 = Prepared_statement,
            where_sub_query_apply(_pipe@3, Query)
    end,
    Prepared_statement@2 = begin
        _pipe@4 = Prepared_statement@1,
        cake@internal@prepared_statement:append_sql(
            _pipe@4,
            <<" BETWEEN "/utf8>>
        )
    end,
    Prepared_statement@3 = case Value_b of
        {where_column_value, Name@1} ->
            _pipe@5 = Prepared_statement@2,
            cake@internal@prepared_statement:append_sql(_pipe@5, Name@1);

        {where_param_value, Value@2} ->
            _pipe@6 = Prepared_statement@2,
            cake@internal@prepared_statement:append_param(_pipe@6, Value@2);

        {where_fragment_value, Value@3} ->
            _pipe@7 = Prepared_statement@2,
            fragment_apply(_pipe@7, Value@3);

        {where_sub_query_value, Query@1} ->
            _pipe@8 = Prepared_statement@2,
            where_sub_query_apply(_pipe@8, Query@1)
    end,
    Prepared_statement@4 = begin
        _pipe@9 = Prepared_statement@3,
        cake@internal@prepared_statement:append_sql(_pipe@9, <<" AND "/utf8>>)
    end,
    Prepared_statement@5 = case Value_c of
        {where_column_value, Name@2} ->
            _pipe@10 = Prepared_statement@4,
            cake@internal@prepared_statement:append_sql(_pipe@10, Name@2);

        {where_param_value, Value@4} ->
            _pipe@11 = Prepared_statement@4,
            cake@internal@prepared_statement:append_param(_pipe@11, Value@4);

        {where_fragment_value, Value@5} ->
            _pipe@12 = Prepared_statement@4,
            fragment_apply(_pipe@12, Value@5);

        {where_sub_query_value, Query@2} ->
            _pipe@13 = Prepared_statement@4,
            where_sub_query_apply(_pipe@13, Query@2)
    end,
    Prepared_statement@5.

-file("src/cake/internal/read_query.gleam", 691).
?DOC(false).
-spec where_literal_apply(
    cake@internal@prepared_statement:prepared_statement(),
    where_value(),
    binary()
) -> cake@internal@prepared_statement:prepared_statement().
where_literal_apply(Prepared_statement, Value, Literal) ->
    case Value of
        {where_column_value, Name} ->
            _pipe = Prepared_statement,
            cake@internal@prepared_statement:append_sql(
                _pipe,
                <<<<Name/binary, " "/utf8>>/binary, Literal/binary>>
            );

        {where_param_value, Value@1} ->
            _pipe@1 = Prepared_statement,
            cake@internal@prepared_statement:append_param(_pipe@1, Value@1);

        {where_fragment_value, Value@2} ->
            _pipe@2 = Prepared_statement,
            _pipe@3 = fragment_apply(_pipe@2, Value@2),
            cake@internal@prepared_statement:append_sql(
                _pipe@3,
                <<" "/utf8, Literal/binary>>
            );

        {where_sub_query_value, Query} ->
            _pipe@4 = Prepared_statement,
            _pipe@5 = where_sub_query_apply(_pipe@4, Query),
            cake@internal@prepared_statement:append_sql(
                _pipe@5,
                <<" "/utf8, Literal/binary>>
            )
    end.

-file("src/cake/internal/read_query.gleam", 1012).
?DOC(false).
-spec where_maria_mysql_xor_parity_apply(
    cake@internal@prepared_statement:prepared_statement(),
    list(where())
) -> cake@internal@prepared_statement:prepared_statement().
where_maria_mysql_xor_parity_apply(Prepared_statement, Wheres) ->
    Prepared_statement@1 = begin
        _pipe = Prepared_statement,
        cake@internal@prepared_statement:append_sql(_pipe, <<"("/utf8>>)
    end,
    _pipe@1 = Wheres,
    _pipe@5 = gleam@list:fold(
        _pipe@1,
        Prepared_statement@1,
        fun(New_prepared_statement, Where) ->
            case New_prepared_statement =:= Prepared_statement@1 of
                true ->
                    _pipe@2 = New_prepared_statement,
                    where_apply(_pipe@2, Where);

                false ->
                    _pipe@3 = New_prepared_statement,
                    _pipe@4 = cake@internal@prepared_statement:append_sql(
                        _pipe@3,
                        <<" XOR "/utf8>>
                    ),
                    where_apply(_pipe@4, Where)
            end
        end
    ),
    cake@internal@prepared_statement:append_sql(_pipe@5, <<")"/utf8>>).

-file("src/cake/internal/read_query.gleam", 982).
?DOC(false).
-spec where_sqlite_xor_parity_apply(
    cake@internal@prepared_statement:prepared_statement(),
    list(where())
) -> cake@internal@prepared_statement:prepared_statement().
where_sqlite_xor_parity_apply(Prepared_statement, Wheres) ->
    Prepared_statement@1 = begin
        _pipe = Prepared_statement,
        cake@internal@prepared_statement:append_sql(_pipe, <<"(("/utf8>>)
    end,
    Prepared_statement@2 = begin
        _pipe@1 = Wheres,
        gleam@list:fold(
            _pipe@1,
            Prepared_statement@1,
            fun(New_prepared_statement, Where) ->
                case New_prepared_statement =:= Prepared_statement@1 of
                    true ->
                        _pipe@2 = New_prepared_statement,
                        _pipe@3 = cake@internal@prepared_statement:append_sql(
                            _pipe@2,
                            <<"("/utf8>>
                        ),
                        _pipe@4 = where_apply(_pipe@3, Where),
                        cake@internal@prepared_statement:append_sql(
                            _pipe@4,
                            <<")"/utf8>>
                        );

                    false ->
                        _pipe@5 = New_prepared_statement,
                        _pipe@6 = cake@internal@prepared_statement:append_sql(
                            _pipe@5,
                            <<" + ("/utf8>>
                        ),
                        _pipe@7 = where_apply(_pipe@6, Where),
                        cake@internal@prepared_statement:append_sql(
                            _pipe@7,
                            <<")"/utf8>>
                        )
                end
            end
        )
    end,
    _pipe@8 = Prepared_statement@2,
    cake@internal@prepared_statement:append_sql(_pipe@8, <<") % 2) = 1"/utf8>>).

-file("src/cake/internal/read_query.gleam", 947).
?DOC(false).
-spec where_postgres_xor_parity_apply(
    cake@internal@prepared_statement:prepared_statement(),
    list(where())
) -> cake@internal@prepared_statement:prepared_statement().
where_postgres_xor_parity_apply(Prepared_statement, Wheres) ->
    Prepared_statement@1 = begin
        _pipe = Prepared_statement,
        cake@internal@prepared_statement:append_sql(_pipe, <<"(("/utf8>>)
    end,
    Prepared_statement@2 = begin
        _pipe@1 = Wheres,
        gleam@list:fold(
            _pipe@1,
            Prepared_statement@1,
            fun(New_prepared_statement, Where) ->
                case New_prepared_statement =:= Prepared_statement@1 of
                    true ->
                        _pipe@2 = New_prepared_statement,
                        _pipe@3 = cake@internal@prepared_statement:append_sql(
                            _pipe@2,
                            <<"("/utf8>>
                        ),
                        _pipe@4 = where_apply(_pipe@3, Where),
                        cake@internal@prepared_statement:append_sql(
                            _pipe@4,
                            <<")::int"/utf8>>
                        );

                    false ->
                        _pipe@5 = New_prepared_statement,
                        _pipe@6 = cake@internal@prepared_statement:append_sql(
                            _pipe@5,
                            <<" + ("/utf8>>
                        ),
                        _pipe@7 = where_apply(_pipe@6, Where),
                        cake@internal@prepared_statement:append_sql(
                            _pipe@7,
                            <<")::int"/utf8>>
                        )
                end
            end
        )
    end,
    _pipe@8 = Prepared_statement@2,
    cake@internal@prepared_statement:append_sql(_pipe@8, <<") % 2) = 1"/utf8>>).

-file("src/cake/internal/read_query.gleam", 931).
?DOC(false).
-spec where_xor_parity_apply(
    cake@internal@prepared_statement:prepared_statement(),
    list(where())
) -> cake@internal@prepared_statement:prepared_statement().
where_xor_parity_apply(Prepared_statement, Wheres) ->
    case begin
        _pipe = Prepared_statement,
        cake@internal@prepared_statement:get_dialect(_pipe)
    end of
        postgres ->
            where_postgres_xor_parity_apply(Prepared_statement, Wheres);

        sqlite ->
            where_sqlite_xor_parity_apply(Prepared_statement, Wheres);

        maria ->
            where_maria_mysql_xor_parity_apply(Prepared_statement, Wheres);

        mysql ->
            where_maria_mysql_xor_parity_apply(Prepared_statement, Wheres)
    end.

-file("src/cake/internal/read_query.gleam", 855).
?DOC(false).
-spec where_xor_apply(
    cake@internal@prepared_statement:prepared_statement(),
    list(where())
) -> cake@internal@prepared_statement:prepared_statement().
where_xor_apply(Prepared_statement, Wheres) ->
    Xor_indexes = begin
        _pipe@1 = gleam@int:range(
            0,
            begin
                _pipe = Wheres,
                erlang:length(_pipe)
            end,
            [],
            fun(Accumulator, I) -> [I | Accumulator] end
        ),
        lists:reverse(_pipe@1)
    end,
    Prepared_statement@1 = begin
        _pipe@2 = Prepared_statement,
        cake@internal@prepared_statement:append_sql(_pipe@2, <<"("/utf8>>)
    end,
    Prepared_statement@2 = begin
        _pipe@3 = Xor_indexes,
        gleam@list:fold(
            _pipe@3,
            Prepared_statement@1,
            fun(New_prepared_statement, Xor_index) ->
                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,
                            <<") OR ("/utf8>>
                        )
                end,
                {New_prepared_statement@2, _} = begin
                    _pipe@5 = Wheres,
                    gleam@list:fold(
                        _pipe@5,
                        {New_prepared_statement@1, 0},
                        fun(Accumulator@1, Where) ->
                            {New_prepared_statement_per_xor, Where_index} = Accumulator@1,
                            New_prepared_statement_per_xor@1 = case {Where_index
                                =:= Xor_index,
                                Where_index} of
                                {true, 0} ->
                                    _pipe@6 = New_prepared_statement_per_xor,
                                    where_apply(_pipe@6, Where);

                                {true, _} ->
                                    _pipe@7 = New_prepared_statement_per_xor,
                                    _pipe@8 = cake@internal@prepared_statement:append_sql(
                                        _pipe@7,
                                        <<" AND ("/utf8>>
                                    ),
                                    _pipe@9 = where_apply(_pipe@8, Where),
                                    cake@internal@prepared_statement:append_sql(
                                        _pipe@9,
                                        <<")"/utf8>>
                                    );

                                {false, 0} ->
                                    _pipe@10 = New_prepared_statement_per_xor,
                                    _pipe@11 = cake@internal@prepared_statement:append_sql(
                                        _pipe@10,
                                        <<"NOT("/utf8>>
                                    ),
                                    _pipe@12 = where_apply(_pipe@11, Where),
                                    cake@internal@prepared_statement:append_sql(
                                        _pipe@12,
                                        <<")"/utf8>>
                                    );

                                {false, _} ->
                                    _pipe@13 = New_prepared_statement_per_xor,
                                    _pipe@14 = cake@internal@prepared_statement:append_sql(
                                        _pipe@13,
                                        <<" AND NOT("/utf8>>
                                    ),
                                    _pipe@15 = where_apply(_pipe@14, Where),
                                    cake@internal@prepared_statement:append_sql(
                                        _pipe@15,
                                        <<")"/utf8>>
                                    )
                            end,
                            {New_prepared_statement_per_xor@1, Where_index + 1}
                        end
                    )
                end,
                New_prepared_statement@2
            end
        )
    end,
    Prepared_statement@3 = begin
        _pipe@16 = Prepared_statement@2,
        cake@internal@prepared_statement:append_sql(_pipe@16, <<")"/utf8>>)
    end,
    Prepared_statement@3.

-file("src/cake/internal/read_query.gleam", 819).
?DOC(false).
-spec where_logical_operator_apply(
    cake@internal@prepared_statement:prepared_statement(),
    binary(),
    list(where()),
    boolean()
) -> cake@internal@prepared_statement:prepared_statement().
where_logical_operator_apply(
    Prepared_statement,
    Operator,
    Wheres,
    Wrap_in_parentheses
) ->
    Prepared_statement@1 = case Wrap_in_parentheses of
        true ->
            _pipe = Prepared_statement,
            cake@internal@prepared_statement:append_sql(_pipe, <<"("/utf8>>);

        false ->
            Prepared_statement
    end,
    Prepared_statement@2 = begin
        _pipe@1 = Wheres,
        gleam@list:fold(
            _pipe@1,
            Prepared_statement@1,
            fun(New_prepared_statement, Where) ->
                case New_prepared_statement =:= Prepared_statement@1 of
                    true ->
                        _pipe@2 = New_prepared_statement,
                        where_apply(_pipe@2, Where);

                    false ->
                        _pipe@3 = New_prepared_statement,
                        _pipe@4 = cake@internal@prepared_statement:append_sql(
                            _pipe@3,
                            <<<<" "/utf8, Operator/binary>>/binary, " "/utf8>>
                        ),
                        where_apply(_pipe@4, Where)
                end
            end
        )
    end,
    Prepared_statement@3 = case Wrap_in_parentheses of
        true ->
            _pipe@5 = Prepared_statement@2,
            cake@internal@prepared_statement:append_sql(_pipe@5, <<")"/utf8>>);

        false ->
            Prepared_statement@2
    end,
    Prepared_statement@3.

-file("src/cake/internal/read_query.gleam", 538).
?DOC(false).
-spec where_apply(
    cake@internal@prepared_statement:prepared_statement(),
    where()
) -> cake@internal@prepared_statement:prepared_statement().
where_apply(Prepared_statement, Where) ->
    case Where of
        no_where ->
            Prepared_statement;

        {and_where, Conditions} ->
            _pipe = Prepared_statement,
            where_logical_operator_apply(
                _pipe,
                <<"AND"/utf8>>,
                Conditions,
                false
            );

        {or_where, Conditions@1} ->
            _pipe@1 = Prepared_statement,
            where_logical_operator_apply(
                _pipe@1,
                <<"OR"/utf8>>,
                Conditions@1,
                true
            );

        {xor_where, Conditions@2} ->
            _pipe@2 = Prepared_statement,
            where_xor_apply(_pipe@2, Conditions@2);

        {xor_parity_where, Conditions@3} ->
            _pipe@3 = Prepared_statement,
            where_xor_parity_apply(_pipe@3, Conditions@3);

        {not_where, Condition} ->
            _pipe@4 = Prepared_statement,
            _pipe@5 = cake@internal@prepared_statement:append_sql(
                _pipe@4,
                <<"NOT("/utf8>>
            ),
            _pipe@6 = where_apply(_pipe@5, Condition),
            cake@internal@prepared_statement:append_sql(_pipe@6, <<")"/utf8>>);

        {where_is_bool, Value, true} ->
            _pipe@7 = Prepared_statement,
            where_literal_apply(_pipe@7, Value, <<"IS TRUE"/utf8>>);

        {where_is_bool, Value@1, false} ->
            _pipe@8 = Prepared_statement,
            where_literal_apply(_pipe@8, Value@1, <<"IS FALSE"/utf8>>);

        {where_is_not_bool, Value@2, true} ->
            _pipe@9 = Prepared_statement,
            where_literal_apply(_pipe@9, Value@2, <<"IS NOT TRUE"/utf8>>);

        {where_is_not_bool, Value@3, false} ->
            _pipe@10 = Prepared_statement,
            where_literal_apply(_pipe@10, Value@3, <<"IS NOT FALSE"/utf8>>);

        {where_is_null, Value@4} ->
            _pipe@11 = Prepared_statement,
            where_literal_apply(_pipe@11, Value@4, <<"IS NULL"/utf8>>);

        {where_is_not_null, Value@5} ->
            _pipe@12 = Prepared_statement,
            where_literal_apply(_pipe@12, Value@5, <<"IS NOT NULL"/utf8>>);

        {where_comparison, Value_a, equal, Value_b} ->
            _pipe@13 = Prepared_statement,
            where_comparison_apply(_pipe@13, Value_a, <<"="/utf8>>, Value_b);

        {where_comparison, Value_a@1, greater, Value_b@1} ->
            _pipe@14 = Prepared_statement,
            where_comparison_apply(_pipe@14, Value_a@1, <<">"/utf8>>, Value_b@1);

        {where_comparison, Value_a@2, greater_or_equal, Value_b@2} ->
            _pipe@15 = Prepared_statement,
            where_comparison_apply(
                _pipe@15,
                Value_a@2,
                <<">="/utf8>>,
                Value_b@2
            );

        {where_comparison, Value_a@3, lower, Value_b@3} ->
            _pipe@16 = Prepared_statement,
            where_comparison_apply(_pipe@16, Value_a@3, <<"<"/utf8>>, Value_b@3);

        {where_comparison, Value_a@4, lower_or_equal, Value_b@4} ->
            _pipe@17 = Prepared_statement,
            where_comparison_apply(
                _pipe@17,
                Value_a@4,
                <<"<="/utf8>>,
                Value_b@4
            );

        {where_comparison, Value_a@5, unequal, Value_b@5} ->
            _pipe@18 = Prepared_statement,
            where_comparison_apply(
                _pipe@18,
                Value_a@5,
                <<"<>"/utf8>>,
                Value_b@5
            );

        {where_any_of_sub_query, Value@6, equal, Query} ->
            _pipe@19 = Prepared_statement,
            _pipe@20 = where_literal_apply(_pipe@19, Value@6, <<"= ANY"/utf8>>),
            where_sub_query_apply(_pipe@20, Query);

        {where_any_of_sub_query, Value@7, greater, Query@1} ->
            _pipe@21 = Prepared_statement,
            _pipe@22 = where_literal_apply(_pipe@21, Value@7, <<"> ANY"/utf8>>),
            where_sub_query_apply(_pipe@22, Query@1);

        {where_any_of_sub_query, Value@8, greater_or_equal, Query@2} ->
            _pipe@23 = Prepared_statement,
            _pipe@24 = where_literal_apply(_pipe@23, Value@8, <<">= ANY"/utf8>>),
            where_sub_query_apply(_pipe@24, Query@2);

        {where_any_of_sub_query, Value@9, lower, Query@3} ->
            _pipe@25 = Prepared_statement,
            _pipe@26 = where_literal_apply(_pipe@25, Value@9, <<"< ANY"/utf8>>),
            where_sub_query_apply(_pipe@26, Query@3);

        {where_any_of_sub_query, Value@10, lower_or_equal, Query@4} ->
            _pipe@27 = Prepared_statement,
            _pipe@28 = where_literal_apply(
                _pipe@27,
                Value@10,
                <<"<= ANY"/utf8>>
            ),
            where_sub_query_apply(_pipe@28, Query@4);

        {where_any_of_sub_query, Value@11, unequal, Query@5} ->
            _pipe@29 = Prepared_statement,
            _pipe@30 = where_literal_apply(
                _pipe@29,
                Value@11,
                <<"<> ANY"/utf8>>
            ),
            where_sub_query_apply(_pipe@30, Query@5);

        {where_all_of_sub_query, Value@12, equal, Query@6} ->
            _pipe@31 = Prepared_statement,
            _pipe@32 = where_literal_apply(_pipe@31, Value@12, <<"= ALL"/utf8>>),
            where_sub_query_apply(_pipe@32, Query@6);

        {where_all_of_sub_query, Value@13, greater, Query@7} ->
            _pipe@33 = Prepared_statement,
            _pipe@34 = where_literal_apply(_pipe@33, Value@13, <<"> ALL"/utf8>>),
            where_sub_query_apply(_pipe@34, Query@7);

        {where_all_of_sub_query, Value@14, greater_or_equal, Query@8} ->
            _pipe@35 = Prepared_statement,
            _pipe@36 = where_literal_apply(
                _pipe@35,
                Value@14,
                <<">= ALL"/utf8>>
            ),
            where_sub_query_apply(_pipe@36, Query@8);

        {where_all_of_sub_query, Value@15, lower, Query@9} ->
            _pipe@37 = Prepared_statement,
            _pipe@38 = where_literal_apply(_pipe@37, Value@15, <<"< ALL"/utf8>>),
            where_sub_query_apply(_pipe@38, Query@9);

        {where_all_of_sub_query, Value@16, lower_or_equal, Query@10} ->
            _pipe@39 = Prepared_statement,
            _pipe@40 = where_literal_apply(
                _pipe@39,
                Value@16,
                <<"<= ALL"/utf8>>
            ),
            where_sub_query_apply(_pipe@40, Query@10);

        {where_all_of_sub_query, Value@17, unequal, Query@11} ->
            _pipe@41 = Prepared_statement,
            _pipe@42 = where_literal_apply(
                _pipe@41,
                Value@17,
                <<"<> ALL"/utf8>>
            ),
            where_sub_query_apply(_pipe@42, Query@11);

        {where_between, Value_a@6, Value_b@6, Value_c} ->
            _pipe@43 = Prepared_statement,
            where_between_apply(_pipe@43, Value_a@6, Value_b@6, Value_c);

        {where_in, Value@18, Values} ->
            _pipe@44 = Prepared_statement,
            where_value_in_values_apply(_pipe@44, Value@18, Values);

        {where_exists_in_sub_query, Query@12} ->
            _pipe@45 = Prepared_statement,
            _pipe@46 = cake@internal@prepared_statement:append_sql(
                _pipe@45,
                <<" EXISTS "/utf8>>
            ),
            where_sub_query_apply(_pipe@46, Query@12);

        {where_like, Value@19, Param} ->
            _pipe@47 = Prepared_statement,
            where_comparison_apply(
                _pipe@47,
                Value@19,
                <<"LIKE"/utf8>>,
                begin
                    _pipe@48 = Param,
                    _pipe@49 = {string_param, _pipe@48},
                    {where_param_value, _pipe@49}
                end
            );

        {where_i_like, Value@20, Param@1} ->
            _pipe@50 = Prepared_statement,
            where_comparison_apply(
                _pipe@50,
                Value@20,
                <<"ILIKE"/utf8>>,
                begin
                    _pipe@51 = Param@1,
                    _pipe@52 = {string_param, _pipe@51},
                    {where_param_value, _pipe@52}
                end
            );

        {where_similar_to, Value@21, Param@2, Escape_char} ->
            _pipe@53 = Prepared_statement,
            _pipe@56 = where_comparison_apply(
                _pipe@53,
                Value@21,
                <<"SIMILAR TO"/utf8>>,
                begin
                    _pipe@54 = Param@2,
                    _pipe@55 = {string_param, _pipe@54},
                    {where_param_value, _pipe@55}
                end
            ),
            cake@internal@prepared_statement:append_sql(
                _pipe@56,
                <<<<" ESCAPE '"/utf8, Escape_char/binary>>/binary, "'"/utf8>>
            );

        {where_fragment, Value@22} ->
            _pipe@57 = Prepared_statement,
            fragment_apply(_pipe@57, Value@22)
    end.

-file("src/cake/internal/read_query.gleam", 525).
?DOC(false).
-spec having_clause_apply(
    cake@internal@prepared_statement:prepared_statement(),
    where()
) -> cake@internal@prepared_statement:prepared_statement().
having_clause_apply(Prepared_statement, Where) ->
    case Where of
        no_where ->
            Prepared_statement;

        _ ->
            _pipe = Prepared_statement,
            _pipe@1 = cake@internal@prepared_statement:append_sql(
                _pipe,
                <<" HAVING "/utf8>>
            ),
            where_apply(_pipe@1, Where)
    end.

-file("src/cake/internal/read_query.gleam", 512).
?DOC(false).
-spec where_clause_apply(
    cake@internal@prepared_statement:prepared_statement(),
    where()
) -> cake@internal@prepared_statement:prepared_statement().
where_clause_apply(Prepared_statement, Where) ->
    case Where of
        no_where ->
            Prepared_statement;

        _ ->
            _pipe = Prepared_statement,
            _pipe@1 = cake@internal@prepared_statement:append_sql(
                _pipe,
                <<" WHERE "/utf8>>
            ),
            where_apply(_pipe@1, Where)
    end.

-file("src/cake/internal/read_query.gleam", 1321).
?DOC(false).
-spec join_apply(cake@internal@prepared_statement:prepared_statement(), join()) -> cake@internal@prepared_statement:prepared_statement().
join_apply(Prepared_statement, Join) ->
    case erlang:element(2, Join) of
        {join_table, Table} ->
            _pipe = Prepared_statement,
            cake@internal@prepared_statement:append_sql(
                _pipe,
                <<<<Table/binary, " AS "/utf8>>/binary,
                    (erlang:element(3, Join))/binary>>
            );

        {join_sub_query, Query} ->
            _pipe@1 = Prepared_statement,
            _pipe@2 = cake@internal@prepared_statement:append_sql(
                _pipe@1,
                <<"("/utf8>>
            ),
            _pipe@3 = apply(_pipe@2, Query),
            cake@internal@prepared_statement:append_sql(
                _pipe@3,
                <<") AS "/utf8, (erlang:element(3, Join))/binary>>
            )
    end.

-file("src/cake/internal/read_query.gleam", 1256).
?DOC(false).
-spec join_clause_apply(
    cake@internal@prepared_statement:prepared_statement(),
    joins()
) -> cake@internal@prepared_statement:prepared_statement().
join_clause_apply(Prepared_statement, Joins) ->
    case Joins of
        {joins, Items} ->
            _pipe = Items,
            gleam@list:fold(
                _pipe,
                Prepared_statement,
                fun(New_prepared_statement, Join) ->
                    Join_command_apply = fun(
                        New_prepared_statement@1,
                        Sql_command
                    ) ->
                        _pipe@1 = New_prepared_statement@1,
                        _pipe@2 = cake@internal@prepared_statement:append_sql(
                            _pipe@1,
                            <<<<" "/utf8, Sql_command/binary>>/binary,
                                " "/utf8>>
                        ),
                        join_apply(_pipe@2, Join)
                    end,
                    On_apply = fun(New_prepared_statement@2, On) ->
                        _pipe@3 = New_prepared_statement@2,
                        _pipe@4 = cake@internal@prepared_statement:append_sql(
                            _pipe@3,
                            <<" ON "/utf8>>
                        ),
                        where_apply(_pipe@4, On)
                    end,
                    case Join of
                        {inner_join, _, _, On@1} ->
                            _pipe@5 = New_prepared_statement,
                            _pipe@6 = Join_command_apply(
                                _pipe@5,
                                <<"INNER JOIN"/utf8>>
                            ),
                            On_apply(_pipe@6, On@1);

                        {inner_join_lateral_on_true, _, _} ->
                            _pipe@7 = New_prepared_statement,
                            _pipe@8 = Join_command_apply(
                                _pipe@7,
                                <<"INNER JOIN LATERAL"/utf8>>
                            ),
                            cake@internal@prepared_statement:append_sql(
                                _pipe@8,
                                <<" ON TRUE"/utf8>>
                            );

                        {left_join, _, _, On@2} ->
                            _pipe@9 = New_prepared_statement,
                            _pipe@10 = Join_command_apply(
                                _pipe@9,
                                <<"LEFT OUTER JOIN"/utf8>>
                            ),
                            On_apply(_pipe@10, On@2);

                        {left_join_lateral_on_true, _, _} ->
                            _pipe@11 = New_prepared_statement,
                            _pipe@12 = Join_command_apply(
                                _pipe@11,
                                <<"LEFT JOIN LATERAL"/utf8>>
                            ),
                            cake@internal@prepared_statement:append_sql(
                                _pipe@12,
                                <<" ON TRUE"/utf8>>
                            );

                        {right_join, _, _, On@3} ->
                            _pipe@13 = New_prepared_statement,
                            _pipe@14 = Join_command_apply(
                                _pipe@13,
                                <<"RIGHT OUTER JOIN"/utf8>>
                            ),
                            On_apply(_pipe@14, On@3);

                        {full_join, _, _, On@4} ->
                            _pipe@15 = New_prepared_statement,
                            _pipe@16 = Join_command_apply(
                                _pipe@15,
                                <<"FULL OUTER JOIN"/utf8>>
                            ),
                            On_apply(_pipe@16, On@4);

                        {cross_join, _, _} ->
                            _pipe@17 = New_prepared_statement,
                            Join_command_apply(_pipe@17, <<"CROSS JOIN"/utf8>>);

                        {cross_join_lateral, _, _} ->
                            _pipe@18 = New_prepared_statement,
                            Join_command_apply(
                                _pipe@18,
                                <<"CROSS JOIN LATERAL"/utf8>>
                            )
                    end
                end
            );

        no_joins ->
            Prepared_statement
    end.

-file("src/cake/internal/read_query.gleam", 418).
?DOC(false).
-spec from_clause_apply(
    cake@internal@prepared_statement:prepared_statement(),
    from()
) -> cake@internal@prepared_statement:prepared_statement().
from_clause_apply(Prepared_statement, From) ->
    case From of
        no_from ->
            Prepared_statement;

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

        {from_sub_query, Query, Alias} ->
            _pipe@1 = Prepared_statement,
            _pipe@2 = cake@internal@prepared_statement:append_sql(
                _pipe@1,
                <<" FROM ("/utf8>>
            ),
            _pipe@3 = apply(_pipe@2, Query),
            cake@internal@prepared_statement:append_sql(
                _pipe@3,
                <<") AS "/utf8, Alias/binary>>
            )
    end.

-file("src/cake/internal/read_query.gleam", 251).
?DOC(false).
-spec select_builder(
    cake@internal@prepared_statement:prepared_statement(),
    select()
) -> cake@internal@prepared_statement:prepared_statement().
select_builder(Prepared_statement, Query) ->
    _pipe = Prepared_statement,
    _pipe@1 = select_clause_apply(
        _pipe,
        erlang:element(2, Query),
        erlang:element(3, Query)
    ),
    _pipe@2 = from_clause_apply(_pipe@1, erlang:element(4, Query)),
    _pipe@3 = join_clause_apply(_pipe@2, erlang:element(5, Query)),
    _pipe@4 = where_clause_apply(_pipe@3, erlang:element(6, Query)),
    _pipe@5 = group_by_clause_apply(_pipe@4, erlang:element(7, Query)),
    _pipe@6 = having_clause_apply(_pipe@5, erlang:element(8, Query)),
    _pipe@7 = order_by_clause_apply(_pipe@6, erlang:element(9, Query)),
    _pipe@8 = limit_clause_apply(_pipe@7, erlang:element(10, Query)),
    _pipe@9 = offset_clause_apply(_pipe@8, erlang:element(11, Query)),
    _pipe@10 = epilog_apply(_pipe@9, erlang:element(12, Query)),
    comment_apply(_pipe@10, erlang:element(13, Query)).

-file("src/cake/internal/read_query.gleam", 105).
?DOC(false).
-spec combined_clause_apply(
    cake@internal@prepared_statement:prepared_statement(),
    combined()
) -> cake@internal@prepared_statement:prepared_statement().
combined_clause_apply(Prepared_statement, Query) ->
    Sql_command = case erlang:element(2, Query) of
        union_distinct ->
            <<"UNION"/utf8>>;

        union_all ->
            <<"UNION ALL"/utf8>>;

        except_distinct ->
            <<"EXCEPT"/utf8>>;

        except_all ->
            <<"EXCEPT ALL"/utf8>>;

        intersect_distinct ->
            <<"INTERSECT"/utf8>>;

        intersect_all ->
            <<"INTERSECT ALL"/utf8>>
    end,
    Open_nested_query = fun(Prepared_statement@1) ->
        case begin
            _pipe = Prepared_statement@1,
            cake@internal@prepared_statement:get_dialect(_pipe)
        end of
            sqlite ->
                _pipe@1 = Prepared_statement@1,
                cake@internal@prepared_statement:append_sql(
                    _pipe@1,
                    <<"SELECT * FROM ("/utf8>>
                );

            _ ->
                _pipe@2 = Prepared_statement@1,
                cake@internal@prepared_statement:append_sql(
                    _pipe@2,
                    <<"("/utf8>>
                )
        end
    end,
    Close_nested_query = fun(Prepared_statement@2, Nested_index) ->
        case begin
            _pipe@3 = Prepared_statement@2,
            cake@internal@prepared_statement:get_dialect(_pipe@3)
        end of
            sqlite ->
                _pipe@4 = Prepared_statement@2,
                cake@internal@prepared_statement:append_sql(
                    _pipe@4,
                    <<<<") AS "/utf8, "__cake_computed_alias_"/utf8>>/binary,
                        (begin
                            _pipe@5 = Nested_index,
                            erlang:integer_to_binary(_pipe@5)
                        end)/binary>>
                );

            _ ->
                _pipe@6 = Prepared_statement@2,
                cake@internal@prepared_statement:append_sql(
                    _pipe@6,
                    <<")"/utf8>>
                )
        end
    end,
    Prepared_statement@3 = begin
        _pipe@7 = Prepared_statement,
        Open_nested_query(_pipe@7)
    end,
    {New_prepared_statement@2, Nested_index@3} = begin
        _pipe@8 = erlang:element(3, Query),
        gleam@list:fold(
            _pipe@8,
            {Prepared_statement@3, 0},
            fun(Accumulator, Query@1) ->
                {New_prepared_statement, Nested_index@1} = Accumulator,
                case New_prepared_statement =:= Prepared_statement@3 of
                    true ->
                        {begin
                                _pipe@9 = New_prepared_statement,
                                select_builder(_pipe@9, Query@1)
                            end,
                            Nested_index@1};

                    false ->
                        Nested_index@2 = Nested_index@1 + 1,
                        New_prepared_statement@1 = begin
                            _pipe@10 = New_prepared_statement,
                            _pipe@11 = Close_nested_query(
                                _pipe@10,
                                Nested_index@2
                            ),
                            _pipe@12 = cake@internal@prepared_statement:append_sql(
                                _pipe@11,
                                <<<<" "/utf8, Sql_command/binary>>/binary,
                                    " "/utf8>>
                            ),
                            _pipe@13 = Open_nested_query(_pipe@12),
                            select_builder(_pipe@13, Query@1)
                        end,
                        {New_prepared_statement@1, Nested_index@2}
                end
            end
        )
    end,
    _pipe@14 = New_prepared_statement@2,
    Close_nested_query(_pipe@14, Nested_index@3 + 1).

-file("src/cake/internal/read_query.gleam", 90).
?DOC(false).
-spec combined_builder(
    cake@internal@prepared_statement:prepared_statement(),
    combined()
) -> cake@internal@prepared_statement:prepared_statement().
combined_builder(Prepared_statement, Query) ->
    _pipe = Prepared_statement,
    _pipe@1 = combined_clause_apply(_pipe, Query),
    _pipe@2 = order_by_clause_apply(_pipe@1, erlang:element(6, Query)),
    _pipe@3 = limit_clause_apply(_pipe@2, erlang:element(4, Query)),
    _pipe@4 = offset_clause_apply(_pipe@3, erlang:element(5, Query)),
    _pipe@5 = epilog_apply(_pipe@4, erlang:element(7, Query)),
    comment_apply(_pipe@5, erlang:element(8, Query)).

-file("src/cake/internal/read_query.gleam", 76).
?DOC(false).
-spec apply(cake@internal@prepared_statement:prepared_statement(), read_query()) -> cake@internal@prepared_statement:prepared_statement().
apply(Prepared_statement, Query) ->
    case Query of
        {select_query, Query@1} ->
            _pipe = Prepared_statement,
            select_builder(_pipe, Query@1);

        {combined_query, Query@2} ->
            _pipe@1 = Prepared_statement,
            combined_builder(_pipe@1, Query@2)
    end.

-file("src/cake/internal/read_query.gleam", 64).
?DOC(false).
-spec to_prepared_statement(
    read_query(),
    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).

-file("src/cake/internal/read_query.gleam", 218).
?DOC(false).
-spec combined_query_new(combined_query_kind(), list(select())) -> combined().
combined_query_new(Kind, Queries) ->
    _pipe = Queries,
    {combined,
        Kind,
        _pipe,
        no_limit,
        no_offset,
        no_order_by,
        no_epilog,
        no_comment}.

-file("src/cake/internal/read_query.gleam", 1377).
?DOC(false).
-spec order_by_append(order_by(), order_by()) -> order_by().
order_by_append(Existing_order_by, New_order_by) ->
    case {Existing_order_by, New_order_by} of
        {no_order_by, _} ->
            New_order_by;

        {_, no_order_by} ->
            Existing_order_by;

        {{order_by, Existing_items}, {order_by, New_items}} ->
            Combined = lists:append(Existing_items, New_items),
            {order_by, Combined}
    end.

-file("src/cake/internal/read_query.gleam", 235).
?DOC(false).
-spec combined_order_by(combined(), order_by(), boolean()) -> combined().
combined_order_by(Query, Order_by, Append) ->
    case Append of
        true ->
            {combined,
                erlang:element(2, Query),
                erlang:element(3, Query),
                erlang:element(4, Query),
                erlang:element(5, Query),
                begin
                    _pipe = erlang:element(6, Query),
                    order_by_append(_pipe, Order_by)
                end,
                erlang:element(7, Query),
                erlang:element(8, Query)};

        false ->
            {combined,
                erlang:element(2, Query),
                erlang:element(3, Query),
                erlang:element(4, Query),
                erlang:element(5, Query),
                Order_by,
                erlang:element(7, Query),
                erlang:element(8, Query)}
    end.

-file("src/cake/internal/read_query.gleam", 299).
?DOC(false).
-spec select_order_by(select(), order_by(), boolean()) -> select().
select_order_by(Query, Order_by, Append) ->
    case Append of
        true ->
            {select,
                erlang:element(2, Query),
                erlang:element(3, Query),
                erlang:element(4, Query),
                erlang:element(5, Query),
                erlang:element(6, Query),
                erlang:element(7, Query),
                erlang:element(8, Query),
                begin
                    _pipe = erlang:element(9, Query),
                    order_by_append(_pipe, Order_by)
                end,
                erlang:element(10, Query),
                erlang:element(11, Query),
                erlang:element(12, Query),
                erlang:element(13, Query)};

        false ->
            {select,
                erlang:element(2, Query),
                erlang:element(3, Query),
                erlang:element(4, Query),
                erlang:element(5, Query),
                erlang:element(6, Query),
                erlang:element(7, Query),
                erlang:element(8, Query),
                Order_by,
                erlang:element(10, Query),
                erlang:element(11, Query),
                erlang:element(12, Query),
                erlang:element(13, Query)}
    end.

-file("src/cake/internal/read_query.gleam", 1479).
?DOC(false).
-spec limit_new(integer()) -> limit().
limit_new(Limit) ->
    case Limit > 0 of
        false ->
            no_limit;

        true ->
            {limit, Limit}
    end.

-file("src/cake/internal/read_query.gleam", 1510).
?DOC(false).
-spec offset_new(integer()) -> offset().
offset_new(Offset) ->
    case Offset > 0 of
        false ->
            no_offset;

        true ->
            {offset, Offset}
    end.