squirrel

-module(squirrel@internal@database@postgres).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([main/2]).
-export_type([pg_type/0, context/0, nullability/0, plan/0, join_type/0, parent_relation/0, connection_options/0]).

-type pg_type() :: {p_base, binary()} |
    {p_array, pg_type()} |
    {p_option, pg_type()}.

-type context() :: {context,
        squirrel@internal@database@postgres_protocol:connection(),
        gleam@dict:dict(integer(), squirrel@internal@gleam:type()),
        gleam@dict:dict({integer(), integer()}, nullability())}.

-type nullability() :: nullable | not_nullable.

-type plan() :: {plan,
        gleam@option:option(join_type()),
        gleam@option:option(parent_relation()),
        gleam@option:option(list(binary())),
        gleam@option:option(list(plan()))}.

-type join_type() :: full | left | right | other.

-type parent_relation() :: inner | not_inner.

-type connection_options() :: {connection_options,
        binary(),
        integer(),
        binary(),
        binary(),
        binary(),
        integer()}.

-spec pg_to_gleam_type(pg_type()) -> {ok, squirrel@internal@gleam:type()} |
    {error, binary()}.
pg_to_gleam_type(Type_) ->
    case Type_ of
        {p_array, Inner} ->
            _pipe = pg_to_gleam_type(Inner),
            _pipe@1 = gleam@result:map(
                _pipe,
                fun(Field@0) -> {list, Field@0} end
            ),
            gleam@result:map_error(
                _pipe@1,
                fun(Inner@1) -> <<Inner@1/binary, "[]"/utf8>> end
            );

        {p_option, Inner@2} ->
            _pipe@2 = pg_to_gleam_type(Inner@2),
            _pipe@3 = gleam@result:map(
                _pipe@2,
                fun(Field@0) -> {option, Field@0} end
            ),
            gleam@result:map_error(
                _pipe@3,
                fun(Inner@3) -> <<Inner@3/binary, "?"/utf8>> end
            );

        {p_base, Name} ->
            case Name of
                <<"bool"/utf8>> ->
                    {ok, bool};

                <<"text"/utf8>> ->
                    {ok, string};

                <<"char"/utf8>> ->
                    {ok, string};

                <<"bpchar"/utf8>> ->
                    {ok, string};

                <<"varchar"/utf8>> ->
                    {ok, string};

                <<"float4"/utf8>> ->
                    {ok, float};

                <<"float8"/utf8>> ->
                    {ok, float};

                <<"numeric"/utf8>> ->
                    {ok, float};

                <<"int2"/utf8>> ->
                    {ok, int};

                <<"int4"/utf8>> ->
                    {ok, int};

                <<"int8"/utf8>> ->
                    {ok, int};

                <<"json"/utf8>> ->
                    {ok, json};

                <<"jsonb"/utf8>> ->
                    {ok, json};

                _ ->
                    {error, Name}
            end
    end.

-spec check_sasl_final_message(bitstring(), bitstring(), binary()) -> eval:eval(nil, squirrel@internal@error:error(), context()).
check_sasl_final_message(Msg, Expected_server_proof, User) ->
    case squirrel@internal@scram:parse_server_final(Msg) of
        {error, nil} ->
            eval:throw(pg_invalid_sha256_server_proof);

        {ok, {failed, _}} ->
            eval:throw({pg_invalid_password, User});

        {ok, {successful, Server_proof}} ->
            case Server_proof =:= Expected_server_proof of
                true ->
                    eval:return(nil);

                false ->
                    eval:throw(pg_invalid_sha256_server_proof)
            end
    end.

-spec do_nullables_from_plan(
    plan(),
    gleam@dict:dict(binary(), integer()),
    gleam@set:set(integer())
) -> gleam@set:set(integer()).
do_nullables_from_plan(Plan, Query_outputs, Nullables) ->
    Nullables@2 = case {erlang:element(4, Plan),
        erlang:element(2, Plan),
        erlang:element(3, Plan)} of
        {{some, Outputs}, {some, full}, _} ->
            gleam@list:fold(
                Outputs,
                Nullables,
                fun(Nullables@1, Output) ->
                    case gleam@dict:get(Query_outputs, Output) of
                        {ok, I} ->
                            gleam@set:insert(Nullables@1, I);

                        {error, _} ->
                            Nullables@1
                    end
                end
            );

        {{some, Outputs}, _, {some, inner}} ->
            gleam@list:fold(
                Outputs,
                Nullables,
                fun(Nullables@1, Output) ->
                    case gleam@dict:get(Query_outputs, Output) of
                        {ok, I} ->
                            gleam@set:insert(Nullables@1, I);

                        {error, _} ->
                            Nullables@1
                    end
                end
            );

        {_, _, _} ->
            Nullables
    end,
    case {erlang:element(5, Plan), erlang:element(2, Plan)} of
        {{some, Plans}, {some, left}} ->
            gleam@list:fold(
                Plans,
                Nullables@2,
                fun(Nullables@3, Plan@1) ->
                    do_nullables_from_plan(Plan@1, Query_outputs, Nullables@3)
                end
            );

        {{some, Plans}, {some, right}} ->
            gleam@list:fold(
                Plans,
                Nullables@2,
                fun(Nullables@3, Plan@1) ->
                    do_nullables_from_plan(Plan@1, Query_outputs, Nullables@3)
                end
            );

        {_, _} ->
            Nullables@2
    end.

-spec nullables_from_plan(plan()) -> gleam@set:set(integer()).
nullables_from_plan(Plan) ->
    Outputs@1 = case erlang:element(4, Plan) of
        {some, Outputs} ->
            gleam@list:index_fold(
                Outputs,
                gleam@dict:new(),
                fun gleam@dict:insert/3
            );

        none ->
            gleam@dict:new()
    end,
    do_nullables_from_plan(Plan, Outputs@1, gleam@set:new()).

-spec fields_to_premission_denied_error(
    binary(),
    gleam@set:set(squirrel@internal@database@postgres_protocol:error_or_notice_field())
) -> {ok, squirrel@internal@error:error()} | {error, nil}.
fields_to_premission_denied_error(Query_file, Fields) ->
    {Code@2, Reason@2} = (gleam@set:fold(
        Fields,
        {none, none},
        fun(_use0, Field) ->
            {Code, Reason} = _use0,
            case Field of
                {code, Code@1} ->
                    {{some, Code@1}, Reason};

                {message, Reason@1} ->
                    {Code, {some, Reason@1}};

                _ ->
                    {Code, Reason}
            end
        end
    )),
    case {Code@2, Reason@2} of
        {{some, <<"42501"/utf8>>}, {some, Reason@3}} ->
            {ok, {pg_permission_denied, Query_file, Reason@3}};

        {_, _} ->
            {error, nil}
    end.

-spec expect_data_row(
    squirrel@internal@database@postgres_protocol:backend_message(),
    binary()
) -> eval:eval(list(bitstring()), squirrel@internal@error:error(), context()).
expect_data_row(Msg, Query_file) ->
    case Msg of
        {be_message_data_row, Res} ->
            eval:return(Res);

        {be_error_response, Fields} ->
            case fields_to_premission_denied_error(Query_file, Fields) of
                {ok, Error} ->
                    eval:throw(Error);

                {error, _} ->
                    erlang:error(#{gleam_error => panic,
                            message => gleam@string:inspect(Msg),
                            module => <<"squirrel/internal/database/postgres"/utf8>>,
                            function => <<"expect_data_row"/utf8>>,
                            line => 846})
            end;

        _ ->
            erlang:error(#{gleam_error => panic,
                    message => gleam@string:inspect(Msg),
                    module => <<"squirrel/internal/database/postgres"/utf8>>,
                    function => <<"expect_data_row"/utf8>>,
                    line => 848})
    end.

-spec 'receive'() -> eval:eval(squirrel@internal@database@postgres_protocol:backend_message(), squirrel@internal@error:error(), context()).
'receive'() ->
    eval:from(
        fun(_use0) ->
            {context, Db, _, _} = Context = _use0,
            case squirrel@internal@database@postgres_protocol:'receive'(Db) of
                {ok, {Db@1, Msg}} ->
                    {erlang:setelement(2, Context, Db@1), {ok, Msg}};

                {error, {read_decode_error, Error}} ->
                    {Context,
                        {error,
                            {pg_cannot_decode_received_message,
                                gleam@string:inspect(Error)}}};

                {error, {socket_error, Error@1}} ->
                    {Context,
                        {error,
                            {pg_cannot_receive_message,
                                gleam@string:inspect(Error@1)}}}
            end
        end
    ).

-spec send(squirrel@internal@database@postgres_protocol:frontend_message()) -> eval:eval(nil, squirrel@internal@error:error(), context()).
send(Message) ->
    eval:from(
        fun(_use0) ->
            {context, Db, _, _} = Context = _use0,
            Result = begin
                _pipe = Message,
                _pipe@1 = squirrel@internal@database@postgres_protocol:encode_frontend_message(
                    _pipe
                ),
                squirrel@internal@database@postgres_protocol:send(Db, _pipe@1)
            end,
            {Db@2, Result@1} = case Result of
                {ok, Db@1} ->
                    {Db@1, {ok, nil}};

                {error, Error} ->
                    {Db,
                        {error,
                            {pg_cannot_send_message,
                                gleam@string:inspect(Error)}}}
            end,
            {erlang:setelement(2, Context, Db@2), Result@1}
        end
    ).

-spec send_all(
    list(squirrel@internal@database@postgres_protocol:frontend_message())
) -> eval:eval(nil, squirrel@internal@error:error(), context()).
send_all(Messages) ->
    squirrel@internal@eval_extra:try_fold(
        Messages,
        nil,
        fun(Acc, Msg) ->
            eval:'try'(send(Msg), fun(_) -> eval:return(Acc) end)
        end
    ).

-spec run_query(
    binary(),
    binary(),
    list(squirrel@internal@database@postgres_protocol:parameter_value()),
    list(integer())
) -> eval:eval(list(bitstring()), squirrel@internal@error:error(), context()).
run_query(Query, Query_file, Parameters, Parameters_object_ids) ->
    eval:'try'(
        send_all(
            [{fe_parse, <<""/utf8>>, Query, Parameters_object_ids},
                {fe_bind,
                    <<""/utf8>>,
                    <<""/utf8>>,
                    {format_all, binary},
                    Parameters,
                    {format_all, binary}},
                {fe_execute, <<""/utf8>>, 0},
                {fe_close, prepared_statement, <<""/utf8>>},
                {fe_close, portal, <<""/utf8>>},
                fe_sync]
        ),
        fun(_) ->
            eval:'try'(
                'receive'(),
                fun(Msg) ->
                    be_parse_complete = case Msg of
                        be_parse_complete -> Msg;
                        _assert_fail ->
                            erlang:error(#{gleam_error => let_assert,
                                        message => <<"Assertion pattern match failed"/utf8>>,
                                        value => _assert_fail,
                                        module => <<"squirrel/internal/database/postgres"/utf8>>,
                                        function => <<"run_query"/utf8>>,
                                        line => 819})
                    end,
                    eval:'try'(
                        'receive'(),
                        fun(Msg@1) ->
                            be_bind_complete = case Msg@1 of
                                be_bind_complete -> Msg@1;
                                _assert_fail@1 ->
                                    erlang:error(#{gleam_error => let_assert,
                                                message => <<"Assertion pattern match failed"/utf8>>,
                                                value => _assert_fail@1,
                                                module => <<"squirrel/internal/database/postgres"/utf8>>,
                                                function => <<"run_query"/utf8>>,
                                                line => 821})
                            end,
                            eval:'try'(
                                'receive'(),
                                fun(Msg@2) ->
                                    eval:'try'(
                                        expect_data_row(Msg@2, Query_file),
                                        fun(Res) ->
                                            eval:'try'(
                                                'receive'(),
                                                fun(Msg@3) ->
                                                    {be_command_complete, _, _} = case Msg@3 of
                                                        {be_command_complete,
                                                            _,
                                                            _} -> Msg@3;
                                                        _assert_fail@2 ->
                                                            erlang:error(
                                                                    #{gleam_error => let_assert,
                                                                        message => <<"Assertion pattern match failed"/utf8>>,
                                                                        value => _assert_fail@2,
                                                                        module => <<"squirrel/internal/database/postgres"/utf8>>,
                                                                        function => <<"run_query"/utf8>>,
                                                                        line => 825}
                                                                )
                                                    end,
                                                    eval:'try'(
                                                        'receive'(),
                                                        fun(Msg@4) ->
                                                            be_close_complete = case Msg@4 of
                                                                be_close_complete -> Msg@4;
                                                                _assert_fail@3 ->
                                                                    erlang:error(
                                                                            #{gleam_error => let_assert,
                                                                                message => <<"Assertion pattern match failed"/utf8>>,
                                                                                value => _assert_fail@3,
                                                                                module => <<"squirrel/internal/database/postgres"/utf8>>,
                                                                                function => <<"run_query"/utf8>>,
                                                                                line => 827}
                                                                        )
                                                            end,
                                                            eval:'try'(
                                                                'receive'(),
                                                                fun(Msg@5) ->
                                                                    be_close_complete = case Msg@5 of
                                                                        be_close_complete -> Msg@5;
                                                                        _assert_fail@4 ->
                                                                            erlang:error(
                                                                                    #{gleam_error => let_assert,
                                                                                        message => <<"Assertion pattern match failed"/utf8>>,
                                                                                        value => _assert_fail@4,
                                                                                        module => <<"squirrel/internal/database/postgres"/utf8>>,
                                                                                        function => <<"run_query"/utf8>>,
                                                                                        line => 829}
                                                                                )
                                                                    end,
                                                                    eval:'try'(
                                                                        'receive'(
                                                                            
                                                                        ),
                                                                        fun(
                                                                            Msg@6
                                                                        ) ->
                                                                            {be_ready_for_query,
                                                                                _} = case Msg@6 of
                                                                                {be_ready_for_query,
                                                                                    _} -> Msg@6;
                                                                                _assert_fail@5 ->
                                                                                    erlang:error(
                                                                                            #{gleam_error => let_assert,
                                                                                                message => <<"Assertion pattern match failed"/utf8>>,
                                                                                                value => _assert_fail@5,
                                                                                                module => <<"squirrel/internal/database/postgres"/utf8>>,
                                                                                                function => <<"run_query"/utf8>>,
                                                                                                line => 831}
                                                                                        )
                                                                            end,
                                                                            eval:return(
                                                                                Res
                                                                            )
                                                                        end
                                                                    )
                                                                end
                                                            )
                                                        end
                                                    )
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-spec do_wait_until_ready() -> eval:eval(nil, squirrel@internal@error:error(), context()).
do_wait_until_ready() ->
    eval:'try'('receive'(), fun(Msg) -> case Msg of
                {be_ready_for_query, _} ->
                    eval:return(nil);

                _ ->
                    do_wait_until_ready()
            end end).

-spec wait_until_ready() -> eval:eval(nil, squirrel@internal@error:error(), context()).
wait_until_ready() ->
    eval:'try'(send(fe_flush), fun(_) -> do_wait_until_ready() end).

-spec unexpected_message(
    fun((binary(), binary()) -> squirrel@internal@error:error()),
    binary(),
    squirrel@internal@database@postgres_protocol:backend_message()
) -> eval:eval(any(), squirrel@internal@error:error(), any()).
unexpected_message(Builder, Expected, Got) ->
    _pipe = Builder(Expected, gleam@string:inspect(Got)),
    eval:throw(_pipe).

-spec cleartext_authenticate(binary(), binary()) -> eval:eval(nil, squirrel@internal@error:error(), context()).
cleartext_authenticate(User, Password) ->
    eval:'try'(
        send({fe_ambigous, {fe_password_message, Password}}),
        fun(_) -> eval:'try'('receive'(), fun(Msg) -> case Msg of
                        be_authentication_ok ->
                            eval:return(nil);

                        {be_error_response, _} ->
                            eval:throw({pg_invalid_password, User});

                        _ ->
                            unexpected_message(
                                fun(Field@0, Field@1) -> {pg_unexpected_cleartext_auth_message, Field@0, Field@1} end,
                                <<"AuthenticationOk ok ErrorRespose"/utf8>>,
                                Msg
                            )
                    end end) end
    ).

-spec expect_sasl_continue_message(
    squirrel@internal@database@postgres_protocol:backend_message()
) -> eval:eval(bitstring(), squirrel@internal@error:error(), context()).
expect_sasl_continue_message(Msg) ->
    case Msg of
        {be_authentication_sasl_continue, Server_first} ->
            eval:return(Server_first);

        _ ->
            unexpected_message(
                fun(Field@0, Field@1) -> {pg_unexpected_sha256_auth_message, Field@0, Field@1} end,
                <<"AuthenticationSASLContinue(server-first)"/utf8>>,
                Msg
            )
    end.

-spec expect_sasl_final_message(
    squirrel@internal@database@postgres_protocol:backend_message(),
    binary()
) -> eval:eval(bitstring(), squirrel@internal@error:error(), any()).
expect_sasl_final_message(Msg, User) ->
    Unexpected_message = unexpected_message(
        fun(Field@0, Field@1) -> {pg_unexpected_sha256_auth_message, Field@0, Field@1} end,
        <<"AuthenticationSASLFinal or BeErrorResponse"/utf8>>,
        Msg
    ),
    case Msg of
        {be_authentication_sasl_final, Msg@1} ->
            eval:return(Msg@1);

        {be_error_response, Fields} ->
            case gleam@set:contains(Fields, {code, <<"28P01"/utf8>>}) of
                true ->
                    eval:throw({pg_invalid_password, User});

                false ->
                    Unexpected_message
            end;

        _ ->
            Unexpected_message
    end.

-spec sha_256_authenticate(binary(), binary()) -> eval:eval(nil, squirrel@internal@error:error(), context()).
sha_256_authenticate(User, Password) ->
    Nonce = squirrel@internal@scram:nonce(),
    Client_first_msg = {client_first, User, Nonce},
    eval:'try'(
        begin
            _pipe = squirrel@internal@scram:encode_client_first(
                Client_first_msg
            ),
            _pipe@1 = {fe_sasl_initial_response,
                <<"SCRAM-SHA-256"/utf8>>,
                _pipe},
            _pipe@2 = {fe_ambigous, _pipe@1},
            send(_pipe@2)
        end,
        fun(_) ->
            eval:'try'(
                'receive'(),
                fun(Msg) ->
                    eval:'try'(
                        expect_sasl_continue_message(Msg),
                        fun(Raw_server_first_msg) ->
                            _assert_subject = squirrel@internal@scram:parse_server_first(
                                Raw_server_first_msg,
                                Nonce
                            ),
                            {ok, Server_first_msg} = case _assert_subject of
                                {ok, _} -> _assert_subject;
                                _assert_fail ->
                                    erlang:error(#{gleam_error => let_assert,
                                                message => <<"Assertion pattern match failed"/utf8>>,
                                                value => _assert_fail,
                                                module => <<"squirrel/internal/database/postgres"/utf8>>,
                                                function => <<"sha_256_authenticate"/utf8>>,
                                                line => 344})
                            end,
                            Client_last_msg = {client_last,
                                Client_first_msg,
                                Server_first_msg,
                                Password},
                            {Client_last_msg@1, Expected_server_proof} = squirrel@internal@scram:encode_client_last(
                                Client_last_msg
                            ),
                            eval:'try'(
                                begin
                                    _pipe@3 = Client_last_msg@1,
                                    _pipe@4 = {fe_sasl_response, _pipe@3},
                                    _pipe@5 = {fe_ambigous, _pipe@4},
                                    send(_pipe@5)
                                end,
                                fun(_) ->
                                    eval:'try'(
                                        'receive'(),
                                        fun(Msg@1) ->
                                            eval:'try'(
                                                expect_sasl_final_message(
                                                    Msg@1,
                                                    User
                                                ),
                                                fun(Msg@2) ->
                                                    check_sasl_final_message(
                                                        Msg@2,
                                                        Expected_server_proof,
                                                        User
                                                    )
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-spec unsupported_authentication(binary()) -> eval:eval(any(), squirrel@internal@error:error(), any()).
unsupported_authentication(Auth) ->
    eval:throw({pg_unsupported_authentication, Auth}).

-spec authenticate(connection_options()) -> eval:eval(nil, squirrel@internal@error:error(), context()).
authenticate(Connection) ->
    {connection_options, _, _, User, Password, Database, _} = Connection,
    Params = [{<<"user"/utf8>>, User}, {<<"database"/utf8>>, Database}],
    eval:'try'(
        send({fe_startup_message, Params}),
        fun(_) -> eval:'try'('receive'(), fun(Msg) -> eval:'try'(case Msg of
                            be_authentication_ok ->
                                eval:return(nil);

                            be_authentication_cleartext_password ->
                                cleartext_authenticate(User, Password);

                            {be_authentication_md5_password, _} ->
                                unsupported_authentication(<<"md5"/utf8>>);

                            be_authentication_gss ->
                                unsupported_authentication(<<"GSS"/utf8>>);

                            {be_authentication_sasl, Methods} ->
                                case gleam@list:contains(
                                    Methods,
                                    <<"SCRAM-SHA-256"/utf8>>
                                ) of
                                    true ->
                                        sha_256_authenticate(User, Password);

                                    _ ->
                                        _pipe = case gleam@list:filter(
                                            Methods,
                                            fun(Method) ->
                                                Method /= <<""/utf8>>
                                            end
                                        ) of
                                            [_ | _] ->
                                                <<<<"SASL("/utf8,
                                                        (gleam@string:join(
                                                            Methods,
                                                            <<","/utf8>>
                                                        ))/binary>>/binary,
                                                    ")"/utf8>>;

                                            [] ->
                                                <<"SASL"/utf8>>
                                        end,
                                        unsupported_authentication(_pipe)
                                end;

                            be_authentication_sspi ->
                                unsupported_authentication(<<"SSPI"/utf8>>);

                            be_authentication_kerberos_v5 ->
                                unsupported_authentication(
                                    <<"KerberosV5"/utf8>>
                                );

                            _ ->
                                unexpected_message(
                                    fun(Field@0, Field@1) -> {pg_unexpected_auth_method_message, Field@0, Field@1} end,
                                    <<"AuthMethod"/utf8>>,
                                    Msg
                                )
                        end, fun(_) ->
                            eval:'try'(
                                begin
                                    _pipe@1 = wait_until_ready(),
                                    eval:replace_error(
                                        _pipe@1,
                                        {pg_invalid_user_database,
                                            erlang:element(4, Connection),
                                            erlang:element(6, Connection)}
                                    )
                                end,
                                fun(_) -> eval:return(nil) end
                            )
                        end) end) end
    ).

-spec with_cached_gleam_type(
    integer(),
    fun(() -> eval:eval(squirrel@internal@gleam:type(), squirrel@internal@error:error(), context()))
) -> eval:eval(squirrel@internal@gleam:type(), squirrel@internal@error:error(), context()).
with_cached_gleam_type(Oid, Do) ->
    eval:from(
        fun(Context) -> case gleam@dict:get(erlang:element(3, Context), Oid) of
                {ok, Type_} ->
                    {Context, {ok, Type_}};

                {error, _} ->
                    case eval:step(Do(), Context) of
                        {_, {error, _}} = Result ->
                            Result;

                        {{context, _, Gleam_types, _} = Context@1,
                            {ok, Type_@1}} ->
                            Gleam_types@1 = gleam@dict:insert(
                                Gleam_types,
                                Oid,
                                Type_@1
                            ),
                            New_context = erlang:setelement(
                                3,
                                Context@1,
                                Gleam_types@1
                            ),
                            {New_context, {ok, Type_@1}}
                    end
            end end
    ).

-spec with_cached_column(
    integer(),
    integer(),
    fun(() -> eval:eval(nullability(), squirrel@internal@error:error(), context()))
) -> eval:eval(nullability(), squirrel@internal@error:error(), context()).
with_cached_column(Table_oid, Column, Do) ->
    eval:from(
        fun(Context) ->
            Key = {Table_oid, Column},
            case gleam@dict:get(erlang:element(4, Context), Key) of
                {ok, Type_} ->
                    {Context, {ok, Type_}};

                {error, _} ->
                    case eval:step(Do(), Context) of
                        {_, {error, _}} = Result ->
                            Result;

                        {{context, _, _, Column_nullability} = Context@1,
                            {ok, Type_@1}} ->
                            Column_nullability@1 = gleam@dict:insert(
                                Column_nullability,
                                Key,
                                Type_@1
                            ),
                            New_context = erlang:setelement(
                                4,
                                Context@1,
                                Column_nullability@1
                            ),
                            {New_context, {ok, Type_@1}}
                    end
            end
        end
    ).

-spec unsupported_type_error(squirrel@internal@query:untyped_query(), binary()) -> squirrel@internal@error:error().
unsupported_type_error(Query, Type_) ->
    {untyped_query, File, Starting_line, Name, _, Content} = Query,
    {query_has_unsupported_type,
        File,
        squirrel@internal@gleam:identifier_to_string(Name),
        Content,
        Starting_line,
        Type_}.

-spec cannot_parse_error(
    squirrel@internal@query:untyped_query(),
    gleam@option:option(binary()),
    gleam@option:option(binary()),
    gleam@option:option(squirrel@internal@error:pointer())
) -> squirrel@internal@error:error().
cannot_parse_error(Query, Error_code, Hint, Pointer) ->
    {untyped_query, File, Starting_line, Name, _, Content} = Query,
    {cannot_parse_query,
        File,
        squirrel@internal@gleam:identifier_to_string(Name),
        Content,
        Starting_line,
        Error_code,
        Pointer,
        Hint}.

-spec error_fields_to_parse_error(
    squirrel@internal@query:untyped_query(),
    gleam@set:set(squirrel@internal@database@postgres_protocol:error_or_notice_field())
) -> squirrel@internal@error:error().
error_fields_to_parse_error(Query, Errors) ->
    {Error_code, Message@2, Position@3, Hint@2} = (gleam@set:fold(
        Errors,
        {none, none, none, none},
        fun(Acc, Error_field) ->
            {Code, Message, Position, Hint} = Acc,
            case Error_field of
                {code, Code@1} ->
                    {{some, Code@1}, Message, Position, Hint};

                {message, Message@1} ->
                    {Code, {some, Message@1}, Position, Hint};

                {hint, Hint@1} ->
                    {Code, Message, Position, {some, Hint@1}};

                {position, Position@1} ->
                    case gleam@int:parse(Position@1) of
                        {ok, Position@2} ->
                            {Code, Message, {some, Position@2}, Hint};

                        {error, _} ->
                            Acc
                    end;

                _ ->
                    Acc
            end
        end
    )),
    Pointer = case {Message@2, Position@3} of
        {{some, Message@3}, {some, Position@4}} ->
            {some, {pointer, {byte_index, Position@4}, Message@3}};

        {_, _} ->
            none
    end,
    cannot_parse_error(Query, Error_code, Hint@2, Pointer).

-spec parameters_and_returns(squirrel@internal@query:untyped_query()) -> eval:eval({list(integer()),
    list(squirrel@internal@database@postgres_protocol:row_description_field())}, squirrel@internal@error:error(), context()).
parameters_and_returns(Query) ->
    eval:'try'(
        send_all(
            [{fe_parse, <<""/utf8>>, erlang:element(6, Query), []},
                {fe_describe, prepared_statement, <<""/utf8>>},
                fe_sync]
        ),
        fun(_) ->
            Cannot_describe = fun(Expected, Got) ->
                {pg_cannot_describe_query,
                    erlang:element(2, Query),
                    squirrel@internal@gleam:identifier_to_string(
                        erlang:element(4, Query)
                    ),
                    Expected,
                    Got}
            end,
            eval:'try'('receive'(), fun(Msg) -> case Msg of
                        {be_error_response, Errors} ->
                            eval:throw(
                                error_fields_to_parse_error(Query, Errors)
                            );

                        be_parse_complete ->
                            eval:'try'(
                                'receive'(),
                                fun(Msg@1) -> eval:'try'(case Msg@1 of
                                            {be_parameter_description,
                                                Parameters} ->
                                                eval:return(Parameters);

                                            be_no_data ->
                                                eval:return([]);

                                            _ ->
                                                unexpected_message(
                                                    Cannot_describe,
                                                    <<"ParameterDescription"/utf8>>,
                                                    Msg@1
                                                )
                                        end, fun(Parameters@1) ->
                                            eval:'try'(
                                                'receive'(),
                                                fun(Msg@2) ->
                                                    eval:'try'(case Msg@2 of
                                                            {be_row_descriptions,
                                                                Rows} ->
                                                                eval:return(
                                                                    Rows
                                                                );

                                                            be_no_data ->
                                                                eval:return([]);

                                                            _ ->
                                                                unexpected_message(
                                                                    Cannot_describe,
                                                                    <<"RowDescriptions"/utf8>>,
                                                                    Msg@2
                                                                )
                                                        end, fun(Rows@1) ->
                                                            eval:'try'(
                                                                'receive'(),
                                                                fun(Msg@3) ->
                                                                    eval:'try'(
                                                                        case Msg@3 of
                                                                            {be_ready_for_query,
                                                                                _} ->
                                                                                eval:return(
                                                                                    nil
                                                                                );

                                                                            _ ->
                                                                                unexpected_message(
                                                                                    Cannot_describe,
                                                                                    <<"ReadyForQuery"/utf8>>,
                                                                                    Msg@3
                                                                                )
                                                                        end,
                                                                        fun(_) ->
                                                                            eval:return(
                                                                                {Parameters@1,
                                                                                    Rows@1}
                                                                            )
                                                                        end
                                                                    )
                                                                end
                                                            )
                                                        end)
                                                end
                                            )
                                        end) end
                            );

                        _ ->
                            unexpected_message(
                                Cannot_describe,
                                <<"ParseComplete or ErrorResponse"/utf8>>,
                                Msg
                            )
                    end end)
        end
    ).

-spec invalid_column_error(
    squirrel@internal@query:untyped_query(),
    binary(),
    squirrel@internal@error:value_identifier_error()
) -> squirrel@internal@error:error().
invalid_column_error(Query, Column_name, Reason) ->
    {untyped_query, File, Starting_line, _, _, Content} = Query,
    {query_has_invalid_column,
        File,
        Column_name,
        begin
            _pipe = squirrel@internal@gleam:similar_identifier_string(
                Column_name
            ),
            gleam@option:from_result(_pipe)
        end,
        Content,
        Starting_line,
        Reason}.

-spec join_type_decoder(gleam@dynamic:dynamic_()) -> {ok, join_type()} |
    {error, list(gleam@dynamic:decode_error())}.
join_type_decoder(Data) ->
    gleam@result:map(gleam@dynamic:string(Data), fun(Data@1) -> case Data@1 of
                <<"Full"/utf8>> ->
                    full;

                <<"Left"/utf8>> ->
                    left;

                <<"Right"/utf8>> ->
                    right;

                _ ->
                    other
            end end).

-spec parent_relation_decoder(gleam@dynamic:dynamic_()) -> {ok,
        parent_relation()} |
    {error, list(gleam@dynamic:decode_error())}.
parent_relation_decoder(Data) ->
    gleam@result:map(gleam@dynamic:string(Data), fun(Data@1) -> case Data@1 of
                <<"Inner"/utf8>> ->
                    inner;

                _ ->
                    not_inner
            end end).

-spec plan_decoder(gleam@dynamic:dynamic_()) -> {ok, plan()} |
    {error, list(gleam@dynamic:decode_error())}.
plan_decoder(Data) ->
    (gleam@dynamic:decode4(
        fun(Field@0, Field@1, Field@2, Field@3) -> {plan, Field@0, Field@1, Field@2, Field@3} end,
        gleam@dynamic:optional_field(
            <<"Join Type"/utf8>>,
            fun join_type_decoder/1
        ),
        gleam@dynamic:optional_field(
            <<"Parent Relationship"/utf8>>,
            fun parent_relation_decoder/1
        ),
        gleam@dynamic:optional_field(
            <<"Output"/utf8>>,
            gleam@dynamic:list(fun gleam@dynamic:string/1)
        ),
        gleam@dynamic:optional_field(
            <<"Plans"/utf8>>,
            gleam@dynamic:list(fun plan_decoder/1)
        )
    ))(Data).

-spec json_plans_decoder(gleam@dynamic:dynamic_()) -> {ok, list(plan())} |
    {error, list(gleam@dynamic:decode_error())}.
json_plans_decoder(Data) ->
    (gleam@dynamic:list(
        gleam@dynamic:field(<<"Plan"/utf8>>, fun plan_decoder/1)
    ))(Data).

-spec query_plan(squirrel@internal@query:untyped_query(), integer()) -> eval:eval(plan(), squirrel@internal@error:error(), context()).
query_plan(Query, Parameters) ->
    Explain_query = <<"explain (format json, verbose) "/utf8,
        (erlang:element(6, Query))/binary>>,
    Params = gleam@list:repeat(null, Parameters),
    Run_query = run_query(Explain_query, erlang:element(2, Query), Params, []),
    eval:'try'(
        Run_query,
        fun(Res) ->
            [Plan] = case Res of
                [_] -> Res;
                _assert_fail ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Assertion pattern match failed"/utf8>>,
                                value => _assert_fail,
                                module => <<"squirrel/internal/database/postgres"/utf8>>,
                                function => <<"query_plan"/utf8>>,
                                line => 622})
            end,
            _assert_subject = gleam@json:decode_bits(
                Plan,
                fun json_plans_decoder/1
            ),
            {ok, [Plan@1 | _]} = case _assert_subject of
                {ok, [_ | _]} -> _assert_subject;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Assertion pattern match failed"/utf8>>,
                                value => _assert_fail@1,
                                module => <<"squirrel/internal/database/postgres"/utf8>>,
                                function => <<"query_plan"/utf8>>,
                                line => 623})
            end,
            eval:return(Plan@1)
        end
    ).

-spec bit_array_to_bool(bitstring()) -> boolean().
bit_array_to_bool(Bit_array) ->
    case Bit_array of
        <<0, Rest/bitstring>> ->
            bit_array_to_bool(Rest);

        <<>> ->
            false;

        _ ->
            true
    end.

-spec find_gleam_type(squirrel@internal@query:untyped_query(), integer()) -> eval:eval(squirrel@internal@gleam:type(), squirrel@internal@error:error(), context()).
find_gleam_type(Query, Oid) ->
    with_cached_gleam_type(
        Oid,
        fun() ->
            Params = [{parameter, <<Oid:32>>}],
            Run_query = begin
                _pipe = <<"
select
  -- The name of the type or, if the type is an array, the name of its
  -- elements' type.
  case
    when elem.typname is null then type.typname
    else elem.typname
 	end as type,
  -- Tells us how to interpret the firs column: if this is true then the first
  -- column is the type of the elements of the array type.
  -- Otherwise it means we've found a base type.
  case
    when elem.typname is null then false
    else true
 	end as is_array
from
  pg_type as type
  left join pg_type as elem on type.typelem = elem.oid
where
  type.oid = $1
"/utf8>>,
                run_query(_pipe, erlang:element(2, Query), Params, [23])
            end,
            eval:'try'(
                Run_query,
                fun(Res) ->
                    [Name, Is_array] = case Res of
                        [_, _] -> Res;
                        _assert_fail ->
                            erlang:error(#{gleam_error => let_assert,
                                        message => <<"Assertion pattern match failed"/utf8>>,
                                        value => _assert_fail,
                                        module => <<"squirrel/internal/database/postgres"/utf8>>,
                                        function => <<"find_gleam_type"/utf8>>,
                                        line => 591})
                    end,
                    _assert_subject = gleam@bit_array:to_string(Name),
                    {ok, Name@1} = case _assert_subject of
                        {ok, _} -> _assert_subject;
                        _assert_fail@1 ->
                            erlang:error(#{gleam_error => let_assert,
                                        message => <<"Assertion pattern match failed"/utf8>>,
                                        value => _assert_fail@1,
                                        module => <<"squirrel/internal/database/postgres"/utf8>>,
                                        function => <<"find_gleam_type"/utf8>>,
                                        line => 596})
                    end,
                    Type_ = case bit_array_to_bool(Is_array) of
                        true ->
                            {p_array, {p_base, Name@1}};

                        false ->
                            {p_base, Name@1}
                    end,
                    _pipe@1 = pg_to_gleam_type(Type_),
                    _pipe@2 = gleam@result:map_error(
                        _pipe@1,
                        fun(_capture) ->
                            unsupported_type_error(Query, _capture)
                        end
                    ),
                    eval:from_result(_pipe@2)
                end
            )
        end
    ).

-spec resolve_parameters(
    squirrel@internal@query:untyped_query(),
    list(integer())
) -> eval:eval(list(squirrel@internal@gleam:type()), squirrel@internal@error:error(), context()).
resolve_parameters(Query, Parameters) ->
    squirrel@internal@eval_extra:try_map(
        Parameters,
        fun(Oid) -> find_gleam_type(Query, Oid) end
    ).

-spec column_nullability(integer(), integer()) -> eval:eval(nullability(), squirrel@internal@error:error(), context()).
column_nullability(Table, Column) ->
    with_cached_column(
        Table,
        Column,
        fun() ->
            gleam@bool:guard(
                Table =:= 0,
                eval:return(not_nullable),
                fun() ->
                    Params = [{parameter, <<Table:32>>},
                        {parameter, <<Column:32>>}],
                    Run_query = begin
                        _pipe = <<"
select
  -- Whether the column has a not-null constraint.
  attnotnull
from
  pg_attribute
where
  -- The oid of the table the column comes from.
  attrelid = $1
  -- The index of the column we're looking for.
  and attnum = $2
"/utf8>>,
                        run_query(_pipe, <<""/utf8>>, Params, [23, 23])
                    end,
                    eval:'try'(
                        Run_query,
                        fun(Res) ->
                            [Has_non_null_constraint] = case Res of
                                [_] -> Res;
                                _assert_fail ->
                                    erlang:error(#{gleam_error => let_assert,
                                                message => <<"Assertion pattern match failed"/utf8>>,
                                                value => _assert_fail,
                                                module => <<"squirrel/internal/database/postgres"/utf8>>,
                                                function => <<"column_nullability"/utf8>>,
                                                line => 751})
                            end,
                            case bit_array_to_bool(Has_non_null_constraint) of
                                true ->
                                    eval:return(not_nullable);

                                false ->
                                    eval:return(nullable)
                            end
                        end
                    )
                end
            )
        end
    ).

-spec resolve_returns(
    squirrel@internal@query:untyped_query(),
    list(squirrel@internal@database@postgres_protocol:row_description_field()),
    gleam@set:set(integer())
) -> eval:eval(list(squirrel@internal@gleam:field()), squirrel@internal@error:error(), context()).
resolve_returns(Query, Returns, Nullables) ->
    squirrel@internal@eval_extra:try_index_map(
        Returns,
        fun(Column, I) ->
            {row_description_field, Name, Table, Column@1, Type_oid, _, _, _} = Column,
            eval:'try'(
                find_gleam_type(Query, Type_oid),
                fun(Type_) ->
                    Ends_with_exclamation_mark = gleam@string:ends_with(
                        Name,
                        <<"!"/utf8>>
                    ),
                    Ends_with_question_mark = gleam@string:ends_with(
                        Name,
                        <<"?"/utf8>>
                    ),
                    eval:'try'(case Ends_with_exclamation_mark of
                            true ->
                                eval:return(not_nullable);

                            false ->
                                case Ends_with_question_mark of
                                    true ->
                                        eval:return(nullable);

                                    false ->
                                        case gleam@set:contains(Nullables, I) of
                                            true ->
                                                eval:return(nullable);

                                            false ->
                                                column_nullability(
                                                    Table,
                                                    Column@1
                                                )
                                        end
                                end
                        end, fun(Nullability) ->
                            Type_@1 = case Nullability of
                                nullable ->
                                    {option, Type_};

                                not_nullable ->
                                    Type_
                            end,
                            Try_convert_name = begin
                                _pipe = case Ends_with_exclamation_mark orelse Ends_with_question_mark of
                                    true ->
                                        gleam@string:drop_right(Name, 1);

                                    false ->
                                        Name
                                end,
                                _pipe@1 = squirrel@internal@gleam:identifier(
                                    _pipe
                                ),
                                gleam@result:map_error(
                                    _pipe@1,
                                    fun(_capture) ->
                                        invalid_column_error(
                                            Query,
                                            Name,
                                            _capture
                                        )
                                    end
                                )
                            end,
                            eval:'try'(
                                eval:from_result(Try_convert_name),
                                fun(Name@1) ->
                                    Field = {field, Name@1, Type_@1},
                                    eval:return(Field)
                                end
                            )
                        end)
                end
            )
        end
    ).

-spec infer_types(squirrel@internal@query:untyped_query()) -> eval:eval(squirrel@internal@query:typed_query(), squirrel@internal@error:error(), context()).
infer_types(Query) ->
    Action = parameters_and_returns(Query),
    eval:'try'(
        Action,
        fun(_use0) ->
            {Parameters, Returns} = _use0,
            eval:'try'(
                resolve_parameters(Query, Parameters),
                fun(Parameters@1) ->
                    eval:'try'(
                        query_plan(Query, erlang:length(Parameters@1)),
                        fun(Plan) ->
                            Nullables = nullables_from_plan(Plan),
                            eval:'try'(
                                resolve_returns(Query, Returns, Nullables),
                                fun(Returns@1) -> _pipe = Query,
                                    _pipe@1 = squirrel@internal@query:add_types(
                                        _pipe,
                                        Parameters@1,
                                        Returns@1
                                    ),
                                    eval:return(_pipe@1) end
                            )
                        end
                    )
                end
            )
        end
    ).

-spec main(list(squirrel@internal@query:untyped_query()), connection_options()) -> {ok,
        {list(squirrel@internal@query:typed_query()),
            list(squirrel@internal@error:error())}} |
    {error, squirrel@internal@error:error()}.
main(Queries, Connection) ->
    gleam@result:'try'(
        begin
            _pipe = squirrel@internal@database@postgres_protocol:connect(
                erlang:element(2, Connection),
                erlang:element(3, Connection),
                erlang:element(7, Connection)
            ),
            gleam@result:map_error(
                _pipe,
                fun(_capture) ->
                    {pg_cannot_establish_tcp_connection,
                        erlang:element(2, Connection),
                        erlang:element(3, Connection),
                        _capture}
                end
            )
        end,
        fun(Db) ->
            Context = {context, Db, gleam@dict:new(), gleam@dict:new()},
            {Context@1, Connection@1} = eval:step(
                authenticate(Connection),
                Context
            ),
            case Connection@1 of
                {error, Error} ->
                    {error, Error};

                {ok, _} ->
                    _pipe@1 = gleam@list:map(Queries, fun infer_types/1),
                    _pipe@2 = squirrel@internal@eval_extra:run_all(
                        _pipe@1,
                        Context@1
                    ),
                    _pipe@3 = gleam@result:partition(_pipe@2),
                    {ok, _pipe@3}
            end
        end
    ).