diff --git a/lib/ecto/adapters/qlc.ex b/lib/ecto/adapters/qlc.ex
index 3ca80a3..75e98ac 100644
--- a/lib/ecto/adapters/qlc.ex
+++ b/lib/ecto/adapters/qlc.ex
@@ -91,8 +91,8 @@ defmodule EctoQLC.Adapters.QLC do
       end
 
       @impl Ecto.Adapter.Schema
-      def delete(adapter_meta, schema_meta, filters, options) do
-        EctoQLC.Adapters.QLC.delete(@driver, adapter_meta, schema_meta, filters, options)
+      def delete(adapter_meta, schema_meta, filters, returning, options) do
+        EctoQLC.Adapters.QLC.delete(@driver, adapter_meta, schema_meta, filters, returning, options)
       end
 
       @impl Ecto.Adapter.Schema
@@ -548,8 +548,8 @@ defmodule EctoQLC.Adapters.QLC do
     raise Ecto.QueryError, query: query, message: "QLC adapter does not support combinations like: #{Enum.map_join(combinations, ", ", fn {k, _} -> k end)}"
   end
   def prepare(adapter_meta, query_meta, %Ecto.Query{} = query, params, options) do
-    if query.select && Enum.any?(query.select.fields, &has_fragment/1), do: raise Ecto.QueryError, query: query, message: "QLC adapter does not support fragemnt in select clauses"
-    if query.wheres |> Enum.flat_map(&(&1.subqueries)) |> Enum.any?(&has_parent_as/1), do: raise Ecto.QueryError, query: query, message: "QLC adapter does not support parent_as in a subquery's where clauses"
+    if query.select && Enum.any?(query.select.fields, &has_fragment/1), do: raise(Ecto.QueryError, query: query, message: "QLC adapter does not support fragemnt in select clauses")
+    if query.wheres |> Enum.flat_map(&(&1.subqueries)) |> Enum.any?(&has_parent_as/1), do: raise(Ecto.QueryError, query: query, message: "QLC adapter does not support parent_as in a subquery's where clauses")
     options = options(query, options)
     prefix = options[:prefix] || query.from.prefix || query.prefix
     order_bys = if query.distinct && Keyword.keyword?(query.distinct.expr), do: [query.distinct | query.order_bys], else: query.order_bys
@@ -567,7 +567,7 @@ defmodule EctoQLC.Adapters.QLC do
   defp lock(adapter_meta, %Ecto.Query{lock: "write", from: %{source: {source, _module}}}, prefix), do: {{:table, to_table(adapter_meta, source, prefix, [])}, :write}
   defp lock(adapter_meta, %Ecto.Query{lock: "read", from: %{source: {source, _module}}}, prefix), do: {{:table, to_table(adapter_meta, source, prefix, [])}, :read}
   defp lock(adapter_meta, %Ecto.Query{lock: "sticky_write", from: %{source: {source, _module}}}, prefix), do: {{:table, to_table(adapter_meta, source, prefix, [])}, :sticky_write}
-  defp lock(_adapter_meta, %Ecto.Query{lock: lock} = query, _prefix), do: raise Ecto.QueryError, query: query, message: "Unsupported lock: #{inspect lock}, supported locks: write, read, stickey_write"
+  defp lock(_adapter_meta, %Ecto.Query{lock: lock} = query, _prefix), do: raise(Ecto.QueryError, query: query, message: "Unsupported lock: #{inspect lock}, supported locks: write, read, stickey_write")
 
   defp offset(%Ecto.Query{offset: %{expr: {:^, _, [idx]}}}, params), do: Enum.at(params, idx, idx)
   defp offset(%Ecto.Query{offset: %{expr: expr}}, _params), do: expr
@@ -648,7 +648,7 @@ defmodule EctoQLC.Adapters.QLC do
 
   defp options(%Ecto.Query{} = query, options) do
     unique = unique?(query)
-    if options[:unique] && unique, do: raise Ecto.QueryError, query: query, message: "QLC does not support mixing distinct in queries and unique options"
+    if options[:unique] && unique, do: raise(Ecto.QueryError, query: query, message: "QLC does not support mixing distinct in queries and unique options")
     options
     # |> Keyword.put_new(:unique, unique)
     |> Enum.take_while(fn
@@ -656,7 +656,7 @@ defmodule EctoQLC.Adapters.QLC do
       k -> k in ~w[cache unique]a
     end)
     |> Enum.map(fn
-      {:join, join} when join not in ~w[any merge lookup nested_loop]a -> raise Ecto.QueryError, query: query, message: "QLC only supports: :any, :merge, :lookup or :nested_loop joins, got: `#{inspect(join)}`"
+      {:join, join} when join not in ~w[any merge lookup nested_loop]a -> raise(Ecto.QueryError, query: query, message: "QLC only supports: :any, :merge, :lookup or :nested_loop joins, got: `#{inspect(join)}`")
       x -> x
     end)
   end
@@ -680,20 +680,20 @@ defmodule EctoQLC.Adapters.QLC do
      else
       '{#{Enum.map_join(0..count, ", ", fn idx ->
         case elem(query.sources, idx) do
-          {<<s::binary-size(1), _::binary()>> = source, nil, prefix} ->
+          {<<s::binary-size(1), _::binary>> = source, nil, prefix} ->
             table = to_table(adapter_meta, source, prefix, options)
             [primary_keys | fields] = if mod == :mnesia and table in :mnesia.system_info(:tables), do: :mnesia.table_info(table, :attributes), else: [:version, :inserted_at]
             primary_keys = if source == "schema_migrations", do: [:version], else: [primary_keys]
             Enum.map_join(fields, ", ", &to_element(adapter_meta, &1, fields, primary_keys, "#{String.upcase(s)}#{idx}"))
 
-          {<<s::binary-size(1), _::binary()>>, module, _} ->
+          {<<s::binary-size(1), _::binary>>, module, _} ->
             Enum.map_join(module.__schema__(:fields), ", ", &to_element(adapter_meta, &1, module.__schema__(:fields), module.__schema__(:primary_key), "#{String.upcase(s)}#{idx}"))
 
-          %{query: %{sources: {{<<s::binary-size(1), _::binary()>>, module, _}}}} ->
+          %{query: %{sources: {{<<s::binary-size(1), _::binary>>, module, _}}}} ->
             Enum.map_join(module.__schema__(:fields), ", ", &to_element(adapter_meta, &1, module.__schema__(:fields), module.__schema__(:primary_key), "#{String.upcase(s)}#{idx}"))
 
           %{query: query} ->
-            {<<s::binary-size(1), _::binary()>>, module, _} = elem(query.sources, idx)
+            {<<s::binary-size(1), _::binary>>, module, _} = elem(query.sources, idx)
             Enum.map_join(module.__schema__(:fields), ", ", &to_element(adapter_meta, &1, module.__schema__(:fields), module.__schema__(:primary_key), "#{String.upcase(s)}#{idx}"))
 
         end
@@ -711,13 +711,13 @@ defmodule EctoQLC.Adapters.QLC do
     table_opts = Keyword.take(options, take)
     generators = Enum.map_join(0..count, ", ", fn idx ->
       case elem(query.sources, idx) do
-      {<<s::binary-size(1), _::binary()>> = source, _module, _} ->
+      {<<s::binary-size(1), _::binary>> = source, _module, _} ->
       "#{String.upcase(s)}#{idx} <- #{mod}:table('#{to_table(adapter_meta, source, prefix, options)}', [#{Enum.map_join(table_opts, ", ", fn {k, v} -> "{#{k}, #{v}}" end)}])"
-      %{query: %{sources: {{<<s::binary-size(1), _::binary()>> = source, _module, _}}}} ->
+      %{query: %{sources: {{<<s::binary-size(1), _::binary>> = source, _module, _}}}} ->
         "#{String.upcase(s)}#{idx} <- #{mod}:table('#{to_table(adapter_meta, source, prefix, options)}', [#{Enum.map_join(table_opts, ", ", fn {k, v} -> "{#{k}, #{v}}" end)}])"
 
       %{query: %{sources: sources}} ->
-        {<<s::binary-size(1), _::binary()>> = source, _module, _} = elem(sources, idx)
+        {<<s::binary-size(1), _::binary>> = source, _module, _} = elem(sources, idx)
         "#{String.upcase(s)}#{idx} <- #{mod}:table('#{to_table(adapter_meta, source, prefix, options)}', [#{Enum.map_join(table_opts, ", ", fn {k, v} -> "{#{k}, #{v}}" end)}])"
       end
     end)
@@ -759,7 +759,7 @@ defmodule EctoQLC.Adapters.QLC do
 
   defp to_order(_query, :asc), do: :ascending
   defp to_order(_query, :desc), do: :descending
-  defp to_order(query, order), do: raise Ecto.QueryError, query: query, message: "QLC does not support ordering by: #{inspect order}"
+  defp to_order(query, order), do: raise(Ecto.QueryError, query: query, message: "QLC does not support ordering by: #{inspect order}")
 
   defp expr({_, _,[{{_, _, [{:parent_as, _, _}, _]}, _, _}, _]}, _query), do: ""
   defp expr({_, _,[_, {{_, _, [{:parent_as, _, _}, _]}, _, _}]}, _query), do: ""
@@ -793,7 +793,7 @@ defmodule EctoQLC.Adapters.QLC do
   defp expr({:not = operator, mdl, [{:in, mdr, [left, %Ecto.SubQuery{} = subquery]}]}, {adapter_meta, _query_meta, query, params, options} = q), do: expr({operator, mdl, [{:in, mdr, [left, elem(execute(adapter_meta, query, {:all, subquery.query}, params, options), 1)]}]}, q)
   defp expr({:not = operator, _, [{:in, _, _} = expr]}, query), do: unroll(expr, query, operator)
   defp expr({:not = operator, [], [{:is_nil, _, [{{:., _, [{:&, _, [index]}, column]}, _, _}]}]}, {adapter_meta, _query_meta, query, _params, _options}) do
-    {<<s::binary-size(1), _::binary()>>, module, _prefix} = elem(query.sources, index)
+    {<<s::binary-size(1), _::binary>>, module, _prefix} = elem(query.sources, index)
     "#{to_element(adapter_meta, column, module.__schema__(:fields), module.__schema__(:primary_key), "#{String.upcase(s)}#{index}")} #{to_erlang_term(operator)} nil"
   end
   defp expr({:not, _, [expr]}, query) do
@@ -837,20 +837,20 @@ defmodule EctoQLC.Adapters.QLC do
   defp expr({:parent_as, _, [key]}, {_adapter_meta, query_meta, _query, _params, _options}), do: query_meta.aliases[key]
   defp expr({:., _, [{:&, _, [idx]}, column]}, {adapter_meta, _query_meta, query, _params, options}) do
     case elem(query.sources, idx) do
-      {<<s::binary-size(1), _::binary()>> = source, nil, prefix} when adapter_meta.adapter == EctoQLC.Adapters.Mnesia ->
+      {<<s::binary-size(1), _::binary>> = source, nil, prefix} when adapter_meta.adapter == EctoQLC.Adapters.Mnesia ->
         attributes = :mnesia.table_info(to_table(adapter_meta, source, prefix, options), :attributes)
         to_element(adapter_meta, column, tl(attributes), [hd(attributes)], "#{String.upcase(s)}#{idx}")
 
       {"schema_migrations", nil, _prefix} ->
         to_element(adapter_meta, column, Ecto.Migration.SchemaMigration.__schema__(:fields), Ecto.Migration.SchemaMigration.__schema__(:primary_key), "S#{idx}")
 
-      {<<s::binary-size(1), _::binary()>>, module, _prefix} ->
+      {<<s::binary-size(1), _::binary>>, module, _prefix} ->
         to_element(adapter_meta, column, module.__schema__(:fields), module.__schema__(:primary_key), "#{String.upcase(s)}#{idx}")
     end
   end
   defp expr({:., _, [{:parent_as, _, [key]}, column]}, {adapter_meta, query_meta, _query, _params, _options}) do
     idx = query_meta.aliases[key]
-    {<<s::binary-size(1), _::binary()>>, module, _prefix} = elem(query_meta.sources, query_meta.aliases[key])
+    {<<s::binary-size(1), _::binary>>, module, _prefix} = elem(query_meta.sources, query_meta.aliases[key])
     to_element(adapter_meta, column, module.__schema__(:fields), module.__schema__(:primary_key), "#{String.upcase(s)}#{idx}")
   end
   defp expr({:in, metadata, [left, %Ecto.SubQuery{} = subquery]}, {adapter_meta, _query_meta, query, params, options} = q), do: expr({:in, metadata, [left, elem(execute(adapter_meta, query, {:all, subquery.query}, params, options), 1)]}, q)
@@ -914,10 +914,15 @@ defmodule EctoQLC.Adapters.QLC do
   defp expr({:^, _, [idx]}, _row, {_adapter_meta, _query_meta, _query, params, _options}), do: Enum.at(params, idx, idx)
   defp expr({:like, _, [left, right]}, row, query), do: String.match?(expr(left, row, query), Regex.compile!(expr(right, row, query)))
   defp expr({:ilike, _, [left, right]}, row, query), do: String.match?(expr(left, row, query), Regex.compile!(expr(right, row, query), [:caseless]))
-  defp expr({:json_extract_path, _, [left, right]}, row, query), do: Enum.reduce(expr(right, row, query), expr(left, row, query), fn
+  defp expr({:json_extract_path, _, [left, right]}, row, query) do
+    Enum.reduce(expr(right, row, query), expr(left, row, query), fn
+    _k, nil = data -> data
     k, %_{} = struct -> Map.get(struct, String.to_existing_atom(k))
+    k, data when is_integer(k) and is_list(data) -> Enum.at(data, k)
+    k, data when is_integer(k) and is_tuple(data) -> elem(data, k)
     k, data -> data[k] || data[String.to_existing_atom(k)]
   end)
+  end
   defp expr({operator, md, [%Ecto.Query.Tagged{value: expr}, right, interval]}, row, query) when operator in ~w[datetime_add date_add]a do
     expr({operator, md, [expr, right, interval]}, row, query)
   end
@@ -1027,7 +1032,7 @@ defmodule EctoQLC.Adapters.QLC do
   defp update(:dets = mod, table, row, query), do: mod.insert(table, Enum.reduce(Keyword.values(query.updates), row, fn {idx, value}, row -> :erlang.setelement(idx, row, value) end))
 
   @doc false
-  def delete(mod, adapter_meta, %{source: source, prefix: prefix, schema: schema}, filters, options) when mod in ~w[dets ets]a do
+  def delete(mod, adapter_meta, %{source: source, prefix: prefix, schema: schema}, filters, _returning, options) when mod in ~w[dets ets]a do
     table = to_table(adapter_meta, source, prefix, options)
     ms = to_match_spec(adapter_meta, schema, filters)
     {query_time, count} = :timer.tc(mod, :select_delete, [table, ms])
@@ -1038,7 +1043,7 @@ defmodule EctoQLC.Adapters.QLC do
     end
     |> log(source, "DELETE #{inspect source} #{inspect filters} MATCHSPEC #{inspect ms}", query_time, 0, 0, 0, :delete_all, adapter_meta.telemetry, filters, options ++ adapter_meta.opts)
   end
-  def delete(:mnesia = mod, adapter_meta, %{source: source, prefix: prefix, schema: schema}, filters, options) do
+  def delete(:mnesia = mod, adapter_meta, %{source: source, prefix: prefix, schema: schema}, filters, _returning, options) do
     ms = to_match_spec(adapter_meta, schema, filters)
     fun = fn ->
             with table <- to_table(adapter_meta, source, prefix, options),
@@ -1294,7 +1299,7 @@ defmodule EctoQLC.Adapters.QLC do
 
   defp unroll({:in, _, [{{:., [], [{:&, [], [index]}, column]}, _, _}, values]}, {adapter_meta, _query_meta, query, _params, _options} = q, operator) do
     [v | values] = unbind(values, q)
-    {<<s::binary-size(1), _::binary()>>, module, _prefix} = elem(query.sources, index)
+    {<<s::binary-size(1), _::binary>>, module, _prefix} = elem(query.sources, index)
     el = to_element(adapter_meta, column, module.__schema__(:fields), module.__schema__(:primary_key), "#{String.upcase(s)}#{index}")
     values
     |> Enum.reduce(["#{el} #{to_erlang_term(operator)} #{v}"], fn v, acc -> acc ++ [" orelse #{el} #{to_erlang_term(operator)} #{v}"] end)
@@ -1306,7 +1311,7 @@ defmodule EctoQLC.Adapters.QLC do
   defp unbind([_ | _] = values, query), do: Enum.map(values, &unbind(&1, query))
   defp unbind(value, _meta), do: to_erlang_term(value)
 
-  defp to_erlang_term(<<value::binary()>>), do: '<<"#{value}">>'
+  defp to_erlang_term(<<value::binary>>), do: '<<"#{value}">>'
   defp to_erlang_term(:or), do: :orelse
   defp to_erlang_term(:and), do: :andalso
   defp to_erlang_term(:<=), do: :"=<"
diff --git a/mix.exs b/mix.exs
index ffc7213..7435f34 100644
--- a/mix.exs
+++ b/mix.exs
@@ -50,7 +50,7 @@ defmodule EctoQlc.MixProject do
     if path = System.get_env("ECTO_PATH") do
       {:ecto, path: path}
     else
-      {:ecto, "~> 3.9.0"}
+      {:ecto, git: "https://github.com/elixir-ecto/ecto.git"}
     end
   end
 
@@ -58,7 +58,7 @@ defmodule EctoQlc.MixProject do
     if path = System.get_env("ECTO_SQL_PATH") do
       {:ecto_sql, path: path}
     else
-      {:ecto_sql, "~> 3.9.0"}
+      {:ecto_sql, git: "https://github.com/elixir-ecto/ecto_sql.git"}
     end
   end
 
diff --git a/mix.lock b/mix.lock
index b62fc7d..245f890 100644
--- a/mix.lock
+++ b/mix.lock
@@ -2,20 +2,19 @@
   "benchee": {:hex, :benchee, "1.1.0", "f3a43817209a92a1fade36ef36b86e1052627fd8934a8b937ac9ab3a76c43062", [:mix], [{:deep_merge, "~> 1.0", [hex: :deep_merge, repo: "hexpm", optional: false]}, {:statistex, "~> 1.0", [hex: :statistex, repo: "hexpm", optional: false]}], "hexpm", "7da57d545003165a012b587077f6ba90b89210fd88074ce3c60ce239eb5e6d93"},
   "benchee_html": {:hex, :benchee_html, "1.0.0", "5b4d24effebd060f466fb460ec06576e7b34a00fc26b234fe4f12c4f05c95947", [:mix], [{:benchee, ">= 0.99.0 and < 2.0.0", [hex: :benchee, repo: "hexpm", optional: false]}, {:benchee_json, "~> 1.0", [hex: :benchee_json, repo: "hexpm", optional: false]}], "hexpm", "5280af9aac432ff5ca4216d03e8a93f32209510e925b60e7f27c33796f69e699"},
   "benchee_json": {:hex, :benchee_json, "1.0.0", "cc661f4454d5995c08fe10dd1f2f72f229c8f0fb1c96f6b327a8c8fc96a91fe5", [:mix], [{:benchee, ">= 0.99.0 and < 2.0.0", [hex: :benchee, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm", "da05d813f9123505f870344d68fb7c86a4f0f9074df7d7b7e2bb011a63ec231c"},
-  "connection": {:hex, :connection, "1.1.0", "ff2a49c4b75b6fb3e674bfc5536451607270aac754ffd1bdfe175abe4a6d7a68", [:mix], [], "hexpm", "722c1eb0a418fbe91ba7bd59a47e28008a189d47e37e0e7bb85585a016b2869c"},
-  "db_connection": {:hex, :db_connection, "2.4.3", "3b9aac9f27347ec65b271847e6baeb4443d8474289bd18c1d6f4de655b70c94d", [:mix], [{:connection, "~> 1.0", [hex: :connection, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "c127c15b0fa6cfb32eed07465e05da6c815b032508d4ed7c116122871df73c12"},
-  "decimal": {:hex, :decimal, "2.0.0", "a78296e617b0f5dd4c6caf57c714431347912ffb1d0842e998e9792b5642d697", [:mix], [], "hexpm", "34666e9c55dea81013e77d9d87370fe6cb6291d1ef32f46a1600230b1d44f577"},
+  "db_connection": {:hex, :db_connection, "2.6.0", "77d835c472b5b67fc4f29556dee74bf511bbafecdcaf98c27d27fa5918152086", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "c2f992d15725e721ec7fbc1189d4ecdb8afef76648c746a8e1cad35e3b8a35f3"},
+  "decimal": {:hex, :decimal, "2.1.1", "5611dca5d4b2c3dd497dec8f68751f1f1a54755e8ed2a966c2633cf885973ad6", [:mix], [], "hexpm", "53cfe5f497ed0e7771ae1a475575603d77425099ba5faef9394932b35020ffcc"},
   "deep_merge": {:hex, :deep_merge, "1.0.0", "b4aa1a0d1acac393bdf38b2291af38cb1d4a52806cf7a4906f718e1feb5ee961", [:mix], [], "hexpm", "ce708e5f094b9cd4e8f2be4f00d2f4250c4095be93f8cd6d018c753894885430"},
-  "earmark_parser": {:hex, :earmark_parser, "1.4.29", "149d50dcb3a93d9f3d6f3ecf18c918fb5a2d3c001b5d3305c926cddfbd33355b", [:mix], [], "hexpm", "4902af1b3eb139016aed210888748db8070b8125c2342ce3dcae4f38dcc63503"},
-  "ecto": {:hex, :ecto, "3.9.2", "017db3bc786ff64271108522c01a5d3f6ba0aea5c84912cfb0dd73bf13684108", [:mix], [{:decimal, "~> 1.6 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "21466d5177e09e55289ac7eade579a642578242c7a3a9f91ad5c6583337a9d15"},
-  "ecto_sql": {:hex, :ecto_sql, "3.9.1", "9bd5894eecc53d5b39d0c95180d4466aff00e10679e13a5cfa725f6f85c03c22", [:mix], [{:db_connection, "~> 2.4.1 or ~> 2.5", [hex: :db_connection, repo: "hexpm", optional: false]}, {:ecto, "~> 3.9.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:myxql, "~> 0.6.0", [hex: :myxql, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.16.0 or ~> 1.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:tds, "~> 2.1.1 or ~> 2.2", [hex: :tds, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.0 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "5fd470a4fff2e829bbf9dcceb7f3f9f6d1e49b4241e802f614de6b8b67c51118"},
-  "ex_doc": {:hex, :ex_doc, "0.29.1", "b1c652fa5f92ee9cf15c75271168027f92039b3877094290a75abcaac82a9f77", [: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", "b7745fa6374a36daf484e2a2012274950e084815b936b1319aeebcf7809574f6"},
-  "jason": {:hex, :jason, "1.4.0", "e855647bc964a44e2f67df589ccf49105ae039d4179db7f6271dfd3843dc27e6", [:mix], [{:decimal, "~> 1.0 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "79a3791085b2a0f743ca04cec0f7be26443738779d09302e01318f97bdb82121"},
+  "earmark_parser": {:hex, :earmark_parser, "1.4.37", "2ad73550e27c8946648b06905a57e4d454e4d7229c2dafa72a0348c99d8be5f7", [:mix], [], "hexpm", "6b19783f2802f039806f375610faa22da130b8edc21209d0bff47918bb48360e"},
+  "ecto": {:git, "https://github.com/elixir-ecto/ecto.git", "8fac7068ed28cbb63c9844bb4cfba09fb48b9a09", []},
+  "ecto_sql": {:git, "https://github.com/elixir-ecto/ecto_sql.git", "6ee09bca6c79ec273a6cf178f45f594fb51dd68b", []},
+  "ex_doc": {:hex, :ex_doc, "0.30.9", "d691453495c47434c0f2052b08dd91cc32bc4e1a218f86884563448ee2502dd2", [:mix], [{:earmark_parser, "~> 1.4.31", [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", "d7aaaf21e95dc5cddabf89063327e96867d00013963eadf2c6ad135506a8bc10"},
+  "jason": {:hex, :jason, "1.4.1", "af1504e35f629ddcdd6addb3513c3853991f694921b1b9368b0bd32beb9f1b63", [:mix], [{:decimal, "~> 1.0 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "fbb01ecdfd565b56261302f7e1fcc27c4fb8f32d56eab74db621fc154604a7a1"},
   "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"},
-  "makeup_elixir": {:hex, :makeup_elixir, "0.16.0", "f8c570a0d33f8039513fbccaf7108c5d750f47d8defd44088371191b76492b0b", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}, {:nimble_parsec, "~> 1.2.3", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "28b2cbdc13960a46ae9a8858c4bebdec3c9a6d7b4b9e7f4ed1502f8159f338e7"},
-  "makeup_erlang": {:hex, :makeup_erlang, "0.1.1", "3fcb7f09eb9d98dc4d208f49cc955a34218fc41ff6b84df7c75b3e6e533cc65f", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm", "174d0809e98a4ef0b3309256cbf97101c6ec01c4ab0b23e926a9e17df2077cbb"},
-  "nimble_parsec": {:hex, :nimble_parsec, "1.2.3", "244836e6e3f1200c7f30cb56733fd808744eca61fd182f731eac4af635cc6d0b", [:mix], [], "hexpm", "c8d789e39b9131acf7b99291e93dae60ab48ef14a7ee9d58c6964f59efb570b0"},
-  "postgrex": {:hex, :postgrex, "0.16.5", "fcc4035cc90e23933c5d69a9cd686e329469446ef7abba2cf70f08e2c4b69810", [:mix], [{:connection, "~> 1.1", [hex: :connection, repo: "hexpm", optional: false]}, {:db_connection, "~> 2.1", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.5 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:table, "~> 0.1.0", [hex: :table, repo: "hexpm", optional: true]}], "hexpm", "edead639dc6e882618c01d8fc891214c481ab9a3788dfe38dd5e37fd1d5fb2e8"},
+  "makeup_elixir": {:hex, :makeup_elixir, "0.16.1", "cc9e3ca312f1cfeccc572b37a09980287e243648108384b97ff2b76e505c3555", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}, {:nimble_parsec, "~> 1.2.3 or ~> 1.3", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "e127a341ad1b209bd80f7bd1620a15693a9908ed780c3b763bccf7d200c767c6"},
+  "makeup_erlang": {:hex, :makeup_erlang, "0.1.2", "ad87296a092a46e03b7e9b0be7631ddcf64c790fa68a9ef5323b6cbb36affc72", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm", "f3f5a1ca93ce6e092d92b6d9c049bcda58a3b617a8d888f8e7231c85630e8108"},
+  "nimble_parsec": {:hex, :nimble_parsec, "1.3.1", "2c54013ecf170e249e9291ed0a62e5832f70a476c61da16f6aac6dca0189f2af", [:mix], [], "hexpm", "2682e3c0b2eb58d90c6375fc0cc30bc7be06f365bf72608804fb9cffa5e1b167"},
+  "postgrex": {:hex, :postgrex, "0.17.3", "c92cda8de2033a7585dae8c61b1d420a1a1322421df84da9a82a6764580c503d", [:mix], [{:db_connection, "~> 2.1", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.5 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:table, "~> 0.1.0", [hex: :table, repo: "hexpm", optional: true]}], "hexpm", "946cf46935a4fdca7a81448be76ba3503cff082df42c6ec1ff16a4bdfbfb098d"},
   "statistex": {:hex, :statistex, "1.0.0", "f3dc93f3c0c6c92e5f291704cf62b99b553253d7969e9a5fa713e5481cd858a5", [:mix], [], "hexpm", "ff9d8bee7035028ab4742ff52fc80a2aa35cece833cf5319009b52f1b5a86c27"},
-  "telemetry": {:hex, :telemetry, "1.1.0", "a589817034a27eab11144ad24d5c0f9fab1f58173274b1e9bae7074af9cbee51", [:rebar3], [], "hexpm", "b727b2a1f75614774cff2d7565b64d0dfa5bd52ba517f16543e6fc7efcc0df48"},
+  "telemetry": {:hex, :telemetry, "1.2.1", "68fdfe8d8f05a8428483a97d7aab2f268aaff24b49e0f599faa091f1d4e7f61c", [:rebar3], [], "hexpm", "dad9ce9d8effc621708f99eac538ef1cbe05d6a874dd741de2e689c47feafed5"},
 }
diff --git a/test/ecto/adapters/dets_test.exs b/test/ecto/adapters/dets_test.exs
index b560dc5..bb0bdfd 100644
--- a/test/ecto/adapters/dets_test.exs
+++ b/test/ecto/adapters/dets_test.exs
@@ -326,7 +326,7 @@ defmodule EctoQLC.Adapters.DETSTest do
       refute Repo.one(where(User, [u], u.email not in subquery(select(User, [:email]))))
       assert Repo.one(select(User, [u], u.email in subquery(select(User, [:email]))))
       assert 0 < Repo.one(from u in subquery(where(User, email: "user@example.com")), select: avg(u.id))
-      assert [%User{email: "user@example.com"}] = Repo.all(join(User, :inner, [u], t in subquery(where(User, email: "user@example.com")), as: :users))
+      assert [%User{email: "user@example.com"}] = Repo.all(join(User, :inner, [u], t in subquery(where(User, email: "user@example.com")), on: true, as: :users))
     end
 
     test "union/1" do
diff --git a/test/ecto/adapters/ets_test.exs b/test/ecto/adapters/ets_test.exs
index 3626f59..f1858e5 100644
--- a/test/ecto/adapters/ets_test.exs
+++ b/test/ecto/adapters/ets_test.exs
@@ -326,7 +326,7 @@ defmodule EctoQLC.Adapters.ETSTest do
       refute Repo.one(where(User, [u], u.email not in subquery(select(User, [:email]))))
       assert Repo.one(select(User, [u], u.email in subquery(select(User, [:email]))))
       assert 0 < Repo.one(from u in subquery(where(User, email: "user@example.com")), select: avg(u.id))
-      assert [%User{email: "user@example.com"}] = Repo.all(join(User, :inner, [u], t in subquery(where(User, email: "user@example.com")), as: :users))
+      assert [%User{email: "user@example.com"}] = Repo.all(join(User, :inner, [u], t in subquery(where(User, email: "user@example.com")), on: true, as: :users))
     end
 
     test "union/1" do
diff --git a/test/ecto/adapters/mnesia_test.exs b/test/ecto/adapters/mnesia_test.exs
index d24d603..6ed7ae4 100644
--- a/test/ecto/adapters/mnesia_test.exs
+++ b/test/ecto/adapters/mnesia_test.exs
@@ -329,7 +329,7 @@ defmodule EctoQLC.Adapters.MnesiaTest do
       refute Repo.one(where(User, [u], u.email not in subquery(select(User, [:email]))))
       assert Repo.one(select(User, [u], u.email in subquery(select(User, [:email]))))
       assert 0 < Repo.one(from u in subquery(where(User, email: "user@example.com")), select: avg(u.id))
-      assert [%User{email: "user@example.com"}] = Repo.all(join(User, :inner, [u], t in subquery(where(User, email: "user@example.com")), as: :users))
+      assert [%User{email: "user@example.com"}] = Repo.all(join(User, :inner, [u], t in subquery(where(User, email: "user@example.com")), on: true, as: :users))
     end
 
     test "union/1" do
diff --git a/test/ecto/adapters/postgres_test.exs b/test/ecto/adapters/postgres_test.exs
index 78bc2ee..39f5501 100644
--- a/test/ecto/adapters/postgres_test.exs
+++ b/test/ecto/adapters/postgres_test.exs
@@ -307,7 +307,7 @@ defmodule EctoQLC.Adapters.PostgresTest do
       refute Repo.one(where(User, [u], u.email not in subquery(select(User, [:email]))))
       assert Repo.one(select(User, [u], u.email in subquery(select(User, [:email]))))
       assert [%Decimal{}] = Repo.all(from u in subquery(where(User, email: "user@example.com")), select: avg(u.id))
-      assert [%User{email: "user@example.com"}] = Repo.all(join(User, :inner, [u], t in subquery(where(User, email: "user@example.com")), as: :users))
+      assert [%User{email: "user@example.com"}] = Repo.all(join(User, :inner, [u], t in subquery(where(User, email: "user@example.com")), on: true, as: :users))
     end
 
     test "union/1" do