Support json_extract_path/2 (elixir-ecto#187)

Author: wojtekmach

integration_test/tds/test_helper.exs

@@ -53,7 +53,10 @@ ExUnit.start(
     # and after insert we need to turn it on, must be run manually in transaction
     :pk_insert,
     # Tds allows nested transactions so this will never raise and SQL query should be "BEGIN TRAN"
-    :transaction_checkout_raises
+    :transaction_checkout_raises,
+    # JSON_VALUE always returns strings (even for e.g. integers) and returns null for
+    # arrays/objects (JSON_QUERY must be used for these)
+    :json_extract_path
   ]
 )
 

lib/ecto/adapters/myxql/connection.ex

@@ -547,6 +547,19 @@ if Code.ensure_loaded?(MyXQL) do
 
     defp expr({:count, _, []}, _sources, _query), do: "count(*)"
 
+    defp expr({:json_extract_path, _, [expr, path]}, sources, query) do
+      path =
+        Enum.map(path, fn
+          binary when is_binary(binary) ->
+            [?., ?", escape_json_key(binary), ?"]
+
+          integer when is_integer(integer) ->
+            "[#{integer}]"
+        end)
+
+      ["json_extract(", expr(expr, sources, query), ", '$", path, "')"]
+    end
+
     defp expr({fun, _, args}, sources, query) when is_atom(fun) and is_list(args) do
       {modifier, args} =
         case args do
@@ -975,6 +988,12 @@ if Code.ensure_loaded?(MyXQL) do
       |> :binary.replace("\\", "\\\\", [:global])
     end
 
+    defp escape_json_key(value) when is_binary(value) do
+      value
+      |> escape_string()
+      |> :binary.replace("\"", "\\\\\"", [:global])
+    end
+
     defp ecto_cast_to_db(:id, _query), do: "unsigned"
     defp ecto_cast_to_db(:integer, _query), do: "unsigned"
     defp ecto_cast_to_db(:string, _query), do: "char"

lib/ecto/adapters/postgres/connection.ex

@@ -570,6 +570,19 @@ if Code.ensure_loaded?(Postgrex) do
        interval(count, interval, sources, query) | ")::date"]
     end
 
+    defp expr({:json_extract_path, _, [expr, path]}, sources, query) do
+      path =
+        intersperse_map(path, ?,, fn
+          binary when is_binary(binary) ->
+            [?", escape_json_key(binary), ?"]
+
+          integer when is_integer(integer) ->
+            Integer.to_string(integer)
+        end)
+
+      [?(, expr(expr, sources, query), "#>'{", path, "}')"]
+    end
+
     defp expr({:filter, _, [agg, filter]}, sources, query) do
       aggregate = expr(agg, sources, query)
       [aggregate, " FILTER (WHERE ", expr(filter, sources, query), ?)]
@@ -1148,6 +1161,12 @@ if Code.ensure_loaded?(Postgrex) do
       :binary.replace(value, "'", "''", [:global])
     end
 
+    defp escape_json_key(value) when is_binary(value) do
+      value
+      |> escape_string()
+      |> :binary.replace("\"", "\\\"", [:global])
+    end
+
     defp ecto_to_db({:array, t}),          do: [ecto_to_db(t), ?[, ?]]
     defp ecto_to_db(:id),                  do: "integer"
     defp ecto_to_db(:serial),              do: "serial"

lib/ecto/adapters/tds/connection.ex

@@ -213,7 +213,7 @@ if Code.ensure_loaded?(Tds) do
     end
 
     defp on_conflict({_, _, _}, _header) do
-      error!(nil, "MSSQL supports only on_conflict: :raise")
+      error!(nil, "Tds adapter supports only on_conflict: :raise")
     end
 
     defp insert_all(rows, counter) do
@@ -383,7 +383,7 @@ if Code.ensure_loaded?(Tds) do
     defp cte_header(%QueryExpr{}, query) do
       error!(
         query,
-        "Unfortunately Tds adapter does not support fragment in CTE"
+        "Tds adapter does not support fragment in CTE"
       )
     end
 
@@ -704,6 +704,14 @@ if Code.ensure_loaded?(Tds) do
 
     defp expr({:count, _, []}, _sources, _query), do: "count(*)"
 
+    defp expr({:json_extract_path, _, _}, _sources, query) do
+      error!(
+        query,
+        "Tds adapter does not support json_extract_path expression" <>
+          ", use fragment with JSON_VALUE/JSON_QUERY"
+      )
+    end
+
     defp expr({fun, _, args}, sources, query) when is_atom(fun) and is_list(args) do
       {modifier, args} =
         case args do
@@ -997,10 +1005,10 @@ if Code.ensure_loaded?(Tds) do
     end
 
     def execute_ddl({:create, %Constraint{check: check}}) when is_binary(check),
-      do: error!(nil, "MSSQL adapter does not support check constraints")
+      do: error!(nil, "Tds adapter does not support check constraints")
 
     def execute_ddl({:create, %Constraint{exclude: exclude}}) when is_binary(exclude),
-      do: error!(nil, "MSSQL adapter does not support exclusion constraints")
+      do: error!(nil, "Tds adapter does not support exclusion constraints")
 
     def execute_ddl({command, %Index{} = index}) when command in [:drop, :drop_if_exists] do
       prefix = index.prefix
@@ -1023,7 +1031,7 @@ if Code.ensure_loaded?(Tds) do
     end
 
     def execute_ddl({:drop, %Constraint{}}),
-      do: error!(nil, "MSSQL adapter does not support constraints")
+      do: error!(nil, "Tds adapter does not support constraints")
 
     def execute_ddl({:rename, %Table{} = current_table, %Table{} = new_table}) do
       [
@@ -1052,7 +1060,7 @@ if Code.ensure_loaded?(Tds) do
     def execute_ddl(string) when is_binary(string), do: [string]
 
     def execute_ddl(keyword) when is_list(keyword),
-      do: error!(nil, "MSSQL adapter does not support keyword lists in execute")
+      do: error!(nil, "Tds adapter does not support keyword lists in execute")
 
     @impl true
     def ddl_logs(_), do: []
@@ -1244,7 +1252,7 @@ if Code.ensure_loaded?(Tds) do
     defp options_expr(nil), do: []
 
     defp options_expr(keyword) when is_list(keyword),
-      do: error!(nil, "MSSQL adapter does not support keyword lists in :options")
+      do: error!(nil, "Tds adapter does not support keyword lists in :options")
 
     defp options_expr(options), do: [" ", to_string(options)]
 

mix.lock

@@ -6,7 +6,7 @@
   "decimal": {:hex, :decimal, "1.8.1", "a4ef3f5f3428bdbc0d35374029ffcf4ede8533536fa79896dd450168d9acdf3c", [:mix], [], "hexpm", "3cb154b00225ac687f6cbd4acc4b7960027c757a5152b369923ead9ddbca7aec"},
   "deep_merge": {:hex, :deep_merge, "0.2.0", "c1050fa2edf4848b9f556fba1b75afc66608a4219659e3311d9c9427b5b680b3", [:mix], [], "hexpm", "e3bf435a54ed27b0ba3a01eb117ae017988804e136edcbe8a6a14c310daa966e"},
   "earmark": {:hex, :earmark, "1.4.3", "364ca2e9710f6bff494117dbbd53880d84bebb692dafc3a78eb50aa3183f2bfd", [:mix], [], "hexpm", "8cf8a291ebf1c7b9539e3cddb19e9cef066c2441b1640f13c34c1d3cfc825fec"},
-  "ecto": {:git, "https://github.com/elixir-ecto/ecto.git", "e5908c0ed7b988c8c230502d31e278a85f3d2a68", []},
+  "ecto": {:git, "https://github.com/elixir-ecto/ecto.git", "cb2f03964dac324a9771f84f5088e395326e6de8", []},
   "ex_doc": {:hex, :ex_doc, "0.21.3", "857ec876b35a587c5d9148a2512e952e24c24345552259464b98bfbb883c7b42", [:mix], [{:earmark, "~> 1.4", [hex: :earmark, repo: "hexpm", optional: false]}, {:makeup_elixir, "~> 0.14", [hex: :makeup_elixir, repo: "hexpm", optional: false]}], "hexpm", "0db1ee8d1547ab4877c5b5dffc6604ef9454e189928d5ba8967d4a58a801f161"},
   "jason": {:hex, :jason, "1.1.2", "b03dedea67a99223a2eaf9f1264ce37154564de899fd3d8b9a21b1a6fd64afe7", [:mix], [{:decimal, "~> 1.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "fdf843bca858203ae1de16da2ee206f53416bbda5dc8c9e78f43243de4bc3afe"},
   "makeup": {:hex, :makeup, "1.0.0", "671df94cf5a594b739ce03b0d0316aa64312cee2574b6a44becb83cd90fb05dc", [:mix], [{:nimble_parsec, "~> 0.5.0", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "a10c6eb62cca416019663129699769f0c2ccf39428b3bb3c0cb38c718a0c186d"},

test/ecto/adapters/myxql_test.exs

@@ -492,6 +492,20 @@ defmodule Ecto.Adapters.MyXQLTest do
     assert all(query) == ~s{SELECT CAST(? AS char) FROM `schema` AS s0}
   end
 
+  test "json_extract_path" do
+    query = Schema |> select([r], json_extract_path(r, [0, 1])) |> plan()
+    assert all(query) == ~s{SELECT json_extract(s0, '$[0][1]') FROM `schema` AS s0}
+
+    query = Schema |> select([r], json_extract_path(r, ["a", "b"])) |> plan()
+    assert all(query) == ~s{SELECT json_extract(s0, '$."a"."b"') FROM `schema` AS s0}
+
+    query = Schema |> select([r], json_extract_path(r, ["'a"])) |> plan()
+    assert all(query) == ~s{SELECT json_extract(s0, '$."''a"') FROM `schema` AS s0}
+
+    query = Schema |> select([r], json_extract_path(r, ["\"a"])) |> plan()
+    assert all(query) == ~s{SELECT json_extract(s0, '$."\\\\"a"') FROM `schema` AS s0}
+  end
+
   test "nested expressions" do
     z = 123
     query = from(r in Schema, []) |> select([r], r.x > 0 and (r.y > ^(-z)) or true) |> plan()

test/ecto/adapters/postgres_test.exs

@@ -532,6 +532,20 @@ defmodule Ecto.Adapters.PostgresTest do
     assert all(query) == ~s{SELECT $1::uuid[] FROM "schema" AS s0}
   end
 
+  test "json_extract_path" do
+    query = Schema |> select([r], json_extract_path(r, [0, 1])) |> plan()
+    assert all(query) == ~s|SELECT (s0#>'{0,1}') FROM "schema" AS s0|
+
+    query = Schema |> select([r], json_extract_path(r, ["a", "b"])) |> plan()
+    assert all(query) == ~s|SELECT (s0#>'{"a","b"}') FROM "schema" AS s0|
+
+    query = Schema |> select([r], json_extract_path(r, ["'a"])) |> plan()
+    assert all(query) == ~s|SELECT (s0#>'{"''a"}') FROM "schema" AS s0|
+
+    query = Schema |> select([r], json_extract_path(r, ["\"a"])) |> plan()
+    assert all(query) == ~s|SELECT (s0#>'{"\\"a"}') FROM "schema" AS s0|
+  end
+
   test "nested expressions" do
     z = 123
     query = from(r in Schema, []) |> select([r], r.x > 0 and (r.y > ^(-z)) or true) |> plan()

test/ecto/adapters/tds_test.exs

@@ -204,7 +204,7 @@ defmodule Ecto.Adapters.TdsTest do
       |> select([r], r.x)
       |> plan()
 
-    assert_raise Ecto.QueryError, ~r"Unfortunately Tds adapter does not support fragment in CTE", fn ->
+    assert_raise Ecto.QueryError, ~r"Tds adapter does not support fragment in CTE", fn ->
       all(query)
     end
   end