Implement values

integration_test/test_helper.exs

@@ -126,9 +126,6 @@ excludes = [
 
   # SQLite does not support anything except a single column in DISTINCT
   :multicolumn_distinct,
-
-  # Values list
-  :values_list
 ]
 
 ExUnit.configure(exclude: excludes)

integration_test/values_test.exs

@@ -0,0 +1,59 @@
+defmodule Ecto.Integration.ValuesTest do
+  use Ecto.Integration.Case, async: true
+
+  import Ecto.Query, only: [from: 2, with_cte: 3]
+
+  alias Ecto.Integration.Comment
+  alias Ecto.Integration.Post
+  alias Ecto.Integration.TestRepo
+
+  test "join to values works" do
+    TestRepo.insert!(%Post{id: 1})
+    TestRepo.insert!(%Comment{post_id: 1, text: "short"})
+    TestRepo.insert!(%Comment{post_id: 1, text: "much longer text"})
+
+    params = [%{id: 1, post_id: 1, n: 0}, %{id: 2, post_id: 1, n: 10}]
+    types = %{id: :integer, post_id: :integer, n: :integer}
+
+    results =
+      from(p in Post,
+        right_join: params in values(params, types),
+        on: params.post_id == p.id,
+        left_join: c in Comment,
+        on: c.post_id == p.id and fragment("LENGTH(?)", c.text) > params.n,
+        group_by: params.id,
+        select: {params.id, count(c.id)}
+      )
+      |> TestRepo.all()
+
+    assert [{1, 2}, {2, 1}] = results
+  end
+
+  test "values can be used together with CTE" do
+    TestRepo.insert!(%Post{id: 1, visits: 42})
+    TestRepo.insert!(%Comment{post_id: 1, text: "short"})
+    TestRepo.insert!(%Comment{post_id: 1, text: "much longer text"})
+
+    params = [%{id: 1, post_id: 1, n: 0}, %{id: 2, post_id: 1, n: 10}]
+    types = %{id: :integer, post_id: :integer, n: :integer}
+
+    cte_query = from(p in Post, select: %{id: p.id, visits: coalesce(p.visits, 0)})
+
+    q = Post |> with_cte("xxx", as: ^cte_query)
+
+    results =
+      from(p in q,
+        right_join: params in values(params, types),
+        on: params.post_id == p.id,
+        left_join: c in Comment,
+        on: c.post_id == p.id and fragment("LENGTH(?)", c.text) > params.n,
+        left_join: cte in "xxx",
+        on: cte.id == p.id,
+        group_by: params.id,
+        select: {params.id, count(c.id), cte.visits}
+      )
+      |> TestRepo.all()
+
+    assert [{1, 2, 42}, {2, 1, 42}] = results
+  end
+end

lib/ecto/adapters/sqlite3/connection.ex

@@ -1037,12 +1037,6 @@ defmodule Ecto.Adapters.SQLite3.Connection do
       message: "join hints are not supported by SQLite3"
   end
 
-  defp assert_valid_join(%JoinExpr{source: {:values, _, _}}, query) do
-    raise Ecto.QueryError,
-      query: query,
-      message: "SQLite3 adapter does not support values lists"
-  end
-
   defp assert_valid_join(_join_expr, _query), do: :ok
 
   defp join_on(:cross, true, _sources, _query), do: []
@@ -1368,8 +1362,8 @@ defmodule Ecto.Adapters.SQLite3.Connection do
     |> parens_for_select
   end
 
-  defp expr({:values, _, _}, _, _query) do
-    raise ArgumentError, "SQLite3 adapter does not support values lists"
+  defp expr({:values, _, [types, idx, num_rows]}, _, _query) do
+    [?(, values_list(types, idx + 1, num_rows), ?)]
   end
 
   defp expr({:identifier, _, [literal]}, _sources, _query) do
@@ -1560,6 +1554,36 @@ defmodule Ecto.Adapters.SQLite3.Connection do
       message: "unsupported expression #{inspect(expr)}"
   end
 
+  defp values_list(types, idx, num_rows) do
+    rows = :lists.seq(1, num_rows, 1)
+    col_names = Enum.map_join(types, ", ", &elem(&1, 0))
+
+    [
+      "WITH xxx(",
+      col_names,
+      ") AS (VALUES ",
+      intersperse_reduce(rows, ?,, idx, fn _, idx ->
+        {value, idx} = values_expr(types, idx)
+        {[?(, value, ?)], idx}
+      end)
+      |> elem(0),
+      ") SELECT * FROM xxx"
+    ]
+  end
+
+  defp values_expr(types, idx) do
+    intersperse_reduce(types, ?,, idx, fn {_field, _type}, idx ->
+      # TODO: cast?
+      # {[?$, Integer.to_string(idx), ?:, ?: | tagged_to_db(type)], idx + 1}
+      {[?$, Integer.to_string(idx)], idx + 1}
+    end)
+  end
+
+  # defp tagged_to_db(:id), do: "bigint"
+  # defp tagged_to_db(:integer), do: "bigint"
+  # defp tagged_to_db({:array, type}), do: [tagged_to_db(type), ?[, ?]]
+  # defp tagged_to_db(type), do: ecto_to_db(type)
+
   def interval(_, "microsecond", _sources) do
     raise ArgumentError,
           "SQLite does not support microsecond precision in datetime intervals"
@@ -1618,6 +1642,9 @@ defmodule Ecto.Adapters.SQLite3.Connection do
       {:fragment, _, _} ->
         {nil, as_prefix ++ [?f | Integer.to_string(pos)], nil}
 
+      {:values, _, _} ->
+        {nil, as_prefix ++ [?v | Integer.to_string(pos)], nil}
+
       {table, schema, prefix} ->
         name = as_prefix ++ [create_alias(table) | Integer.to_string(pos)]
         {quote_table(prefix, table), name, schema}

test/ecto/adapters/sqlite3/connection/join_test.exs

@@ -135,11 +135,11 @@
     end
   end
 
-  test "join with values is not supported" do
-    assert_raise Ecto.QueryError, fn ->
-      rows = [%{x: 1, y: 1}, %{x: 2, y: 2}]
-      types = %{x: :integer, y: :integer}
+  test "join with values" do
+    rows = [%{x: 1, y: 1}, %{x: 2, y: 2}]
+    types = %{x: :integer, y: :integer}
 
+    query =
       Schema
       |> join(
         :inner,
@@ -149,8 +149,11 @@
       )
       |> select([p, q], {p.id, q.x})
       |> plan()
-      |> all()
-    end
+
+    assert ~s{SELECT s0."id", v1."x" FROM "schema" AS s0 } <>
+             ~s{INNER JOIN (WITH xxx(y, x) AS (VALUES ($1,$2),($3,$4)) SELECT * FROM xxx) AS v1 } <>
+             ~s{ON (v1."x" = s0."x") AND (v1."y" = s0."y")} ==
+             all(query)
   end
 
   test "join with fragment" do