-module(cake@insert).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/cake/insert.gleam").
-export([to_query/1, row/1, bool/1, float/1, int/1, string/1, null/0, date/1, fragment/1, new/0, from_records/4, from_values/3, table/2, get_table/1, modifier/2, no_modifier/1, get_modifier/1, source_records/3, source_values/2, get_source/1, columns/2, get_columns/1, on_conflict_error/1, on_columns_conflict_ignore/3, on_constraint_conflict_ignore/3, on_columns_conflict_update/4, on_constraint_conflict_update/4, get_on_conflict/1, on_duplicate_key_update/2, returning/2, no_returning/1, epilog/2, no_epilog/1, get_epilog/1, comment/2, no_comment/1, get_comment/1]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC(
    " A DSL to build `INSERT` queries.\n"
    "\n"
).

-file("src/cake/insert.gleam", 66).
?DOC(" Creates a `WriteQuery` from an `Insert` query.\n").
-spec to_query(cake@internal@write_query:insert(FNY)) -> cake@internal@write_query:write_query(FNY).
to_query(Insert) ->
    _pipe = Insert,
    {insert_query, _pipe}.

-file("src/cake/insert.gleam", 74).
?DOC(" Create an `InsertRow` from a list of `InsertValue`s.\n").
-spec row(list(cake@internal@write_query:insert_value())) -> cake@internal@write_query:insert_row().
row(Values) ->
    _pipe = Values,
    {insert_row, _pipe}.

-file("src/cake/insert.gleam", 80).
?DOC(" Create an `InsertValue` from a column `String` and a `Bool` value.\n").
-spec bool(boolean()) -> cake@internal@write_query:insert_value().
bool(Value) ->
    _pipe = Value,
    _pipe@1 = {bool_param, _pipe},
    {insert_param, _pipe@1}.

-file("src/cake/insert.gleam", 86).
?DOC(" Create an `InsertValue` from a column `String` and a `Float` value.\n").
-spec float(float()) -> cake@internal@write_query:insert_value().
float(Value) ->
    _pipe = Value,
    _pipe@1 = {float_param, _pipe},
    {insert_param, _pipe@1}.

-file("src/cake/insert.gleam", 92).
?DOC(" Create an `InsertValue` from a column `String` and an `Int` value.\n").
-spec int(integer()) -> cake@internal@write_query:insert_value().
int(Value) ->
    _pipe = Value,
    _pipe@1 = {int_param, _pipe},
    {insert_param, _pipe@1}.

-file("src/cake/insert.gleam", 98).
?DOC(" Create an `InsertValue` from a column `String` and a `String` value.\n").
-spec string(binary()) -> cake@internal@write_query:insert_value().
string(Value) ->
    _pipe = Value,
    _pipe@1 = {string_param, _pipe},
    {insert_param, _pipe@1}.

-file("src/cake/insert.gleam", 104).
?DOC(" Create a NULL `InsertValue`.\n").
-spec null() -> cake@internal@write_query:insert_value().
null() ->
    _pipe = null_param,
    {insert_param, _pipe}.

-file("src/cake/insert.gleam", 110).
?DOC(" Create an `InsertValue` from a `calendar.Date`.\n").
-spec date(gleam@time@calendar:date()) -> cake@internal@write_query:insert_value().
date(Value) ->
    _pipe = Value,
    _pipe@1 = {date_param, _pipe},
    {insert_param, _pipe@1}.

-file("src/cake/insert.gleam", 125).
?DOC(
    " Create an `InsertValue` from a `Fragment`.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import cake/fragment as f\n"
    " import cake/insert as i\n"
    "\n"
    " i.fragment(f.prepared(\"$::uuid\", [f.string(\"0000000000-0000-4000-a000-a00000000000\")]))\n"
    " ```\n"
).
-spec fragment(cake@internal@read_query:fragment()) -> cake@internal@write_query:insert_value().
fragment(Value) ->
    {insert_fragment, Value}.

-file("src/cake/insert.gleam", 133).
?DOC(" Create an empty `INSERT` query.\n").
-spec new() -> cake@internal@write_query:insert(any()).
new() ->
    {insert,
        no_insert_into_table,
        no_insert_columns,
        no_insert_modifier,
        no_insert_source,
        insert_conflict_error,
        no_returning,
        no_epilog,
        no_comment}.

-file("src/cake/insert.gleam", 150).
?DOC(
    " Create an `INSERT` query from a list of gleam records.\n"
    "\n"
    " The `encoder` function is used to convert each record into an `InsertRow`.\n"
).
-spec from_records(
    binary(),
    list(binary()),
    list(FOF),
    fun((FOF) -> cake@internal@write_query:insert_row())
) -> cake@internal@write_query:insert(FOF).
from_records(Table_name, Columns, Records, Encoder) ->
    {insert,
        begin
            _pipe = Table_name,
            {insert_into_table, _pipe}
        end,
        begin
            _pipe@1 = Columns,
            {insert_columns, _pipe@1}
        end,
        no_insert_modifier,
        begin
            _pipe@2 = Records,
            {insert_source_records, _pipe@2, Encoder}
        end,
        insert_conflict_error,
        no_returning,
        no_epilog,
        no_comment}.

-file("src/cake/insert.gleam", 170).
?DOC(" Create an `INSERT` query from a list of `InsertRow`s.\n").
-spec from_values(
    binary(),
    list(binary()),
    list(cake@internal@write_query:insert_row())
) -> cake@internal@write_query:insert(any()).
from_values(Table_name, Columns, Values) ->
    {insert,
        begin
            _pipe = Table_name,
            {insert_into_table, _pipe}
        end,
        begin
            _pipe@1 = Columns,
            {insert_columns, _pipe@1}
        end,
        no_insert_modifier,
        begin
            _pipe@2 = Values,
            {insert_source_rows, _pipe@2}
        end,
        insert_conflict_error,
        no_returning,
        no_epilog,
        no_comment}.

-file("src/cake/insert.gleam", 191).
?DOC(" Specify the table to insert into.\n").
-spec table(cake@internal@write_query:insert(FOM), binary()) -> cake@internal@write_query:insert(FOM).
table(Insert, Table_name) ->
    {insert,
        begin
            _pipe = Table_name,
            {insert_into_table, _pipe}
        end,
        erlang:element(3, Insert),
        erlang:element(4, Insert),
        erlang:element(5, Insert),
        erlang:element(6, Insert),
        erlang:element(7, Insert),
        erlang:element(8, Insert),
        erlang:element(9, Insert)}.

-file("src/cake/insert.gleam", 200).
?DOC(" Get the table name to insert into from an `Insert` query.\n").
-spec get_table(cake@internal@write_query:insert(any())) -> cake@internal@write_query:insert_into_table().
get_table(Insert) ->
    erlang:element(2, Insert).

-file("src/cake/insert.gleam", 208).
?DOC(" Specify a modifier for the `INSERT` query.\n").
-spec modifier(cake@internal@write_query:insert(FOR), binary()) -> cake@internal@write_query:insert(FOR).
modifier(Insert, Modifier) ->
    Modifier@1 = begin
        _pipe = Modifier,
        gleam@string:trim(_pipe)
    end,
    case Modifier@1 of
        <<""/utf8>> ->
            {insert,
                erlang:element(2, Insert),
                erlang:element(3, Insert),
                no_insert_modifier,
                erlang:element(5, Insert),
                erlang:element(6, Insert),
                erlang:element(7, Insert),
                erlang:element(8, Insert),
                erlang:element(9, Insert)};

        _ ->
            {insert,
                erlang:element(2, Insert),
                erlang:element(3, Insert),
                begin
                    _pipe@1 = Modifier@1,
                    {insert_modifier, _pipe@1}
                end,
                erlang:element(5, Insert),
                erlang:element(6, Insert),
                erlang:element(7, Insert),
                erlang:element(8, Insert),
                erlang:element(9, Insert)}
    end.

-file("src/cake/insert.gleam", 221).
?DOC(" Specify that no modifier should be used for the given `INSERT` query.\n").
-spec no_modifier(cake@internal@write_query:insert(FOU)) -> cake@internal@write_query:insert(FOU).
no_modifier(Insert) ->
    {insert,
        erlang:element(2, Insert),
        erlang:element(3, Insert),
        no_insert_modifier,
        erlang:element(5, Insert),
        erlang:element(6, Insert),
        erlang:element(7, Insert),
        erlang:element(8, Insert),
        erlang:element(9, Insert)}.

-file("src/cake/insert.gleam", 227).
?DOC(" Get the modifier from an `Insert` query.\n").
-spec get_modifier(cake@internal@write_query:insert(any())) -> binary().
get_modifier(Insert) ->
    case erlang:element(4, Insert) of
        no_insert_modifier ->
            <<""/utf8>>;

        {insert_modifier, Keyword} ->
            Keyword
    end.

-file("src/cake/insert.gleam", 238).
?DOC(" Specify the source records to insert.\n").
-spec source_records(
    cake@internal@write_query:insert(FOZ),
    list(FOZ),
    fun((FOZ) -> cake@internal@write_query:insert_row())
) -> cake@internal@write_query:insert(FOZ).
source_records(Insert, Records, Encoder) ->
    {insert,
        erlang:element(2, Insert),
        erlang:element(3, Insert),
        erlang:element(4, Insert),
        begin
            _pipe = Records,
            {insert_source_records, _pipe, Encoder}
        end,
        erlang:element(6, Insert),
        erlang:element(7, Insert),
        erlang:element(8, Insert),
        erlang:element(9, Insert)}.

-file("src/cake/insert.gleam", 248).
?DOC(" Specify the source values to insert.\n").
-spec source_values(
    cake@internal@write_query:insert(FPD),
    list(cake@internal@write_query:insert_row())
) -> cake@internal@write_query:insert(FPD).
source_values(Insert, Rows) ->
    {insert,
        erlang:element(2, Insert),
        erlang:element(3, Insert),
        erlang:element(4, Insert),
        begin
            _pipe = Rows,
            {insert_source_rows, _pipe}
        end,
        erlang:element(6, Insert),
        erlang:element(7, Insert),
        erlang:element(8, Insert),
        erlang:element(9, Insert)}.

-file("src/cake/insert.gleam", 258).
?DOC(
    " Get the source from an `Insert` query which is either a list of records,\n"
    " accompanied by an encoder function or a list of `InsertRow`s.\n"
).
-spec get_source(cake@internal@write_query:insert(FPH)) -> cake@internal@write_query:insert_source(FPH).
get_source(Insert) ->
    erlang:element(5, Insert).

-file("src/cake/insert.gleam", 269).
?DOC(
    " Specify the columns to insert into.\n"
    "\n"
    " NOTICE: You have to specify the columns and ensure their names are\n"
    " correct, as well as their count which must be equal to the count of\n"
    " `InsertRows` the encoder function returns or is given as source\n"
    "          values.\n"
).
-spec columns(cake@internal@write_query:insert(FPK), list(binary())) -> cake@internal@write_query:insert(FPK).
columns(Insert, Columns) ->
    {insert,
        erlang:element(2, Insert),
        begin
            _pipe = Columns,
            {insert_columns, _pipe}
        end,
        erlang:element(4, Insert),
        erlang:element(5, Insert),
        erlang:element(6, Insert),
        erlang:element(7, Insert),
        erlang:element(8, Insert),
        erlang:element(9, Insert)}.

-file("src/cake/insert.gleam", 278).
?DOC(" Get the columns to insert into from an `Insert` query.\n").
-spec get_columns(cake@internal@write_query:insert(any())) -> cake@internal@write_query:insert_columns().
get_columns(Insert) ->
    erlang:element(3, Insert).

-file("src/cake/insert.gleam", 288).
?DOC(
    " This specifies that any conflicts result in the query to fail\n"
    "\n"
    " This is the default behaviour.\n"
).
-spec on_conflict_error(cake@internal@write_query:insert(FPQ)) -> cake@internal@write_query:insert(FPQ).
on_conflict_error(Insert) ->
    {insert,
        erlang:element(2, Insert),
        erlang:element(3, Insert),
        erlang:element(4, Insert),
        erlang:element(5, Insert),
        insert_conflict_error,
        erlang:element(7, Insert),
        erlang:element(8, Insert),
        erlang:element(9, Insert)}.

-file("src/cake/insert.gleam", 297).
?DOC(
    " This specifies that specific conflicts do not result in an error but instead\n"
    " are just ignored and not inserted.\n"
    "\n"
    " Conflict Target: Columns\n"
).
-spec on_columns_conflict_ignore(
    cake@internal@write_query:insert(FPT),
    list(binary()),
    cake@internal@read_query:where()
) -> cake@internal@write_query:insert(FPT).
on_columns_conflict_ignore(Insert, Columns, Where) ->
    {insert,
        erlang:element(2, Insert),
        erlang:element(3, Insert),
        erlang:element(4, Insert),
        erlang:element(5, Insert),
        {insert_conflict_ignore,
            begin
                _pipe = Columns,
                {insert_conflict_target, _pipe}
            end,
            Where},
        erlang:element(7, Insert),
        erlang:element(8, Insert),
        erlang:element(9, Insert)}.

-file("src/cake/insert.gleam", 316).
?DOC(
    " This specifies that specific conflicts do not result in an error but instead\n"
    " are just ignored and not inserted.\n"
    "\n"
    " Conflict Target: Constraint\n"
).
-spec on_constraint_conflict_ignore(
    cake@internal@write_query:insert(FPX),
    binary(),
    cake@internal@read_query:where()
) -> cake@internal@write_query:insert(FPX).
on_constraint_conflict_ignore(Insert, Constraint, Where) ->
    {insert,
        erlang:element(2, Insert),
        erlang:element(3, Insert),
        erlang:element(4, Insert),
        erlang:element(5, Insert),
        {insert_conflict_ignore,
            begin
                _pipe = Constraint,
                {insert_conflict_target_constraint, _pipe}
            end,
            Where},
        erlang:element(7, Insert),
        erlang:element(8, Insert),
        erlang:element(9, Insert)}.

-file("src/cake/insert.gleam", 352).
?DOC(
    " Inserts or updates on conflict, also called ´UPSERT´.\n"
    "\n"
    " This function generates PostgreSQL/SQLite-specific upsert queries using\n"
    " `ON CONFLICT ... DO UPDATE` syntax.\n"
    "\n"
    " **For MySQL/MariaDB, use `on_duplicate_key_update()` instead.**\n"
    "\n"
    " Conflict Target: Columns\n"
    "\n"
    " ## Important\n"
    "\n"
    " - Use `excluded.column` in UPDATE expressions to reference insert values\n"
    " - Explicitly specify which columns to check for conflicts\n"
    " - Supports optional WHERE clause for conditional updates\n"
    "\n"
    " ## Database Support\n"
    "\n"
    " - **🐘PostgreSQL**: ✅ Fully supported\n"
    " - **🪶SQLite**: ✅ Fully supported\n"
    " - **🦭MariaDB**: ❌ Not supported - use `on_duplicate_key_update()`\n"
    " - **🐬MySQL**: ❌ Not supported - use `on_duplicate_key_update()`\n"
).
-spec on_columns_conflict_update(
    cake@internal@write_query:insert(FQA),
    list(binary()),
    cake@internal@read_query:where(),
    cake@internal@write_query:update(FQA)
) -> cake@internal@write_query:insert(FQA).
on_columns_conflict_update(Insert, Columns, Where, Update) ->
    {insert,
        erlang:element(2, Insert),
        erlang:element(3, Insert),
        erlang:element(4, Insert),
        erlang:element(5, Insert),
        {insert_conflict_update,
            begin
                _pipe = Columns,
                {insert_conflict_target, _pipe}
            end,
            Where,
            Update},
        erlang:element(7, Insert),
        erlang:element(8, Insert),
        erlang:element(9, Insert)}.

-file("src/cake/insert.gleam", 385).
?DOC(
    " Inserts or updates on conflict, also called ´UPSERT´.\n"
    "\n"
    " This function generates PostgreSQL-specific upsert queries using\n"
    " `ON CONFLICT ON CONSTRAINT ... DO UPDATE` syntax.\n"
    "\n"
    " **For MySQL/MariaDB, use `on_duplicate_key_update()` instead.**\n"
    " **For SQLite, use `on_columns_conflict_update()` instead.**\n"
    "\n"
    " Conflict Target: Named Constraint\n"
    "\n"
    " ## Database Support\n"
    "\n"
    " - **🐘PostgreSQL**: ✅ Fully supported\n"
    " - **🪶SQLite**: ❌ Not supported - use `on_columns_conflict_update()`\n"
    " - **🦭MariaDB**: ❌ Not supported - use `on_duplicate_key_update()`\n"
    " - **🐬MySQL**: ❌ Not supported - use `on_duplicate_key_update()`\n"
).
-spec on_constraint_conflict_update(
    cake@internal@write_query:insert(FQF),
    binary(),
    cake@internal@read_query:where(),
    cake@internal@write_query:update(FQF)
) -> cake@internal@write_query:insert(FQF).
on_constraint_conflict_update(Insert, Constraint, Where, Update) ->
    {insert,
        erlang:element(2, Insert),
        erlang:element(3, Insert),
        erlang:element(4, Insert),
        erlang:element(5, Insert),
        {insert_conflict_update,
            begin
                _pipe = Constraint,
                {insert_conflict_target_constraint, _pipe}
            end,
            Where,
            Update},
        erlang:element(7, Insert),
        erlang:element(8, Insert),
        erlang:element(9, Insert)}.

-file("src/cake/insert.gleam", 403).
?DOC(" Get the conflict strategy from an `Insert` query.\n").
-spec get_on_conflict(cake@internal@write_query:insert(FQJ)) -> cake@internal@write_query:insert_conflict_strategy(FQJ).
get_on_conflict(Insert) ->
    erlang:element(6, Insert).

-file("src/cake/insert.gleam", 450).
?DOC(
    " MySQL/MariaDB upsert using `ON DUPLICATE KEY UPDATE` syntax.\n"
    "\n"
    " This function generates MySQL/MariaDB-specific upsert queries.\n"
    " **Only use this when targeting MySQL or MariaDB databases.**\n"
    "\n"
    " For PostgreSQL/SQLite, use `on_columns_conflict_update()` or\n"
    " `on_constraint_conflict_update()` instead.\n"
    "\n"
    " ## Important\n"
    "\n"
    " - Use `VALUES(column)` (not `excluded.column`) in your UPDATE expressions\n"
    " - Updates occur on the **first** matched unique/primary key constraint\n"
    " - No explicit conflict target - relies on existing indexes\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import cake/insert as i\n"
    " import cake/update as u\n"
    "\n"
    " [[i.string(\"user1\"), i.int(100)] |> i.row]\n"
    " |> i.from_values(table_name: \"scores\", columns: [\"username\", \"score\"])\n"
    " |> i.on_duplicate_key_update(\n"
    "   update: u.new()\n"
    "     |> u.set(\"score\" |> u.set_expression(\"VALUES(score) + scores.score\")),\n"
    " )\n"
    " ```\n"
    "\n"
    " Generates:\n"
    " ```sql\n"
    " INSERT INTO scores (username, score) VALUES (?, ?)\n"
    " ON DUPLICATE KEY UPDATE score = VALUES(score) + scores.score\n"
    " ```\n"
    "\n"
    " ## Database Support\n"
    "\n"
    " - **🦭MariaDB**: ✅ Supported\n"
    " - **🐬MySQL**: ✅ Supported\n"
    " - **🐘PostgreSQL**: ❌ Not supported - use `on_columns_conflict_update()`\n"
    " - **🪶SQLite**: ❌ Not supported - use `on_columns_conflict_update()`\n"
).
-spec on_duplicate_key_update(
    cake@internal@write_query:insert(FQM),
    cake@internal@write_query:update(FQM)
) -> cake@internal@write_query:insert(FQM).
on_duplicate_key_update(Insert, Update) ->
    {insert,
        erlang:element(2, Insert),
        erlang:element(3, Insert),
        erlang:element(4, Insert),
        erlang:element(5, Insert),
        {insert_duplicate_key_update, Update},
        erlang:element(7, Insert),
        erlang:element(8, Insert),
        erlang:element(9, Insert)}.

-file("src/cake/insert.gleam", 461).
?DOC(" Specify the columns to return after the `INSERT` query.\n").
-spec returning(cake@internal@write_query:insert(FQQ), list(binary())) -> cake@internal@write_query:insert(FQQ).
returning(Insert, Returning) ->
    case Returning of
        [] ->
            {insert,
                erlang:element(2, Insert),
                erlang:element(3, Insert),
                erlang:element(4, Insert),
                erlang:element(5, Insert),
                erlang:element(6, Insert),
                no_returning,
                erlang:element(8, Insert),
                erlang:element(9, Insert)};

        _ ->
            {insert,
                erlang:element(2, Insert),
                erlang:element(3, Insert),
                erlang:element(4, Insert),
                erlang:element(5, Insert),
                erlang:element(6, Insert),
                begin
                    _pipe = Returning,
                    {returning, _pipe}
                end,
                erlang:element(8, Insert),
                erlang:element(9, Insert)}
    end.

-file("src/cake/insert.gleam", 473).
?DOC(" Specify that no columns should be returned after the `INSERT` query.\n").
-spec no_returning(cake@internal@write_query:insert(FQU)) -> cake@internal@write_query:insert(FQU).
no_returning(Insert) ->
    {insert,
        erlang:element(2, Insert),
        erlang:element(3, Insert),
        erlang:element(4, Insert),
        erlang:element(5, Insert),
        erlang:element(6, Insert),
        no_returning,
        erlang:element(8, Insert),
        erlang:element(9, Insert)}.

-file("src/cake/insert.gleam", 481).
?DOC(" Specify an epilog for the `INSERT` query.\n").
-spec epilog(cake@internal@write_query:insert(FQX), binary()) -> cake@internal@write_query:insert(FQX).
epilog(Insert, Epilog) ->
    Epilog@1 = begin
        _pipe = Epilog,
        gleam@string:trim(_pipe)
    end,
    case Epilog@1 of
        <<""/utf8>> ->
            {insert,
                erlang:element(2, Insert),
                erlang:element(3, Insert),
                erlang:element(4, Insert),
                erlang:element(5, Insert),
                erlang:element(6, Insert),
                erlang:element(7, Insert),
                no_epilog,
                erlang:element(9, Insert)};

        _ ->
            {insert,
                erlang:element(2, Insert),
                erlang:element(3, Insert),
                erlang:element(4, Insert),
                erlang:element(5, Insert),
                erlang:element(6, Insert),
                erlang:element(7, Insert),
                begin
                    _pipe@1 = (<<" "/utf8, Epilog@1/binary>>),
                    {epilog, _pipe@1}
                end,
                erlang:element(9, Insert)}
    end.

-file("src/cake/insert.gleam", 491).
?DOC(" Specify that no epilog should be added to the `INSERT` query.\n").
-spec no_epilog(cake@internal@write_query:insert(FRA)) -> cake@internal@write_query:insert(FRA).
no_epilog(Insert) ->
    {insert,
        erlang:element(2, Insert),
        erlang:element(3, Insert),
        erlang:element(4, Insert),
        erlang:element(5, Insert),
        erlang:element(6, Insert),
        erlang:element(7, Insert),
        no_epilog,
        erlang:element(9, Insert)}.

-file("src/cake/insert.gleam", 497).
?DOC(" Get the epilog from an `INSERT` query.\n").
-spec get_epilog(cake@internal@write_query:insert(any())) -> cake@internal@read_query:epilog().
get_epilog(Insert) ->
    erlang:element(8, Insert).

-file("src/cake/insert.gleam", 505).
?DOC(" Specify a comment for the `INSERT` query.\n").
-spec comment(cake@internal@write_query:insert(FRF), binary()) -> cake@internal@write_query:insert(FRF).
comment(Insert, Comment) ->
    Comment@1 = begin
        _pipe = Comment,
        gleam@string:trim(_pipe)
    end,
    case Comment@1 of
        <<""/utf8>> ->
            {insert,
                erlang:element(2, Insert),
                erlang:element(3, Insert),
                erlang:element(4, Insert),
                erlang:element(5, Insert),
                erlang:element(6, Insert),
                erlang:element(7, Insert),
                erlang:element(8, Insert),
                no_comment};

        _ ->
            {insert,
                erlang:element(2, Insert),
                erlang:element(3, Insert),
                erlang:element(4, Insert),
                erlang:element(5, Insert),
                erlang:element(6, Insert),
                erlang:element(7, Insert),
                erlang:element(8, Insert),
                begin
                    _pipe@1 = (<<" "/utf8, Comment@1/binary>>),
                    {comment, _pipe@1}
                end}
    end.

-file("src/cake/insert.gleam", 515).
?DOC(" Specify that no comment should be added to the `INSERT` query.\n").
-spec no_comment(cake@internal@write_query:insert(FRI)) -> cake@internal@write_query:insert(FRI).
no_comment(Insert) ->
    {insert,
        erlang:element(2, Insert),
        erlang:element(3, Insert),
        erlang:element(4, Insert),
        erlang:element(5, Insert),
        erlang:element(6, Insert),
        erlang:element(7, Insert),
        erlang:element(8, Insert),
        no_comment}.

-file("src/cake/insert.gleam", 521).
?DOC(" Get the comment from an `INSERT` query.\n").
-spec get_comment(cake@internal@write_query:insert(any())) -> cake@internal@read_query:comment().
get_comment(Insert) ->
    erlang:element(9, Insert).