Add Exqlite.TypeExtensions to allow more types to be stored in the database (#333)

Introduces a runtime extension to convert data types into something
that can be serialized into the database.

See elixir-sqlite/ecto_sqlite3#167 and
elixir-sqlite/ecto_sqlite3#166

My primary goal is to be able to use Spatialite from Elixir. With this
PR and the one against `ecto_sqlite3`, it is 95% of the way there. With
these two PRs applied, one can now do things like:

```elixir
defmodule Location do
  use Ecto.Schema

  schema "locations" do
    field(:name, :string)
    field(:geom, GeoSQL.Geometry)
  end
end

MyApp.Repo.all(from(location in Location, select: MM2.distance(location.geom, ^geometry)))
```

.. and it just works, regardless of whether `MyApp.Repo` is point at a
PostgreSQL database with PostGIS enabled, or an SQLite3 database with
Spatialite loaded.

The one remaining annoyance is getting structs back *out* of the
database without going through ecto (which *does* work with the
`ecto_sqlite3` PR!). So, I still have to figure out a nice way for the
user to get back `Geo` structs from raw queries such as:

```
from(location in Location, limit: 1, select: MM2.transform(location.geom, 3452))
```

But otherwise everything Just Works transparently with this change.

Author: aseigo

README.md

@@ -46,12 +46,17 @@ end
 ### Runtime Configuration
 
 ```elixir
-config :exqlite, default_chunk_size: 100
+config :exqlite,
+    default_chunk_size: 100,
+    type_extensions: [MyApp.TypeExtension]
 ```
 
 * `default_chunk_size` - The chunk size that is used when multi-stepping when
   not specifying the chunk size explicitly.
-  
+* `type_extensions`: An optional list of modules that implement the
+  Exqlite.TypeExtension behaviour, allowing types beyond the default set that
+  can be stored and retrieved from the database.
+
 ### Compile-time Configuration
 
 In `config/config.exs`,

lib/exqlite/sqlite3.ex

@@ -481,5 +481,28 @@ defmodule Exqlite.Sqlite3 do
     raise ArgumentError, "#{inspect(datetime)} is not in UTC"
   end
 
-  defp convert(val), do: val
+  defp convert(val) do
+    convert_with_type_extensions(type_extensions(), val)
+  end
+
+  defp convert_with_type_extensions(nil, val), do: val
+  defp convert_with_type_extensions([], val), do: val
+
+  defp convert_with_type_extensions([extension | other_extensions], val) do
+    case extension.convert(val) do
+      nil ->
+        convert_with_type_extensions(other_extensions, val)
+
+      {:ok, converted} ->
+        converted
+
+      {:error, reason} ->
+        raise ArgumentError,
+              "Failed conversion by TypeExtension #{extension}: #{inspect(val)}. Reason: #{inspect(reason)}."
+    end
+  end
+
+  defp type_extensions do
+    Application.get_env(:exqlite, :type_extensions)
+  end
 end

lib/exqlite/type_extension.ex

@@ -0,0 +1,14 @@
+defmodule Exqlite.TypeExtension do
+  @moduledoc """
+  A behaviour that defines the API for extensions providing custom data loaders and dumpers
+  for Ecto schemas.
+  """
+
+  @doc """
+  Takes a value and convers it to data suitable for storage in the database.
+
+  Returns a tagged :ok/:error tuple. If the value is not convertable by this
+  extension, returns nil.
+  """
+  @callback convert(value :: term) :: {:ok, term} | {:error, reason :: term} | nil
+end