Make uuid encoding configurable and consistent

CHANGELOG.md

@@ -5,6 +5,12 @@ All notable changes will be documented in this file.
 The format is based on [Keep a Changelog][keepachangelog], and this project
 adheres to [Semantic Versioning][semver].
 
+## [Unreleased]
+### Changed
+- UUID encoding for both `:binary_id` and `:uuid`/`Ecto.UUID` is now configurable
+- `:uuid`/`Ecto.UUID` is now encoded as a string by default
+
+
 ## [0.6.0] - 2021-08-25
 ### Changed
 - `:utc_datetime` handling has been updated to completely remove the `Z` supplied and

lib/ecto/adapters/sqlite3.ex

@@ -284,6 +284,22 @@ defmodule Ecto.Adapters.SQLite3 do
     [&Codec.decimal_decode/1, type]
   end
 
+  @impl Ecto.Adapter
+  def loaders(:binary_id, type) do
+    case Application.get_env(:ecto_sqlite3, :binary_id_type, :string) do
+      :string -> [type]
+      :binary -> [Ecto.UUID, type]
+    end
+  end
+
+  @impl Ecto.Adapter
+  def loaders(:uuid, type) do
+    case Application.get_env(:ecto_sqlite3, :uuid_type, :string) do
+      :string -> []
+      :binary -> [type]
+    end
+  end
+
   # when we have an e.g., max(created_date) function
   # Ecto does not truly know the return type, hence :maybe
   # see Ecto.Query.Planner.collect_fields
@@ -316,6 +332,22 @@ defmodule Ecto.Adapters.SQLite3 do
     [type, &Codec.decimal_encode/1]
   end
 
+  @impl Ecto.Adapter
+  def dumpers(:binary_id, type) do
+    case Application.get_env(:ecto_sqlite3, :binary_id_type, :string) do
+      :string -> [type]
+      :binary -> [type, Ecto.UUID]
+    end
+  end
+
+  @impl Ecto.Adapter
+  def dumpers(:uuid, type) do
+    case Application.get_env(:ecto_sqlite3, :uuid_type, :string) do
+      :string -> []
+      :binary -> [type]
+    end
+  end
+
   @impl Ecto.Adapter
   def dumpers(:time, type) do
     [type, &Codec.time_encode/1]

lib/ecto/adapters/sqlite3/data_type.ex

@@ -12,14 +12,9 @@ defmodule Ecto.Adapters.SQLite3.DataType do
   def column_type(:serial, _opts), do: "INTEGER"
   def column_type(:bigserial, _opts), do: "INTEGER"
   def column_type(:bigint, _opts), do: "INTEGER"
-  # TODO: We should make this configurable
-  def column_type(:binary_id, _opts), do: "TEXT"
   def column_type(:string, _opts), do: "TEXT"
   def column_type(:float, _opts), do: "NUMERIC"
   def column_type(:binary, _opts), do: "BLOB"
-  # TODO: We should make this configurable
-  # SQLite3 does not support uuid
-  def column_type(:uuid, _opts), do: "TEXT"
   def column_type(:map, _opts), do: "JSON"
   def column_type(:array, _opts), do: "JSON"
   def column_type({:map, _}, _opts), do: "JSON"
@@ -42,6 +37,20 @@ defmodule Ecto.Adapters.SQLite3.DataType do
     end
   end
 
+  def column_type(:binary_id, _opts) do
+    case Application.get_env(:ecto_sqlite3, :binary_id_type, :string) do
+      :string -> "TEXT_UUID"
+      :binary -> "UUID"
+    end
+  end
+
+  def column_type(:uuid, _opts) do
+    case Application.get_env(:ecto_sqlite3, :uuid_type, :string) do
+      :string -> "TEXT_UUID"
+      :binary -> "UUID"
+    end
+  end
+
   def column_type(type, _) do
     type
     |> Atom.to_string()

test/ecto/adapters/sqlite3/connection_test.exs

@@ -947,15 +947,13 @@ defmodule Ecto.Adapters.SQLite3.ConnectionTest do
     assert all(query) == ~s{SELECT 1 FROM "schema" AS s0 WHERE (s0."foo" = (0 + 123.0))}
   end
 
-  # TODO: We need to determine what format to store the UUID. Is it Text or binary 16?
-  #       Are we going for readability or for compactness?
   test "tagged type" do
     query =
       Schema
       |> select([], type(^"601d74e4-a8d3-4b6e-8365-eddb4c893327", Ecto.UUID))
       |> plan()
 
-    assert all(query) == ~s{SELECT CAST(? AS TEXT) FROM "schema" AS s0}
+    assert all(query) == ~s{SELECT CAST(? AS TEXT_UUID) FROM "schema" AS s0}
   end
 
   test "string type" do

test/ecto/adapters/sqlite3/data_type_test.exs

@@ -1,8 +1,18 @@
 defmodule Ecto.Adapters.SQLite3.DataTypeTest do
-  use ExUnit.Case, async: true
+  use ExUnit.Case, async: false
 
   alias Ecto.Adapters.SQLite3.DataType
 
+  setup do
+    Application.put_env(:ecto_sqlite3, :binary_id_type, :string)
+    Application.put_env(:ecto_sqlite3, :uuid_type, :string)
+
+    on_exit(fn ->
+      Application.put_env(:ecto_sqlite3, :binary_id_type, :string)
+      Application.put_env(:ecto_sqlite3, :uuid_type, :string)
+    end)
+  end
+
   describe ".column_type/2" do
     test ":id is INTEGER" do
       assert DataType.column_type(:id, nil) == "INTEGER"
@@ -16,16 +26,24 @@ defmodule Ecto.Adapters.SQLite3.DataTypeTest do
       assert DataType.column_type(:bigserial, nil) == "INTEGER"
     end
 
-    test ":binary_id is TEXT" do
-      assert DataType.column_type(:binary_id, nil) == "TEXT"
+    test ":binary_id is TEXT_UUID OR UUID" do
+      assert DataType.column_type(:binary_id, nil) == "TEXT_UUID"
+
+      Application.put_env(:ecto_sqlite3, :binary_id_type, :binary)
+
+      assert DataType.column_type(:binary_id, nil) == "UUID"
     end
 
     test ":string is TEXT" do
       assert DataType.column_type(:string, nil) == "TEXT"
     end
 
-    test ":uuid is TEXT" do
-      assert DataType.column_type(:uuid, nil) == "TEXT"
+    test ":uuid is TEXT_UUID or UUID" do
+      assert DataType.column_type(:uuid, nil) == "TEXT_UUID"
+
+      Application.put_env(:ecto_sqlite3, :uuid_type, :binary)
+
+      assert DataType.column_type(:uuid, nil) == "UUID"
     end
 
     test ":map is JSON" do

test/ecto/integration/uuid_test.exs

@@ -1,10 +1,29 @@
 defmodule Ecto.Integration.UUIDTest do
-  use Ecto.Integration.Case
+  use Ecto.Integration.Case, async: false
 
   alias Ecto.Integration.TestRepo
   alias EctoSQLite3.Integration.Product
 
-  test "handles uuid serialization and deserialization" do
+  setup do
+    Application.put_env(:ecto_sqlite3, :uuid_type, :string)
+    on_exit(fn -> Application.put_env(:ecto_sqlite3, :uuid_type, :string) end)
+  end
+
+  test "handles uuid serialization and deserialization with string format " do
+    external_id = Ecto.UUID.generate()
+    product = TestRepo.insert!(%Product{name: "Pupper Beer", external_id: external_id})
+
+    assert product.id
+    assert product.external_id == external_id
+
+    found = TestRepo.get(Product, product.id)
+    assert found
+    assert found.external_id == external_id
+  end
+
+  test "handles uuid serialization and deserialization with binary format " do
+    Application.put_env(:ecto_sqlite3, :uuid_type, :binary)
+
     external_id = Ecto.UUID.generate()
     product = TestRepo.insert!(%Product{name: "Pupper Beer", external_id: external_id})