-module(sqlode@internal@codegen@adapter).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/sqlode/internal/codegen/adapter.gleam").
-export([render/4]).
-export_type([adapter_config/0, render_context/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 adapter_config() :: {adapter_config,
        binary(),
        binary(),
        binary(),
        fun((sqlode@internal@model:scalar_type()) -> binary()),
        fun((sqlode@internal@model:scalar_type()) -> binary()),
        fun((list(sqlode@internal@model:query_param()), binary()) -> binary()),
        fun((binary(), binary(), binary(), binary(), list(sqlode@internal@model:query_param())) -> list(binary())),
        fun(() -> list(binary())),
        fun(() -> list(binary())),
        fun(() -> list(binary())),
        fun((binary(), binary(), binary(), list(sqlode@internal@model:query_param())) -> list(binary())),
        binary(),
        binary(),
        binary()}.

-type render_context() :: {render_context,
        sqlode@internal@naming:naming_context(),
        adapter_config(),
        gleam@dict:dict(binary(), binary()),
        boolean(),
        boolean(),
        sqlode@internal@model:type_mapping()}.

-file("src/sqlode/internal/codegen/adapter.gleam", 140).
?DOC(false).
-spec pog_value_to_driver_helper() -> binary().
pog_value_to_driver_helper() ->
    <<"fn value_to_pog(value: runtime.Value) -> pog.Value {
  case value {
    runtime.Null -> pog.null()
    runtime.String(v) -> pog.text(v)
    runtime.Int(v) -> pog.int(v)
    runtime.Float(v) -> pog.float(v)
    runtime.Bool(v) -> pog.bool(v)
    runtime.Bytes(v) -> pog.bytea(v)
    runtime.Array(vs) -> pog.array(value_to_pog, vs)
  }
}"/utf8>>.

-file("src/sqlode/internal/codegen/adapter.gleam", 154).
?DOC(false).
-spec sqlight_value_to_driver_helper() -> binary().
sqlight_value_to_driver_helper() ->
    <<"fn value_to_sqlight(value: runtime.Value) -> sqlight.Value {
  case value {
    runtime.Null -> sqlight.null()
    runtime.String(v) -> sqlight.text(v)
    runtime.Int(v) -> sqlight.int(v)
    runtime.Float(v) -> sqlight.float(v)
    runtime.Bool(v) -> sqlight.bool(v)
    runtime.Bytes(v) -> sqlight.blob(v)
    runtime.Array(_) -> panic as \"Array is not supported in the SQLite native adapter. Use raw runtime for array parameters, or ensure sqlode.slice() values are expanded before reaching value_to_sqlight.\"
  }
}"/utf8>>.

-file("src/sqlode/internal/codegen/adapter.gleam", 209).
?DOC(false).
-spec shork_value_to_driver_helper() -> binary().
shork_value_to_driver_helper() ->
    <<"@external(erlang, \"shork_ffi\", \"coerce\")
fn bit_array_to_shork(value: BitArray) -> shork.Value

fn value_to_shork(value: runtime.Value) -> shork.Value {
  case value {
    runtime.Null -> shork.null()
    runtime.String(v) -> shork.text(v)
    runtime.Int(v) -> shork.int(v)
    runtime.Float(v) -> shork.float(v)
    runtime.Bool(True) -> shork.int(1)
    runtime.Bool(False) -> shork.int(0)
    runtime.Bytes(v) -> bit_array_to_shork(v)
    runtime.Array(_) -> panic as \"Array is not supported in the MySQL native adapter. Use raw runtime for array parameters, or ensure sqlode.slice() values are expanded before reaching value_to_shork.\"
  }
}"/utf8>>.

-file("src/sqlode/internal/codegen/adapter.gleam", 309).
?DOC(false).
-spec value_to_driver_helper(adapter_config()) -> binary().
value_to_driver_helper(Config) ->
    erlang:element(14, Config).

-file("src/sqlode/internal/codegen/adapter.gleam", 366).
?DOC(false).
-spec render_params_arg(
    sqlode@internal@naming:naming_context(),
    sqlode@internal@model:analyzed_query(),
    boolean()
) -> binary().
render_params_arg(Naming_ctx, Query, Has_params) ->
    case Has_params of
        true ->
            <<<<", p: params."/utf8,
                    (sqlode@internal@naming:to_pascal_case(
                        Naming_ctx,
                        erlang:element(2, erlang:element(2, Query))
                    ))/binary>>/binary,
                "Params"/utf8>>;

        false ->
            <<""/utf8>>
    end.

-file("src/sqlode/internal/codegen/adapter.gleam", 511).
?DOC(false).
-spec module_alias_for(binary()) -> binary().
module_alias_for(Module_path) ->
    case gleam@string:split(Module_path, <<"/"/utf8>>) of
        [] ->
            Module_path;

        Segments ->
            case gleam@list:last(Segments) of
                {ok, Last} ->
                    Last;

                {error, _} ->
                    Module_path
            end
    end.

-file("src/sqlode/internal/codegen/adapter.gleam", 501).
?DOC(false).
-spec qualified_decoder_hook_call(gleam@option:option(binary()), binary()) -> binary().
qualified_decoder_hook_call(Module, Fn_name) ->
    case Module of
        {some, Module_path} ->
            <<<<(module_alias_for(Module_path))/binary, "."/utf8>>/binary,
                Fn_name/binary>>;

        none ->
            Fn_name
    end.

-file("src/sqlode/internal/codegen/adapter.gleam", 456).
?DOC(false).
-spec render_base_decoder(
    sqlode@internal@model:scalar_type(),
    adapter_config(),
    sqlode@internal@model:type_mapping()
) -> binary().
render_base_decoder(Scalar_type, Config, Type_mapping) ->
    case Scalar_type of
        {enum_type, _} ->
            sqlode@internal@codegen@common:render_enum_or_set_decoder(
                Scalar_type,
                erlang:element(6, Config)
            );

        {set_type, _} ->
            sqlode@internal@codegen@common:render_enum_or_set_decoder(
                Scalar_type,
                erlang:element(6, Config)
            );

        {custom_type, _, Module, _, {some, Hooks}} ->
            <<<<<<<<"decode.map("/utf8,
                            ((erlang:element(6, Config))(Scalar_type))/binary>>/binary,
                        ", "/utf8>>/binary,
                    (qualified_decoder_hook_call(
                        Module,
                        erlang:element(3, Hooks)
                    ))/binary>>/binary,
                ")"/utf8>>;

        _ ->
            case (Type_mapping =:= strong_mapping) andalso sqlode@internal@type_mapping:is_rich_type(
                Scalar_type
            ) of
                true ->
                    Constructor = sqlode@internal@type_mapping:scalar_type_to_gleam_type(
                        Scalar_type,
                        strong_mapping
                    ),
                    <<<<<<<<"decode.map("/utf8,
                                    ((erlang:element(6, Config))(Scalar_type))/binary>>/binary,
                                ", models."/utf8>>/binary,
                            Constructor/binary>>/binary,
                        ")"/utf8>>;

                false ->
                    (erlang:element(6, Config))(Scalar_type)
            end
    end.

-file("src/sqlode/internal/codegen/adapter.gleam", 522).
?DOC(false).
-spec wrap_nullable_decoder(binary(), boolean()) -> binary().
wrap_nullable_decoder(Base_decoder, Nullable) ->
    case Nullable of
        true ->
            <<<<"decode.optional("/utf8, Base_decoder/binary>>/binary,
                ")"/utf8>>;

        false ->
            Base_decoder
    end.

-file("src/sqlode/internal/codegen/adapter.gleam", 529).
?DOC(false).
-spec render_field_decode_line(
    binary(),
    integer(),
    sqlode@internal@model:scalar_type(),
    boolean(),
    adapter_config(),
    sqlode@internal@model:type_mapping()
) -> binary().
render_field_decode_line(
    Field_name,
    Idx,
    Scalar_type,
    Nullable,
    Config,
    Type_mapping
) ->
    Full_decoder = begin
        _pipe = render_base_decoder(Scalar_type, Config, Type_mapping),
        wrap_nullable_decoder(_pipe, Nullable)
    end,
    <<<<<<<<<<<<"    use "/utf8, Field_name/binary>>/binary,
                        " <- decode.field("/utf8>>/binary,
                    (erlang:integer_to_binary(Idx))/binary>>/binary,
                ", "/utf8>>/binary,
            Full_decoder/binary>>/binary,
        ")"/utf8>>.

-file("src/sqlode/internal/codegen/adapter.gleam", 549).
?DOC(false).
-spec render_embedded_column_lines(
    render_context(),
    binary(),
    binary(),
    list(sqlode@internal@model:column()),
    integer()
) -> {integer(), list(binary())}.
render_embedded_column_lines(Ctx, Embed_name, Table_name, Embed_cols, Start_idx) ->
    Embed_field_name = sqlode@internal@naming:to_snake_case(
        erlang:element(2, Ctx),
        Embed_name
    ),
    Embed_type_name = sqlode@internal@naming:table_type_name(
        erlang:element(2, Ctx),
        Table_name,
        erlang:element(6, Ctx)
    ),
    Embed_lines = gleam@list:index_map(
        Embed_cols,
        fun(Embed_col, Embed_idx) ->
            Full_decoder = begin
                _pipe = render_base_decoder(
                    erlang:element(3, Embed_col),
                    erlang:element(3, Ctx),
                    erlang:element(7, Ctx)
                ),
                wrap_nullable_decoder(_pipe, erlang:element(4, Embed_col))
            end,
            <<<<<<<<<<<<"    use "/utf8,
                                    (sqlode@internal@naming:to_snake_case(
                                        erlang:element(2, Ctx),
                                        erlang:element(2, Embed_col)
                                    ))/binary>>/binary,
                                " <- decode.field("/utf8>>/binary,
                            (erlang:integer_to_binary(Start_idx + Embed_idx))/binary>>/binary,
                        ", "/utf8>>/binary,
                    Full_decoder/binary>>/binary,
                ")"/utf8>>
        end
    ),
    Embed_constructor_fields = begin
        _pipe@1 = gleam@list:map(
            Embed_cols,
            fun(C) ->
                <<(sqlode@internal@naming:to_snake_case(
                        erlang:element(2, Ctx),
                        erlang:element(2, C)
                    ))/binary,
                    ":"/utf8>>
            end
        ),
        gleam@string:join(_pipe@1, <<", "/utf8>>)
    end,
    Constructor_line = <<<<<<<<<<<<"    let "/utf8, Embed_field_name/binary>>/binary,
                        " = models."/utf8>>/binary,
                    Embed_type_name/binary>>/binary,
                "("/utf8>>/binary,
            Embed_constructor_fields/binary>>/binary,
        ")"/utf8>>,
    All_lines = lists:append(Embed_lines, [Constructor_line]),
    {Start_idx + erlang:length(Embed_cols), All_lines}.

-file("src/sqlode/internal/codegen/adapter.gleam", 380).
?DOC(false).
-spec render_decoder(
    render_context(),
    sqlode@internal@model:analyzed_query(),
    binary()
) -> binary().
render_decoder(Ctx, Query, Type_name) ->
    case erlang:element(4, Query) of
        [] ->
            <<"decode.success(Nil)"/utf8>>;

        Columns ->
            {_, Field_lines} = gleam@list:fold(
                Columns,
                {0, []},
                fun(Acc, Col) ->
                    {Idx, Lines} = Acc,
                    case Col of
                        {scalar_result,
                            {result_column, Name, Scalar_type, Nullable, _}} ->
                            Line = render_field_decode_line(
                                sqlode@internal@naming:to_snake_case(
                                    erlang:element(2, Ctx),
                                    Name
                                ),
                                Idx,
                                Scalar_type,
                                Nullable,
                                erlang:element(3, Ctx),
                                erlang:element(7, Ctx)
                            ),
                            {Idx + 1, lists:append(Lines, [Line])};

                        {embedded_result,
                            {embedded_column,
                                Embed_name,
                                Table_name,
                                Embed_cols}} ->
                            {New_idx, Embed_lines} = render_embedded_column_lines(
                                Ctx,
                                Embed_name,
                                Table_name,
                                Embed_cols,
                                Idx
                            ),
                            {New_idx, lists:append(Lines, Embed_lines)}
                    end
                end
            ),
            Constructor_fields = begin
                _pipe = Columns,
                _pipe@1 = gleam@list:map(_pipe, fun(Col@1) -> case Col@1 of
                            {scalar_result, {result_column, Name@1, _, _, _}} ->
                                <<(sqlode@internal@naming:to_snake_case(
                                        erlang:element(2, Ctx),
                                        Name@1
                                    ))/binary,
                                    ":"/utf8>>;

                            {embedded_result, {embedded_column, Name@2, _, _}} ->
                                <<(sqlode@internal@naming:to_snake_case(
                                        erlang:element(2, Ctx),
                                        Name@2
                                    ))/binary,
                                    ":"/utf8>>
                        end end),
                gleam@string:join(_pipe@1, <<", "/utf8>>)
            end,
            _pipe@2 = sqlode@internal@codegen@builder:concat(
                [sqlode@internal@codegen@builder:line(<<"{"/utf8>>),
                    sqlode@internal@codegen@builder:lines(Field_lines),
                    sqlode@internal@codegen@builder:line(
                        <<<<<<<<"    decode.success(models."/utf8,
                                        Type_name/binary>>/binary,
                                    "("/utf8>>/binary,
                                Constructor_fields/binary>>/binary,
                            "))"/utf8>>
                    ),
                    sqlode@internal@codegen@builder:line(<<"  }"/utf8>>)]
            ),
            sqlode@internal@codegen@builder:render(_pipe@2)
    end.

-file("src/sqlode/internal/codegen/adapter.gleam", 671).
?DOC(false).
-spec query_fn_signature(binary(), binary(), binary(), binary(), binary()) -> binary().
query_fn_signature(
    Fn_name,
    Connection_type,
    Params_arg,
    Return_type,
    Error_type
) ->
    <<<<<<<<<<<<<<<<<<"pub fn "/utf8, Fn_name/binary>>/binary, "(db: "/utf8>>/binary,
                                Connection_type/binary>>/binary,
                            Params_arg/binary>>/binary,
                        ") -> Result("/utf8>>/binary,
                    Return_type/binary>>/binary,
                ", "/utf8>>/binary,
            Error_type/binary>>/binary,
        ") {"/utf8>>.

-file("src/sqlode/internal/codegen/adapter.gleam", 625).
?DOC(false).
-spec render_adapter_query_result(
    render_context(),
    sqlode@internal@model:analyzed_query(),
    binary(),
    boolean(),
    binary(),
    fun(() -> list(binary()))
) -> binary().
render_adapter_query_result(
    Ctx,
    Query,
    Fn_name,
    Has_params,
    Return_type_wrapper,
    Render_result
) ->
    Type_name = <<(sqlode@internal@naming:to_pascal_case(
            erlang:element(2, Ctx),
            erlang:element(2, erlang:element(2, Query))
        ))/binary,
        "Row"/utf8>>,
    Constructor_name = case gleam_stdlib:map_get(
        erlang:element(4, Ctx),
        erlang:element(3, erlang:element(2, Query))
    ) of
        {ok, Table_type} ->
            Table_type;

        {error, _} ->
            Type_name
    end,
    Params_arg = render_params_arg(erlang:element(2, Ctx), Query, Has_params),
    Params_str = (erlang:element(7, erlang:element(3, Ctx)))(
        erlang:element(3, Query),
        <<"p"/utf8>>
    ),
    Decoder = render_decoder(Ctx, Query, Constructor_name),
    Return_type = <<<<<<Return_type_wrapper/binary, "(models."/utf8>>/binary,
            Type_name/binary>>/binary,
        ")"/utf8>>,
    _pipe = sqlode@internal@codegen@builder:concat(
        [sqlode@internal@codegen@builder:line(
                query_fn_signature(
                    Fn_name,
                    erlang:element(3, erlang:element(3, Ctx)),
                    Params_arg,
                    Return_type,
                    erlang:element(4, erlang:element(3, Ctx))
                )
            ),
            sqlode@internal@codegen@builder:line(
                <<<<"  let q = queries."/utf8, Fn_name/binary>>/binary,
                    "()"/utf8>>
            ),
            sqlode@internal@codegen@builder:lines(
                (erlang:element(8, erlang:element(3, Ctx)))(
                    Fn_name,
                    Params_str,
                    Decoder,
                    <<"q.sql"/utf8>>,
                    erlang:element(3, Query)
                )
            ),
            sqlode@internal@codegen@builder:lines(Render_result()),
            sqlode@internal@codegen@builder:line(<<"}"/utf8>>)]
    ),
    sqlode@internal@codegen@builder:render(_pipe).

-file("src/sqlode/internal/codegen/adapter.gleam", 593).
?DOC(false).
-spec render_adapter_one(
    render_context(),
    sqlode@internal@model:analyzed_query(),
    binary(),
    boolean()
) -> binary().
render_adapter_one(Ctx, Query, Fn_name, Has_params) ->
    render_adapter_query_result(
        Ctx,
        Query,
        Fn_name,
        Has_params,
        <<"Option"/utf8>>,
        erlang:element(9, erlang:element(3, Ctx))
    ).

-file("src/sqlode/internal/codegen/adapter.gleam", 609).
?DOC(false).
-spec render_adapter_many(
    render_context(),
    sqlode@internal@model:analyzed_query(),
    binary(),
    boolean()
) -> binary().
render_adapter_many(Ctx, Query, Fn_name, Has_params) ->
    render_adapter_query_result(
        Ctx,
        Query,
        Fn_name,
        Has_params,
        <<"List"/utf8>>,
        erlang:element(10, erlang:element(3, Ctx))
    ).

-file("src/sqlode/internal/codegen/adapter.gleam", 690).
?DOC(false).
-spec render_adapter_exec(
    sqlode@internal@naming:naming_context(),
    sqlode@internal@model:analyzed_query(),
    binary(),
    boolean(),
    adapter_config()
) -> binary().
render_adapter_exec(Naming_ctx, Query, Fn_name, Has_params, Config) ->
    Params_arg = render_params_arg(Naming_ctx, Query, Has_params),
    Params_str = (erlang:element(7, Config))(
        erlang:element(3, Query),
        <<"p"/utf8>>
    ),
    _pipe = sqlode@internal@codegen@builder:concat(
        [sqlode@internal@codegen@builder:line(
                query_fn_signature(
                    Fn_name,
                    erlang:element(3, Config),
                    Params_arg,
                    <<"Nil"/utf8>>,
                    erlang:element(4, Config)
                )
            ),
            sqlode@internal@codegen@builder:line(
                <<<<"  let q = queries."/utf8, Fn_name/binary>>/binary,
                    "()"/utf8>>
            ),
            sqlode@internal@codegen@builder:lines(
                (erlang:element(8, Config))(
                    Fn_name,
                    Params_str,
                    <<"decode.success(Nil)"/utf8>>,
                    <<"q.sql"/utf8>>,
                    erlang:element(3, Query)
                )
            ),
            sqlode@internal@codegen@builder:line(
                <<"  |> result.map(fn(_) { Nil })"/utf8>>
            ),
            sqlode@internal@codegen@builder:line(<<"}"/utf8>>)]
    ),
    sqlode@internal@codegen@builder:render(_pipe).

-file("src/sqlode/internal/codegen/adapter.gleam", 722).
?DOC(false).
-spec render_adapter_exec_rows(
    sqlode@internal@naming:naming_context(),
    sqlode@internal@model:analyzed_query(),
    binary(),
    boolean(),
    adapter_config()
) -> binary().
render_adapter_exec_rows(Naming_ctx, Query, Fn_name, Has_params, Config) ->
    Params_arg = render_params_arg(Naming_ctx, Query, Has_params),
    Params_str = (erlang:element(7, Config))(
        erlang:element(3, Query),
        <<"p"/utf8>>
    ),
    _pipe = sqlode@internal@codegen@builder:concat(
        [sqlode@internal@codegen@builder:line(
                query_fn_signature(
                    Fn_name,
                    erlang:element(3, Config),
                    Params_arg,
                    <<"Int"/utf8>>,
                    erlang:element(4, Config)
                )
            ),
            sqlode@internal@codegen@builder:line(
                <<<<"  let q = queries."/utf8, Fn_name/binary>>/binary,
                    "()"/utf8>>
            ),
            sqlode@internal@codegen@builder:lines(
                (erlang:element(8, Config))(
                    Fn_name,
                    Params_str,
                    erlang:element(15, Config),
                    <<"q.sql"/utf8>>,
                    erlang:element(3, Query)
                )
            ),
            sqlode@internal@codegen@builder:lines(
                (erlang:element(11, Config))()
            ),
            sqlode@internal@codegen@builder:line(<<"}"/utf8>>)]
    ),
    sqlode@internal@codegen@builder:render(_pipe).

-file("src/sqlode/internal/codegen/adapter.gleam", 754).
?DOC(false).
-spec render_adapter_exec_last_id(
    sqlode@internal@naming:naming_context(),
    sqlode@internal@model:analyzed_query(),
    binary(),
    boolean(),
    adapter_config()
) -> binary().
render_adapter_exec_last_id(Naming_ctx, Query, Fn_name, Has_params, Config) ->
    Params_arg = render_params_arg(Naming_ctx, Query, Has_params),
    Params_str = (erlang:element(7, Config))(
        erlang:element(3, Query),
        <<"p"/utf8>>
    ),
    _pipe = sqlode@internal@codegen@builder:concat(
        [sqlode@internal@codegen@builder:line(
                query_fn_signature(
                    Fn_name,
                    erlang:element(3, Config),
                    Params_arg,
                    <<"Int"/utf8>>,
                    erlang:element(4, Config)
                )
            ),
            sqlode@internal@codegen@builder:line(
                <<<<"  let q = queries."/utf8, Fn_name/binary>>/binary,
                    "()"/utf8>>
            ),
            sqlode@internal@codegen@builder:lines(
                (erlang:element(12, Config))(
                    Fn_name,
                    Params_str,
                    <<"q.sql"/utf8>>,
                    erlang:element(3, Query)
                )
            ),
            sqlode@internal@codegen@builder:line(<<"}"/utf8>>)]
    ),
    sqlode@internal@codegen@builder:render(_pipe).

-file("src/sqlode/internal/codegen/adapter.gleam", 313).
?DOC(false).
-spec render_adapter_function(
    render_context(),
    sqlode@internal@model:analyzed_query()
) -> binary().
render_adapter_function(Ctx, Query) ->
    Fn_name = erlang:element(3, erlang:element(2, Query)),
    Has_params = not gleam@list:is_empty(erlang:element(3, Query)),
    Comment = case erlang:element(5, Ctx) of
        true ->
            <<<<"// SQL: "/utf8,
                    (erlang:element(5, erlang:element(2, Query)))/binary>>/binary,
                "\n"/utf8>>;

        false ->
            <<""/utf8>>
    end,
    <<Comment/binary, (case erlang:element(4, erlang:element(2, Query)) of
            one ->
                render_adapter_one(Ctx, Query, Fn_name, Has_params);

            batch_one ->
                render_adapter_one(Ctx, Query, Fn_name, Has_params);

            many ->
                render_adapter_many(Ctx, Query, Fn_name, Has_params);

            batch_many ->
                render_adapter_many(Ctx, Query, Fn_name, Has_params);

            exec ->
                render_adapter_exec(
                    erlang:element(2, Ctx),
                    Query,
                    Fn_name,
                    Has_params,
                    erlang:element(3, Ctx)
                );

            batch_exec ->
                render_adapter_exec(
                    erlang:element(2, Ctx),
                    Query,
                    Fn_name,
                    Has_params,
                    erlang:element(3, Ctx)
                );

            copy_from ->
                render_adapter_exec(
                    erlang:element(2, Ctx),
                    Query,
                    Fn_name,
                    Has_params,
                    erlang:element(3, Ctx)
                );

            exec_result ->
                render_adapter_exec(
                    erlang:element(2, Ctx),
                    Query,
                    Fn_name,
                    Has_params,
                    erlang:element(3, Ctx)
                );

            exec_rows ->
                render_adapter_exec_rows(
                    erlang:element(2, Ctx),
                    Query,
                    Fn_name,
                    Has_params,
                    erlang:element(3, Ctx)
                );

            exec_last_id ->
                render_adapter_exec_last_id(
                    erlang:element(2, Ctx),
                    Query,
                    Fn_name,
                    Has_params,
                    erlang:element(3, Ctx)
                )
        end)/binary>>.

-file("src/sqlode/internal/codegen/adapter.gleam", 806).
?DOC(false).
-spec render_pog_params(list(sqlode@internal@model:query_param()), binary()) -> binary().
render_pog_params(_, _) ->
    <<""/utf8>>.

-file("src/sqlode/internal/codegen/adapter.gleam", 816).
?DOC(false).
-spec render_prepare_lines(
    binary(),
    binary(),
    list(sqlode@internal@model:query_param())
) -> list(binary()).
render_prepare_lines(Driver, Value_to_driver, Params) ->
    case gleam@list:is_empty(Params) of
        true ->
            [<<"  let #(sql, _values) = runtime.prepare(q, Nil)"/utf8>>,
                <<<<"  "/utf8, Driver/binary>>/binary, ".query(sql)"/utf8>>];

        false ->
            [<<"  let #(sql, values) = runtime.prepare(q, p)"/utf8>>,
                <<<<"  let query = "/utf8, Driver/binary>>/binary,
                    ".query(sql)"/utf8>>,
                <<<<<<<<"  let query = list.fold(values, query, fn(acc, v) { "/utf8,
                                Driver/binary>>/binary,
                            ".parameter(acc, "/utf8>>/binary,
                        Value_to_driver/binary>>/binary,
                    "(v)) })"/utf8>>,
                <<"  query"/utf8>>]
    end.

-file("src/sqlode/internal/codegen/adapter.gleam", 788).
?DOC(false).
-spec render_pog_query_call(
    binary(),
    binary(),
    binary(),
    binary(),
    list(sqlode@internal@model:query_param())
) -> list(binary()).
render_pog_query_call(_, _, Decoder, _, Params) ->
    lists:append(
        [render_prepare_lines(<<"pog"/utf8>>, <<"value_to_pog"/utf8>>, Params),
            [<<<<"  |> pog.returning("/utf8, Decoder/binary>>/binary, ")"/utf8>>,
                <<"  |> pog.execute(db)"/utf8>>]]
    ).

-file("src/sqlode/internal/codegen/adapter.gleam", 843).
?DOC(false).
-spec render_pog_many_result() -> list(binary()).
render_pog_many_result() ->
    [<<"  |> result.map(fn(returned) { returned.rows })"/utf8>>].

-file("src/sqlode/internal/codegen/adapter.gleam", 847).
?DOC(false).
-spec render_pog_exec_rows_result() -> list(binary()).
render_pog_exec_rows_result() ->
    [<<"  |> result.map(fn(returned) { returned.count })"/utf8>>].

-file("src/sqlode/internal/codegen/adapter.gleam", 879).
?DOC(false).
-spec render_sqlight_query_call(
    binary(),
    binary(),
    binary(),
    binary(),
    list(sqlode@internal@model:query_param())
) -> list(binary()).
render_sqlight_query_call(_, _, Decoder, _, Params) ->
    Prepare_line = case gleam@list:is_empty(Params) of
        true ->
            <<"  let #(sql, values) = runtime.prepare(q, Nil)"/utf8>>;

        false ->
            <<"  let #(sql, values) = runtime.prepare(q, p)"/utf8>>
    end,
    [Prepare_line,
        <<"  sqlight.query("/utf8>>,
        <<"    sql,"/utf8>>,
        <<"    on: db,"/utf8>>,
        <<"    with: list.map(values, value_to_sqlight),"/utf8>>,
        <<<<"    expecting: "/utf8, Decoder/binary>>/binary, ","/utf8>>,
        <<"  )"/utf8>>].

-file("src/sqlode/internal/codegen/adapter.gleam", 903).
?DOC(false).
-spec render_sqlight_params(list(sqlode@internal@model:query_param()), binary()) -> binary().
render_sqlight_params(_, _) ->
    <<""/utf8>>.

-file("src/sqlode/internal/codegen/adapter.gleam", 914).
?DOC(false).
-spec render_sqlight_many_result() -> list(binary()).
render_sqlight_many_result() ->
    [].

-file("src/sqlode/internal/codegen/adapter.gleam", 979).
?DOC(false).
-spec render_shork_query_call(
    binary(),
    binary(),
    binary(),
    binary(),
    list(sqlode@internal@model:query_param())
) -> list(binary()).
render_shork_query_call(_, _, Decoder, _, Params) ->
    lists:append(
        [render_prepare_lines(
                <<"shork"/utf8>>,
                <<"value_to_shork"/utf8>>,
                Params
            ),
            [<<<<"  |> shork.returning("/utf8, Decoder/binary>>/binary,
                    ")"/utf8>>,
                <<"  |> shork.execute(db)"/utf8>>]]
    ).

-file("src/sqlode/internal/codegen/adapter.gleam", 994).
?DOC(false).
-spec render_shork_params(list(sqlode@internal@model:query_param()), binary()) -> binary().
render_shork_params(_, _) ->
    <<""/utf8>>.

-file("src/sqlode/internal/codegen/adapter.gleam", 1005).
?DOC(false).
-spec render_shork_many_result() -> list(binary()).
render_shork_many_result() ->
    [<<"  |> result.map(fn(returned) { returned.rows })"/utf8>>].

-file("src/sqlode/internal/codegen/adapter.gleam", 1011).
?DOC(false).
-spec render_shork_exec_rows_result() -> list(binary()).
render_shork_exec_rows_result() ->
    [<<"  |> result.map(fn(returned) {"/utf8>>,
        <<"    case returned.rows {"/utf8>>,
        <<"      [rows, ..] -> rows"/utf8>>,
        <<"      [] -> 0"/utf8>>,
        <<"    }"/utf8>>,
        <<"  })"/utf8>>].

-file("src/sqlode/internal/codegen/adapter.gleam", 1047).
?DOC(false).
-spec render_one_result_with(binary(), binary()) -> list(binary()).
render_one_result_with(Param, Rows_expr) ->
    [<<<<"  |> result.map(fn("/utf8, Param/binary>>/binary, ") {"/utf8>>,
        <<<<"    case "/utf8, Rows_expr/binary>>/binary, " {"/utf8>>,
        <<"      [row, ..] -> Some(row)"/utf8>>,
        <<"      [] -> None"/utf8>>,
        <<"    }"/utf8>>,
        <<"  })"/utf8>>].

-file("src/sqlode/internal/codegen/adapter.gleam", 839).
?DOC(false).
-spec render_pog_one_result() -> list(binary()).
render_pog_one_result() ->
    render_one_result_with(<<"returned"/utf8>>, <<"returned.rows"/utf8>>).

-file("src/sqlode/internal/codegen/adapter.gleam", 910).
?DOC(false).
-spec render_sqlight_one_result() -> list(binary()).
render_sqlight_one_result() ->
    render_one_result_with(<<"rows"/utf8>>, <<"rows"/utf8>>).

-file("src/sqlode/internal/codegen/adapter.gleam", 1001).
?DOC(false).
-spec render_shork_one_result() -> list(binary()).
render_shork_one_result() ->
    render_one_result_with(<<"returned"/utf8>>, <<"returned.rows"/utf8>>).

-file("src/sqlode/internal/codegen/adapter.gleam", 1058).
?DOC(false).
-spec render_first_or_default(binary(), binary(), binary()) -> list(binary()).
render_first_or_default(Param, Rows_expr, Default) ->
    [<<<<"  |> result.map(fn("/utf8, Param/binary>>/binary, ") {"/utf8>>,
        <<<<"    case "/utf8, Rows_expr/binary>>/binary, " {"/utf8>>,
        <<"      [id, ..] -> id"/utf8>>,
        <<"      [] -> "/utf8, Default/binary>>,
        <<"    }"/utf8>>,
        <<"  })"/utf8>>].

-file("src/sqlode/internal/codegen/adapter.gleam", 851).
?DOC(false).
-spec render_pog_exec_last_id(
    binary(),
    binary(),
    binary(),
    list(sqlode@internal@model:query_param())
) -> list(binary()).
render_pog_exec_last_id(_, _, _, Params) ->
    Result_lines = [<<"  |> pog.returning({"/utf8>>,
        <<"    use id <- decode.field(0, decode.int)"/utf8>>,
        <<"    decode.success(id)"/utf8>>,
        <<"  })"/utf8>>,
        <<"  |> pog.execute(db)"/utf8>> |
        render_first_or_default(
            <<"returned"/utf8>>,
            <<"returned.rows"/utf8>>,
            <<"0"/utf8>>
        )],
    lists:append(
        [render_prepare_lines(<<"pog"/utf8>>, <<"value_to_pog"/utf8>>, Params),
            Result_lines]
    ).

-file("src/sqlode/internal/codegen/adapter.gleam", 99).
?DOC(false).
-spec pog_adapter_config() -> adapter_config().
pog_adapter_config() ->
    {adapter_config,
        <<"import pog"/utf8>>,
        <<"pog.Connection"/utf8>>,
        <<"pog.QueryError"/utf8>>,
        fun(_capture) ->
            sqlode@internal@type_mapping:scalar_type_to_value_function(
                postgre_s_q_l,
                _capture
            )
        end,
        fun(_capture@1) ->
            sqlode@internal@type_mapping:scalar_type_to_decoder(
                postgre_s_q_l,
                _capture@1
            )
        end,
        fun render_pog_params/2,
        fun render_pog_query_call/5,
        fun render_pog_one_result/0,
        fun render_pog_many_result/0,
        fun render_pog_exec_rows_result/0,
        fun render_pog_exec_last_id/4,
        <<"$"/utf8>>,
        pog_value_to_driver_helper(),
        <<"decode.success(Nil)"/utf8>>}.

-file("src/sqlode/internal/codegen/adapter.gleam", 918).
?DOC(false).
-spec render_sqlight_exec_rows_result() -> list(binary()).
render_sqlight_exec_rows_result() ->
    lists:append(
        [[<<"  |> result.try(fn(_) {"/utf8>>,
                <<"    sqlight.query("/utf8>>,
                <<"      \"SELECT changes()\","/utf8>>,
                <<"      on: db,"/utf8>>,
                <<"      with: [],"/utf8>>,
                <<"      expecting: decode.at([0], decode.int),"/utf8>>,
                <<"    )"/utf8>>,
                <<"  })"/utf8>>],
            render_first_or_default(
                <<"rows"/utf8>>,
                <<"rows"/utf8>>,
                <<"0"/utf8>>
            )]
    ).

-file("src/sqlode/internal/codegen/adapter.gleam", 934).
?DOC(false).
-spec render_sqlight_exec_last_id(
    binary(),
    binary(),
    binary(),
    list(sqlode@internal@model:query_param())
) -> list(binary()).
render_sqlight_exec_last_id(_, _, _, Params) ->
    Prepare_line = case gleam@list:is_empty(Params) of
        true ->
            <<"  let #(sql, values) = runtime.prepare(q, Nil)"/utf8>>;

        false ->
            <<"  let #(sql, values) = runtime.prepare(q, p)"/utf8>>
    end,
    lists:append(
        [[Prepare_line,
                <<"  sqlight.query("/utf8>>,
                <<"    sql,"/utf8>>,
                <<"    on: db,"/utf8>>,
                <<"    with: list.map(values, value_to_sqlight),"/utf8>>,
                <<"    expecting: decode.success(Nil),"/utf8>>,
                <<"  )"/utf8>>,
                <<"  |> result.try(fn(_) {"/utf8>>,
                <<"    sqlight.query("/utf8>>,
                <<"      \"SELECT last_insert_rowid()\","/utf8>>,
                <<"      on: db,"/utf8>>,
                <<"      with: [],"/utf8>>,
                <<"      expecting: decode.at([0], decode.int),"/utf8>>,
                <<"    )"/utf8>>,
                <<"  })"/utf8>>],
            render_first_or_default(
                <<"rows"/utf8>>,
                <<"rows"/utf8>>,
                <<"0"/utf8>>
            )]
    ).

-file("src/sqlode/internal/codegen/adapter.gleam", 121).
?DOC(false).
-spec sqlight_adapter_config() -> adapter_config().
sqlight_adapter_config() ->
    {adapter_config,
        <<"import sqlight"/utf8>>,
        <<"sqlight.Connection"/utf8>>,
        <<"sqlight.Error"/utf8>>,
        fun(_capture) ->
            sqlode@internal@type_mapping:scalar_type_to_value_function(
                s_q_lite,
                _capture
            )
        end,
        fun(_capture@1) ->
            sqlode@internal@type_mapping:scalar_type_to_decoder(
                s_q_lite,
                _capture@1
            )
        end,
        fun render_sqlight_params/2,
        fun render_sqlight_query_call/5,
        fun render_sqlight_one_result/0,
        fun render_sqlight_many_result/0,
        fun render_sqlight_exec_rows_result/0,
        fun render_sqlight_exec_last_id/4,
        <<"?"/utf8>>,
        sqlight_value_to_driver_helper(),
        <<"decode.success(Nil)"/utf8>>}.

-file("src/sqlode/internal/codegen/adapter.gleam", 1024).
?DOC(false).
-spec render_shork_exec_last_id(
    binary(),
    binary(),
    binary(),
    list(sqlode@internal@model:query_param())
) -> list(binary()).
render_shork_exec_last_id(_, _, _, Params) ->
    lists:append(
        [render_prepare_lines(
                <<"shork"/utf8>>,
                <<"value_to_shork"/utf8>>,
                Params
            ),
            [<<"  |> shork.returning({"/utf8>>,
                <<"    use id <- decode.field(0, decode.int)"/utf8>>,
                <<"    decode.success(id)"/utf8>>,
                <<"  })"/utf8>>,
                <<"  |> shork.execute(db)"/utf8>>],
            render_first_or_default(
                <<"returned"/utf8>>,
                <<"returned.rows"/utf8>>,
                <<"0"/utf8>>
            )]
    ).

-file("src/sqlode/internal/codegen/adapter.gleam", 168).
?DOC(false).
-spec shork_adapter_config() -> adapter_config().
shork_adapter_config() ->
    {adapter_config,
        <<"import shork"/utf8>>,
        <<"shork.Connection"/utf8>>,
        <<"shork.QueryError"/utf8>>,
        fun(_capture) ->
            sqlode@internal@type_mapping:scalar_type_to_value_function(
                my_s_q_l,
                _capture
            )
        end,
        fun(_capture@1) ->
            sqlode@internal@type_mapping:scalar_type_to_decoder(
                my_s_q_l,
                _capture@1
            )
        end,
        fun render_shork_params/2,
        fun render_shork_query_call/5,
        fun render_shork_one_result/0,
        fun render_shork_many_result/0,
        fun render_shork_exec_rows_result/0,
        fun render_shork_exec_last_id/4,
        <<"?"/utf8>>,
        shork_value_to_driver_helper(),
        <<"{
    use affected <- decode.field(1, decode.int)
    decode.success(affected)
  }"/utf8>>}.

-file("src/sqlode/internal/codegen/adapter.gleam", 1121).
?DOC(false).
-spec adapter_query_uses_option_constructors(
    sqlode@internal@model:analyzed_query()
) -> boolean().
adapter_query_uses_option_constructors(Query) ->
    (erlang:element(4, erlang:element(2, Query)) =:= one) orelse (erlang:element(
        4,
        erlang:element(2, Query)
    )
    =:= batch_one).

-file("src/sqlode/internal/codegen/adapter.gleam", 1098).
?DOC(false).
-spec adapter_needs_option_type(list(sqlode@internal@model:analyzed_query())) -> boolean().
adapter_needs_option_type(Queries) ->
    gleam@list:any(
        Queries,
        fun(Query) ->
            Has_nullable_params = gleam@list:any(
                erlang:element(3, Query),
                fun(Param) -> erlang:element(5, Param) end
            ),
            Has_nullable_results = gleam@list:any(
                erlang:element(4, Query),
                fun(Col) -> case Col of
                        {scalar_result, {result_column, _, _, true, _}} ->
                            true;

                        {scalar_result, _} ->
                            false;

                        {embedded_result, {embedded_column, _, _, Columns}} ->
                            gleam@list:any(
                                Columns,
                                fun(C) -> erlang:element(4, C) end
                            )
                    end end
            ),
            (Has_nullable_params orelse Has_nullable_results) orelse adapter_query_uses_option_constructors(
                Query
            )
        end
    ).

-file("src/sqlode/internal/codegen/adapter.gleam", 1117).
?DOC(false).
-spec adapter_needs_option_constructors(
    list(sqlode@internal@model:analyzed_query())
) -> boolean().
adapter_needs_option_constructors(Queries) ->
    gleam@list:any(Queries, fun adapter_query_uses_option_constructors/1).

-file("src/sqlode/internal/codegen/adapter.gleam", 1083).
?DOC(false).
-spec adapter_option_import(list(sqlode@internal@model:analyzed_query())) -> list(binary()).
adapter_option_import(Queries) ->
    Needs_type = adapter_needs_option_type(Queries),
    Needs_constructors = adapter_needs_option_constructors(Queries),
    case {Needs_type, Needs_constructors} of
        {false, false} ->
            [];

        {true, true} ->
            [<<"import gleam/option.{type Option, None, Some}"/utf8>>];

        {true, false} ->
            [<<"import gleam/option.{type Option}"/utf8>>];

        {false, true} ->
            [<<"import gleam/option.{None, Some}"/utf8>>]
    end.

-file("src/sqlode/internal/codegen/adapter.gleam", 231).
?DOC(false).
-spec render_adapter(
    sqlode@internal@naming:naming_context(),
    sqlode@internal@model:sql_block(),
    list(sqlode@internal@model:analyzed_query()),
    gleam@dict:dict(binary(), binary()),
    adapter_config()
) -> binary().
render_adapter(Naming_ctx, Block, Queries, Table_matches, Config) ->
    {sql_block, _, _, _, _, Gleam, _} = Block,
    {gleam_output, Out, _, _, _, _, _, _, _, _} = Gleam,
    Module_path = sqlode@internal@codegen@common:out_to_module_path(Out),
    Has_results = gleam@list:any(
        Queries,
        fun(Query) ->
            sqlode@internal@model:is_result_command(
                erlang:element(4, erlang:element(2, Query))
            )
            andalso not gleam@list:is_empty(erlang:element(4, Query))
        end
    ),
    Has_params = gleam@list:any(
        Queries,
        fun(Q) -> not gleam@list:is_empty(erlang:element(3, Q)) end
    ),
    Has_enums = sqlode@internal@codegen@common:queries_have_enums(Queries),
    Imports = lists:append(
        [[<<"// Code generated by sqlode. DO NOT EDIT."/utf8>>,
                <<""/utf8>>,
                <<"import gleam/dynamic/decode"/utf8>>],
            case Has_params of
                true ->
                    [<<"import gleam/list"/utf8>>];

                false ->
                    []
            end,
            [<<"import gleam/result"/utf8>>],
            adapter_option_import(Queries),
            [erlang:element(2, Config)],
            [<<"import "/utf8,
                    (sqlode@internal@codegen@common:runtime_import_path(Gleam))/binary>>],
            case Has_results orelse Has_enums of
                true ->
                    [<<<<"import "/utf8, Module_path/binary>>/binary,
                            "/models"/utf8>>];

                false ->
                    []
            end,
            case gleam@list:any(
                Queries,
                fun(Q@1) -> not gleam@list:is_empty(erlang:element(3, Q@1)) end
            ) of
                true ->
                    [<<<<"import "/utf8, Module_path/binary>>/binary,
                            "/params"/utf8>>];

                false ->
                    []
            end,
            [<<<<"import "/utf8, Module_path/binary>>/binary, "/queries"/utf8>>]]
    ),
    Ctx = {render_context,
        Naming_ctx,
        Config,
        Table_matches,
        erlang:element(5, Gleam),
        erlang:element(6, Gleam),
        erlang:element(4, Gleam)},
    Functions = begin
        _pipe = Queries,
        _pipe@1 = gleam@list:map(
            _pipe,
            fun(_capture) -> render_adapter_function(Ctx, _capture) end
        ),
        gleam@string:join(_pipe@1, <<"\n\n"/utf8>>)
    end,
    Helper = value_to_driver_helper(Config),
    gleam@string:join(
        lists:append([Imports, [<<""/utf8>>, Helper, <<""/utf8>>, Functions]]),
        <<"\n"/utf8>>
    ).

-file("src/sqlode/internal/codegen/adapter.gleam", 61).
?DOC(false).
-spec render(
    sqlode@internal@naming:naming_context(),
    sqlode@internal@model:sql_block(),
    list(sqlode@internal@model:analyzed_query()),
    gleam@dict:dict(binary(), binary())
) -> binary().
render(Naming_ctx, Block, Queries, Table_matches) ->
    case erlang:element(3, Block) of
        postgre_s_q_l ->
            render_adapter(
                Naming_ctx,
                Block,
                Queries,
                Table_matches,
                pog_adapter_config()
            );

        s_q_lite ->
            render_adapter(
                Naming_ctx,
                Block,
                Queries,
                Table_matches,
                sqlight_adapter_config()
            );

        my_s_q_l ->
            render_adapter(
                Naming_ctx,
                Block,
                Queries,
                Table_matches,
                shork_adapter_config()
            )
    end.