improvement: update to the latest ash

improvement: remove the need to dynamically expand fragments

Author: zachdaniel

.check.exs

@@ -2,7 +2,7 @@
   ## all available options with default values (see `mix check` docs for description)
   # parallel: true,
   # skipped: true,
-
+  retry: false,
   ## list of tools (see `mix check` docs for defaults)
   tools: [
     ## curated tools may be disabled (e.g. the check for compilation warnings)

.github/workflows/elixir.yml

@@ -18,7 +18,7 @@ jobs:
       matrix:
         otp: ["24"]
         elixir: ["1.14.0"]
-        ash: ["2.0.0-rc.10"]
+        ash: ["2.0.0-rc.14"]
         pg_version: ["13"]
     env:
       GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

lib/aggregate.ex

@@ -149,77 +149,26 @@ defmodule AshPostgres.Aggregate do
     {in_aggregates, in_body} =
       Enum.split_with(dynamics, fn {load, _name, _dynamic} -> is_nil(load) end)
 
-    query =
-      if query.select do
-        query
+    aggs =
+      in_body
+      |> Map.new(fn {load, _, dynamic} ->
+        {load, dynamic}
+      end)
+
+    aggs =
+      if Enum.empty?(in_aggregates) do
+        aggs
       else
-        Ecto.Query.select_merge(query, %{})
+        Map.put(
+          aggs,
+          :aggregates,
+          Map.new(in_aggregates, fn {_, name, dynamic} ->
+            {name, dynamic}
+          end)
+        )
       end
 
-    {exprs, new_params, count} =
-      Enum.reduce(
-        in_body,
-        {[], Enum.reverse(query.select.params), Enum.count(query.select.params)},
-        fn {load, _, dynamic}, {exprs, params, count} ->
-          {expr, new_params, count} =
-            Ecto.Query.Builder.Dynamic.partially_expand(
-              :select,
-              query,
-              dynamic,
-              params,
-              count
-            )
-
-          {[{load, expr} | exprs], new_params, count}
-        end
-      )
-
-    query = %{
-      query
-      | select: %{
-          query.select
-          | expr: {:merge, [], [query.select.expr, {:%{}, [], Enum.reverse(exprs)}]}
-        }
-    }
-
-    add_aggregates_in_aggregates(query, in_aggregates, new_params, count)
-  end
-
-  defp add_aggregates_in_aggregates(query, [], params, _count),
-    do: %{query | select: %{query.select | params: Enum.reverse(params)}}
-
-  defp add_aggregates_in_aggregates(
-         %{select: %{expr: expr} = select} = query,
-         in_aggregates,
-         params,
-         count
-       ) do
-    {exprs, new_params, _} =
-      Enum.reduce(
-        in_aggregates,
-        {[], params, count},
-        fn {_, name, dynamic}, {exprs, params, count} ->
-          {expr, new_params, count} =
-            Ecto.Query.Builder.Dynamic.partially_expand(
-              :select,
-              query,
-              dynamic,
-              params,
-              count
-            )
-
-          {[{name, expr} | exprs], new_params, count}
-        end
-      )
-
-    %{
-      query
-      | select: %{
-          select
-          | expr: {:merge, [], [expr, {:%{}, [], [aggregates: {:%{}, [], Enum.reverse(exprs)}]}]},
-            params: Enum.reverse(new_params)
-        }
-    }
+    Ecto.Query.select_merge(query, ^aggs)
   end
 
   def agg_subquery_for_lateral_join(
@@ -608,23 +557,7 @@ defmodule AshPostgres.Aggregate do
         Ecto.Query.select(query, %{})
       end
 
-    {expr, new_params, _} =
-      Ecto.Query.Builder.Dynamic.partially_expand(
-        :select,
-        query,
-        casted,
-        Enum.reverse(query.select.params),
-        Enum.count(query.select.params)
-      )
-
-    %{
-      query
-      | select: %{
-          query.select
-          | expr: {:merge, [], [query.select.expr, {:%{}, [], [{aggregate_name, expr}]}]},
-            params: Enum.reverse(new_params)
-        }
-    }
+    Ecto.Query.select_merge(query, ^%{aggregate_name => casted})
   end
 
   defp aggregate_subquery(

lib/calculation.ex

@@ -36,75 +36,25 @@ defmodule AshPostgres.Calculation do
     {in_calculations, in_body} =
       Enum.split_with(dynamics, fn {load, _name, _dynamic} -> is_nil(load) end)
 
-    query =
-      if query.select do
-        query
+    calcs =
+      in_body
+      |> Map.new(fn {load, _, dynamic} ->
+        {load, dynamic}
+      end)
+
+    calcs =
+      if Enum.empty?(in_calculations) do
+        calcs
       else
-        Ecto.Query.select(query, %{})
+        Map.put(
+          calcs,
+          :calculations,
+          Map.new(in_calculations, fn {_, name, dynamic} ->
+            {name, dynamic}
+          end)
+        )
       end
 
-    {exprs, new_params, _} =
-      Enum.reduce(
-        in_body,
-        {[], Enum.reverse(query.select.params), Enum.count(query.select.params)},
-        fn {load, _, dynamic}, {exprs, params, count} ->
-          {expr, new_params, count} =
-            Ecto.Query.Builder.Dynamic.partially_expand(
-              :select,
-              query,
-              dynamic,
-              params,
-              count
-            )
-
-          {[{load, expr} | exprs], new_params, count}
-        end
-      )
-
-    query = %{
-      query
-      | select: %{
-          query.select
-          | expr: {:merge, [], [query.select.expr, {:%{}, [], Enum.reverse(exprs)}]},
-            params: Enum.reverse(new_params)
-        }
-    }
-
-    add_calculations_in_calculations(query, in_calculations)
-  end
-
-  defp add_calculations_in_calculations(query, []), do: query
-
-  defp add_calculations_in_calculations(
-         %{select: %{expr: expr} = select} = query,
-         in_calculations
-       ) do
-    {exprs, new_params, _} =
-      Enum.reduce(
-        in_calculations,
-        {[], Enum.reverse(query.select.params), Enum.count(query.select.params)},
-        fn {_, name, dynamic}, {exprs, params, count} ->
-          {expr, new_params, count} =
-            Ecto.Query.Builder.Dynamic.partially_expand(
-              :select,
-              query,
-              dynamic,
-              params,
-              count
-            )
-
-          {[{name, expr} | exprs], new_params, count}
-        end
-      )
-
-    %{
-      query
-      | select: %{
-          select
-          | expr:
-              {:merge, [], [expr, {:%{}, [], [calculations: {:%{}, [], Enum.reverse(exprs)}]}]},
-            params: Enum.reverse(new_params)
-        }
-    }
+    Ecto.Query.select_merge(query, ^calcs)
   end
 end

lib/expr.ex

@@ -4,8 +4,8 @@ defmodule AshPostgres.Expr do
   alias Ash.Filter
   alias Ash.Query.{BooleanExpression, Exists, Not, Ref}
   alias Ash.Query.Operator.IsNil
-  alias Ash.Query.Function.{Ago, Contains, GetPath, If, Length}
-  alias AshPostgres.Functions.{Fragment, TrigramSimilarity, Type}
+  alias Ash.Query.Function.{Ago, Contains, GetPath, If, Length, Type}
+  alias AshPostgres.Functions.{Fragment, TrigramSimilarity}
 
   require Ecto.Query
 
@@ -47,22 +47,8 @@ defmodule AshPostgres.Expr do
     arg1 = do_dynamic_expr(query, arg1, bindings, pred_embedded? || embedded?)
     arg2 = do_dynamic_expr(query, arg2, bindings, pred_embedded? || embedded?)
 
-    do_dynamic_expr(
-      query,
-      %Fragment{
-        embedded?: pred_embedded?,
-        arguments: [
-          raw: "similarity(",
-          expr: arg1,
-          raw: ", ",
-          expr: arg2,
-          raw: ")"
-        ]
-      },
-      bindings,
-      embedded?,
-      type
-    )
+    Ecto.Query.dynamic(fragment("similarity(?, ?)", ^arg1, ^arg2))
+    |> maybe_type(type, query)
   end
 
   defp do_dynamic_expr(
@@ -330,38 +316,20 @@ defmodule AshPostgres.Expr do
     {params, fragment_data, _} =
       Enum.reduce(arguments, {[], [], 0}, fn
         {:raw, str}, {params, fragment_data, count} ->
-          {params, fragment_data ++ [{:raw, str}], count}
+          {params, [{:raw, str} | fragment_data], count}
 
         {:casted_expr, dynamic}, {params, fragment_data, count} ->
-          {expr, new_params, new_count} =
-            Ecto.Query.Builder.Dynamic.partially_expand(
-              :select,
-              query,
-              dynamic,
-              params,
-              count
-            )
-
-          {new_params, fragment_data ++ [{:expr, expr}], new_count}
+          {[{dynamic, :any} | params], [{:expr, {:^, [], [count]}} | fragment_data], count + 1}
 
         {:expr, expr}, {params, fragment_data, count} ->
           dynamic = do_dynamic_expr(query, expr, bindings, pred_embedded? || embedded?)
 
-          {expr, new_params, new_count} =
-            Ecto.Query.Builder.Dynamic.partially_expand(
-              :select,
-              query,
-              dynamic,
-              params,
-              count
-            )
-
-          {new_params, fragment_data ++ [{:expr, expr}], new_count}
+          {[{dynamic, :any} | params], [{:expr, {:^, [], [count]}} | fragment_data], count + 1}
       end)
 
     frag_dynamic = %Ecto.Query.DynamicExpr{
       fun: fn _query ->
-        {{:fragment, [], fragment_data}, Enum.reverse(params), []}
+        {{:fragment, [], Enum.reverse(fragment_data)}, Enum.reverse(params), [], %{}}
       end,
       binding: [],
       file: __ENV__.file,
@@ -694,40 +662,16 @@ defmodule AshPostgres.Expr do
 
   defp do_dynamic_expr(
          query,
-         %Type{arguments: [arg1, arg2], embedded?: pred_embedded?} = type_expr,
-         bindings,
-         embedded?,
-         _type
-       ) do
-    arg1 = do_dynamic_expr(query, arg1, bindings, false)
-    arg2 = do_dynamic_expr(query, arg2, bindings, pred_embedded? || embedded?)
-    type = AshPostgres.Types.parameterized_type(arg2, [])
-    validate_type!(query, type, type_expr)
-
-    if type do
-      Ecto.Query.dynamic(type(^arg1, ^type))
-    else
-      raise "Attempted to explicitly cast to a type that has `cast_in_query?` configured to `false`, or for which a type could not be determined."
-    end
-  end
-
-  defp do_dynamic_expr(
-         query,
-         %Type{arguments: [arg1, arg2, constraints], embedded?: pred_embedded?} = type_expr,
+         %Type{arguments: [arg1, arg2, constraints]} = type_expr,
          bindings,
-         embedded?,
+         _embedded?,
          _type
        ) do
     arg1 = do_dynamic_expr(query, arg1, bindings, false)
-    arg2 = do_dynamic_expr(query, arg2, bindings, pred_embedded? || embedded?)
     type = AshPostgres.Types.parameterized_type(arg2, constraints)
     validate_type!(query, type, type_expr)
 
-    if type do
-      Ecto.Query.dynamic(type(^arg1, ^type))
-    else
-      raise "Attempted to explicitly cast to a type that has `cast_in_query?` configured to `false`, or for which a type could not be determined."
-    end
+    Ecto.Query.dynamic(type(^arg1, ^type))
   end
 
   defp do_dynamic_expr(
@@ -871,6 +815,15 @@ defmodule AshPostgres.Expr do
     end
   end
 
+  defp maybe_type(dynamic, nil, _query), do: dynamic
+
+  defp maybe_type(dynamic, type, query) do
+    type = AshPostgres.Types.parameterized_type(type, [])
+    validate_type!(query, type, type)
+
+    Ecto.Query.dynamic(type(^dynamic, ^type))
+  end
+
   defp maybe_sanitize_list(value) do
     if is_list(value) do
       Enum.map(value, fn value ->

lib/migration_generator/migration_generator.ex

@@ -1947,9 +1947,11 @@ defmodule AshPostgres.MigrationGenerator do
         constraint.attribute
         |> List.wrap()
         |> Enum.map(fn attribute ->
-          resource
-          |> Ash.Resource.Info.attribute(attribute)
-          |> Map.get(:source)
+          attr =
+            resource
+            |> Ash.Resource.Info.attribute(attribute)
+
+          attr.source || attr.name
         end)
 
       %{

mix.exs

@@ -134,11 +134,11 @@ defmodule AshPostgres.MixProject do
   # Run "mix help deps" to learn about dependencies.
   defp deps do
     [
-      {:ecto_sql, "~> 3.8"},
-      {:ecto, "~> 3.8"},
+      {:ecto_sql, "~> 3.9"},
+      {:ecto, "~> 3.9"},
       {:jason, "~> 1.0"},
       {:postgrex, ">= 0.0.0"},
-      {:ash, ash_version("~> 2.0.0-rc.11")},
+      {:ash, ash_version("~> 2.0.0-rc.14")},
       {:git_ops, "~> 2.4.5", only: :dev},
       {:ex_doc, "~> 0.22", only: :dev, runtime: false},
       {:ex_check, "~> 0.14", only: :dev},