galchemy

-module(galchemy@orm@query).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src\\galchemy\\orm\\query.gleam").
-export([from_metadata/1, from_model/1, as_/2, field/1, field_as/2, where_/2, order_by/2, limit/2, offset/2, distinct/1, select_all/1, col/2, item/2, item_as/3, is_null/2, is_not_null/2, in_list/3, asc/2, desc/2, select_fields/2, eq/3, neq/3, gt/3, gte/3, lt/3, lte/3, like/3, ilike/3, inner_join_relation/4, left_join_relation/4]).
-export_type([model_ref/0, selection/0, query_error/0]).

-type model_ref() :: {model_ref,
        galchemy@orm@metadata:model_metadata(),
        galchemy@ast@schema:table()}.

-type selection() :: {selection, binary(), gleam@option:option(binary())}.

-type query_error() :: {declarative_error,
        galchemy@orm@declarative:declarative_error()} |
    {unknown_column, galchemy@schema@relation:table_ref(), binary()} |
    {unknown_relation, galchemy@schema@relation:table_ref(), binary()} |
    {related_table_mismatch,
        binary(),
        galchemy@schema@relation:table_ref(),
        galchemy@schema@relation:table_ref()}.

-file("src\\galchemy\\orm\\query.gleam", 38).
-spec from_metadata(galchemy@orm@metadata:model_metadata()) -> model_ref().
from_metadata(Next_metadata) ->
    {model_ref,
        Next_metadata,
        {table,
            {some, erlang:element(2, erlang:element(2, Next_metadata))},
            erlang:element(3, erlang:element(2, Next_metadata)),
            none}}.

-file("src\\galchemy\\orm\\query.gleam", 31).
-spec from_model(galchemy@orm@declarative:model()) -> {ok, model_ref()} |
    {error, query_error()}.
from_model(Next_model) ->
    case galchemy@orm@declarative:to_metadata(Next_model) of
        {ok, Next_metadata} ->
            {ok, from_metadata(Next_metadata)};

        {error, Error} ->
            {error, {declarative_error, Error}}
    end.

-file("src\\galchemy\\orm\\query.gleam", 49).
-spec as_(model_ref(), binary()) -> model_ref().
as_(Model_ref, Alias) ->
    {model_ref,
        erlang:element(2, Model_ref),
        begin
            _record = erlang:element(3, Model_ref),
            {table,
                erlang:element(2, _record),
                erlang:element(3, _record),
                {some, Alias}}
        end}.

-file("src\\galchemy\\orm\\query.gleam", 56).
-spec field(binary()) -> selection().
field(Column) ->
    {selection, Column, none}.

-file("src\\galchemy\\orm\\query.gleam", 60).
-spec field_as(binary(), binary()) -> selection().
field_as(Column, Alias) ->
    {selection, Column, {some, Alias}}.

-file("src\\galchemy\\orm\\query.gleam", 217).
-spec where_(
    galchemy@ast@expression:select_query(),
    galchemy@ast@expression:predicate()
) -> galchemy@ast@expression:select_query().
where_(Query, Next_predicate) ->
    galchemy@dsl@select:where_(Query, Next_predicate).

-file("src\\galchemy\\orm\\query.gleam", 224).
-spec order_by(
    galchemy@ast@expression:select_query(),
    galchemy@ast@expression:order()
) -> galchemy@ast@expression:select_query().
order_by(Query, Next_order) ->
    galchemy@dsl@select:order_by(Query, Next_order).

-file("src\\galchemy\\orm\\query.gleam", 231).
-spec limit(galchemy@ast@expression:select_query(), integer()) -> galchemy@ast@expression:select_query().
limit(Query, Value) ->
    galchemy@dsl@select:limit(Query, Value).

-file("src\\galchemy\\orm\\query.gleam", 238).
-spec offset(galchemy@ast@expression:select_query(), integer()) -> galchemy@ast@expression:select_query().
offset(Query, Value) ->
    galchemy@dsl@select:offset(Query, Value).

-file("src\\galchemy\\orm\\query.gleam", 245).
-spec distinct(galchemy@ast@expression:select_query()) -> galchemy@ast@expression:select_query().
distinct(Query) ->
    galchemy@dsl@select:distinct(Query).

-file("src\\galchemy\\orm\\query.gleam", 324).
-spec relation_named(model_ref(), binary()) -> {ok,
        galchemy@schema@relation:relation()} |
    {error, query_error()}.
relation_named(Model_ref, Relation_name) ->
    case galchemy@orm@metadata:relation_named(
        erlang:element(2, Model_ref),
        Relation_name
    ) of
        {some, Next_relation} ->
            {ok, Next_relation};

        none ->
            {error,
                {unknown_relation,
                    erlang:element(2, erlang:element(2, Model_ref)),
                    Relation_name}}
    end.

-file("src\\galchemy\\orm\\query.gleam", 335).
-spec validate_related_model(galchemy@schema@relation:relation(), model_ref()) -> {ok,
        nil} |
    {error, query_error()}.
validate_related_model(Next_relation, Related_model) ->
    case erlang:element(5, Next_relation) =:= erlang:element(
        2,
        erlang:element(2, Related_model)
    ) of
        true ->
            {ok, nil};

        false ->
            {error,
                {related_table_mismatch,
                    erlang:element(2, Next_relation),
                    erlang:element(5, Next_relation),
                    erlang:element(2, erlang:element(2, Related_model))}}
    end.

-file("src\\galchemy\\orm\\query.gleam", 404).
-spec column_expression(model_ref(), binary()) -> galchemy@ast@expression:expression().
column_expression(Model_ref, Column_name) ->
    {column_expr, {column_meta, erlang:element(3, Model_ref), Column_name}}.

-file("src\\galchemy\\orm\\query.gleam", 81).
-spec select_all(model_ref()) -> galchemy@ast@expression:select_query().
select_all(Model_ref) ->
    _pipe = galchemy@dsl@select:select(
        gleam@list:map(
            erlang:element(4, erlang:element(2, Model_ref)),
            fun(Column_name) ->
                galchemy@dsl@expr:item(
                    column_expression(Model_ref, Column_name)
                )
            end
        )
    ),
    galchemy@dsl@select:from(_pipe, erlang:element(3, Model_ref)).

-file("src\\galchemy\\orm\\query.gleam", 102).
-spec col(model_ref(), binary()) -> {ok, galchemy@ast@expression:expression()} |
    {error, query_error()}.
col(Model_ref, Column_name) ->
    case galchemy@orm@metadata:has_column(
        erlang:element(2, Model_ref),
        Column_name
    ) of
        true ->
            {ok, column_expression(Model_ref, Column_name)};

        false ->
            {error,
                {unknown_column,
                    erlang:element(2, erlang:element(2, Model_ref)),
                    Column_name}}
    end.

-file("src\\galchemy\\orm\\query.gleam", 414).
-spec result_try(
    {ok, MEP} | {error, MEQ},
    fun((MEP) -> {ok, MET} | {error, MEQ})
) -> {ok, MET} | {error, MEQ}.
result_try(Value, Next) ->
    case Value of
        {ok, Inner} ->
            Next(Inner);

        {error, Error} ->
            {error, Error}
    end.

-file("src\\galchemy\\orm\\query.gleam", 64).
-spec item(model_ref(), binary()) -> {ok, galchemy@ast@expression:select_item()} |
    {error, query_error()}.
item(Model_ref, Column_name) ->
    result_try(
        col(Model_ref, Column_name),
        fun(Next_column) -> {ok, galchemy@dsl@expr:item(Next_column)} end
    ).

-file("src\\galchemy\\orm\\query.gleam", 72).
-spec item_as(model_ref(), binary(), binary()) -> {ok,
        galchemy@ast@expression:select_item()} |
    {error, query_error()}.
item_as(Model_ref, Column_name, Alias) ->
    result_try(
        col(Model_ref, Column_name),
        fun(Next_column) -> {ok, galchemy@dsl@expr:as_(Next_column, Alias)} end
    ).

-file("src\\galchemy\\orm\\query.gleam", 176).
-spec is_null(model_ref(), binary()) -> {ok,
        galchemy@ast@expression:predicate()} |
    {error, query_error()}.
is_null(Model_ref, Column_name) ->
    result_try(
        col(Model_ref, Column_name),
        fun(Column) -> {ok, galchemy@dsl@predicate:is_null(Column)} end
    ).

-file("src\\galchemy\\orm\\query.gleam", 184).
-spec is_not_null(model_ref(), binary()) -> {ok,
        galchemy@ast@expression:predicate()} |
    {error, query_error()}.
is_not_null(Model_ref, Column_name) ->
    result_try(
        col(Model_ref, Column_name),
        fun(Column) -> {ok, galchemy@dsl@predicate:is_not_null(Column)} end
    ).

-file("src\\galchemy\\orm\\query.gleam", 192).
-spec in_list(model_ref(), binary(), list(galchemy@ast@expression:expression())) -> {ok,
        galchemy@ast@expression:predicate()} |
    {error, query_error()}.
in_list(Model_ref, Column_name, Values) ->
    result_try(
        col(Model_ref, Column_name),
        fun(Column) -> {ok, galchemy@dsl@predicate:in_list(Column, Values)} end
    ).

-file("src\\galchemy\\orm\\query.gleam", 201).
-spec asc(model_ref(), binary()) -> {ok, galchemy@ast@expression:order()} |
    {error, query_error()}.
asc(Model_ref, Column_name) ->
    result_try(
        col(Model_ref, Column_name),
        fun(Column) -> {ok, galchemy@dsl@select:asc(Column)} end
    ).

-file("src\\galchemy\\orm\\query.gleam", 209).
-spec desc(model_ref(), binary()) -> {ok, galchemy@ast@expression:order()} |
    {error, query_error()}.
desc(Model_ref, Column_name) ->
    result_try(
        col(Model_ref, Column_name),
        fun(Column) -> {ok, galchemy@dsl@select:desc(Column)} end
    ).

-file("src\\galchemy\\orm\\query.gleam", 279).
-spec select_items(
    model_ref(),
    list(selection()),
    list(galchemy@ast@expression:select_item())
) -> {ok, list(galchemy@ast@expression:select_item())} | {error, query_error()}.
select_items(Model_ref, Selections, Acc) ->
    case Selections of
        [] ->
            {ok, lists:reverse(Acc)};

        [Selection | Rest] ->
            result_try(
                col(Model_ref, erlang:element(2, Selection)),
                fun(Column) ->
                    Next_item = case erlang:element(3, Selection) of
                        {some, Alias} ->
                            galchemy@dsl@expr:as_(Column, Alias);

                        none ->
                            galchemy@dsl@expr:item(Column)
                    end,
                    select_items(Model_ref, Rest, [Next_item | Acc])
                end
            )
    end.

-file("src\\galchemy\\orm\\query.gleam", 90).
-spec select_fields(model_ref(), list(selection())) -> {ok,
        galchemy@ast@expression:select_query()} |
    {error, query_error()}.
select_fields(Model_ref, Selections) ->
    result_try(
        select_items(Model_ref, Selections, []),
        fun(Items) ->
            {ok,
                begin
                    _pipe = galchemy@dsl@select:select(Items),
                    galchemy@dsl@select:from(
                        _pipe,
                        erlang:element(3, Model_ref)
                    )
                end}
        end
    ).

-file("src\\galchemy\\orm\\query.gleam", 298).
-spec compare(
    model_ref(),
    binary(),
    galchemy@ast@expression:expression(),
    fun((galchemy@ast@expression:expression(), galchemy@ast@expression:expression()) -> galchemy@ast@expression:predicate())
) -> {ok, galchemy@ast@expression:predicate()} | {error, query_error()}.
compare(Model_ref, Column_name, Value, Builder) ->
    result_try(
        col(Model_ref, Column_name),
        fun(Column) -> {ok, Builder(Column, Value)} end
    ).

-file("src\\galchemy\\orm\\query.gleam", 112).
-spec eq(model_ref(), binary(), galchemy@ast@expression:expression()) -> {ok,
        galchemy@ast@expression:predicate()} |
    {error, query_error()}.
eq(Model_ref, Column_name, Value) ->
    compare(Model_ref, Column_name, Value, fun galchemy@dsl@predicate:eq/2).

-file("src\\galchemy\\orm\\query.gleam", 120).
-spec neq(model_ref(), binary(), galchemy@ast@expression:expression()) -> {ok,
        galchemy@ast@expression:predicate()} |
    {error, query_error()}.
neq(Model_ref, Column_name, Value) ->
    compare(Model_ref, Column_name, Value, fun galchemy@dsl@predicate:neq/2).

-file("src\\galchemy\\orm\\query.gleam", 128).
-spec gt(model_ref(), binary(), galchemy@ast@expression:expression()) -> {ok,
        galchemy@ast@expression:predicate()} |
    {error, query_error()}.
gt(Model_ref, Column_name, Value) ->
    compare(Model_ref, Column_name, Value, fun galchemy@dsl@predicate:gt/2).

-file("src\\galchemy\\orm\\query.gleam", 136).
-spec gte(model_ref(), binary(), galchemy@ast@expression:expression()) -> {ok,
        galchemy@ast@expression:predicate()} |
    {error, query_error()}.
gte(Model_ref, Column_name, Value) ->
    compare(Model_ref, Column_name, Value, fun galchemy@dsl@predicate:gte/2).

-file("src\\galchemy\\orm\\query.gleam", 144).
-spec lt(model_ref(), binary(), galchemy@ast@expression:expression()) -> {ok,
        galchemy@ast@expression:predicate()} |
    {error, query_error()}.
lt(Model_ref, Column_name, Value) ->
    compare(Model_ref, Column_name, Value, fun galchemy@dsl@predicate:lt/2).

-file("src\\galchemy\\orm\\query.gleam", 152).
-spec lte(model_ref(), binary(), galchemy@ast@expression:expression()) -> {ok,
        galchemy@ast@expression:predicate()} |
    {error, query_error()}.
lte(Model_ref, Column_name, Value) ->
    compare(Model_ref, Column_name, Value, fun galchemy@dsl@predicate:lte/2).

-file("src\\galchemy\\orm\\query.gleam", 160).
-spec like(model_ref(), binary(), galchemy@ast@expression:expression()) -> {ok,
        galchemy@ast@expression:predicate()} |
    {error, query_error()}.
like(Model_ref, Column_name, Value) ->
    compare(Model_ref, Column_name, Value, fun galchemy@dsl@predicate:like/2).

-file("src\\galchemy\\orm\\query.gleam", 168).
-spec ilike(model_ref(), binary(), galchemy@ast@expression:expression()) -> {ok,
        galchemy@ast@expression:predicate()} |
    {error, query_error()}.
ilike(Model_ref, Column_name, Value) ->
    compare(Model_ref, Column_name, Value, fun galchemy@dsl@predicate:ilike/2).

-file("src\\galchemy\\orm\\query.gleam", 394).
-spec pair_predicate(
    model_ref(),
    model_ref(),
    galchemy@schema@relation:column_pair()
) -> {ok, galchemy@ast@expression:predicate()} | {error, query_error()}.
pair_predicate(Model_ref, Related_model, Next_pair) ->
    result_try(
        col(Model_ref, erlang:element(2, Next_pair)),
        fun(Left) ->
            result_try(
                col(Related_model, erlang:element(3, Next_pair)),
                fun(Right) -> {ok, galchemy@dsl@predicate:eq(Left, Right)} end
            )
        end
    ).

-file("src\\galchemy\\orm\\query.gleam", 369).
-spec join_predicate_rest(
    model_ref(),
    model_ref(),
    list(galchemy@schema@relation:column_pair()),
    galchemy@ast@expression:predicate()
) -> {ok, galchemy@ast@expression:predicate()} | {error, query_error()}.
join_predicate_rest(Model_ref, Related_model, Pairs, Acc) ->
    case Pairs of
        [] ->
            {ok, Acc};

        [Next_pair | Rest] ->
            result_try(
                pair_predicate(Model_ref, Related_model, Next_pair),
                fun(Next_predicate) ->
                    join_predicate_rest(
                        Model_ref,
                        Related_model,
                        Rest,
                        galchemy@dsl@predicate:'and'(Acc, Next_predicate)
                    )
                end
            )
    end.

-file("src\\galchemy\\orm\\query.gleam", 350).
-spec join_predicate(
    model_ref(),
    model_ref(),
    galchemy@schema@relation:relation()
) -> {ok, galchemy@ast@expression:predicate()} | {error, query_error()}.
join_predicate(Model_ref, Related_model, Next_relation) ->
    case erlang:element(6, Next_relation) of
        [] ->
            erlang:error(#{gleam_error => panic,
                    message => <<"relation metadata requires at least one column pair"/utf8>>,
                    file => <<?FILEPATH/utf8>>,
                    module => <<"galchemy/orm/query"/utf8>>,
                    function => <<"join_predicate"/utf8>>,
                    line => 356});

        [First_pair | Rest] ->
            result_try(
                pair_predicate(Model_ref, Related_model, First_pair),
                fun(First_predicate) ->
                    join_predicate_rest(
                        Model_ref,
                        Related_model,
                        Rest,
                        First_predicate
                    )
                end
            )
    end.

-file("src\\galchemy\\orm\\query.gleam", 309).
-spec join_relation(
    galchemy@ast@expression:select_query(),
    model_ref(),
    binary(),
    model_ref(),
    fun((galchemy@ast@expression:select_query(), galchemy@ast@schema:table(), galchemy@ast@expression:predicate()) -> galchemy@ast@expression:select_query())
) -> {ok, galchemy@ast@expression:select_query()} | {error, query_error()}.
join_relation(Query, Model_ref, Relation_name, Related_model, Join_builder) ->
    result_try(
        relation_named(Model_ref, Relation_name),
        fun(Next_relation) ->
            result_try(
                validate_related_model(Next_relation, Related_model),
                fun(_) ->
                    result_try(
                        join_predicate(Model_ref, Related_model, Next_relation),
                        fun(On) ->
                            {ok,
                                Join_builder(
                                    Query,
                                    erlang:element(3, Related_model),
                                    On
                                )}
                        end
                    )
                end
            )
        end
    ).

-file("src\\galchemy\\orm\\query.gleam", 249).
-spec inner_join_relation(
    galchemy@ast@expression:select_query(),
    model_ref(),
    binary(),
    model_ref()
) -> {ok, galchemy@ast@expression:select_query()} | {error, query_error()}.
inner_join_relation(Query, Model_ref, Relation_name, Related_model) ->
    join_relation(
        Query,
        Model_ref,
        Relation_name,
        Related_model,
        fun galchemy@dsl@select:inner_join/3
    ).

-file("src\\galchemy\\orm\\query.gleam", 264).
-spec left_join_relation(
    galchemy@ast@expression:select_query(),
    model_ref(),
    binary(),
    model_ref()
) -> {ok, galchemy@ast@expression:select_query()} | {error, query_error()}.
left_join_relation(Query, Model_ref, Relation_name, Related_model) ->
    join_relation(
        Query,
        Model_ref,
        Relation_name,
        Related_model,
        fun galchemy@dsl@select:left_join/3
    ).