-module(cquill@query).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/cquill/query.gleam").
-export([from/1, from_table/1, from_qualified/2, from_subquery/1, select/2, select_all/1, select_expr/2, distinct/1, where/2, or_where/2, where_replace/2, where_clear/1, like/2, not_like/2, ilike/2, not_ilike/2, is_null/1, is_not_null/1, 'and'/1, 'or'/1, 'not'/1, eq/2, not_eq/2, gt/2, gte/2, lt/2, lte/2, is_in/2, is_not_in/2, between/3, int_value/1, float_value/1, string_value/1, bool_value/1, null_value/0, list_value/1, eq_int/2, eq_string/2, eq_bool/2, gt_int/2, lt_int/2, gte_int/2, lte_int/2, in_ints/2, in_strings/2, order_by/3, order_by_asc/2, order_by_desc/2, order_by_with_nulls/4, order_by_clear/1, limit/2, offset/2, paginate/3, no_pagination/1, join/3, join_as/4, left_join/3, left_join_as/4, right_join/3, full_join/3, cross_join/2, group_by/2, group_by_fields/2, having/2, get_conditions/1, get_order_bys/1, get_select/1, get_limit/1, get_offset/1, get_joins/1, get_source/1, has_conditions/1, has_order_by/1, has_pagination/1, is_distinct/1, condition_count/1, to_debug_string/1]).
-export_type([dyn_value/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.

-type dyn_value() :: {int_val, integer()} |
    {float_val, float()} |
    {string_val, binary()} |
    {bool_val, boolean()} |
    nil_val |
    {list_val, list(dyn_value())} |
    unknown_val.

-file("src/cquill/query.gleam", 44).
?DOC(
    " Create a new query from a schema.\n"
    " This is the primary entry point for building queries.\n"
    "\n"
    " ## Example\n"
    " ```gleam\n"
    " let query = query.from(user_schema)\n"
    " ```\n"
).
-spec from(cquill@schema:schema()) -> cquill@query@ast:'query'(cquill@schema:schema()).
from(Schema) ->
    Source = case erlang:element(3, Schema) of
        {some, Schema_name} ->
            {table_source, erlang:element(2, Schema), {some, Schema_name}};

        none ->
            {table_source, erlang:element(2, Schema), none}
    end,
    {'query', Source, select_all, [], [], none, none, [], false, [], []}.

-file("src/cquill/query.gleam", 67).
?DOC(
    " Create a query from a table name directly (without schema metadata).\n"
    " Useful for simple queries or testing.\n"
).
-spec from_table(binary()) -> cquill@query@ast:'query'(nil).
from_table(Table) ->
    cquill@query@ast:new(Table).

-file("src/cquill/query.gleam", 72).
?DOC(" Create a query from a qualified table name (schema.table).\n").
-spec from_qualified(binary(), binary()) -> cquill@query@ast:'query'(nil).
from_qualified(Schema_name, Table) ->
    cquill@query@ast:new_qualified(Schema_name, Table).

-file("src/cquill/query.gleam", 94).
-spec coerce_query(cquill@query@ast:'query'(any())) -> cquill@query@ast:'query'(nil).
coerce_query(Query) ->
    {'query',
        Source,
        Select,
        Wheres,
        Order_bys,
        Limit,
        Offset,
        Joins,
        Distinct,
        Group_bys,
        Havings} = Query,
    {'query',
        Source,
        Select,
        Wheres,
        Order_bys,
        Limit,
        Offset,
        Joins,
        Distinct,
        Group_bys,
        Havings}.

-file("src/cquill/query.gleam", 77).
?DOC(" Create a query from a subquery.\n").
-spec from_subquery(cquill@query@ast:'query'(any())) -> cquill@query@ast:'query'(nil).
from_subquery(Subquery) ->
    Source = {subquery_source, coerce_query(Subquery)},
    {'query', Source, select_all, [], [], none, none, [], false, [], []}.

-file("src/cquill/query.gleam", 132).
?DOC(
    " Select specific fields by name.\n"
    "\n"
    " ## Example\n"
    " ```gleam\n"
    " user_query\n"
    " |> query.select([\"id\", \"email\", \"name\"])\n"
    " ```\n"
).
-spec select(cquill@query@ast:'query'(NZP), list(binary())) -> cquill@query@ast:'query'(NZP).
select(Query, Fields) ->
    {'query', _, _, _, _, _, _, _, _, _, _} = Query,
    {'query',
        erlang:element(2, Query),
        {select_fields, Fields},
        erlang:element(4, Query),
        erlang:element(5, Query),
        erlang:element(6, Query),
        erlang:element(7, Query),
        erlang:element(8, Query),
        erlang:element(9, Query),
        erlang:element(10, Query),
        erlang:element(11, Query)}.

-file("src/cquill/query.gleam", 139).
?DOC(
    " Select all fields (SELECT *).\n"
    " This is the default behavior.\n"
).
-spec select_all(cquill@query@ast:'query'(NZT)) -> cquill@query@ast:'query'(NZT).
select_all(Query) ->
    {'query', _, _, _, _, _, _, _, _, _, _} = Query,
    {'query',
        erlang:element(2, Query),
        select_all,
        erlang:element(4, Query),
        erlang:element(5, Query),
        erlang:element(6, Query),
        erlang:element(7, Query),
        erlang:element(8, Query),
        erlang:element(9, Query),
        erlang:element(10, Query),
        erlang:element(11, Query)}.

-file("src/cquill/query.gleam", 145).
?DOC(" Select with expressions (for computed columns, aggregates).\n").
-spec select_expr(
    cquill@query@ast:'query'(NZW),
    list(cquill@query@ast:select_expression())
) -> cquill@query@ast:'query'(NZW).
select_expr(Query, Expressions) ->
    {'query', _, _, _, _, _, _, _, _, _, _} = Query,
    {'query',
        erlang:element(2, Query),
        {select_expr, Expressions},
        erlang:element(4, Query),
        erlang:element(5, Query),
        erlang:element(6, Query),
        erlang:element(7, Query),
        erlang:element(8, Query),
        erlang:element(9, Query),
        erlang:element(10, Query),
        erlang:element(11, Query)}.

-file("src/cquill/query.gleam", 154).
?DOC(" Add DISTINCT to the query.\n").
-spec distinct(cquill@query@ast:'query'(OAA)) -> cquill@query@ast:'query'(OAA).
distinct(Query) ->
    {'query', _, _, _, _, _, _, _, _, _, _} = Query,
    {'query',
        erlang:element(2, Query),
        erlang:element(3, Query),
        erlang:element(4, Query),
        erlang:element(5, Query),
        erlang:element(6, Query),
        erlang:element(7, Query),
        erlang:element(8, Query),
        true,
        erlang:element(10, Query),
        erlang:element(11, Query)}.

-file("src/cquill/query.gleam", 172).
?DOC(
    " Add a WHERE condition to the query.\n"
    " Multiple where clauses are combined with AND.\n"
    "\n"
    " ## Example\n"
    " ```gleam\n"
    " user_query\n"
    " |> query.where(query.eq(\"active\", True))\n"
    " |> query.where(query.gt(\"age\", 18))\n"
    " ```\n"
).
-spec where(cquill@query@ast:'query'(OAD), cquill@query@ast:condition()) -> cquill@query@ast:'query'(OAD).
where(Query, Condition) ->
    {'query', _, _, Wheres, _, _, _, _, _, _, _} = Query,
    {'query',
        erlang:element(2, Query),
        erlang:element(3, Query),
        lists:append(Wheres, [{where, Condition}]),
        erlang:element(5, Query),
        erlang:element(6, Query),
        erlang:element(7, Query),
        erlang:element(8, Query),
        erlang:element(9, Query),
        erlang:element(10, Query),
        erlang:element(11, Query)}.

-file("src/cquill/query.gleam", 186).
?DOC(
    " Add an OR condition to the query.\n"
    " This wraps existing conditions and the new one in an OR.\n"
    "\n"
    " ## Example\n"
    " ```gleam\n"
    " user_query\n"
    " |> query.where(query.eq(\"role\", \"admin\"))\n"
    " |> query.or_where(query.eq(\"role\", \"moderator\"))\n"
    " ```\n"
).
-spec or_where(cquill@query@ast:'query'(OAG), cquill@query@ast:condition()) -> cquill@query@ast:'query'(OAG).
or_where(Query, Condition) ->
    {'query', _, _, Wheres, _, _, _, _, _, _, _} = Query,
    case Wheres of
        [] ->
            {'query',
                erlang:element(2, Query),
                erlang:element(3, Query),
                [{where, Condition}],
                erlang:element(5, Query),
                erlang:element(6, Query),
                erlang:element(7, Query),
                erlang:element(8, Query),
                erlang:element(9, Query),
                erlang:element(10, Query),
                erlang:element(11, Query)};

        Existing ->
            Existing_conditions = gleam@list:map(
                Existing,
                fun(W) -> erlang:element(2, W) end
            ),
            Combined = {'or', [{'and', Existing_conditions}, Condition]},
            {'query',
                erlang:element(2, Query),
                erlang:element(3, Query),
                [{where, Combined}],
                erlang:element(5, Query),
                erlang:element(6, Query),
                erlang:element(7, Query),
                erlang:element(8, Query),
                erlang:element(9, Query),
                erlang:element(10, Query),
                erlang:element(11, Query)}
    end.

-file("src/cquill/query.gleam", 199).
?DOC(" Replace all WHERE conditions with the given condition.\n").
-spec where_replace(cquill@query@ast:'query'(OAJ), cquill@query@ast:condition()) -> cquill@query@ast:'query'(OAJ).
where_replace(Query, Condition) ->
    {'query', _, _, _, _, _, _, _, _, _, _} = Query,
    {'query',
        erlang:element(2, Query),
        erlang:element(3, Query),
        [{where, Condition}],
        erlang:element(5, Query),
        erlang:element(6, Query),
        erlang:element(7, Query),
        erlang:element(8, Query),
        erlang:element(9, Query),
        erlang:element(10, Query),
        erlang:element(11, Query)}.

-file("src/cquill/query.gleam", 205).
?DOC(" Clear all WHERE conditions.\n").
-spec where_clear(cquill@query@ast:'query'(OAM)) -> cquill@query@ast:'query'(OAM).
where_clear(Query) ->
    {'query', _, _, _, _, _, _, _, _, _, _} = Query,
    {'query',
        erlang:element(2, Query),
        erlang:element(3, Query),
        [],
        erlang:element(5, Query),
        erlang:element(6, Query),
        erlang:element(7, Query),
        erlang:element(8, Query),
        erlang:element(9, Query),
        erlang:element(10, Query),
        erlang:element(11, Query)}.

-file("src/cquill/query.gleam", 255).
?DOC(" Create a LIKE condition: field LIKE pattern\n").
-spec like(binary(), binary()) -> cquill@query@ast:condition().
like(Field, Pattern) ->
    {like, Field, Pattern}.

-file("src/cquill/query.gleam", 260).
?DOC(" Create a NOT LIKE condition: field NOT LIKE pattern\n").
-spec not_like(binary(), binary()) -> cquill@query@ast:condition().
not_like(Field, Pattern) ->
    {not_like, Field, Pattern}.

-file("src/cquill/query.gleam", 268).
?DOC(
    " Create a case-insensitive LIKE condition: field ILIKE pattern (PostgreSQL)\n"
    " For case-insensitive pattern matching. The pattern uses SQL wildcards:\n"
    " - `%` matches any sequence of characters\n"
    " - `_` matches any single character\n"
).
-spec ilike(binary(), binary()) -> cquill@query@ast:condition().
ilike(Field, Pattern) ->
    {i_like, Field, Pattern}.

-file("src/cquill/query.gleam", 274).
?DOC(
    " Create a case-insensitive NOT LIKE condition: field NOT ILIKE pattern (PostgreSQL)\n"
    " Negated case-insensitive pattern matching.\n"
).
-spec not_ilike(binary(), binary()) -> cquill@query@ast:condition().
not_ilike(Field, Pattern) ->
    {not_i_like, Field, Pattern}.

-file("src/cquill/query.gleam", 279).
?DOC(" Create an IS NULL condition\n").
-spec is_null(binary()) -> cquill@query@ast:condition().
is_null(Field) ->
    {is_null, Field}.

-file("src/cquill/query.gleam", 284).
?DOC(" Create an IS NOT NULL condition\n").
-spec is_not_null(binary()) -> cquill@query@ast:condition().
is_not_null(Field) ->
    {is_not_null, Field}.

-file("src/cquill/query.gleam", 294).
?DOC(" Combine conditions with AND\n").
-spec 'and'(list(cquill@query@ast:condition())) -> cquill@query@ast:condition().
'and'(Conditions) ->
    {'and', Conditions}.

-file("src/cquill/query.gleam", 299).
?DOC(" Combine conditions with OR\n").
-spec 'or'(list(cquill@query@ast:condition())) -> cquill@query@ast:condition().
'or'(Conditions) ->
    {'or', Conditions}.

-file("src/cquill/query.gleam", 304).
?DOC(" Negate a condition\n").
-spec 'not'(cquill@query@ast:condition()) -> cquill@query@ast:condition().
'not'(Condition) ->
    {'not', Condition}.

-file("src/cquill/query.gleam", 343).
-spec to_value_from_dyn(dyn_value()) -> cquill@query@ast:value().
to_value_from_dyn(Dyn) ->
    case Dyn of
        {int_val, I} ->
            {int_value, I};

        {float_val, F} ->
            {float_value, F};

        {string_val, S} ->
            {string_value, S};

        {bool_val, B} ->
            {bool_value, B};

        nil_val ->
            null_value;

        {list_val, Vals} ->
            {list_value, gleam@list:map(Vals, fun to_value_from_dyn/1)};

        unknown_val ->
            {string_value, <<""/utf8>>}
    end.

-file("src/cquill/query.gleam", 314).
?DOC(
    " Convert a Gleam value to a query Value.\n"
    " Uses dynamic dispatch to determine the type.\n"
).
-spec to_value(any()) -> cquill@query@ast:value().
to_value(Value) ->
    case cquill_ffi:coerce_value(Value) of
        {int_val, I} ->
            {int_value, I};

        {float_val, F} ->
            {float_value, F};

        {string_val, S} ->
            {string_value, S};

        {bool_val, B} ->
            {bool_value, B};

        nil_val ->
            null_value;

        {list_val, Vals} ->
            {list_value,
                gleam@list:map(Vals, fun(V) -> to_value_from_dyn(V) end)};

        unknown_val ->
            {string_value, <<""/utf8>>}
    end.

-file("src/cquill/query.gleam", 215).
?DOC(" Create an equality condition: field = value\n").
-spec eq(binary(), any()) -> cquill@query@ast:condition().
eq(Field, Value) ->
    {eq, Field, to_value(Value)}.

-file("src/cquill/query.gleam", 220).
?DOC(" Create a not-equal condition: field != value\n").
-spec not_eq(binary(), any()) -> cquill@query@ast:condition().
not_eq(Field, Value) ->
    {not_eq, Field, to_value(Value)}.

-file("src/cquill/query.gleam", 225).
?DOC(" Create a greater-than condition: field > value\n").
-spec gt(binary(), any()) -> cquill@query@ast:condition().
gt(Field, Value) ->
    {gt, Field, to_value(Value)}.

-file("src/cquill/query.gleam", 230).
?DOC(" Create a greater-than-or-equal condition: field >= value\n").
-spec gte(binary(), any()) -> cquill@query@ast:condition().
gte(Field, Value) ->
    {gte, Field, to_value(Value)}.

-file("src/cquill/query.gleam", 235).
?DOC(" Create a less-than condition: field < value\n").
-spec lt(binary(), any()) -> cquill@query@ast:condition().
lt(Field, Value) ->
    {lt, Field, to_value(Value)}.

-file("src/cquill/query.gleam", 240).
?DOC(" Create a less-than-or-equal condition: field <= value\n").
-spec lte(binary(), any()) -> cquill@query@ast:condition().
lte(Field, Value) ->
    {lte, Field, to_value(Value)}.

-file("src/cquill/query.gleam", 245).
?DOC(" Create an IN condition: field IN (values...)\n").
-spec is_in(binary(), list(any())) -> cquill@query@ast:condition().
is_in(Field, Values) ->
    {in, Field, gleam@list:map(Values, fun to_value/1)}.

-file("src/cquill/query.gleam", 250).
?DOC(" Create a NOT IN condition: field NOT IN (values...)\n").
-spec is_not_in(binary(), list(any())) -> cquill@query@ast:condition().
is_not_in(Field, Values) ->
    {not_in, Field, gleam@list:map(Values, fun to_value/1)}.

-file("src/cquill/query.gleam", 289).
?DOC(" Create a BETWEEN condition: field BETWEEN low AND high\n").
-spec between(binary(), OAZ, OAZ) -> cquill@query@ast:condition().
between(Field, Low, High) ->
    {between, Field, to_value(Low), to_value(High)}.

-file("src/cquill/query.gleam", 357).
?DOC(" Create an integer value\n").
-spec int_value(integer()) -> cquill@query@ast:value().
int_value(Value) ->
    {int_value, Value}.

-file("src/cquill/query.gleam", 362).
?DOC(" Create a float value\n").
-spec float_value(float()) -> cquill@query@ast:value().
float_value(Value) ->
    {float_value, Value}.

-file("src/cquill/query.gleam", 367).
?DOC(" Create a string value\n").
-spec string_value(binary()) -> cquill@query@ast:value().
string_value(Value) ->
    {string_value, Value}.

-file("src/cquill/query.gleam", 372).
?DOC(" Create a boolean value\n").
-spec bool_value(boolean()) -> cquill@query@ast:value().
bool_value(Value) ->
    {bool_value, Value}.

-file("src/cquill/query.gleam", 377).
?DOC(" Create a null value\n").
-spec null_value() -> cquill@query@ast:value().
null_value() ->
    null_value.

-file("src/cquill/query.gleam", 382).
?DOC(" Create a list value\n").
-spec list_value(list(cquill@query@ast:value())) -> cquill@query@ast:value().
list_value(Values) ->
    {list_value, Values}.

-file("src/cquill/query.gleam", 388).
?DOC(" Create an equality condition with explicit integer value\n").
-spec eq_int(binary(), integer()) -> cquill@query@ast:condition().
eq_int(Field, Value) ->
    {eq, Field, {int_value, Value}}.

-file("src/cquill/query.gleam", 393).
?DOC(" Create an equality condition with explicit string value\n").
-spec eq_string(binary(), binary()) -> cquill@query@ast:condition().
eq_string(Field, Value) ->
    {eq, Field, {string_value, Value}}.

-file("src/cquill/query.gleam", 398).
?DOC(" Create an equality condition with explicit boolean value\n").
-spec eq_bool(binary(), boolean()) -> cquill@query@ast:condition().
eq_bool(Field, Value) ->
    {eq, Field, {bool_value, Value}}.

-file("src/cquill/query.gleam", 403).
?DOC(" Create a greater-than condition with explicit integer value\n").
-spec gt_int(binary(), integer()) -> cquill@query@ast:condition().
gt_int(Field, Value) ->
    {gt, Field, {int_value, Value}}.

-file("src/cquill/query.gleam", 408).
?DOC(" Create a less-than condition with explicit integer value\n").
-spec lt_int(binary(), integer()) -> cquill@query@ast:condition().
lt_int(Field, Value) ->
    {lt, Field, {int_value, Value}}.

-file("src/cquill/query.gleam", 413).
?DOC(" Create a greater-than-or-equal condition with explicit integer value\n").
-spec gte_int(binary(), integer()) -> cquill@query@ast:condition().
gte_int(Field, Value) ->
    {gte, Field, {int_value, Value}}.

-file("src/cquill/query.gleam", 418).
?DOC(" Create a less-than-or-equal condition with explicit integer value\n").
-spec lte_int(binary(), integer()) -> cquill@query@ast:condition().
lte_int(Field, Value) ->
    {lte, Field, {int_value, Value}}.

-file("src/cquill/query.gleam", 423).
?DOC(" Create an IN condition with explicit integer values\n").
-spec in_ints(binary(), list(integer())) -> cquill@query@ast:condition().
in_ints(Field, Values) ->
    {in,
        Field,
        gleam@list:map(Values, fun(Field@0) -> {int_value, Field@0} end)}.

-file("src/cquill/query.gleam", 428).
?DOC(" Create an IN condition with explicit string values\n").
-spec in_strings(binary(), list(binary())) -> cquill@query@ast:condition().
in_strings(Field, Values) ->
    {in,
        Field,
        gleam@list:map(Values, fun(Field@0) -> {string_value, Field@0} end)}.

-file("src/cquill/query.gleam", 443).
?DOC(
    " Add an ORDER BY clause to the query.\n"
    "\n"
    " ## Example\n"
    " ```gleam\n"
    " user_query\n"
    " |> query.order_by(\"created_at\", ast.Desc)\n"
    " ```\n"
).
-spec order_by(
    cquill@query@ast:'query'(OBH),
    binary(),
    cquill@query@ast:direction()
) -> cquill@query@ast:'query'(OBH).
order_by(Query, Field, Direction) ->
    {'query', _, _, _, Order_bys, _, _, _, _, _, _} = Query,
    New_order = {order_by, Field, Direction, nulls_default},
    {'query',
        erlang:element(2, Query),
        erlang:element(3, Query),
        erlang:element(4, Query),
        lists:append(Order_bys, [New_order]),
        erlang:element(6, Query),
        erlang:element(7, Query),
        erlang:element(8, Query),
        erlang:element(9, Query),
        erlang:element(10, Query),
        erlang:element(11, Query)}.

-file("src/cquill/query.gleam", 454).
?DOC(" Add an ORDER BY ASC clause.\n").
-spec order_by_asc(cquill@query@ast:'query'(OBK), binary()) -> cquill@query@ast:'query'(OBK).
order_by_asc(Query, Field) ->
    order_by(Query, Field, asc).

-file("src/cquill/query.gleam", 459).
?DOC(" Add an ORDER BY DESC clause.\n").
-spec order_by_desc(cquill@query@ast:'query'(OBN), binary()) -> cquill@query@ast:'query'(OBN).
order_by_desc(Query, Field) ->
    order_by(Query, Field, desc).

-file("src/cquill/query.gleam", 464).
?DOC(" Add an ORDER BY clause with null ordering.\n").
-spec order_by_with_nulls(
    cquill@query@ast:'query'(OBQ),
    binary(),
    cquill@query@ast:direction(),
    cquill@query@ast:nulls_order()
) -> cquill@query@ast:'query'(OBQ).
order_by_with_nulls(Query, Field, Direction, Nulls) ->
    {'query', _, _, _, Order_bys, _, _, _, _, _, _} = Query,
    New_order = {order_by, Field, Direction, Nulls},
    {'query',
        erlang:element(2, Query),
        erlang:element(3, Query),
        erlang:element(4, Query),
        lists:append(Order_bys, [New_order]),
        erlang:element(6, Query),
        erlang:element(7, Query),
        erlang:element(8, Query),
        erlang:element(9, Query),
        erlang:element(10, Query),
        erlang:element(11, Query)}.

-file("src/cquill/query.gleam", 476).
?DOC(" Clear all ORDER BY clauses.\n").
-spec order_by_clear(cquill@query@ast:'query'(OBT)) -> cquill@query@ast:'query'(OBT).
order_by_clear(Query) ->
    {'query', _, _, _, _, _, _, _, _, _, _} = Query,
    {'query',
        erlang:element(2, Query),
        erlang:element(3, Query),
        erlang:element(4, Query),
        [],
        erlang:element(6, Query),
        erlang:element(7, Query),
        erlang:element(8, Query),
        erlang:element(9, Query),
        erlang:element(10, Query),
        erlang:element(11, Query)}.

-file("src/cquill/query.gleam", 492).
?DOC(
    " Set the LIMIT for the query.\n"
    "\n"
    " ## Example\n"
    " ```gleam\n"
    " user_query\n"
    " |> query.limit(10)\n"
    " ```\n"
).
-spec limit(cquill@query@ast:'query'(OBW), integer()) -> cquill@query@ast:'query'(OBW).
limit(Query, Count) ->
    {'query', _, _, _, _, _, _, _, _, _, _} = Query,
    {'query',
        erlang:element(2, Query),
        erlang:element(3, Query),
        erlang:element(4, Query),
        erlang:element(5, Query),
        {some, Count},
        erlang:element(7, Query),
        erlang:element(8, Query),
        erlang:element(9, Query),
        erlang:element(10, Query),
        erlang:element(11, Query)}.

-file("src/cquill/query.gleam", 505).
?DOC(
    " Set the OFFSET for the query.\n"
    "\n"
    " ## Example\n"
    " ```gleam\n"
    " user_query\n"
    " |> query.offset(20)\n"
    " |> query.limit(10)\n"
    " ```\n"
).
-spec offset(cquill@query@ast:'query'(OBZ), integer()) -> cquill@query@ast:'query'(OBZ).
offset(Query, Count) ->
    {'query', _, _, _, _, _, _, _, _, _, _} = Query,
    {'query',
        erlang:element(2, Query),
        erlang:element(3, Query),
        erlang:element(4, Query),
        erlang:element(5, Query),
        erlang:element(6, Query),
        {some, Count},
        erlang:element(8, Query),
        erlang:element(9, Query),
        erlang:element(10, Query),
        erlang:element(11, Query)}.

-file("src/cquill/query.gleam", 518).
?DOC(
    " Set both LIMIT and OFFSET for pagination.\n"
    "\n"
    " ## Example\n"
    " ```gleam\n"
    " // Page 3 with 10 items per page\n"
    " user_query\n"
    " |> query.paginate(page: 3, per_page: 10)\n"
    " ```\n"
).
-spec paginate(cquill@query@ast:'query'(OCC), integer(), integer()) -> cquill@query@ast:'query'(OCC).
paginate(Query, Page, Per_page) ->
    Offset_val = (Page - 1) * Per_page,
    _pipe = Query,
    _pipe@1 = limit(_pipe, Per_page),
    offset(_pipe@1, Offset_val).

-file("src/cquill/query.gleam", 530).
?DOC(" Remove LIMIT and OFFSET.\n").
-spec no_pagination(cquill@query@ast:'query'(OCF)) -> cquill@query@ast:'query'(OCF).
no_pagination(Query) ->
    {'query', _, _, _, _, _, _, _, _, _, _} = Query,
    {'query',
        erlang:element(2, Query),
        erlang:element(3, Query),
        erlang:element(4, Query),
        erlang:element(5, Query),
        none,
        none,
        erlang:element(8, Query),
        erlang:element(9, Query),
        erlang:element(10, Query),
        erlang:element(11, Query)}.

-file("src/cquill/query.gleam", 585).
-spec add_join(
    cquill@query@ast:'query'(ODD),
    cquill@query@ast:join_type(),
    binary(),
    gleam@option:option(binary()),
    cquill@query@ast:condition()
) -> cquill@query@ast:'query'(ODD).
add_join(Query, Join_type, Table, Table_alias, On) ->
    {'query', _, _, _, _, _, _, Joins, _, _, _} = Query,
    New_join = {join, Join_type, Table, Table_alias, On},
    {'query',
        erlang:element(2, Query),
        erlang:element(3, Query),
        erlang:element(4, Query),
        erlang:element(5, Query),
        erlang:element(6, Query),
        erlang:element(7, Query),
        lists:append(Joins, [New_join]),
        erlang:element(9, Query),
        erlang:element(10, Query),
        erlang:element(11, Query)}.

-file("src/cquill/query.gleam", 540).
?DOC(" Add an INNER JOIN to the query.\n").
-spec join(
    cquill@query@ast:'query'(OCI),
    binary(),
    cquill@query@ast:condition()
) -> cquill@query@ast:'query'(OCI).
join(Query, Table, On) ->
    add_join(Query, inner_join, Table, none, On).

-file("src/cquill/query.gleam", 545).
?DOC(" Add an INNER JOIN with an alias.\n").
-spec join_as(
    cquill@query@ast:'query'(OCL),
    binary(),
    binary(),
    cquill@query@ast:condition()
) -> cquill@query@ast:'query'(OCL).
join_as(Query, Table, Alias, On) ->
    add_join(Query, inner_join, Table, {some, Alias}, On).

-file("src/cquill/query.gleam", 555).
?DOC(" Add a LEFT JOIN to the query.\n").
-spec left_join(
    cquill@query@ast:'query'(OCO),
    binary(),
    cquill@query@ast:condition()
) -> cquill@query@ast:'query'(OCO).
left_join(Query, Table, On) ->
    add_join(Query, left_join, Table, none, On).

-file("src/cquill/query.gleam", 560).
?DOC(" Add a LEFT JOIN with an alias.\n").
-spec left_join_as(
    cquill@query@ast:'query'(OCR),
    binary(),
    binary(),
    cquill@query@ast:condition()
) -> cquill@query@ast:'query'(OCR).
left_join_as(Query, Table, Alias, On) ->
    add_join(Query, left_join, Table, {some, Alias}, On).

-file("src/cquill/query.gleam", 570).
?DOC(" Add a RIGHT JOIN to the query.\n").
-spec right_join(
    cquill@query@ast:'query'(OCU),
    binary(),
    cquill@query@ast:condition()
) -> cquill@query@ast:'query'(OCU).
right_join(Query, Table, On) ->
    add_join(Query, right_join, Table, none, On).

-file("src/cquill/query.gleam", 575).
?DOC(" Add a FULL OUTER JOIN to the query.\n").
-spec full_join(
    cquill@query@ast:'query'(OCX),
    binary(),
    cquill@query@ast:condition()
) -> cquill@query@ast:'query'(OCX).
full_join(Query, Table, On) ->
    add_join(Query, full_join, Table, none, On).

-file("src/cquill/query.gleam", 580).
?DOC(" Add a CROSS JOIN to the query.\n").
-spec cross_join(cquill@query@ast:'query'(ODA), binary()) -> cquill@query@ast:'query'(ODA).
cross_join(Query, Table) ->
    add_join(Query, cross_join, Table, none, {eq, <<"1"/utf8>>, {int_value, 1}}).

-file("src/cquill/query.gleam", 602).
?DOC(" Add a GROUP BY field.\n").
-spec group_by(cquill@query@ast:'query'(ODH), binary()) -> cquill@query@ast:'query'(ODH).
group_by(Query, Field) ->
    {'query', _, _, _, _, _, _, _, _, Group_bys, _} = Query,
    {'query',
        erlang:element(2, Query),
        erlang:element(3, Query),
        erlang:element(4, Query),
        erlang:element(5, Query),
        erlang:element(6, Query),
        erlang:element(7, Query),
        erlang:element(8, Query),
        erlang:element(9, Query),
        lists:append(Group_bys, [Field]),
        erlang:element(11, Query)}.

-file("src/cquill/query.gleam", 608).
?DOC(" Add multiple GROUP BY fields.\n").
-spec group_by_fields(cquill@query@ast:'query'(ODK), list(binary())) -> cquill@query@ast:'query'(ODK).
group_by_fields(Query, Fields) ->
    {'query', _, _, _, _, _, _, _, _, Group_bys, _} = Query,
    {'query',
        erlang:element(2, Query),
        erlang:element(3, Query),
        erlang:element(4, Query),
        erlang:element(5, Query),
        erlang:element(6, Query),
        erlang:element(7, Query),
        erlang:element(8, Query),
        erlang:element(9, Query),
        lists:append(Group_bys, Fields),
        erlang:element(11, Query)}.

-file("src/cquill/query.gleam", 614).
?DOC(" Add a HAVING condition.\n").
-spec having(cquill@query@ast:'query'(ODO), cquill@query@ast:condition()) -> cquill@query@ast:'query'(ODO).
having(Query, Condition) ->
    {'query', _, _, _, _, _, _, _, _, _, Havings} = Query,
    {'query',
        erlang:element(2, Query),
        erlang:element(3, Query),
        erlang:element(4, Query),
        erlang:element(5, Query),
        erlang:element(6, Query),
        erlang:element(7, Query),
        erlang:element(8, Query),
        erlang:element(9, Query),
        erlang:element(10, Query),
        lists:append(Havings, [{where, Condition}])}.

-file("src/cquill/query.gleam", 624).
?DOC(" Get all WHERE conditions from the query.\n").
-spec get_conditions(cquill@query@ast:'query'(any())) -> list(cquill@query@ast:condition()).
get_conditions(Query) ->
    {'query', _, _, Wheres, _, _, _, _, _, _, _} = Query,
    gleam@list:map(Wheres, fun(W) -> erlang:element(2, W) end).

-file("src/cquill/query.gleam", 630).
?DOC(" Get all ORDER BY clauses from the query.\n").
-spec get_order_bys(cquill@query@ast:'query'(any())) -> list(cquill@query@ast:order_by()).
get_order_bys(Query) ->
    {'query', _, _, _, Order_bys, _, _, _, _, _, _} = Query,
    Order_bys.

-file("src/cquill/query.gleam", 636).
?DOC(" Get the SELECT clause.\n").
-spec get_select(cquill@query@ast:'query'(any())) -> cquill@query@ast:select().
get_select(Query) ->
    {'query', _, Select, _, _, _, _, _, _, _, _} = Query,
    Select.

-file("src/cquill/query.gleam", 642).
?DOC(" Get the LIMIT value.\n").
-spec get_limit(cquill@query@ast:'query'(any())) -> gleam@option:option(integer()).
get_limit(Query) ->
    {'query', _, _, _, _, Limit, _, _, _, _, _} = Query,
    Limit.

-file("src/cquill/query.gleam", 648).
?DOC(" Get the OFFSET value.\n").
-spec get_offset(cquill@query@ast:'query'(any())) -> gleam@option:option(integer()).
get_offset(Query) ->
    {'query', _, _, _, _, _, Offset, _, _, _, _} = Query,
    Offset.

-file("src/cquill/query.gleam", 654).
?DOC(" Get all JOIN clauses.\n").
-spec get_joins(cquill@query@ast:'query'(any())) -> list(cquill@query@ast:join()).
get_joins(Query) ->
    {'query', _, _, _, _, _, _, Joins, _, _, _} = Query,
    Joins.

-file("src/cquill/query.gleam", 660).
?DOC(" Get the source of the query.\n").
-spec get_source(cquill@query@ast:'query'(any())) -> cquill@query@ast:source().
get_source(Query) ->
    {'query', Source, _, _, _, _, _, _, _, _, _} = Query,
    Source.

-file("src/cquill/query.gleam", 666).
?DOC(" Check if the query has any WHERE conditions.\n").
-spec has_conditions(cquill@query@ast:'query'(any())) -> boolean().
has_conditions(Query) ->
    {'query', _, _, Wheres, _, _, _, _, _, _, _} = Query,
    not gleam@list:is_empty(Wheres).

-file("src/cquill/query.gleam", 672).
?DOC(" Check if the query has any ORDER BY clauses.\n").
-spec has_order_by(cquill@query@ast:'query'(any())) -> boolean().
has_order_by(Query) ->
    {'query', _, _, _, Order_bys, _, _, _, _, _, _} = Query,
    not gleam@list:is_empty(Order_bys).

-file("src/cquill/query.gleam", 678).
?DOC(" Check if the query has pagination.\n").
-spec has_pagination(cquill@query@ast:'query'(any())) -> boolean().
has_pagination(Query) ->
    {'query', _, _, _, _, Limit, Offset, _, _, _, _} = Query,
    gleam@option:is_some(Limit) orelse gleam@option:is_some(Offset).

-file("src/cquill/query.gleam", 684).
?DOC(" Check if the query is DISTINCT.\n").
-spec is_distinct(cquill@query@ast:'query'(any())) -> boolean().
is_distinct(Query) ->
    {'query', _, _, _, _, _, _, _, Distinct, _, _} = Query,
    Distinct.

-file("src/cquill/query.gleam", 690).
?DOC(" Count the number of WHERE conditions.\n").
-spec condition_count(cquill@query@ast:'query'(any())) -> integer().
condition_count(Query) ->
    {'query', _, _, Wheres, _, _, _, _, _, _, _} = Query,
    erlang:length(Wheres).

-file("src/cquill/query.gleam", 737).
-spec source_to_string(cquill@query@ast:source()) -> binary().
source_to_string(Source) ->
    case Source of
        {table_source, Table, none} ->
            Table;

        {table_source, Table@1, {some, Schema}} ->
            <<<<Schema/binary, "."/utf8>>/binary, Table@1/binary>>;

        {subquery_source, _} ->
            <<"(subquery)"/utf8>>
    end.

-file("src/cquill/query.gleam", 745).
-spec select_to_string(cquill@query@ast:select()) -> binary().
select_to_string(Select) ->
    case Select of
        select_all ->
            <<"*"/utf8>>;

        {select_fields, Fields} ->
            gleam@string:join(Fields, <<", "/utf8>>);

        {select_expr, _} ->
            <<"(expressions)"/utf8>>
    end.

-file("src/cquill/query.gleam", 813).
-spec order_by_to_string(cquill@query@ast:order_by()) -> binary().
order_by_to_string(Ob) ->
    Dir = case erlang:element(3, Ob) of
        asc ->
            <<"ASC"/utf8>>;

        desc ->
            <<"DESC"/utf8>>
    end,
    Nulls = case erlang:element(4, Ob) of
        nulls_default ->
            <<""/utf8>>;

        nulls_first ->
            <<" NULLS FIRST"/utf8>>;

        nulls_last ->
            <<" NULLS LAST"/utf8>>
    end,
    <<<<<<(erlang:element(2, Ob))/binary, " "/utf8>>/binary, Dir/binary>>/binary,
        Nulls/binary>>.

-file("src/cquill/query.gleam", 841).
-spec bool_to_string(boolean()) -> binary().
bool_to_string(B) ->
    case B of
        true ->
            <<"true"/utf8>>;

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

-file("src/cquill/query.gleam", 800).
-spec value_to_string(cquill@query@ast:value()) -> binary().
value_to_string(Value) ->
    case Value of
        {int_value, I} ->
            erlang:integer_to_binary(I);

        {float_value, F} ->
            gleam@string:inspect(F);

        {string_value, S} ->
            <<<<"'"/utf8, S/binary>>/binary, "'"/utf8>>;

        {bool_value, B} ->
            bool_to_string(B);

        null_value ->
            <<"NULL"/utf8>>;

        {param_value, P} ->
            <<"$"/utf8, (erlang:integer_to_binary(P))/binary>>;

        {list_value, Values} ->
            <<<<"["/utf8,
                    (gleam@string:join(
                        gleam@list:map(Values, fun value_to_string/1),
                        <<", "/utf8>>
                    ))/binary>>/binary,
                "]"/utf8>>
    end.

-file("src/cquill/query.gleam", 757).
-spec condition_to_string(cquill@query@ast:condition()) -> binary().
condition_to_string(Cond) ->
    case Cond of
        {eq, Field, Value} ->
            <<<<Field/binary, " = "/utf8>>/binary,
                (value_to_string(Value))/binary>>;

        {not_eq, Field@1, Value@1} ->
            <<<<Field@1/binary, " != "/utf8>>/binary,
                (value_to_string(Value@1))/binary>>;

        {gt, Field@2, Value@2} ->
            <<<<Field@2/binary, " > "/utf8>>/binary,
                (value_to_string(Value@2))/binary>>;

        {gte, Field@3, Value@3} ->
            <<<<Field@3/binary, " >= "/utf8>>/binary,
                (value_to_string(Value@3))/binary>>;

        {lt, Field@4, Value@4} ->
            <<<<Field@4/binary, " < "/utf8>>/binary,
                (value_to_string(Value@4))/binary>>;

        {lte, Field@5, Value@5} ->
            <<<<Field@5/binary, " <= "/utf8>>/binary,
                (value_to_string(Value@5))/binary>>;

        {in, Field@6, Values} ->
            <<<<<<Field@6/binary, " IN ("/utf8>>/binary,
                    (gleam@string:join(
                        gleam@list:map(Values, fun value_to_string/1),
                        <<", "/utf8>>
                    ))/binary>>/binary,
                ")"/utf8>>;

        {not_in, Field@7, Values@1} ->
            <<<<<<Field@7/binary, " NOT IN ("/utf8>>/binary,
                    (gleam@string:join(
                        gleam@list:map(Values@1, fun value_to_string/1),
                        <<", "/utf8>>
                    ))/binary>>/binary,
                ")"/utf8>>;

        {like, Field@8, Pattern} ->
            <<<<<<Field@8/binary, " LIKE '"/utf8>>/binary, Pattern/binary>>/binary,
                "'"/utf8>>;

        {not_like, Field@9, Pattern@1} ->
            <<<<<<Field@9/binary, " NOT LIKE '"/utf8>>/binary,
                    Pattern@1/binary>>/binary,
                "'"/utf8>>;

        {i_like, Field@10, Pattern@2} ->
            <<<<<<Field@10/binary, " ILIKE '"/utf8>>/binary, Pattern@2/binary>>/binary,
                "'"/utf8>>;

        {not_i_like, Field@11, Pattern@3} ->
            <<<<<<Field@11/binary, " NOT ILIKE '"/utf8>>/binary,
                    Pattern@3/binary>>/binary,
                "'"/utf8>>;

        {is_null, Field@12} ->
            <<Field@12/binary, " IS NULL"/utf8>>;

        {is_not_null, Field@13} ->
            <<Field@13/binary, " IS NOT NULL"/utf8>>;

        {between, Field@14, Low, High} ->
            <<<<<<<<Field@14/binary, " BETWEEN "/utf8>>/binary,
                        (value_to_string(Low))/binary>>/binary,
                    " AND "/utf8>>/binary,
                (value_to_string(High))/binary>>;

        {'and', Conditions} ->
            <<<<"("/utf8,
                    (gleam@string:join(
                        gleam@list:map(Conditions, fun condition_to_string/1),
                        <<" AND "/utf8>>
                    ))/binary>>/binary,
                ")"/utf8>>;

        {'or', Conditions@1} ->
            <<<<"("/utf8,
                    (gleam@string:join(
                        gleam@list:map(Conditions@1, fun condition_to_string/1),
                        <<" OR "/utf8>>
                    ))/binary>>/binary,
                ")"/utf8>>;

        {'not', Condition} ->
            <<<<"NOT ("/utf8, (condition_to_string(Condition))/binary>>/binary,
                ")"/utf8>>;

        {raw, Sql, _} ->
            <<"RAW: "/utf8, Sql/binary>>
    end.

-file("src/cquill/query.gleam", 753).
-spec where_to_string(cquill@query@ast:where()) -> binary().
where_to_string(W) ->
    condition_to_string(erlang:element(2, W)).

-file("src/cquill/query.gleam", 826).
-spec join_to_string(cquill@query@ast:join()) -> binary().
join_to_string(J) ->
    Join_type = case erlang:element(2, J) of
        inner_join ->
            <<"INNER JOIN"/utf8>>;

        left_join ->
            <<"LEFT JOIN"/utf8>>;

        right_join ->
            <<"RIGHT JOIN"/utf8>>;

        full_join ->
            <<"FULL JOIN"/utf8>>;

        cross_join ->
            <<"CROSS JOIN"/utf8>>
    end,
    Table = case erlang:element(4, J) of
        {some, Alias} ->
            <<<<(erlang:element(3, J))/binary, " AS "/utf8>>/binary,
                Alias/binary>>;

        none ->
            erlang:element(3, J)
    end,
    <<<<<<<<Join_type/binary, " "/utf8>>/binary, Table/binary>>/binary,
            " ON "/utf8>>/binary,
        (condition_to_string(erlang:element(5, J)))/binary>>.

-file("src/cquill/query.gleam", 848).
-spec option_int_to_string(gleam@option:option(integer())) -> binary().
option_int_to_string(Opt) ->
    case Opt of
        {some, I} ->
            erlang:integer_to_binary(I);

        none ->
            <<"None"/utf8>>
    end.

-file("src/cquill/query.gleam", 701).
?DOC(
    " Convert a query to a debug string representation.\n"
    " This is for debugging and testing, NOT for SQL generation.\n"
).
-spec to_debug_string(cquill@query@ast:'query'(any())) -> binary().
to_debug_string(Query) ->
    {'query',
        Source,
        Select,
        Wheres,
        Order_bys,
        Limit,
        Offset,
        Joins,
        Distinct,
        Group_bys,
        Havings} = Query,
    Parts = [<<"Query {"/utf8>>,
        <<"  source: "/utf8, (source_to_string(Source))/binary>>,
        <<"  select: "/utf8, (select_to_string(Select))/binary>>,
        <<"  distinct: "/utf8, (bool_to_string(Distinct))/binary>>,
        <<<<"  wheres: ["/utf8,
                (gleam@string:join(
                    gleam@list:map(Wheres, fun where_to_string/1),
                    <<", "/utf8>>
                ))/binary>>/binary,
            "]"/utf8>>,
        <<<<"  joins: ["/utf8,
                (gleam@string:join(
                    gleam@list:map(Joins, fun join_to_string/1),
                    <<", "/utf8>>
                ))/binary>>/binary,
            "]"/utf8>>,
        <<<<"  group_bys: ["/utf8,
                (gleam@string:join(Group_bys, <<", "/utf8>>))/binary>>/binary,
            "]"/utf8>>,
        <<<<"  havings: ["/utf8,
                (gleam@string:join(
                    gleam@list:map(Havings, fun where_to_string/1),
                    <<", "/utf8>>
                ))/binary>>/binary,
            "]"/utf8>>,
        <<<<"  order_bys: ["/utf8,
                (gleam@string:join(
                    gleam@list:map(Order_bys, fun order_by_to_string/1),
                    <<", "/utf8>>
                ))/binary>>/binary,
            "]"/utf8>>,
        <<"  limit: "/utf8, (option_int_to_string(Limit))/binary>>,
        <<"  offset: "/utf8, (option_int_to_string(Offset))/binary>>,
        <<"}"/utf8>>],
    gleam@string:join(Parts, <<"\n"/utf8>>).