Refactor selected_as/2 implementation (#434)

Author: greg-rychlewski

CHANGELOG.md

@@ -8,6 +8,7 @@
   * [postgres] Support the use of advisory locks for migrations
   * [sql] Add `dump_cmd` to `postgrex` and `myxql` adapters
   * [sql] Log human-readable UUIDs by using pre-dumped query parameters
+  * [sql] Support select aliases from `selected_as/1` and `selected_as/2`
   * [telemetry] Emit `schema_migration: true` under `telemetry_options`
 
 ## v3.8.3 (2022-06-04)

lib/ecto/adapters/myxql/connection.ex

@@ -279,8 +279,6 @@ if Code.ensure_loaded?(MyXQL) do
           end
         {key, value} ->
           [expr(value, sources, query), " AS ", quote_name(key)]
-        {:selected_as, _, [field_expr, name]} ->
-          [expr(field_expr, sources, query), " AS ", Atom.to_string(name)]
         value ->
           expr(value, sources, query)
       end)
@@ -575,14 +573,7 @@ if Code.ensure_loaded?(MyXQL) do
     end
 
     defp expr({:selected_as, _, [name]}, _sources, _query) do
-      [Atom.to_string(name)]
-    end
-
-    defp expr({:selected_as, _, [_field_expr, _name]}, _sources, _query) do
-      raise ArgumentError,
-          "`selected_as/2` can only be used in the outer most `select` expression. " <>
-            "If you are attempting to alias a field from a subquery, it is not allowed " <>
-              "because subquery fields are automatically aliased by the corresponding map/struct key."
+      [quote_name(name)]
     end
 
     defp expr({:datetime_add, _, [datetime, count, interval]}, sources, query) do

lib/ecto/adapters/postgres/connection.ex

@@ -374,8 +374,6 @@ if Code.ensure_loaded?(Postgrex) do
           end
         {key, value} ->
           [expr(value, sources, query), " AS " | quote_name(key)]
-        {:selected_as, _, [field_expr, name]} ->
-          [expr(field_expr, sources, query), " AS ", Atom.to_string(name)]
         value ->
           expr(value, sources, query)
       end)
@@ -679,14 +677,7 @@ if Code.ensure_loaded?(Postgrex) do
     end
 
     defp expr({:selected_as, _, [name]}, _sources, _query) do
-      [Atom.to_string(name)]
-    end
-
-    defp expr({:selected_as, _, [_field_expr, _name]}, _sources, _query) do
-      raise ArgumentError,
-          "`selected_as/2` can only be used in the outer most `select` expression. " <>
-            "If you are attempting to alias a field from a subquery, it is not allowed " <>
-              "because subquery fields are automatically aliased by the corresponding map/struct key."
+      [quote_name(name)]
     end
 
     defp expr({:datetime_add, _, [datetime, count, interval]}, sources, query) do

lib/ecto/adapters/tds/connection.ex

@@ -409,9 +409,6 @@ if Code.ensure_loaded?(Tds) do
         {key, value} ->
           [select_expr(value, sources, query), " AS ", quote_name(key)]
 
-        {:selected_as, _, [field_expr, name]} ->
-          [expr(field_expr, sources, query), " AS ", Atom.to_string(name)]
-
         value ->
           select_expr(value, sources, query)
       end)
@@ -768,14 +765,7 @@ if Code.ensure_loaded?(Tds) do
     end
 
     defp expr({:selected_as, _, [name]}, _sources, _query) do
-      [Atom.to_string(name)]
-    end
-
-    defp expr({:selected_as, _, [_field_expr, _name]}, _sources, _query) do
-      raise ArgumentError,
-          "`selected_as/2` can only be used in the outer most `select` expression. " <>
-            "If you are attempting to alias a field from a subquery, it is not allowed " <>
-              "because subquery fields are automatically aliased by the corresponding map/struct key."
+      [quote_name(name)]
     end
 
     defp expr({:datetime_add, _, [datetime, count, interval]}, sources, query) do

mix.lock

@@ -6,7 +6,7 @@
   "decimal": {:hex, :decimal, "1.9.0", "83e8daf59631d632b171faabafb4a9f4242c514b0a06ba3df493951c08f64d07", [:mix], [], "hexpm", "b1f2343568eed6928f3e751cf2dffde95bfaa19dd95d09e8a9ea92ccfd6f7d85"},
   "deep_merge": {:hex, :deep_merge, "0.2.0", "c1050fa2edf4848b9f556fba1b75afc66608a4219659e3311d9c9427b5b680b3", [:mix], [], "hexpm", "e3bf435a54ed27b0ba3a01eb117ae017988804e136edcbe8a6a14c310daa966e"},
   "earmark_parser": {:hex, :earmark_parser, "1.4.25", "2024618731c55ebfcc5439d756852ec4e85978a39d0d58593763924d9a15916f", [:mix], [], "hexpm", "56749c5e1c59447f7b7a23ddb235e4b3defe276afc220a6227237f3efe83f51e"},
-  "ecto": {:git, "https://github.com/elixir-ecto/ecto.git", "8d1fa601a91a77f5eeb502ad8787f82c80caab8c", []},
+  "ecto": {:git, "https://github.com/elixir-ecto/ecto.git", "8831fe1fa8223c6db863559c41f68733eec301f6", []},
   "ex_doc": {:hex, :ex_doc, "0.28.4", "001a0ea6beac2f810f1abc3dbf4b123e9593eaa5f00dd13ded024eae7c523298", [:mix], [{:earmark_parser, "~> 1.4.19", [hex: :earmark_parser, repo: "hexpm", optional: false]}, {:makeup_elixir, "~> 0.14", [hex: :makeup_elixir, repo: "hexpm", optional: false]}, {:makeup_erlang, "~> 0.1", [hex: :makeup_erlang, repo: "hexpm", optional: false]}], "hexpm", "bf85d003dd34911d89c8ddb8bda1a958af3471a274a4c2150a9c01c78ac3f8ed"},
   "jason": {:hex, :jason, "1.3.0", "fa6b82a934feb176263ad2df0dbd91bf633d4a46ebfdffea0c8ae82953714946", [:mix], [{:decimal, "~> 1.0 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "53fc1f51255390e0ec7e50f9cb41e751c260d065dcba2bf0d08dc51a4002c2ac"},
   "makeup": {:hex, :makeup, "1.1.0", "6b67c8bc2882a6b6a445859952a602afc1a41c2e08379ca057c0f525366fc3ca", [:mix], [{:nimble_parsec, "~> 1.2.2 or ~> 1.3", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "0a45ed501f4a8897f580eabf99a2e5234ea3e75a4373c8a52824f6e873be57a6"},

test/ecto/adapters/myxql_test.exs

@@ -529,32 +529,23 @@ defmodule Ecto.Adapters.MyXQLTest do
 
   test "aliasing a selected value with selected_as/2" do
     query = "schema" |> select([s], selected_as(s.x, :integer)) |> plan()
-    assert all(query) == ~s{SELECT s0.`x` AS integer FROM `schema` AS s0}
+    assert all(query) == ~s{SELECT s0.`x` AS `integer` FROM `schema` AS s0}
 
     query = "schema" |> select([s], s.x |> coalesce(0) |> sum() |> selected_as(:integer)) |> plan()
-    assert all(query) == ~s{SELECT sum(coalesce(s0.`x`, 0)) AS integer FROM `schema` AS s0}
-  end
-
-  test "raises if selected_as/2 is used in a subquery" do
-    message = ~r"`selected_as/2` can only be used in the outer most `select` expression."
-
-    assert_raise ArgumentError, message, fn ->
-      subquery = "schema" |> select([s], %{x: selected_as(s.x, :integer)}) |> subquery() |> plan()
-      all(subquery)
-    end
+    assert all(query) == ~s{SELECT sum(coalesce(s0.`x`, 0)) AS `integer` FROM `schema` AS s0}
   end
 
   test "group_by can reference the alias of a selected value with selected_as/1" do
     query = "schema" |> select([s], selected_as(s.x, :integer)) |> group_by(selected_as(:integer)) |> plan()
-    assert all(query) == ~s{SELECT s0.`x` AS integer FROM `schema` AS s0 GROUP BY integer}
+    assert all(query) == ~s{SELECT s0.`x` AS `integer` FROM `schema` AS s0 GROUP BY `integer`}
   end
 
   test "order_by can reference the alias of a selected value with selected_as/1" do
     query = "schema" |> select([s], selected_as(s.x, :integer)) |> order_by(selected_as(:integer)) |> plan()
-    assert all(query) == ~s{SELECT s0.`x` AS integer FROM `schema` AS s0 ORDER BY integer}
+    assert all(query) == ~s{SELECT s0.`x` AS `integer` FROM `schema` AS s0 ORDER BY `integer`}
 
     query = "schema" |> select([s], selected_as(s.x, :integer)) |> order_by([desc: selected_as(:integer)]) |> plan()
-    assert all(query) == ~s{SELECT s0.`x` AS integer FROM `schema` AS s0 ORDER BY integer DESC}
+    assert all(query) == ~s{SELECT s0.`x` AS `integer` FROM `schema` AS s0 ORDER BY `integer` DESC}
   end
 
   test "having can reference the alias of a selected value with selected_as/1" do
@@ -565,7 +556,7 @@ defmodule Ecto.Adapters.MyXQLTest do
       |> having(selected_as(:integer) > 0)
       |> plan()
 
-    assert all(query) == ~s{SELECT s0.`x` AS integer FROM `schema` AS s0 GROUP BY integer HAVING (integer > 0)}
+    assert all(query) == ~s{SELECT s0.`x` AS `integer` FROM `schema` AS s0 GROUP BY `integer` HAVING (`integer` > 0)}
   end
 
   test "tagged type" do

test/ecto/adapters/postgres_test.exs

@@ -577,32 +577,23 @@ defmodule Ecto.Adapters.PostgresTest do
 
   test "aliasing a selected value with selected_as/2" do
     query = "schema" |> select([s], selected_as(s.x, :integer)) |> plan()
-    assert all(query) == ~s{SELECT s0."x" AS integer FROM "schema" AS s0}
+    assert all(query) == ~s{SELECT s0."x" AS "integer" FROM "schema" AS s0}
 
     query = "schema" |> select([s], s.x |> coalesce(0) |> sum() |> selected_as(:integer)) |> plan()
-    assert all(query) == ~s{SELECT sum(coalesce(s0."x", 0)) AS integer FROM "schema" AS s0}
-  end
-
-  test "raises if selected_as/2 is used in a subquery" do
-    message = ~r"`selected_as/2` can only be used in the outer most `select` expression."
-
-    assert_raise ArgumentError, message, fn ->
-      subquery = "schema" |> select([s], %{x: selected_as(s.x, :integer)}) |> subquery() |> plan()
-      all(subquery)
-    end
+    assert all(query) == ~s{SELECT sum(coalesce(s0."x", 0)) AS "integer" FROM "schema" AS s0}
   end
 
   test "group_by can reference the alias of a selected value with selected_as/1" do
     query = "schema" |> select([s], selected_as(s.x, :integer)) |> group_by(selected_as(:integer)) |> plan()
-    assert all(query) == ~s{SELECT s0."x" AS integer FROM "schema" AS s0 GROUP BY integer}
+    assert all(query) == ~s{SELECT s0."x" AS "integer" FROM "schema" AS s0 GROUP BY "integer"}
   end
 
   test "order_by can reference the alias of a selected value with selected_as/1" do
     query = "schema" |> select([s], selected_as(s.x, :integer)) |> order_by(selected_as(:integer)) |> plan()
-    assert all(query) == ~s{SELECT s0."x" AS integer FROM "schema" AS s0 ORDER BY integer}
+    assert all(query) == ~s{SELECT s0."x" AS "integer" FROM "schema" AS s0 ORDER BY "integer"}
 
     query = "schema" |> select([s], selected_as(s.x, :integer)) |> order_by([desc: selected_as(:integer)]) |> plan()
-    assert all(query) == ~s{SELECT s0."x" AS integer FROM "schema" AS s0 ORDER BY integer DESC}
+    assert all(query) == ~s{SELECT s0."x" AS "integer" FROM "schema" AS s0 ORDER BY "integer" DESC}
   end
 
   test "datetime_add" do

test/ecto/adapters/tds_test.exs

@@ -643,27 +643,18 @@ defmodule Ecto.Adapters.TdsTest do
 
   test "aliasing a selected value with selected_as/2" do
     query = "schema" |> select([s], selected_as(s.x, :integer)) |> plan()
-    assert all(query) == ~s{SELECT s0.[x] AS integer FROM [schema] AS s0}
+    assert all(query) == ~s{SELECT s0.[x] AS [integer] FROM [schema] AS s0}
 
     query = "schema" |> select([s], s.x |> coalesce(0) |> sum() |> selected_as(:integer)) |> plan()
-    assert all(query) == ~s{SELECT sum(coalesce(s0.[x], 0)) AS integer FROM [schema] AS s0}
-  end
-
-  test "raises if selected_as/2 is used in a subquery" do
-    message = ~r"`selected_as/2` can only be used in the outer most `select` expression."
-
-    assert_raise ArgumentError, message, fn ->
-      subquery = "schema" |> select([s], %{x: selected_as(s.x, :integer)}) |> subquery() |> plan()
-      all(subquery)
-    end
+    assert all(query) == ~s{SELECT sum(coalesce(s0.[x], 0)) AS [integer] FROM [schema] AS s0}
   end
 
   test "order_by can reference the alias of a selected value with selected_as/1s" do
     query = "schema" |> select([s], selected_as(s.x, :integer)) |> order_by(selected_as(:integer)) |> plan()
-    assert all(query) == ~s{SELECT s0.[x] AS integer FROM [schema] AS s0 ORDER BY integer}
+    assert all(query) == ~s{SELECT s0.[x] AS [integer] FROM [schema] AS s0 ORDER BY [integer]}
 
     query = "schema" |> select([s], selected_as(s.x, :integer)) |> order_by([desc: selected_as(:integer)]) |> plan()
-    assert all(query) == ~s{SELECT s0.[x] AS integer FROM [schema] AS s0 ORDER BY integer DESC}
+    assert all(query) == ~s{SELECT s0.[x] AS [integer] FROM [schema] AS s0 ORDER BY [integer] DESC}
   end
 
   test "tagged type" do