Support selected_as/1 and selected_as/2 in psql, mysql and tds (#432)

Author: greg-rychlewski

integration_test/tds/test_helper.exs

@@ -48,7 +48,9 @@ ExUnit.start(
     # MSSQL does not support streaming
     :stream,
     # MSSQL fails the regex matching because it uses square brackets outside of the parameter list
-    :parameter_logging
+    :parameter_logging,
+    # MSSQL can't reference aliased columns in GROUP BY
+    :selected_as_with_group_by
   ]
 )
 

lib/ecto/adapters/myxql/connection.ex

@@ -279,6 +279,8 @@ 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)
@@ -572,6 +574,17 @@ if Code.ensure_loaded?(MyXQL) do
       quote_name(literal)
     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."
+    end
+
     defp expr({:datetime_add, _, [datetime, count, interval]}, sources, query) do
       ["date_add(", expr(datetime, sources, query), ", ",
        interval(count, interval, sources, query) | ")"]

lib/ecto/adapters/postgres/connection.ex

@@ -374,6 +374,8 @@ 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)
@@ -676,6 +678,17 @@ if Code.ensure_loaded?(Postgrex) do
       quote_name(literal)
     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."
+    end
+
     defp expr({:datetime_add, _, [datetime, count, interval]}, sources, query) do
       [expr(datetime, sources, query), type_unless_typed(datetime, "timestamp"), " + ",
        interval(count, interval, sources, query)]

lib/ecto/adapters/tds/connection.ex

@@ -409,6 +409,9 @@ 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)
@@ -764,6 +767,17 @@ if Code.ensure_loaded?(Tds) do
       quote_name(literal)
     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."
+    end
+
     defp expr({:datetime_add, _, [datetime, count, interval]}, sources, query) do
       [
         "DATEADD(",

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", "479484c2dfe637cecb623293a712a2e77632b846", []},
+  "ecto": {:git, "https://github.com/elixir-ecto/ecto.git", "4f541892e738a4dfad66601e19db3567e3335c2c", []},
   "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

@@ -527,6 +527,36 @@ defmodule Ecto.Adapters.MyXQLTest do
     assert all(query) == ~s{SELECT TRUE FROM `schema` AS s0 WHERE (s0.`foo` = (0 + 123.0))}
   end
 
+  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}
+
+    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
+  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}
+  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}
+
+    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}
+  end
+
   test "tagged type" do
     query = Schema |> select([], type(^"601d74e4-a8d3-4b6e-8365-eddb4c893327", Ecto.UUID)) |> plan()
     assert all(query) == ~s{SELECT CAST(? AS binary(16)) FROM `schema` AS s0}

test/ecto/adapters/postgres_test.exs

@@ -575,6 +575,36 @@ defmodule Ecto.Adapters.PostgresTest do
     assert all(query) == ~s{SELECT TRUE FROM "schema" AS s0 WHERE (s0."foo" = 123.0::float)}
   end
 
+  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}
+
+    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
+  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}
+  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}
+
+    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}
+  end
+
   test "datetime_add" do
     query = "schema" |> where([s], datetime_add(s.foo, 1, "month") > s.bar) |> select([], true) |> plan()
     assert all(query) == ~s{SELECT TRUE FROM "schema" AS s0 WHERE (s0."foo"::timestamp + interval '1 month' > s0."bar")}

test/ecto/adapters/tds_test.exs

@@ -641,6 +641,31 @@ defmodule Ecto.Adapters.TdsTest do
     assert all(query) == ~s{SELECT CAST(1 as bit) FROM [schema] AS s0 WHERE (s0.[foo] = 123.0)}
   end
 
+  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}
+
+    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
+  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}
+
+    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}
+  end
+
   test "tagged type" do
     query =
       Schema |> select([], type(^"601d74e4-a8d3-4b6e-8365-eddb4c893327", Tds.Ecto.UUID)) |> plan()