support selecting a subset of a subquery as a struct

Author: zachdaniel

lib/ecto/query/planner.ex

@@ -2207,8 +2207,8 @@ defmodule Ecto.Query.Planner do
       {{:ok, {:struct, _}}, {:fragment, _, _}} ->
         error!(query, "it is not possible to return a struct subset of a fragment")
 
-      {{:ok, {:struct, _}}, %Ecto.SubQuery{}} ->
-        error!(query, "it is not possible to return a struct subset of a subquery")
+      {{:ok, {:struct, fields}}, %Ecto.SubQuery{select: select}} ->
+        handle_subquery_struct(select, fields, ix, query)
 
       {{:ok, {_, []}}, {_, _, _}} ->
         error!(
@@ -2280,6 +2280,39 @@ defmodule Ecto.Query.Planner do
     end)
   end
 
+  defp handle_subquery_struct(select, requested_fields, ix, query) do
+    available_fields = subquery_source_fields(select)
+    requested_fields = List.wrap(requested_fields)
+
+    Enum.each(requested_fields, fn field ->
+      unless field in available_fields do
+        error!(query, "field `#{field}` in struct/2 is not available in the subquery. " <>
+                     "Subquery only returns fields: #{inspect(available_fields)}")
+      end
+    end)
+
+    schema =
+      case select do
+        {:struct, schema, _} -> schema
+        {:source, {_, schema}, _, _} when not is_nil(schema) -> schema
+        _ ->
+          error!(query, "it is not possible to return a struct subset of a subquery that does not return a schema or a struct")
+      end
+
+    types =
+      Enum.map(requested_fields, fn field ->
+        {:ok, type} = subquery_type_for(select, field) 
+        {field, type}
+      end)
+
+    field_exprs =
+      Enum.map(types, fn {field, type} ->
+        {{:., [type: type], [{:&, [], [ix]}, field]}, [], []}
+      end)
+
+    {{:source, {nil, schema}, nil, types}, field_exprs}
+  end
+
   defp select_field(field, ix, writable) do
     {{:., [writable: writable], [{:&, [], [ix]}, field]}, [], []}
   end

test/ecto/query/subquery_test.exs

@@ -447,8 +447,21 @@ defmodule Ecto.Query.SubqueryTest do
       subquery = from p in Post, select: %{id: p.id, title: p.title}
       query = normalize(from(p in subquery(subquery), select: map(p, [:title])))
       assert [{{:., _, [{:&, [], [0]}, :title]}, [], []}] = query.select.fields
+    end
+
+    test "struct/2 with subqueries" do
+      subquery = from p in Post, select: p
+      query = normalize(from(p in subquery(subquery), select: struct(p, [:id, :title])))
+      assert query.select.fields == [
+        {{:., [type: CustomPermalink], [{:&, [], [0]}, :id]}, [], []},
+        {{:., [type: :string], [{:&, [], [0]}, :title]}, [], []}
+      ]
+
+      subquery = from p in Post, select: p
+      query = normalize(from(c in Comment, join: p in subquery(subquery), on: true, select: struct(p, [:title])))
+      assert query.select.fields == [{{:., [type: :string], [{:&, [], [1]}, :title]}, [], []}]
 
-      assert_raise Ecto.QueryError, ~r/it is not possible to return a struct subset of a subquery/, fn ->
+      assert_raise Ecto.QueryError, ~r/it is not possible to return a struct subset of a subquery that does not return a schema or a struct/, fn ->
         subquery = from p in Post, select: %{id: p.id, title: p.title}
         normalize(from(p in subquery(subquery), select: struct(p, [:title])))
       end